projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
iwlagn: bus layer chooses its transport layer
[deliverable/linux.git] / drivers / net / wireless / iwlwifi / iwl-agn-sta.c
CommitLineData
a30e3112
JB		 1/******************************************************************************
2 *
901069c7 3 * Copyright(c) 2003 - 2011 Intel Corporation. All rights reserved.
a30e3112
JB		 4 *
5 * Portions of this file are derived from the ipw3945 project, as well
6 * as portions of the ieee80211 subsystem header files.
7 *
8 * This program is free software; you can redistribute it and/or modify it
9 * under the terms of version 2 of the GNU General Public License as
10 * published by the Free Software Foundation.
11 *
12 * This program is distributed in the hope that it will be useful, but WITHOUT
13 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
15 * more details.
16 *
17 * You should have received a copy of the GNU General Public License along with
18 * this program; if not, write to the Free Software Foundation, Inc.,
19 * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
20 *
21 * The full GNU General Public License is included in this distribution in the
22 * file called LICENSE.
23 *
24 * Contact Information:
25 * Intel Linux Wireless <ilw@linux.intel.com>
26 * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
27 *
28 *****************************************************************************/
29
30#include <net/mac80211.h>
31
32#include "iwl-dev.h"
33#include "iwl-core.h"
34#include "iwl-sta.h"
35#include "iwl-agn.h"
bdfbf092 36#include "iwl-trans.h"
a30e3112
JB		 37
38static struct iwl_link_quality_cmd *
f775aa06 39iwl_sta_alloc_lq(struct iwl_priv *priv, struct iwl_rxon_context *ctx, u8 sta_id)
a30e3112
JB		 40{
41 int i, r;
42 struct iwl_link_quality_cmd *link_cmd;
43 u32 rate_flags = 0;
44 __le32 rate_n_flags;
45
46 link_cmd = kzalloc(sizeof(struct iwl_link_quality_cmd), GFP_KERNEL);
47 if (!link_cmd) {
48 IWL_ERR(priv, "Unable to allocate memory for LQ cmd.\n");
49 return NULL;
50 }
f775aa06 51
6ac2f839 52 lockdep_assert_held(&priv->shrd->mutex);
f775aa06 53
a30e3112
JB		 54 /* Set up the rate scaling to start at selected rate, fall back
55 * all the way down to 1M in IEEE order, and then spin on 1M */
56 if (priv->band == IEEE80211_BAND_5GHZ)
57 r = IWL_RATE_6M_INDEX;
f775aa06
JB		 58 else if (ctx && ctx->vif && ctx->vif->p2p)
59 r = IWL_RATE_6M_INDEX;
a30e3112
JB		 60 else
61 r = IWL_RATE_1M_INDEX;
62
63 if (r >= IWL_FIRST_CCK_RATE && r <= IWL_LAST_CCK_RATE)
64 rate_flags |= RATE_MCS_CCK_MSK;
65
d6189124 66 rate_flags |= first_antenna(hw_params(priv).valid_tx_ant) <<
a30e3112
JB		 67 RATE_MCS_ANT_POS;
68 rate_n_flags = iwl_hw_set_rate_n_flags(iwl_rates[r].plcp, rate_flags);
69 for (i = 0; i < LINK_QUAL_MAX_RETRY_NUM; i++)
70 link_cmd->rs_table[i].rate_n_flags = rate_n_flags;
71
72 link_cmd->general_params.single_stream_ant_msk =
d6189124 73 first_antenna(hw_params(priv).valid_tx_ant);
a30e3112
JB		 74
75 link_cmd->general_params.dual_stream_ant_msk =
d6189124
EG		 76 hw_params(priv).valid_tx_ant &
77 ~first_antenna(hw_params(priv).valid_tx_ant);
a30e3112
JB		 78 if (!link_cmd->general_params.dual_stream_ant_msk) {
79 link_cmd->general_params.dual_stream_ant_msk = ANT_AB;
d6189124 80 } else if (num_of_ant(hw_params(priv).valid_tx_ant) == 2) {
a30e3112 81 link_cmd->general_params.dual_stream_ant_msk =
d6189124 82 hw_params(priv).valid_tx_ant;
a30e3112
JB		 83 }
84
85 link_cmd->agg_params.agg_dis_start_th = LINK_QUAL_AGG_DISABLE_START_DEF;
86 link_cmd->agg_params.agg_time_limit =
87 cpu_to_le16(LINK_QUAL_AGG_TIME_LIMIT_DEF);
88
89 link_cmd->sta_id = sta_id;
90
91 return link_cmd;
92}
93
94/*
95 * iwlagn_add_bssid_station - Add the special IBSS BSSID station
96 *
97 * Function sleeps.
98 */
99int iwlagn_add_bssid_station(struct iwl_priv *priv, struct iwl_rxon_context *ctx,
100 const u8 *addr, u8 *sta_id_r)
101{
102 int ret;
103 u8 sta_id;
104 struct iwl_link_quality_cmd *link_cmd;
105 unsigned long flags;
106
107 if (sta_id_r)
108 *sta_id_r = IWL_INVALID_STATION;
109
110 ret = iwl_add_station_common(priv, ctx, addr, 0, NULL, &sta_id);
111 if (ret) {
112 IWL_ERR(priv, "Unable to add station %pM\n", addr);
113 return ret;
114 }
115
116 if (sta_id_r)
117 *sta_id_r = sta_id;
118
f39c95e8 119 spin_lock_irqsave(&priv->shrd->sta_lock, flags);
a30e3112 120 priv->stations[sta_id].used |= IWL_STA_LOCAL;
f39c95e8 121 spin_unlock_irqrestore(&priv->shrd->sta_lock, flags);
a30e3112
JB		 122
123 /* Set up default rate scaling table in device's station table */
f775aa06 124 link_cmd = iwl_sta_alloc_lq(priv, ctx, sta_id);
a30e3112
JB		 125 if (!link_cmd) {
126 IWL_ERR(priv, "Unable to initialize rate scaling for station %pM.\n",
127 addr);
128 return -ENOMEM;
129 }
130
131 ret = iwl_send_lq_cmd(priv, ctx, link_cmd, CMD_SYNC, true);
132 if (ret)
133 IWL_ERR(priv, "Link quality command failed (%d)\n", ret);
134
f39c95e8 135 spin_lock_irqsave(&priv->shrd->sta_lock, flags);
a30e3112 136 priv->stations[sta_id].lq = link_cmd;
f39c95e8 137 spin_unlock_irqrestore(&priv->shrd->sta_lock, flags);
a30e3112
JB		 138
139 return 0;
140}
141
5a3d9882
JB		 142/*
143 * static WEP keys
144 *
145 * For each context, the device has a table of 4 static WEP keys
146 * (one for each key index) that is updated with the following
147 * commands.
148 */
149
a30e3112
JB		 150static int iwl_send_static_wepkey_cmd(struct iwl_priv *priv,
151 struct iwl_rxon_context *ctx,
152 bool send_if_empty)
153{
154 int i, not_empty = 0;
155 u8 buff[sizeof(struct iwl_wep_cmd) +
156 sizeof(struct iwl_wep_key) * WEP_KEYS_MAX];
157 struct iwl_wep_cmd *wep_cmd = (struct iwl_wep_cmd *)buff;
158 size_t cmd_size = sizeof(struct iwl_wep_cmd);
159 struct iwl_host_cmd cmd = {
160 .id = ctx->wep_key_cmd,
3fa50738 161 .data = { wep_cmd, },
a30e3112
JB		 162 .flags = CMD_SYNC,
163 };
164
165 might_sleep();
166
167 memset(wep_cmd, 0, cmd_size +
168 (sizeof(struct iwl_wep_key) * WEP_KEYS_MAX));
169
170 for (i = 0; i < WEP_KEYS_MAX ; i++) {
171 wep_cmd->key[i].key_index = i;
172 if (ctx->wep_keys[i].key_size) {
173 wep_cmd->key[i].key_offset = i;
174 not_empty = 1;
175 } else {
176 wep_cmd->key[i].key_offset = WEP_INVALID_OFFSET;
177 }
178
179 wep_cmd->key[i].key_size = ctx->wep_keys[i].key_size;
180 memcpy(&wep_cmd->key[i].key[3], ctx->wep_keys[i].key,
181 ctx->wep_keys[i].key_size);
182 }
183
184 wep_cmd->global_key_type = WEP_KEY_WEP_TYPE;
185 wep_cmd->num_keys = WEP_KEYS_MAX;
186
187 cmd_size += sizeof(struct iwl_wep_key) * WEP_KEYS_MAX;
188
3fa50738 189 cmd.len[0] = cmd_size;
a30e3112
JB		 190
191 if (not_empty || send_if_empty)
e6bb4c9c 192 return iwl_trans_send_cmd(trans(priv), &cmd);
a30e3112
JB		 193 else
194 return 0;
195}
196
197int iwl_restore_default_wep_keys(struct iwl_priv *priv,
198 struct iwl_rxon_context *ctx)
199{
6ac2f839 200 lockdep_assert_held(&priv->shrd->mutex);
a30e3112
JB		 201
202 return iwl_send_static_wepkey_cmd(priv, ctx, false);
203}
204
205int iwl_remove_default_wep_key(struct iwl_priv *priv,
206 struct iwl_rxon_context *ctx,
207 struct ieee80211_key_conf *keyconf)
208{
209 int ret;
210
6ac2f839 211 lockdep_assert_held(&priv->shrd->mutex);
a30e3112
JB		 212
213 IWL_DEBUG_WEP(priv, "Removing default WEP key: idx=%d\n",
214 keyconf->keyidx);
215
216 memset(&ctx->wep_keys[keyconf->keyidx], 0, sizeof(ctx->wep_keys[0]));
217 if (iwl_is_rfkill(priv)) {
218 IWL_DEBUG_WEP(priv, "Not sending REPLY_WEPKEY command due to RFKILL.\n");
219 /* but keys in device are clear anyway so return success */
220 return 0;
221 }
222 ret = iwl_send_static_wepkey_cmd(priv, ctx, 1);
223 IWL_DEBUG_WEP(priv, "Remove default WEP key: idx=%d ret=%d\n",
224 keyconf->keyidx, ret);
225
226 return ret;
227}
228
229int iwl_set_default_wep_key(struct iwl_priv *priv,
230 struct iwl_rxon_context *ctx,
231 struct ieee80211_key_conf *keyconf)
232{
233 int ret;
234
6ac2f839 235 lockdep_assert_held(&priv->shrd->mutex);
a30e3112
JB		 236
237 if (keyconf->keylen != WEP_KEY_LEN_128 &&
238 keyconf->keylen != WEP_KEY_LEN_64) {
239 IWL_DEBUG_WEP(priv, "Bad WEP key length %d\n", keyconf->keylen);
240 return -EINVAL;
241 }
242
5a3d9882 243 keyconf->hw_key_idx = IWLAGN_HW_KEY_DEFAULT;
a30e3112
JB		 244
245 ctx->wep_keys[keyconf->keyidx].key_size = keyconf->keylen;
246 memcpy(&ctx->wep_keys[keyconf->keyidx].key, &keyconf->key,
247 keyconf->keylen);
248
249 ret = iwl_send_static_wepkey_cmd(priv, ctx, false);
250 IWL_DEBUG_WEP(priv, "Set default WEP key: len=%d idx=%d ret=%d\n",
251 keyconf->keylen, keyconf->keyidx, ret);
252
253 return ret;
254}
255
5a3d9882
JB		 256/*
257 * dynamic (per-station) keys
258 *
259 * The dynamic keys are a little more complicated. The device has
260 * a key cache of up to STA_KEY_MAX_NUM/STA_KEY_MAX_NUM_PAN keys.
261 * These are linked to stations by a table that contains an index
262 * into the key table for each station/key index/{mcast,unicast},
263 * i.e. it's basically an array of pointers like this:
264 * key_offset_t key_mapping[NUM_STATIONS][4][2];
265 * (it really works differently, but you can think of it as such)
266 *
267 * The key uploading and linking happens in the same command, the
268 * add station command with STA_MODIFY_KEY_MASK.
269 */
a30e3112 270
5a3d9882
JB		 271static u8 iwlagn_key_sta_id(struct iwl_priv *priv,
272 struct ieee80211_vif *vif,
273 struct ieee80211_sta *sta)
274{
275 struct iwl_vif_priv *vif_priv = (void *)vif->drv_priv;
276 u8 sta_id = IWL_INVALID_STATION;
277
278 if (sta)
279 sta_id = iwl_sta_id(sta);
280
281 /*
282 * The device expects GTKs for station interfaces to be
283 * installed as GTKs for the AP station. If we have no
284 * station ID, then use the ap_sta_id in that case.
285 */
286 if (!sta && vif && vif_priv->ctx) {
287 switch (vif->type) {
288 case NL80211_IFTYPE_STATION:
289 sta_id = vif_priv->ctx->ap_sta_id;
290 break;
291 default:
292 /*
293 * In all other cases, the key will be
294 * used either for TX only or is bound
295 * to a station already.
296 */
297 break;
298 }
299 }
a30e3112 300
5a3d9882 301 return sta_id;
a30e3112
JB		 302}
303
e1b1c087
JB		 304static int iwlagn_send_sta_key(struct iwl_priv *priv,
305 struct ieee80211_key_conf *keyconf,
306 u8 sta_id, u32 tkip_iv32, u16 *tkip_p1k,
307 u32 cmd_flags)
a30e3112
JB		 308{
309 unsigned long flags;
5a3d9882 310 __le16 key_flags;
a30e3112 311 struct iwl_addsta_cmd sta_cmd;
5a3d9882 312 int i;
e1b1c087 313
f39c95e8 314 spin_lock_irqsave(&priv->shrd->sta_lock, flags);
5a3d9882 315 memcpy(&sta_cmd, &priv->stations[sta_id].sta, sizeof(sta_cmd));
f39c95e8 316 spin_unlock_irqrestore(&priv->shrd->sta_lock, flags);
a30e3112 317
5a3d9882
JB		 318 key_flags = cpu_to_le16(keyconf->keyidx << STA_KEY_FLG_KEYID_POS);
319 key_flags |= STA_KEY_FLG_MAP_KEY_MSK;
a30e3112 320
5a3d9882
JB		 321 switch (keyconf->cipher) {
322 case WLAN_CIPHER_SUITE_CCMP:
323 key_flags |= STA_KEY_FLG_CCMP;
324 memcpy(sta_cmd.key.key, keyconf->key, keyconf->keylen);
325 break;
326 case WLAN_CIPHER_SUITE_TKIP:
327 key_flags |= STA_KEY_FLG_TKIP;
328 sta_cmd.key.tkip_rx_tsc_byte2 = tkip_iv32;
329 for (i = 0; i < 5; i++)
330 sta_cmd.key.tkip_rx_ttak[i] = cpu_to_le16(tkip_p1k[i]);
331 memcpy(sta_cmd.key.key, keyconf->key, keyconf->keylen);
332 break;
333 case WLAN_CIPHER_SUITE_WEP104:
334 key_flags |= STA_KEY_FLG_KEY_SIZE_MSK;
335 /* fall through */
336 case WLAN_CIPHER_SUITE_WEP40:
337 key_flags |= STA_KEY_FLG_WEP;
338 memcpy(&sta_cmd.key.key[3], keyconf->key, keyconf->keylen);
339 break;
340 default:
341 WARN_ON(1);
342 return -EINVAL;
343 }
a30e3112 344
5a3d9882 345 if (!(keyconf->flags & IEEE80211_KEY_FLAG_PAIRWISE))
a30e3112
JB		 346 key_flags |= STA_KEY_MULTICAST_MSK;
347
5a3d9882
JB		 348 /* key pointer (offset) */
349 sta_cmd.key.key_offset = keyconf->hw_key_idx;
a30e3112 350
5a3d9882
JB		 351 sta_cmd.key.key_flags = key_flags;
352 sta_cmd.mode = STA_CONTROL_MODIFY_MSK;
353 sta_cmd.sta.modify_mask = STA_MODIFY_KEY_MASK;
a30e3112 354
5a3d9882 355 return iwl_send_add_sta(priv, &sta_cmd, cmd_flags);
a30e3112
JB		 356}
357
358void iwl_update_tkip_key(struct iwl_priv *priv,
5a3d9882 359 struct ieee80211_vif *vif,
a30e3112
JB		 360 struct ieee80211_key_conf *keyconf,
361 struct ieee80211_sta *sta, u32 iv32, u16 *phase1key)
362{
5a3d9882
JB		 363 u8 sta_id = iwlagn_key_sta_id(priv, vif, sta);
364
365 if (sta_id == IWL_INVALID_STATION)
366 return;
a30e3112
JB		 367
368 if (iwl_scan_cancel(priv)) {
369 /* cancel scan failed, just live w/ bad key and rely
370 briefly on SW decryption */
371 return;
372 }
373
e1b1c087
JB		 374 iwlagn_send_sta_key(priv, keyconf, sta_id,
375 iv32, phase1key, CMD_ASYNC);
a30e3112
JB		 376}
377
378int iwl_remove_dynamic_key(struct iwl_priv *priv,
379 struct iwl_rxon_context *ctx,
380 struct ieee80211_key_conf *keyconf,
5a3d9882 381 struct ieee80211_sta *sta)
a30e3112
JB		 382{
383 unsigned long flags;
a30e3112 384 struct iwl_addsta_cmd sta_cmd;
5a3d9882
JB		 385 u8 sta_id = iwlagn_key_sta_id(priv, ctx->vif, sta);
386
387 /* if station isn't there, neither is the key */
388 if (sta_id == IWL_INVALID_STATION)
389 return -ENOENT;
390
f39c95e8 391 spin_lock_irqsave(&priv->shrd->sta_lock, flags);
5a3d9882
JB		 392 memcpy(&sta_cmd, &priv->stations[sta_id].sta, sizeof(sta_cmd));
393 if (!(priv->stations[sta_id].used & IWL_STA_UCODE_ACTIVE))
394 sta_id = IWL_INVALID_STATION;
f39c95e8 395 spin_unlock_irqrestore(&priv->shrd->sta_lock, flags);
5a3d9882
JB		 396
397 if (sta_id == IWL_INVALID_STATION)
398 return 0;
a30e3112 399
6ac2f839 400 lockdep_assert_held(&priv->shrd->mutex);
a30e3112
JB		 401
402 ctx->key_mapping_keys--;
403
a30e3112
JB		 404 IWL_DEBUG_WEP(priv, "Remove dynamic key: idx=%d sta=%d\n",
405 keyconf->keyidx, sta_id);
406
5a3d9882
JB		 407 if (!test_and_clear_bit(keyconf->hw_key_idx, &priv->ucode_key_table))
408 IWL_ERR(priv, "offset %d not used in uCode key table.\n",
409 keyconf->hw_key_idx);
a30e3112 410
5a3d9882
JB		 411 sta_cmd.key.key_flags = STA_KEY_FLG_NO_ENC | STA_KEY_FLG_INVALID;
412 sta_cmd.key.key_offset = WEP_INVALID_OFFSET;
413 sta_cmd.sta.modify_mask = STA_MODIFY_KEY_MASK;
414 sta_cmd.mode = STA_CONTROL_MODIFY_MSK;
a30e3112
JB		 415
416 return iwl_send_add_sta(priv, &sta_cmd, CMD_SYNC);
417}
418
5a3d9882
JB		 419int iwl_set_dynamic_key(struct iwl_priv *priv,
420 struct iwl_rxon_context *ctx,
421 struct ieee80211_key_conf *keyconf,
422 struct ieee80211_sta *sta)
a30e3112 423{
5a3d9882
JB		 424 struct ieee80211_key_seq seq;
425 u16 p1k[5];
a30e3112 426 int ret;
5a3d9882
JB		 427 u8 sta_id = iwlagn_key_sta_id(priv, ctx->vif, sta);
428 const u8 *addr;
429
430 if (sta_id == IWL_INVALID_STATION)
431 return -EINVAL;
a30e3112 432
6ac2f839 433 lockdep_assert_held(&priv->shrd->mutex);
a30e3112 434
5a3d9882
JB		 435 keyconf->hw_key_idx = iwl_get_free_ucode_key_offset(priv);
436 if (keyconf->hw_key_idx == WEP_INVALID_OFFSET)
437 return -ENOSPC;
438
a30e3112 439 ctx->key_mapping_keys++;
a30e3112
JB		 440
441 switch (keyconf->cipher) {
a30e3112 442 case WLAN_CIPHER_SUITE_TKIP:
5a3d9882
JB		 443 keyconf->flags |= IEEE80211_KEY_FLAG_GENERATE_MMIC;
444 keyconf->flags |= IEEE80211_KEY_FLAG_GENERATE_IV;
445
446 if (sta)
447 addr = sta->addr;
448 else /* station mode case only */
449 addr = ctx->active.bssid_addr;
450
451 /* pre-fill phase 1 key into device cache */
452 ieee80211_get_key_rx_seq(keyconf, 0, &seq);
453 ieee80211_get_tkip_rx_p1k(keyconf, addr, seq.tkip.iv32, p1k);
e1b1c087
JB		 454 ret = iwlagn_send_sta_key(priv, keyconf, sta_id,
455 seq.tkip.iv32, p1k, CMD_SYNC);
a30e3112 456 break;
5a3d9882
JB		 457 case WLAN_CIPHER_SUITE_CCMP:
458 keyconf->flags |= IEEE80211_KEY_FLAG_GENERATE_IV;
459 /* fall through */
a30e3112
JB		 460 case WLAN_CIPHER_SUITE_WEP40:
461 case WLAN_CIPHER_SUITE_WEP104:
e1b1c087
JB		 462 ret = iwlagn_send_sta_key(priv, keyconf, sta_id,
463 0, NULL, CMD_SYNC);
a30e3112
JB		 464 break;
465 default:
5a3d9882 466 IWL_ERR(priv, "Unknown cipher %x\n", keyconf->cipher);
a30e3112
JB		 467 ret = -EINVAL;
468 }
469
5a3d9882
JB		 470 if (ret) {
471 ctx->key_mapping_keys--;
472 clear_bit(keyconf->hw_key_idx, &priv->ucode_key_table);
473 }
474
475 IWL_DEBUG_WEP(priv, "Set dynamic key: cipher=%x len=%d idx=%d sta=%pM ret=%d\n",
a30e3112 476 keyconf->cipher, keyconf->keylen, keyconf->keyidx,
5a3d9882 477 sta ? sta->addr : NULL, ret);
a30e3112
JB		 478
479 return ret;
480}
481
482/**
483 * iwlagn_alloc_bcast_station - add broadcast station into driver's station table.
484 *
485 * This adds the broadcast station into the driver's station table
486 * and marks it driver active, so that it will be restored to the
487 * device at the next best time.
488 */
489int iwlagn_alloc_bcast_station(struct iwl_priv *priv,
490 struct iwl_rxon_context *ctx)
491{
492 struct iwl_link_quality_cmd *link_cmd;
493 unsigned long flags;
494 u8 sta_id;
495
f39c95e8 496 spin_lock_irqsave(&priv->shrd->sta_lock, flags);
a30e3112
JB		 497 sta_id = iwl_prep_station(priv, ctx, iwl_bcast_addr, false, NULL);
498 if (sta_id == IWL_INVALID_STATION) {
499 IWL_ERR(priv, "Unable to prepare broadcast station\n");
f39c95e8 500 spin_unlock_irqrestore(&priv->shrd->sta_lock, flags);
a30e3112
JB		 501
502 return -EINVAL;
503 }
504
505 priv->stations[sta_id].used |= IWL_STA_DRIVER_ACTIVE;
506 priv->stations[sta_id].used |= IWL_STA_BCAST;
f39c95e8 507 spin_unlock_irqrestore(&priv->shrd->sta_lock, flags);
a30e3112 508
f775aa06 509 link_cmd = iwl_sta_alloc_lq(priv, ctx, sta_id);
a30e3112
JB		 510 if (!link_cmd) {
511 IWL_ERR(priv,
512 "Unable to initialize rate scaling for bcast station.\n");
513 return -ENOMEM;
514 }
515
f39c95e8 516 spin_lock_irqsave(&priv->shrd->sta_lock, flags);
a30e3112 517 priv->stations[sta_id].lq = link_cmd;
f39c95e8 518 spin_unlock_irqrestore(&priv->shrd->sta_lock, flags);
a30e3112
JB		 519
520 return 0;
521}
522
523/**
524 * iwl_update_bcast_station - update broadcast station's LQ command
525 *
526 * Only used by iwlagn. Placed here to have all bcast station management
527 * code together.
528 */
f775aa06
JB		 529int iwl_update_bcast_station(struct iwl_priv *priv,
530 struct iwl_rxon_context *ctx)
a30e3112
JB		 531{
532 unsigned long flags;
533 struct iwl_link_quality_cmd *link_cmd;
534 u8 sta_id = ctx->bcast_sta_id;
535
f775aa06 536 link_cmd = iwl_sta_alloc_lq(priv, ctx, sta_id);
a30e3112
JB		 537 if (!link_cmd) {
538 IWL_ERR(priv, "Unable to initialize rate scaling for bcast station.\n");
539 return -ENOMEM;
540 }
541
f39c95e8 542 spin_lock_irqsave(&priv->shrd->sta_lock, flags);
a30e3112
JB		 543 if (priv->stations[sta_id].lq)
544 kfree(priv->stations[sta_id].lq);
545 else
546 IWL_DEBUG_INFO(priv, "Bcast station rate scaling has not been initialized yet.\n");
547 priv->stations[sta_id].lq = link_cmd;
f39c95e8 548 spin_unlock_irqrestore(&priv->shrd->sta_lock, flags);
a30e3112
JB		 549
550 return 0;
551}
552
553int iwl_update_bcast_stations(struct iwl_priv *priv)
554{
555 struct iwl_rxon_context *ctx;
556 int ret = 0;
557
558 for_each_context(priv, ctx) {
559 ret = iwl_update_bcast_station(priv, ctx);
560 if (ret)
561 break;
562 }
563
564 return ret;
565}
566
567/**
568 * iwl_sta_tx_modify_enable_tid - Enable Tx for this TID in station table
569 */
570int iwl_sta_tx_modify_enable_tid(struct iwl_priv *priv, int sta_id, int tid)
571{
572 unsigned long flags;
573 struct iwl_addsta_cmd sta_cmd;
574
6ac2f839 575 lockdep_assert_held(&priv->shrd->mutex);
a30e3112
JB		 576
577 /* Remove "disable" flag, to enable Tx for this TID */
f39c95e8 578 spin_lock_irqsave(&priv->shrd->sta_lock, flags);
a30e3112
JB		 579 priv->stations[sta_id].sta.sta.modify_mask = STA_MODIFY_TID_DISABLE_TX;
580 priv->stations[sta_id].sta.tid_disable_tx &= cpu_to_le16(~(1 << tid));
581 priv->stations[sta_id].sta.mode = STA_CONTROL_MODIFY_MSK;
582 memcpy(&sta_cmd, &priv->stations[sta_id].sta, sizeof(struct iwl_addsta_cmd));
f39c95e8 583 spin_unlock_irqrestore(&priv->shrd->sta_lock, flags);
a30e3112
JB		 584
585 return iwl_send_add_sta(priv, &sta_cmd, CMD_SYNC);
586}
587
588int iwl_sta_rx_agg_start(struct iwl_priv *priv, struct ieee80211_sta *sta,
589 int tid, u16 ssn)
590{
591 unsigned long flags;
592 int sta_id;
593 struct iwl_addsta_cmd sta_cmd;
594
6ac2f839 595 lockdep_assert_held(&priv->shrd->mutex);
a30e3112
JB		 596
597 sta_id = iwl_sta_id(sta);
598 if (sta_id == IWL_INVALID_STATION)
599 return -ENXIO;
600
f39c95e8 601 spin_lock_irqsave(&priv->shrd->sta_lock, flags);
a30e3112
JB		 602 priv->stations[sta_id].sta.station_flags_msk = 0;
603 priv->stations[sta_id].sta.sta.modify_mask = STA_MODIFY_ADDBA_TID_MSK;
604 priv->stations[sta_id].sta.add_immediate_ba_tid = (u8)tid;
605 priv->stations[sta_id].sta.add_immediate_ba_ssn = cpu_to_le16(ssn);
606 priv->stations[sta_id].sta.mode = STA_CONTROL_MODIFY_MSK;
607 memcpy(&sta_cmd, &priv->stations[sta_id].sta, sizeof(struct iwl_addsta_cmd));
f39c95e8 608 spin_unlock_irqrestore(&priv->shrd->sta_lock, flags);
a30e3112
JB		 609
610 return iwl_send_add_sta(priv, &sta_cmd, CMD_SYNC);
611}
612
613int iwl_sta_rx_agg_stop(struct iwl_priv *priv, struct ieee80211_sta *sta,
614 int tid)
615{
616 unsigned long flags;
617 int sta_id;
618 struct iwl_addsta_cmd sta_cmd;
619
6ac2f839 620 lockdep_assert_held(&priv->shrd->mutex);
a30e3112
JB		 621
622 sta_id = iwl_sta_id(sta);
623 if (sta_id == IWL_INVALID_STATION) {
624 IWL_ERR(priv, "Invalid station for AGG tid %d\n", tid);
625 return -ENXIO;
626 }
627
f39c95e8 628 spin_lock_irqsave(&priv->shrd->sta_lock, flags);
a30e3112
JB		 629 priv->stations[sta_id].sta.station_flags_msk = 0;
630 priv->stations[sta_id].sta.sta.modify_mask = STA_MODIFY_DELBA_TID_MSK;
631 priv->stations[sta_id].sta.remove_immediate_ba_tid = (u8)tid;
632 priv->stations[sta_id].sta.mode = STA_CONTROL_MODIFY_MSK;
633 memcpy(&sta_cmd, &priv->stations[sta_id].sta, sizeof(struct iwl_addsta_cmd));
f39c95e8 634 spin_unlock_irqrestore(&priv->shrd->sta_lock, flags);
a30e3112
JB		 635
636 return iwl_send_add_sta(priv, &sta_cmd, CMD_SYNC);
637}
638
ae79d23d 639static void iwl_sta_modify_ps_wake(struct iwl_priv *priv, int sta_id)
a30e3112
JB		 640{
641 unsigned long flags;
642
f39c95e8 643 spin_lock_irqsave(&priv->shrd->sta_lock, flags);
a30e3112
JB		 644 priv->stations[sta_id].sta.station_flags &= ~STA_FLG_PWR_SAVE_MSK;
645 priv->stations[sta_id].sta.station_flags_msk = STA_FLG_PWR_SAVE_MSK;
646 priv->stations[sta_id].sta.sta.modify_mask = 0;
647 priv->stations[sta_id].sta.sleep_tx_count = 0;
648 priv->stations[sta_id].sta.mode = STA_CONTROL_MODIFY_MSK;
649 iwl_send_add_sta(priv, &priv->stations[sta_id].sta, CMD_ASYNC);
f39c95e8 650 spin_unlock_irqrestore(&priv->shrd->sta_lock, flags);
a30e3112
JB		 651
652}
653
654void iwl_sta_modify_sleep_tx_count(struct iwl_priv *priv, int sta_id, int cnt)
655{
656 unsigned long flags;
657
f39c95e8 658 spin_lock_irqsave(&priv->shrd->sta_lock, flags);
a30e3112
JB		 659 priv->stations[sta_id].sta.station_flags |= STA_FLG_PWR_SAVE_MSK;
660 priv->stations[sta_id].sta.station_flags_msk = STA_FLG_PWR_SAVE_MSK;
661 priv->stations[sta_id].sta.sta.modify_mask =
662 STA_MODIFY_SLEEP_TX_COUNT_MSK;
663 priv->stations[sta_id].sta.sleep_tx_count = cpu_to_le16(cnt);
664 priv->stations[sta_id].sta.mode = STA_CONTROL_MODIFY_MSK;
665 iwl_send_add_sta(priv, &priv->stations[sta_id].sta, CMD_ASYNC);
f39c95e8 666 spin_unlock_irqrestore(&priv->shrd->sta_lock, flags);
a30e3112
JB		 667
668}
ae79d23d
JB		 669
670void iwlagn_mac_sta_notify(struct ieee80211_hw *hw,
671 struct ieee80211_vif *vif,
672 enum sta_notify_cmd cmd,
673 struct ieee80211_sta *sta)
674{
675 struct iwl_priv *priv = hw->priv;
676 struct iwl_station_priv *sta_priv = (void *)sta->drv_priv;
677 int sta_id;
678
679 switch (cmd) {
680 case STA_NOTIFY_SLEEP:
681 WARN_ON(!sta_priv->client);
682 sta_priv->asleep = true;
683 if (atomic_read(&sta_priv->pending_frames) > 0)
684 ieee80211_sta_block_awake(hw, sta, true);
685 break;
686 case STA_NOTIFY_AWAKE:
687 WARN_ON(!sta_priv->client);
688 if (!sta_priv->asleep)
689 break;
690 sta_priv->asleep = false;
691 sta_id = iwl_sta_id(sta);
692 if (sta_id != IWL_INVALID_STATION)
693 iwl_sta_modify_ps_wake(priv, sta_id);
694 break;
695 default:
696 break;
697 }
698}
Linux kernel - Deliverables
This page took 0.165179 seconds and 5 git commands to generate.