aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/net/wireless/iwlwifi/iwl-agn-sta.c
diff options
context:
space:
mode:
Diffstat (limited to 'drivers/net/wireless/iwlwifi/iwl-agn-sta.c')
-rw-r--r--drivers/net/wireless/iwlwifi/iwl-agn-sta.c693
1 files changed, 693 insertions, 0 deletions
diff --git a/drivers/net/wireless/iwlwifi/iwl-agn-sta.c b/drivers/net/wireless/iwlwifi/iwl-agn-sta.c
new file mode 100644
index 00000000000..211a5ad6a4f
--- /dev/null
+++ b/drivers/net/wireless/iwlwifi/iwl-agn-sta.c
@@ -0,0 +1,693 @@
1/******************************************************************************
2 *
3 * Copyright(c) 2003 - 2011 Intel Corporation. All rights reserved.
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"
36#include "iwl-trans.h"
37
38static struct iwl_link_quality_cmd *
39iwl_sta_alloc_lq(struct iwl_priv *priv, struct iwl_rxon_context *ctx, u8 sta_id)
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 }
51
52 lockdep_assert_held(&priv->mutex);
53
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;
58 else if (ctx && ctx->vif && ctx->vif->p2p)
59 r = IWL_RATE_6M_INDEX;
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
66 rate_flags |= first_antenna(priv->hw_params.valid_tx_ant) <<
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 =
73 first_antenna(priv->hw_params.valid_tx_ant);
74
75 link_cmd->general_params.dual_stream_ant_msk =
76 priv->hw_params.valid_tx_ant &
77 ~first_antenna(priv->hw_params.valid_tx_ant);
78 if (!link_cmd->general_params.dual_stream_ant_msk) {
79 link_cmd->general_params.dual_stream_ant_msk = ANT_AB;
80 } else if (num_of_ant(priv->hw_params.valid_tx_ant) == 2) {
81 link_cmd->general_params.dual_stream_ant_msk =
82 priv->hw_params.valid_tx_ant;
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
119 spin_lock_irqsave(&priv->sta_lock, flags);
120 priv->stations[sta_id].used |= IWL_STA_LOCAL;
121 spin_unlock_irqrestore(&priv->sta_lock, flags);
122
123 /* Set up default rate scaling table in device's station table */
124 link_cmd = iwl_sta_alloc_lq(priv, ctx, sta_id);
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
135 spin_lock_irqsave(&priv->sta_lock, flags);
136 priv->stations[sta_id].lq = link_cmd;
137 spin_unlock_irqrestore(&priv->sta_lock, flags);
138
139 return 0;
140}
141
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
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,
161 .data = { wep_cmd, },
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
189 cmd.len[0] = cmd_size;
190
191 if (not_empty || send_if_empty)
192 return trans_send_cmd(&priv->trans, &cmd);
193 else
194 return 0;
195}
196
197int iwl_restore_default_wep_keys(struct iwl_priv *priv,
198 struct iwl_rxon_context *ctx)
199{
200 lockdep_assert_held(&priv->mutex);
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
211 lockdep_assert_held(&priv->mutex);
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
235 lockdep_assert_held(&priv->mutex);
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
243 keyconf->hw_key_idx = IWLAGN_HW_KEY_DEFAULT;
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
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 */
270
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 }
300
301 return sta_id;
302}
303
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)
308{
309 unsigned long flags;
310 __le16 key_flags;
311 struct iwl_addsta_cmd sta_cmd;
312 int i;
313
314 spin_lock_irqsave(&priv->sta_lock, flags);
315 memcpy(&sta_cmd, &priv->stations[sta_id].sta, sizeof(sta_cmd));
316 spin_unlock_irqrestore(&priv->sta_lock, flags);
317
318 key_flags = cpu_to_le16(keyconf->keyidx << STA_KEY_FLG_KEYID_POS);
319 key_flags |= STA_KEY_FLG_MAP_KEY_MSK;
320
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 }
344
345 if (!(keyconf->flags & IEEE80211_KEY_FLAG_PAIRWISE))
346 key_flags |= STA_KEY_MULTICAST_MSK;
347
348 /* key pointer (offset) */
349 sta_cmd.key.key_offset = keyconf->hw_key_idx;
350
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;
354
355 return iwl_send_add_sta(priv, &sta_cmd, cmd_flags);
356}
357
358void iwl_update_tkip_key(struct iwl_priv *priv,
359 struct ieee80211_vif *vif,
360 struct ieee80211_key_conf *keyconf,
361 struct ieee80211_sta *sta, u32 iv32, u16 *phase1key)
362{
363 u8 sta_id = iwlagn_key_sta_id(priv, vif, sta);
364
365 if (sta_id == IWL_INVALID_STATION)
366 return;
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
374 iwlagn_send_sta_key(priv, keyconf, sta_id,
375 iv32, phase1key, CMD_ASYNC);
376}
377
378int iwl_remove_dynamic_key(struct iwl_priv *priv,
379 struct iwl_rxon_context *ctx,
380 struct ieee80211_key_conf *keyconf,
381 struct ieee80211_sta *sta)
382{
383 unsigned long flags;
384 struct iwl_addsta_cmd sta_cmd;
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
391 spin_lock_irqsave(&priv->sta_lock, flags);
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;
395 spin_unlock_irqrestore(&priv->sta_lock, flags);
396
397 if (sta_id == IWL_INVALID_STATION)
398 return 0;
399
400 lockdep_assert_held(&priv->mutex);
401
402 ctx->key_mapping_keys--;
403
404 IWL_DEBUG_WEP(priv, "Remove dynamic key: idx=%d sta=%d\n",
405 keyconf->keyidx, sta_id);
406
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);
410
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;
415
416 return iwl_send_add_sta(priv, &sta_cmd, CMD_SYNC);
417}
418
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)
423{
424 struct ieee80211_key_seq seq;
425 u16 p1k[5];
426 int ret;
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;
432
433 lockdep_assert_held(&priv->mutex);
434
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
439 ctx->key_mapping_keys++;
440
441 switch (keyconf->cipher) {
442 case WLAN_CIPHER_SUITE_TKIP:
443 if (sta)
444 addr = sta->addr;
445 else /* station mode case only */
446 addr = ctx->active.bssid_addr;
447
448 /* pre-fill phase 1 key into device cache */
449 ieee80211_get_key_rx_seq(keyconf, 0, &seq);
450 ieee80211_get_tkip_rx_p1k(keyconf, addr, seq.tkip.iv32, p1k);
451 ret = iwlagn_send_sta_key(priv, keyconf, sta_id,
452 seq.tkip.iv32, p1k, CMD_SYNC);
453 break;
454 case WLAN_CIPHER_SUITE_CCMP:
455 case WLAN_CIPHER_SUITE_WEP40:
456 case WLAN_CIPHER_SUITE_WEP104:
457 ret = iwlagn_send_sta_key(priv, keyconf, sta_id,
458 0, NULL, CMD_SYNC);
459 break;
460 default:
461 IWL_ERR(priv, "Unknown cipher %x\n", keyconf->cipher);
462 ret = -EINVAL;
463 }
464
465 if (ret) {
466 ctx->key_mapping_keys--;
467 clear_bit(keyconf->hw_key_idx, &priv->ucode_key_table);
468 }
469
470 IWL_DEBUG_WEP(priv, "Set dynamic key: cipher=%x len=%d idx=%d sta=%pM ret=%d\n",
471 keyconf->cipher, keyconf->keylen, keyconf->keyidx,
472 sta ? sta->addr : NULL, ret);
473
474 return ret;
475}
476
477/**
478 * iwlagn_alloc_bcast_station - add broadcast station into driver's station table.
479 *
480 * This adds the broadcast station into the driver's station table
481 * and marks it driver active, so that it will be restored to the
482 * device at the next best time.
483 */
484int iwlagn_alloc_bcast_station(struct iwl_priv *priv,
485 struct iwl_rxon_context *ctx)
486{
487 struct iwl_link_quality_cmd *link_cmd;
488 unsigned long flags;
489 u8 sta_id;
490
491 spin_lock_irqsave(&priv->sta_lock, flags);
492 sta_id = iwl_prep_station(priv, ctx, iwl_bcast_addr, false, NULL);
493 if (sta_id == IWL_INVALID_STATION) {
494 IWL_ERR(priv, "Unable to prepare broadcast station\n");
495 spin_unlock_irqrestore(&priv->sta_lock, flags);
496
497 return -EINVAL;
498 }
499
500 priv->stations[sta_id].used |= IWL_STA_DRIVER_ACTIVE;
501 priv->stations[sta_id].used |= IWL_STA_BCAST;
502 spin_unlock_irqrestore(&priv->sta_lock, flags);
503
504 link_cmd = iwl_sta_alloc_lq(priv, ctx, sta_id);
505 if (!link_cmd) {
506 IWL_ERR(priv,
507 "Unable to initialize rate scaling for bcast station.\n");
508 return -ENOMEM;
509 }
510
511 spin_lock_irqsave(&priv->sta_lock, flags);
512 priv->stations[sta_id].lq = link_cmd;
513 spin_unlock_irqrestore(&priv->sta_lock, flags);
514
515 return 0;
516}
517
518/**
519 * iwl_update_bcast_station - update broadcast station's LQ command
520 *
521 * Only used by iwlagn. Placed here to have all bcast station management
522 * code together.
523 */
524int iwl_update_bcast_station(struct iwl_priv *priv,
525 struct iwl_rxon_context *ctx)
526{
527 unsigned long flags;
528 struct iwl_link_quality_cmd *link_cmd;
529 u8 sta_id = ctx->bcast_sta_id;
530
531 link_cmd = iwl_sta_alloc_lq(priv, ctx, sta_id);
532 if (!link_cmd) {
533 IWL_ERR(priv, "Unable to initialize rate scaling for bcast station.\n");
534 return -ENOMEM;
535 }
536
537 spin_lock_irqsave(&priv->sta_lock, flags);
538 if (priv->stations[sta_id].lq)
539 kfree(priv->stations[sta_id].lq);
540 else
541 IWL_DEBUG_INFO(priv, "Bcast station rate scaling has not been initialized yet.\n");
542 priv->stations[sta_id].lq = link_cmd;
543 spin_unlock_irqrestore(&priv->sta_lock, flags);
544
545 return 0;
546}
547
548int iwl_update_bcast_stations(struct iwl_priv *priv)
549{
550 struct iwl_rxon_context *ctx;
551 int ret = 0;
552
553 for_each_context(priv, ctx) {
554 ret = iwl_update_bcast_station(priv, ctx);
555 if (ret)
556 break;
557 }
558
559 return ret;
560}
561
562/**
563 * iwl_sta_tx_modify_enable_tid - Enable Tx for this TID in station table
564 */
565int iwl_sta_tx_modify_enable_tid(struct iwl_priv *priv, int sta_id, int tid)
566{
567 unsigned long flags;
568 struct iwl_addsta_cmd sta_cmd;
569
570 lockdep_assert_held(&priv->mutex);
571
572 /* Remove "disable" flag, to enable Tx for this TID */
573 spin_lock_irqsave(&priv->sta_lock, flags);
574 priv->stations[sta_id].sta.sta.modify_mask = STA_MODIFY_TID_DISABLE_TX;
575 priv->stations[sta_id].sta.tid_disable_tx &= cpu_to_le16(~(1 << tid));
576 priv->stations[sta_id].sta.mode = STA_CONTROL_MODIFY_MSK;
577 memcpy(&sta_cmd, &priv->stations[sta_id].sta, sizeof(struct iwl_addsta_cmd));
578 spin_unlock_irqrestore(&priv->sta_lock, flags);
579
580 return iwl_send_add_sta(priv, &sta_cmd, CMD_SYNC);
581}
582
583int iwl_sta_rx_agg_start(struct iwl_priv *priv, struct ieee80211_sta *sta,
584 int tid, u16 ssn)
585{
586 unsigned long flags;
587 int sta_id;
588 struct iwl_addsta_cmd sta_cmd;
589
590 lockdep_assert_held(&priv->mutex);
591
592 sta_id = iwl_sta_id(sta);
593 if (sta_id == IWL_INVALID_STATION)
594 return -ENXIO;
595
596 spin_lock_irqsave(&priv->sta_lock, flags);
597 priv->stations[sta_id].sta.station_flags_msk = 0;
598 priv->stations[sta_id].sta.sta.modify_mask = STA_MODIFY_ADDBA_TID_MSK;
599 priv->stations[sta_id].sta.add_immediate_ba_tid = (u8)tid;
600 priv->stations[sta_id].sta.add_immediate_ba_ssn = cpu_to_le16(ssn);
601 priv->stations[sta_id].sta.mode = STA_CONTROL_MODIFY_MSK;
602 memcpy(&sta_cmd, &priv->stations[sta_id].sta, sizeof(struct iwl_addsta_cmd));
603 spin_unlock_irqrestore(&priv->sta_lock, flags);
604
605 return iwl_send_add_sta(priv, &sta_cmd, CMD_SYNC);
606}
607
608int iwl_sta_rx_agg_stop(struct iwl_priv *priv, struct ieee80211_sta *sta,
609 int tid)
610{
611 unsigned long flags;
612 int sta_id;
613 struct iwl_addsta_cmd sta_cmd;
614
615 lockdep_assert_held(&priv->mutex);
616
617 sta_id = iwl_sta_id(sta);
618 if (sta_id == IWL_INVALID_STATION) {
619 IWL_ERR(priv, "Invalid station for AGG tid %d\n", tid);
620 return -ENXIO;
621 }
622
623 spin_lock_irqsave(&priv->sta_lock, flags);
624 priv->stations[sta_id].sta.station_flags_msk = 0;
625 priv->stations[sta_id].sta.sta.modify_mask = STA_MODIFY_DELBA_TID_MSK;
626 priv->stations[sta_id].sta.remove_immediate_ba_tid = (u8)tid;
627 priv->stations[sta_id].sta.mode = STA_CONTROL_MODIFY_MSK;
628 memcpy(&sta_cmd, &priv->stations[sta_id].sta, sizeof(struct iwl_addsta_cmd));
629 spin_unlock_irqrestore(&priv->sta_lock, flags);
630
631 return iwl_send_add_sta(priv, &sta_cmd, CMD_SYNC);
632}
633
634static void iwl_sta_modify_ps_wake(struct iwl_priv *priv, int sta_id)
635{
636 unsigned long flags;
637
638 spin_lock_irqsave(&priv->sta_lock, flags);
639 priv->stations[sta_id].sta.station_flags &= ~STA_FLG_PWR_SAVE_MSK;
640 priv->stations[sta_id].sta.station_flags_msk = STA_FLG_PWR_SAVE_MSK;
641 priv->stations[sta_id].sta.sta.modify_mask = 0;
642 priv->stations[sta_id].sta.sleep_tx_count = 0;
643 priv->stations[sta_id].sta.mode = STA_CONTROL_MODIFY_MSK;
644 iwl_send_add_sta(priv, &priv->stations[sta_id].sta, CMD_ASYNC);
645 spin_unlock_irqrestore(&priv->sta_lock, flags);
646
647}
648
649void iwl_sta_modify_sleep_tx_count(struct iwl_priv *priv, int sta_id, int cnt)
650{
651 unsigned long flags;
652
653 spin_lock_irqsave(&priv->sta_lock, flags);
654 priv->stations[sta_id].sta.station_flags |= STA_FLG_PWR_SAVE_MSK;
655 priv->stations[sta_id].sta.station_flags_msk = STA_FLG_PWR_SAVE_MSK;
656 priv->stations[sta_id].sta.sta.modify_mask =
657 STA_MODIFY_SLEEP_TX_COUNT_MSK;
658 priv->stations[sta_id].sta.sleep_tx_count = cpu_to_le16(cnt);
659 priv->stations[sta_id].sta.mode = STA_CONTROL_MODIFY_MSK;
660 iwl_send_add_sta(priv, &priv->stations[sta_id].sta, CMD_ASYNC);
661 spin_unlock_irqrestore(&priv->sta_lock, flags);
662
663}
664
665void iwlagn_mac_sta_notify(struct ieee80211_hw *hw,
666 struct ieee80211_vif *vif,
667 enum sta_notify_cmd cmd,
668 struct ieee80211_sta *sta)
669{
670 struct iwl_priv *priv = hw->priv;
671 struct iwl_station_priv *sta_priv = (void *)sta->drv_priv;
672 int sta_id;
673
674 switch (cmd) {
675 case STA_NOTIFY_SLEEP:
676 WARN_ON(!sta_priv->client);
677 sta_priv->asleep = true;
678 if (atomic_read(&sta_priv->pending_frames) > 0)
679 ieee80211_sta_block_awake(hw, sta, true);
680 break;
681 case STA_NOTIFY_AWAKE:
682 WARN_ON(!sta_priv->client);
683 if (!sta_priv->asleep)
684 break;
685 sta_priv->asleep = false;
686 sta_id = iwl_sta_id(sta);
687 if (sta_id != IWL_INVALID_STATION)
688 iwl_sta_modify_ps_wake(priv, sta_id);
689 break;
690 default:
691 break;
692 }
693}
generated by cgit v1.2.2 (git 2.25.0) at 2025-03-21 14:12:59 -0400