1 /******************************************************************************
3 * Copyright(c) 2003 - 2012 Intel Corporation. All rights reserved.
5 * Portions of this file are derived from the ipw3945 project, as well
6 * as portions of the ieee80211 subsystem header files.
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.
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
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
21 * The full GNU General Public License is included in this distribution in the
22 * file called LICENSE.
24 * Contact Information:
25 * Intel Linux Wireless <ilw@linux.intel.com>
26 * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
28 *****************************************************************************/
30 #include <net/mac80211.h>
35 #include "iwl-trans.h"
37 static int iwl_sta_ucode_activate(struct iwl_priv
*priv
, u8 sta_id
)
39 lockdep_assert_held(&priv
->sta_lock
);
41 if (sta_id
>= IWLAGN_STATION_COUNT
) {
42 IWL_ERR(priv
, "invalid sta_id %u", sta_id
);
45 if (!(priv
->stations
[sta_id
].used
& IWL_STA_DRIVER_ACTIVE
))
46 IWL_ERR(priv
, "ACTIVATE a non DRIVER active station id %u "
48 sta_id
, priv
->stations
[sta_id
].sta
.sta
.addr
);
50 if (priv
->stations
[sta_id
].used
& IWL_STA_UCODE_ACTIVE
) {
52 "STA id %u addr %pM already present in uCode "
53 "(according to driver)\n",
54 sta_id
, priv
->stations
[sta_id
].sta
.sta
.addr
);
56 priv
->stations
[sta_id
].used
|= IWL_STA_UCODE_ACTIVE
;
57 IWL_DEBUG_ASSOC(priv
, "Added STA id %u addr %pM to uCode\n",
58 sta_id
, priv
->stations
[sta_id
].sta
.sta
.addr
);
63 static int iwl_process_add_sta_resp(struct iwl_priv
*priv
,
64 struct iwl_addsta_cmd
*addsta
,
65 struct iwl_rx_packet
*pkt
)
67 u8 sta_id
= addsta
->sta
.sta_id
;
70 if (pkt
->hdr
.flags
& IWL_CMD_FAILED_MSK
) {
71 IWL_ERR(priv
, "Bad return from REPLY_ADD_STA (0x%08X)\n",
76 IWL_DEBUG_INFO(priv
, "Processing response for adding station %u\n",
79 spin_lock(&priv
->sta_lock
);
81 switch (pkt
->u
.add_sta
.status
) {
82 case ADD_STA_SUCCESS_MSK
:
83 IWL_DEBUG_INFO(priv
, "REPLY_ADD_STA PASSED\n");
84 ret
= iwl_sta_ucode_activate(priv
, sta_id
);
86 case ADD_STA_NO_ROOM_IN_TABLE
:
87 IWL_ERR(priv
, "Adding station %d failed, no room in table.\n",
90 case ADD_STA_NO_BLOCK_ACK_RESOURCE
:
91 IWL_ERR(priv
, "Adding station %d failed, no block ack "
92 "resource.\n", sta_id
);
94 case ADD_STA_MODIFY_NON_EXIST_STA
:
95 IWL_ERR(priv
, "Attempting to modify non-existing station %d\n",
99 IWL_DEBUG_ASSOC(priv
, "Received REPLY_ADD_STA:(0x%08X)\n",
100 pkt
->u
.add_sta
.status
);
104 IWL_DEBUG_INFO(priv
, "%s station id %u addr %pM\n",
105 priv
->stations
[sta_id
].sta
.mode
==
106 STA_CONTROL_MODIFY_MSK
? "Modified" : "Added",
107 sta_id
, priv
->stations
[sta_id
].sta
.sta
.addr
);
110 * XXX: The MAC address in the command buffer is often changed from
111 * the original sent to the device. That is, the MAC address
112 * written to the command buffer often is not the same MAC address
113 * read from the command buffer when the command returns. This
114 * issue has not yet been resolved and this debugging is left to
115 * observe the problem.
117 IWL_DEBUG_INFO(priv
, "%s station according to cmd buffer %pM\n",
118 priv
->stations
[sta_id
].sta
.mode
==
119 STA_CONTROL_MODIFY_MSK
? "Modified" : "Added",
121 spin_unlock(&priv
->sta_lock
);
126 int iwl_add_sta_callback(struct iwl_priv
*priv
, struct iwl_rx_mem_buffer
*rxb
,
127 struct iwl_device_cmd
*cmd
)
129 struct iwl_rx_packet
*pkt
= rxb_addr(rxb
);
130 struct iwl_addsta_cmd
*addsta
=
131 (struct iwl_addsta_cmd
*) cmd
->payload
;
133 return iwl_process_add_sta_resp(priv
, addsta
, pkt
);
136 int iwl_send_add_sta(struct iwl_priv
*priv
,
137 struct iwl_addsta_cmd
*sta
, u8 flags
)
140 struct iwl_host_cmd cmd
= {
144 .len
= { sizeof(*sta
), },
146 u8 sta_id __maybe_unused
= sta
->sta
.sta_id
;
148 IWL_DEBUG_INFO(priv
, "Adding sta %u (%pM) %ssynchronously\n",
149 sta_id
, sta
->sta
.addr
, flags
& CMD_ASYNC
? "a" : "");
151 if (!(flags
& CMD_ASYNC
)) {
152 cmd
.flags
|= CMD_WANT_SKB
;
156 ret
= iwl_trans_send_cmd(trans(priv
), &cmd
);
158 if (ret
|| (flags
& CMD_ASYNC
))
160 /*else the command was successfully sent in SYNC mode, need to free
163 iwl_free_pages(priv
->shrd
, cmd
.reply_page
);
165 if (cmd
.handler_status
)
166 IWL_ERR(priv
, "%s - error in the CMD response %d", __func__
,
169 return cmd
.handler_status
;
172 static void iwl_set_ht_add_station(struct iwl_priv
*priv
, u8 index
,
173 struct ieee80211_sta
*sta
,
174 struct iwl_rxon_context
*ctx
)
176 struct ieee80211_sta_ht_cap
*sta_ht_inf
= &sta
->ht_cap
;
180 if (!sta
|| !sta_ht_inf
->ht_supported
)
183 mimo_ps_mode
= (sta_ht_inf
->cap
& IEEE80211_HT_CAP_SM_PS
) >> 2;
184 IWL_DEBUG_ASSOC(priv
, "spatial multiplexing power save mode: %s\n",
185 (mimo_ps_mode
== WLAN_HT_CAP_SM_PS_STATIC
) ?
187 (mimo_ps_mode
== WLAN_HT_CAP_SM_PS_DYNAMIC
) ?
188 "dynamic" : "disabled");
190 sta_flags
= priv
->stations
[index
].sta
.station_flags
;
192 sta_flags
&= ~(STA_FLG_RTS_MIMO_PROT_MSK
| STA_FLG_MIMO_DIS_MSK
);
194 switch (mimo_ps_mode
) {
195 case WLAN_HT_CAP_SM_PS_STATIC
:
196 sta_flags
|= STA_FLG_MIMO_DIS_MSK
;
198 case WLAN_HT_CAP_SM_PS_DYNAMIC
:
199 sta_flags
|= STA_FLG_RTS_MIMO_PROT_MSK
;
201 case WLAN_HT_CAP_SM_PS_DISABLED
:
204 IWL_WARN(priv
, "Invalid MIMO PS mode %d\n", mimo_ps_mode
);
208 sta_flags
|= cpu_to_le32(
209 (u32
)sta_ht_inf
->ampdu_factor
<< STA_FLG_MAX_AGG_SIZE_POS
);
211 sta_flags
|= cpu_to_le32(
212 (u32
)sta_ht_inf
->ampdu_density
<< STA_FLG_AGG_MPDU_DENSITY_POS
);
214 if (iwl_is_ht40_tx_allowed(priv
, ctx
, &sta
->ht_cap
))
215 sta_flags
|= STA_FLG_HT40_EN_MSK
;
217 sta_flags
&= ~STA_FLG_HT40_EN_MSK
;
219 priv
->stations
[index
].sta
.station_flags
= sta_flags
;
225 * iwl_prep_station - Prepare station information for addition
227 * should be called with sta_lock held
229 u8
iwl_prep_station(struct iwl_priv
*priv
, struct iwl_rxon_context
*ctx
,
230 const u8
*addr
, bool is_ap
, struct ieee80211_sta
*sta
)
232 struct iwl_station_entry
*station
;
234 u8 sta_id
= IWL_INVALID_STATION
;
237 sta_id
= ctx
->ap_sta_id
;
238 else if (is_broadcast_ether_addr(addr
))
239 sta_id
= ctx
->bcast_sta_id
;
241 for (i
= IWL_STA_ID
; i
< IWLAGN_STATION_COUNT
; i
++) {
242 if (!compare_ether_addr(priv
->stations
[i
].sta
.sta
.addr
,
248 if (!priv
->stations
[i
].used
&&
249 sta_id
== IWL_INVALID_STATION
)
254 * These two conditions have the same outcome, but keep them
257 if (unlikely(sta_id
== IWL_INVALID_STATION
))
261 * uCode is not able to deal with multiple requests to add a
262 * station. Keep track if one is in progress so that we do not send
265 if (priv
->stations
[sta_id
].used
& IWL_STA_UCODE_INPROGRESS
) {
266 IWL_DEBUG_INFO(priv
, "STA %d already in process of being "
271 if ((priv
->stations
[sta_id
].used
& IWL_STA_DRIVER_ACTIVE
) &&
272 (priv
->stations
[sta_id
].used
& IWL_STA_UCODE_ACTIVE
) &&
273 !compare_ether_addr(priv
->stations
[sta_id
].sta
.sta
.addr
, addr
)) {
274 IWL_DEBUG_ASSOC(priv
, "STA %d (%pM) already added, not "
275 "adding again.\n", sta_id
, addr
);
279 station
= &priv
->stations
[sta_id
];
280 station
->used
= IWL_STA_DRIVER_ACTIVE
;
281 IWL_DEBUG_ASSOC(priv
, "Add STA to driver ID %d: %pM\n",
283 priv
->num_stations
++;
285 /* Set up the REPLY_ADD_STA command to send to device */
286 memset(&station
->sta
, 0, sizeof(struct iwl_addsta_cmd
));
287 memcpy(station
->sta
.sta
.addr
, addr
, ETH_ALEN
);
288 station
->sta
.mode
= 0;
289 station
->sta
.sta
.sta_id
= sta_id
;
290 station
->sta
.station_flags
= ctx
->station_flags
;
291 station
->ctxid
= ctx
->ctxid
;
294 struct iwl_station_priv
*sta_priv
;
296 sta_priv
= (void *)sta
->drv_priv
;
301 * OK to call unconditionally, since local stations (IBSS BSSID
302 * STA and broadcast STA) pass in a NULL sta, and mac80211
303 * doesn't allow HT IBSS.
305 iwl_set_ht_add_station(priv
, sta_id
, sta
, ctx
);
311 #define STA_WAIT_TIMEOUT (HZ/2)
314 * iwl_add_station_common -
316 int iwl_add_station_common(struct iwl_priv
*priv
, struct iwl_rxon_context
*ctx
,
317 const u8
*addr
, bool is_ap
,
318 struct ieee80211_sta
*sta
, u8
*sta_id_r
)
322 struct iwl_addsta_cmd sta_cmd
;
325 spin_lock_bh(&priv
->sta_lock
);
326 sta_id
= iwl_prep_station(priv
, ctx
, addr
, is_ap
, sta
);
327 if (sta_id
== IWL_INVALID_STATION
) {
328 IWL_ERR(priv
, "Unable to prepare station %pM for addition\n",
330 spin_unlock_bh(&priv
->sta_lock
);
335 * uCode is not able to deal with multiple requests to add a
336 * station. Keep track if one is in progress so that we do not send
339 if (priv
->stations
[sta_id
].used
& IWL_STA_UCODE_INPROGRESS
) {
340 IWL_DEBUG_INFO(priv
, "STA %d already in process of being "
342 spin_unlock_bh(&priv
->sta_lock
);
346 if ((priv
->stations
[sta_id
].used
& IWL_STA_DRIVER_ACTIVE
) &&
347 (priv
->stations
[sta_id
].used
& IWL_STA_UCODE_ACTIVE
)) {
348 IWL_DEBUG_ASSOC(priv
, "STA %d (%pM) already added, not "
349 "adding again.\n", sta_id
, addr
);
350 spin_unlock_bh(&priv
->sta_lock
);
354 priv
->stations
[sta_id
].used
|= IWL_STA_UCODE_INPROGRESS
;
355 memcpy(&sta_cmd
, &priv
->stations
[sta_id
].sta
,
356 sizeof(struct iwl_addsta_cmd
));
357 spin_unlock_bh(&priv
->sta_lock
);
359 /* Add station to device's station table */
360 ret
= iwl_send_add_sta(priv
, &sta_cmd
, CMD_SYNC
);
362 spin_lock_bh(&priv
->sta_lock
);
363 IWL_ERR(priv
, "Adding station %pM failed.\n",
364 priv
->stations
[sta_id
].sta
.sta
.addr
);
365 priv
->stations
[sta_id
].used
&= ~IWL_STA_DRIVER_ACTIVE
;
366 priv
->stations
[sta_id
].used
&= ~IWL_STA_UCODE_INPROGRESS
;
367 spin_unlock_bh(&priv
->sta_lock
);
374 * iwl_sta_ucode_deactivate - deactivate ucode status for a station
376 static void iwl_sta_ucode_deactivate(struct iwl_priv
*priv
, u8 sta_id
)
378 lockdep_assert_held(&priv
->sta_lock
);
380 /* Ucode must be active and driver must be non active */
381 if ((priv
->stations
[sta_id
].used
&
382 (IWL_STA_UCODE_ACTIVE
| IWL_STA_DRIVER_ACTIVE
)) !=
383 IWL_STA_UCODE_ACTIVE
)
384 IWL_ERR(priv
, "removed non active STA %u\n", sta_id
);
386 priv
->stations
[sta_id
].used
&= ~IWL_STA_UCODE_ACTIVE
;
388 memset(&priv
->stations
[sta_id
], 0, sizeof(struct iwl_station_entry
));
389 IWL_DEBUG_ASSOC(priv
, "Removed STA %u\n", sta_id
);
392 static int iwl_send_remove_station(struct iwl_priv
*priv
,
393 const u8
*addr
, int sta_id
,
396 struct iwl_rx_packet
*pkt
;
398 struct iwl_rem_sta_cmd rm_sta_cmd
;
400 struct iwl_host_cmd cmd
= {
401 .id
= REPLY_REMOVE_STA
,
402 .len
= { sizeof(struct iwl_rem_sta_cmd
), },
404 .data
= { &rm_sta_cmd
, },
407 memset(&rm_sta_cmd
, 0, sizeof(rm_sta_cmd
));
408 rm_sta_cmd
.num_sta
= 1;
409 memcpy(&rm_sta_cmd
.addr
, addr
, ETH_ALEN
);
411 cmd
.flags
|= CMD_WANT_SKB
;
413 ret
= iwl_trans_send_cmd(trans(priv
), &cmd
);
418 pkt
= (struct iwl_rx_packet
*)cmd
.reply_page
;
419 if (pkt
->hdr
.flags
& IWL_CMD_FAILED_MSK
) {
420 IWL_ERR(priv
, "Bad return from REPLY_REMOVE_STA (0x%08X)\n",
426 switch (pkt
->u
.rem_sta
.status
) {
427 case REM_STA_SUCCESS_MSK
:
429 spin_lock_bh(&priv
->sta_lock
);
430 iwl_sta_ucode_deactivate(priv
, sta_id
);
431 spin_unlock_bh(&priv
->sta_lock
);
433 IWL_DEBUG_ASSOC(priv
, "REPLY_REMOVE_STA PASSED\n");
437 IWL_ERR(priv
, "REPLY_REMOVE_STA failed\n");
441 iwl_free_pages(priv
->shrd
, cmd
.reply_page
);
447 * iwl_remove_station - Remove driver's knowledge of station.
449 int iwl_remove_station(struct iwl_priv
*priv
, const u8 sta_id
,
454 if (!iwl_is_ready(priv
->shrd
)) {
456 "Unable to remove station %pM, device not ready.\n",
459 * It is typical for stations to be removed when we are
460 * going down. Return success since device will be down
466 IWL_DEBUG_ASSOC(priv
, "Removing STA from driver:%d %pM\n",
469 if (WARN_ON(sta_id
== IWL_INVALID_STATION
))
472 spin_lock_bh(&priv
->sta_lock
);
474 if (!(priv
->stations
[sta_id
].used
& IWL_STA_DRIVER_ACTIVE
)) {
475 IWL_DEBUG_INFO(priv
, "Removing %pM but non DRIVER active\n",
480 if (!(priv
->stations
[sta_id
].used
& IWL_STA_UCODE_ACTIVE
)) {
481 IWL_DEBUG_INFO(priv
, "Removing %pM but non UCODE active\n",
486 if (priv
->stations
[sta_id
].used
& IWL_STA_LOCAL
) {
487 kfree(priv
->stations
[sta_id
].lq
);
488 priv
->stations
[sta_id
].lq
= NULL
;
491 for (tid
= 0; tid
< IWL_MAX_TID_COUNT
; tid
++)
492 memset(&priv
->tid_data
[sta_id
][tid
], 0,
493 sizeof(priv
->tid_data
[sta_id
][tid
]));
495 priv
->stations
[sta_id
].used
&= ~IWL_STA_DRIVER_ACTIVE
;
497 priv
->num_stations
--;
499 if (WARN_ON(priv
->num_stations
< 0))
500 priv
->num_stations
= 0;
502 spin_unlock_bh(&priv
->sta_lock
);
504 return iwl_send_remove_station(priv
, addr
, sta_id
, false);
506 spin_unlock_bh(&priv
->sta_lock
);
511 * iwl_clear_ucode_stations - clear ucode station table bits
513 * This function clears all the bits in the driver indicating
514 * which stations are active in the ucode. Call when something
515 * other than explicit station management would cause this in
516 * the ucode, e.g. unassociated RXON.
518 void iwl_clear_ucode_stations(struct iwl_priv
*priv
,
519 struct iwl_rxon_context
*ctx
)
522 bool cleared
= false;
524 IWL_DEBUG_INFO(priv
, "Clearing ucode stations in driver\n");
526 spin_lock_bh(&priv
->sta_lock
);
527 for (i
= 0; i
< IWLAGN_STATION_COUNT
; i
++) {
528 if (ctx
&& ctx
->ctxid
!= priv
->stations
[i
].ctxid
)
531 if (priv
->stations
[i
].used
& IWL_STA_UCODE_ACTIVE
) {
533 "Clearing ucode active for station %d\n", i
);
534 priv
->stations
[i
].used
&= ~IWL_STA_UCODE_ACTIVE
;
538 spin_unlock_bh(&priv
->sta_lock
);
542 "No active stations found to be cleared\n");
546 * iwl_restore_stations() - Restore driver known stations to device
548 * All stations considered active by driver, but not present in ucode, is
553 void iwl_restore_stations(struct iwl_priv
*priv
, struct iwl_rxon_context
*ctx
)
555 struct iwl_addsta_cmd sta_cmd
;
556 struct iwl_link_quality_cmd lq
;
562 if (!iwl_is_ready(priv
->shrd
)) {
564 "Not ready yet, not restoring any stations.\n");
568 IWL_DEBUG_ASSOC(priv
, "Restoring all known stations ... start.\n");
569 spin_lock_bh(&priv
->sta_lock
);
570 for (i
= 0; i
< IWLAGN_STATION_COUNT
; i
++) {
571 if (ctx
->ctxid
!= priv
->stations
[i
].ctxid
)
573 if ((priv
->stations
[i
].used
& IWL_STA_DRIVER_ACTIVE
) &&
574 !(priv
->stations
[i
].used
& IWL_STA_UCODE_ACTIVE
)) {
575 IWL_DEBUG_ASSOC(priv
, "Restoring sta %pM\n",
576 priv
->stations
[i
].sta
.sta
.addr
);
577 priv
->stations
[i
].sta
.mode
= 0;
578 priv
->stations
[i
].used
|= IWL_STA_UCODE_INPROGRESS
;
583 for (i
= 0; i
< IWLAGN_STATION_COUNT
; i
++) {
584 if ((priv
->stations
[i
].used
& IWL_STA_UCODE_INPROGRESS
)) {
585 memcpy(&sta_cmd
, &priv
->stations
[i
].sta
,
586 sizeof(struct iwl_addsta_cmd
));
588 if (priv
->stations
[i
].lq
) {
589 if (priv
->shrd
->wowlan
)
590 iwl_sta_fill_lq(priv
, ctx
, i
, &lq
);
592 memcpy(&lq
, priv
->stations
[i
].lq
,
593 sizeof(struct iwl_link_quality_cmd
));
596 spin_unlock_bh(&priv
->sta_lock
);
597 ret
= iwl_send_add_sta(priv
, &sta_cmd
, CMD_SYNC
);
599 spin_lock_bh(&priv
->sta_lock
);
600 IWL_ERR(priv
, "Adding station %pM failed.\n",
601 priv
->stations
[i
].sta
.sta
.addr
);
602 priv
->stations
[i
].used
&=
603 ~IWL_STA_DRIVER_ACTIVE
;
604 priv
->stations
[i
].used
&=
605 ~IWL_STA_UCODE_INPROGRESS
;
606 spin_unlock_bh(&priv
->sta_lock
);
609 * Rate scaling has already been initialized, send
613 iwl_send_lq_cmd(priv
, ctx
, &lq
,
615 spin_lock_bh(&priv
->sta_lock
);
616 priv
->stations
[i
].used
&= ~IWL_STA_UCODE_INPROGRESS
;
620 spin_unlock_bh(&priv
->sta_lock
);
622 IWL_DEBUG_INFO(priv
, "Restoring all known stations .... "
623 "no stations to be restored.\n");
625 IWL_DEBUG_INFO(priv
, "Restoring all known stations .... "
629 void iwl_reprogram_ap_sta(struct iwl_priv
*priv
, struct iwl_rxon_context
*ctx
)
631 int sta_id
= ctx
->ap_sta_id
;
633 struct iwl_addsta_cmd sta_cmd
;
634 struct iwl_link_quality_cmd lq
;
635 bool active
, have_lq
= false;
637 spin_lock_bh(&priv
->sta_lock
);
638 if (!(priv
->stations
[sta_id
].used
& IWL_STA_DRIVER_ACTIVE
)) {
639 spin_unlock_bh(&priv
->sta_lock
);
643 memcpy(&sta_cmd
, &priv
->stations
[sta_id
].sta
, sizeof(sta_cmd
));
645 if (priv
->stations
[sta_id
].lq
) {
646 memcpy(&lq
, priv
->stations
[sta_id
].lq
, sizeof(lq
));
650 active
= priv
->stations
[sta_id
].used
& IWL_STA_UCODE_ACTIVE
;
651 priv
->stations
[sta_id
].used
&= ~IWL_STA_DRIVER_ACTIVE
;
652 spin_unlock_bh(&priv
->sta_lock
);
655 ret
= iwl_send_remove_station(
656 priv
, priv
->stations
[sta_id
].sta
.sta
.addr
,
659 IWL_ERR(priv
, "failed to remove STA %pM (%d)\n",
660 priv
->stations
[sta_id
].sta
.sta
.addr
, ret
);
662 spin_lock_bh(&priv
->sta_lock
);
663 priv
->stations
[sta_id
].used
|= IWL_STA_DRIVER_ACTIVE
;
664 spin_unlock_bh(&priv
->sta_lock
);
666 ret
= iwl_send_add_sta(priv
, &sta_cmd
, CMD_SYNC
);
668 IWL_ERR(priv
, "failed to re-add STA %pM (%d)\n",
669 priv
->stations
[sta_id
].sta
.sta
.addr
, ret
);
671 iwl_send_lq_cmd(priv
, ctx
, &lq
, CMD_SYNC
, true);
674 int iwl_get_free_ucode_key_offset(struct iwl_priv
*priv
)
678 for (i
= 0; i
< priv
->sta_key_max_num
; i
++)
679 if (!test_and_set_bit(i
, &priv
->ucode_key_table
))
682 return WEP_INVALID_OFFSET
;
685 void iwl_dealloc_bcast_stations(struct iwl_priv
*priv
)
689 spin_lock_bh(&priv
->sta_lock
);
690 for (i
= 0; i
< IWLAGN_STATION_COUNT
; i
++) {
691 if (!(priv
->stations
[i
].used
& IWL_STA_BCAST
))
694 priv
->stations
[i
].used
&= ~IWL_STA_UCODE_ACTIVE
;
695 priv
->num_stations
--;
696 if (WARN_ON(priv
->num_stations
< 0))
697 priv
->num_stations
= 0;
698 kfree(priv
->stations
[i
].lq
);
699 priv
->stations
[i
].lq
= NULL
;
701 spin_unlock_bh(&priv
->sta_lock
);
704 #ifdef CONFIG_IWLWIFI_DEBUG
705 static void iwl_dump_lq_cmd(struct iwl_priv
*priv
,
706 struct iwl_link_quality_cmd
*lq
)
709 IWL_DEBUG_RATE(priv
, "lq station id 0x%x\n", lq
->sta_id
);
710 IWL_DEBUG_RATE(priv
, "lq ant 0x%X 0x%X\n",
711 lq
->general_params
.single_stream_ant_msk
,
712 lq
->general_params
.dual_stream_ant_msk
);
714 for (i
= 0; i
< LINK_QUAL_MAX_RETRY_NUM
; i
++)
715 IWL_DEBUG_RATE(priv
, "lq index %d 0x%X\n",
716 i
, lq
->rs_table
[i
].rate_n_flags
);
719 static inline void iwl_dump_lq_cmd(struct iwl_priv
*priv
,
720 struct iwl_link_quality_cmd
*lq
)
726 * is_lq_table_valid() - Test one aspect of LQ cmd for validity
728 * It sometimes happens when a HT rate has been in use and we
729 * loose connectivity with AP then mac80211 will first tell us that the
730 * current channel is not HT anymore before removing the station. In such a
731 * scenario the RXON flags will be updated to indicate we are not
732 * communicating HT anymore, but the LQ command may still contain HT rates.
733 * Test for this to prevent driver from sending LQ command between the time
734 * RXON flags are updated and when LQ command is updated.
736 static bool is_lq_table_valid(struct iwl_priv
*priv
,
737 struct iwl_rxon_context
*ctx
,
738 struct iwl_link_quality_cmd
*lq
)
745 IWL_DEBUG_INFO(priv
, "Channel %u is not an HT channel\n",
746 ctx
->active
.channel
);
747 for (i
= 0; i
< LINK_QUAL_MAX_RETRY_NUM
; i
++) {
748 if (le32_to_cpu(lq
->rs_table
[i
].rate_n_flags
) &
751 "index %d of LQ expects HT channel\n",
760 * iwl_send_lq_cmd() - Send link quality command
761 * @init: This command is sent as part of station initialization right
762 * after station has been added.
764 * The link quality command is sent as the last step of station creation.
765 * This is the special case in which init is set and we call a callback in
766 * this case to clear the state indicating that station creation is in
769 int iwl_send_lq_cmd(struct iwl_priv
*priv
, struct iwl_rxon_context
*ctx
,
770 struct iwl_link_quality_cmd
*lq
, u8 flags
, bool init
)
773 struct iwl_host_cmd cmd
= {
774 .id
= REPLY_TX_LINK_QUALITY_CMD
,
775 .len
= { sizeof(struct iwl_link_quality_cmd
), },
780 if (WARN_ON(lq
->sta_id
== IWL_INVALID_STATION
))
784 spin_lock_bh(&priv
->sta_lock
);
785 if (!(priv
->stations
[lq
->sta_id
].used
& IWL_STA_DRIVER_ACTIVE
)) {
786 spin_unlock_bh(&priv
->sta_lock
);
789 spin_unlock_bh(&priv
->sta_lock
);
791 iwl_dump_lq_cmd(priv
, lq
);
792 if (WARN_ON(init
&& (cmd
.flags
& CMD_ASYNC
)))
795 if (is_lq_table_valid(priv
, ctx
, lq
))
796 ret
= iwl_trans_send_cmd(trans(priv
), &cmd
);
800 if (cmd
.flags
& CMD_ASYNC
)
804 IWL_DEBUG_INFO(priv
, "init LQ command complete, "
805 "clearing sta addition status for sta %d\n",
807 spin_lock_bh(&priv
->sta_lock
);
808 priv
->stations
[lq
->sta_id
].used
&= ~IWL_STA_UCODE_INPROGRESS
;
809 spin_unlock_bh(&priv
->sta_lock
);
815 void iwl_sta_fill_lq(struct iwl_priv
*priv
, struct iwl_rxon_context
*ctx
,
816 u8 sta_id
, struct iwl_link_quality_cmd
*link_cmd
)
822 lockdep_assert_held(&priv
->shrd
->mutex
);
824 memset(link_cmd
, 0, sizeof(*link_cmd
));
826 /* Set up the rate scaling to start at selected rate, fall back
827 * all the way down to 1M in IEEE order, and then spin on 1M */
828 if (priv
->band
== IEEE80211_BAND_5GHZ
)
829 r
= IWL_RATE_6M_INDEX
;
830 else if (ctx
&& ctx
->vif
&& ctx
->vif
->p2p
)
831 r
= IWL_RATE_6M_INDEX
;
833 r
= IWL_RATE_1M_INDEX
;
835 if (r
>= IWL_FIRST_CCK_RATE
&& r
<= IWL_LAST_CCK_RATE
)
836 rate_flags
|= RATE_MCS_CCK_MSK
;
838 rate_flags
|= first_antenna(hw_params(priv
).valid_tx_ant
) <<
840 rate_n_flags
= iwl_hw_set_rate_n_flags(iwl_rates
[r
].plcp
, rate_flags
);
841 for (i
= 0; i
< LINK_QUAL_MAX_RETRY_NUM
; i
++)
842 link_cmd
->rs_table
[i
].rate_n_flags
= rate_n_flags
;
844 link_cmd
->general_params
.single_stream_ant_msk
=
845 first_antenna(hw_params(priv
).valid_tx_ant
);
847 link_cmd
->general_params
.dual_stream_ant_msk
=
848 hw_params(priv
).valid_tx_ant
&
849 ~first_antenna(hw_params(priv
).valid_tx_ant
);
850 if (!link_cmd
->general_params
.dual_stream_ant_msk
) {
851 link_cmd
->general_params
.dual_stream_ant_msk
= ANT_AB
;
852 } else if (num_of_ant(hw_params(priv
).valid_tx_ant
) == 2) {
853 link_cmd
->general_params
.dual_stream_ant_msk
=
854 hw_params(priv
).valid_tx_ant
;
857 link_cmd
->agg_params
.agg_dis_start_th
=
858 LINK_QUAL_AGG_DISABLE_START_DEF
;
859 link_cmd
->agg_params
.agg_time_limit
=
860 cpu_to_le16(LINK_QUAL_AGG_TIME_LIMIT_DEF
);
862 link_cmd
->sta_id
= sta_id
;
865 static struct iwl_link_quality_cmd
*
866 iwl_sta_alloc_lq(struct iwl_priv
*priv
, struct iwl_rxon_context
*ctx
,
869 struct iwl_link_quality_cmd
*link_cmd
;
871 link_cmd
= kzalloc(sizeof(struct iwl_link_quality_cmd
), GFP_KERNEL
);
873 IWL_ERR(priv
, "Unable to allocate memory for LQ cmd.\n");
877 iwl_sta_fill_lq(priv
, ctx
, sta_id
, link_cmd
);
883 * iwlagn_add_bssid_station - Add the special IBSS BSSID station
887 int iwlagn_add_bssid_station(struct iwl_priv
*priv
,
888 struct iwl_rxon_context
*ctx
,
889 const u8
*addr
, u8
*sta_id_r
)
893 struct iwl_link_quality_cmd
*link_cmd
;
896 *sta_id_r
= IWL_INVALID_STATION
;
898 ret
= iwl_add_station_common(priv
, ctx
, addr
, 0, NULL
, &sta_id
);
900 IWL_ERR(priv
, "Unable to add station %pM\n", addr
);
907 spin_lock_bh(&priv
->sta_lock
);
908 priv
->stations
[sta_id
].used
|= IWL_STA_LOCAL
;
909 spin_unlock_bh(&priv
->sta_lock
);
911 /* Set up default rate scaling table in device's station table */
912 link_cmd
= iwl_sta_alloc_lq(priv
, ctx
, sta_id
);
915 "Unable to initialize rate scaling for station %pM.\n",
920 ret
= iwl_send_lq_cmd(priv
, ctx
, link_cmd
, CMD_SYNC
, true);
922 IWL_ERR(priv
, "Link quality command failed (%d)\n", ret
);
924 spin_lock_bh(&priv
->sta_lock
);
925 priv
->stations
[sta_id
].lq
= link_cmd
;
926 spin_unlock_bh(&priv
->sta_lock
);
934 * For each context, the device has a table of 4 static WEP keys
935 * (one for each key index) that is updated with the following
939 static int iwl_send_static_wepkey_cmd(struct iwl_priv
*priv
,
940 struct iwl_rxon_context
*ctx
,
943 int i
, not_empty
= 0;
944 u8 buff
[sizeof(struct iwl_wep_cmd
) +
945 sizeof(struct iwl_wep_key
) * WEP_KEYS_MAX
];
946 struct iwl_wep_cmd
*wep_cmd
= (struct iwl_wep_cmd
*)buff
;
947 size_t cmd_size
= sizeof(struct iwl_wep_cmd
);
948 struct iwl_host_cmd cmd
= {
949 .id
= ctx
->wep_key_cmd
,
950 .data
= { wep_cmd
, },
956 memset(wep_cmd
, 0, cmd_size
+
957 (sizeof(struct iwl_wep_key
) * WEP_KEYS_MAX
));
959 for (i
= 0; i
< WEP_KEYS_MAX
; i
++) {
960 wep_cmd
->key
[i
].key_index
= i
;
961 if (ctx
->wep_keys
[i
].key_size
) {
962 wep_cmd
->key
[i
].key_offset
= i
;
965 wep_cmd
->key
[i
].key_offset
= WEP_INVALID_OFFSET
;
968 wep_cmd
->key
[i
].key_size
= ctx
->wep_keys
[i
].key_size
;
969 memcpy(&wep_cmd
->key
[i
].key
[3], ctx
->wep_keys
[i
].key
,
970 ctx
->wep_keys
[i
].key_size
);
973 wep_cmd
->global_key_type
= WEP_KEY_WEP_TYPE
;
974 wep_cmd
->num_keys
= WEP_KEYS_MAX
;
976 cmd_size
+= sizeof(struct iwl_wep_key
) * WEP_KEYS_MAX
;
978 cmd
.len
[0] = cmd_size
;
980 if (not_empty
|| send_if_empty
)
981 return iwl_trans_send_cmd(trans(priv
), &cmd
);
986 int iwl_restore_default_wep_keys(struct iwl_priv
*priv
,
987 struct iwl_rxon_context
*ctx
)
989 lockdep_assert_held(&priv
->shrd
->mutex
);
991 return iwl_send_static_wepkey_cmd(priv
, ctx
, false);
994 int iwl_remove_default_wep_key(struct iwl_priv
*priv
,
995 struct iwl_rxon_context
*ctx
,
996 struct ieee80211_key_conf
*keyconf
)
1000 lockdep_assert_held(&priv
->shrd
->mutex
);
1002 IWL_DEBUG_WEP(priv
, "Removing default WEP key: idx=%d\n",
1005 memset(&ctx
->wep_keys
[keyconf
->keyidx
], 0, sizeof(ctx
->wep_keys
[0]));
1006 if (iwl_is_rfkill(priv
->shrd
)) {
1008 "Not sending REPLY_WEPKEY command due to RFKILL.\n");
1009 /* but keys in device are clear anyway so return success */
1012 ret
= iwl_send_static_wepkey_cmd(priv
, ctx
, 1);
1013 IWL_DEBUG_WEP(priv
, "Remove default WEP key: idx=%d ret=%d\n",
1014 keyconf
->keyidx
, ret
);
1019 int iwl_set_default_wep_key(struct iwl_priv
*priv
,
1020 struct iwl_rxon_context
*ctx
,
1021 struct ieee80211_key_conf
*keyconf
)
1025 lockdep_assert_held(&priv
->shrd
->mutex
);
1027 if (keyconf
->keylen
!= WEP_KEY_LEN_128
&&
1028 keyconf
->keylen
!= WEP_KEY_LEN_64
) {
1030 "Bad WEP key length %d\n", keyconf
->keylen
);
1034 keyconf
->hw_key_idx
= IWLAGN_HW_KEY_DEFAULT
;
1036 ctx
->wep_keys
[keyconf
->keyidx
].key_size
= keyconf
->keylen
;
1037 memcpy(&ctx
->wep_keys
[keyconf
->keyidx
].key
, &keyconf
->key
,
1040 ret
= iwl_send_static_wepkey_cmd(priv
, ctx
, false);
1041 IWL_DEBUG_WEP(priv
, "Set default WEP key: len=%d idx=%d ret=%d\n",
1042 keyconf
->keylen
, keyconf
->keyidx
, ret
);
1048 * dynamic (per-station) keys
1050 * The dynamic keys are a little more complicated. The device has
1051 * a key cache of up to STA_KEY_MAX_NUM/STA_KEY_MAX_NUM_PAN keys.
1052 * These are linked to stations by a table that contains an index
1053 * into the key table for each station/key index/{mcast,unicast},
1054 * i.e. it's basically an array of pointers like this:
1055 * key_offset_t key_mapping[NUM_STATIONS][4][2];
1056 * (it really works differently, but you can think of it as such)
1058 * The key uploading and linking happens in the same command, the
1059 * add station command with STA_MODIFY_KEY_MASK.
1062 static u8
iwlagn_key_sta_id(struct iwl_priv
*priv
,
1063 struct ieee80211_vif
*vif
,
1064 struct ieee80211_sta
*sta
)
1066 struct iwl_vif_priv
*vif_priv
= (void *)vif
->drv_priv
;
1069 return iwl_sta_id(sta
);
1072 * The device expects GTKs for station interfaces to be
1073 * installed as GTKs for the AP station. If we have no
1074 * station ID, then use the ap_sta_id in that case.
1076 if (vif
->type
== NL80211_IFTYPE_STATION
&& vif_priv
->ctx
)
1077 return vif_priv
->ctx
->ap_sta_id
;
1079 return IWL_INVALID_STATION
;
1082 static int iwlagn_send_sta_key(struct iwl_priv
*priv
,
1083 struct ieee80211_key_conf
*keyconf
,
1084 u8 sta_id
, u32 tkip_iv32
, u16
*tkip_p1k
,
1088 struct iwl_addsta_cmd sta_cmd
;
1091 spin_lock_bh(&priv
->sta_lock
);
1092 memcpy(&sta_cmd
, &priv
->stations
[sta_id
].sta
, sizeof(sta_cmd
));
1093 spin_unlock_bh(&priv
->sta_lock
);
1095 key_flags
= cpu_to_le16(keyconf
->keyidx
<< STA_KEY_FLG_KEYID_POS
);
1096 key_flags
|= STA_KEY_FLG_MAP_KEY_MSK
;
1098 switch (keyconf
->cipher
) {
1099 case WLAN_CIPHER_SUITE_CCMP
:
1100 key_flags
|= STA_KEY_FLG_CCMP
;
1101 memcpy(sta_cmd
.key
.key
, keyconf
->key
, keyconf
->keylen
);
1103 case WLAN_CIPHER_SUITE_TKIP
:
1104 key_flags
|= STA_KEY_FLG_TKIP
;
1105 sta_cmd
.key
.tkip_rx_tsc_byte2
= tkip_iv32
;
1106 for (i
= 0; i
< 5; i
++)
1107 sta_cmd
.key
.tkip_rx_ttak
[i
] = cpu_to_le16(tkip_p1k
[i
]);
1108 memcpy(sta_cmd
.key
.key
, keyconf
->key
, keyconf
->keylen
);
1110 case WLAN_CIPHER_SUITE_WEP104
:
1111 key_flags
|= STA_KEY_FLG_KEY_SIZE_MSK
;
1113 case WLAN_CIPHER_SUITE_WEP40
:
1114 key_flags
|= STA_KEY_FLG_WEP
;
1115 memcpy(&sta_cmd
.key
.key
[3], keyconf
->key
, keyconf
->keylen
);
1122 if (!(keyconf
->flags
& IEEE80211_KEY_FLAG_PAIRWISE
))
1123 key_flags
|= STA_KEY_MULTICAST_MSK
;
1125 /* key pointer (offset) */
1126 sta_cmd
.key
.key_offset
= keyconf
->hw_key_idx
;
1128 sta_cmd
.key
.key_flags
= key_flags
;
1129 sta_cmd
.mode
= STA_CONTROL_MODIFY_MSK
;
1130 sta_cmd
.sta
.modify_mask
= STA_MODIFY_KEY_MASK
;
1132 return iwl_send_add_sta(priv
, &sta_cmd
, cmd_flags
);
1135 void iwl_update_tkip_key(struct iwl_priv
*priv
,
1136 struct ieee80211_vif
*vif
,
1137 struct ieee80211_key_conf
*keyconf
,
1138 struct ieee80211_sta
*sta
, u32 iv32
, u16
*phase1key
)
1140 u8 sta_id
= iwlagn_key_sta_id(priv
, vif
, sta
);
1142 if (sta_id
== IWL_INVALID_STATION
)
1145 if (iwl_scan_cancel(priv
)) {
1146 /* cancel scan failed, just live w/ bad key and rely
1147 briefly on SW decryption */
1151 iwlagn_send_sta_key(priv
, keyconf
, sta_id
,
1152 iv32
, phase1key
, CMD_ASYNC
);
1155 int iwl_remove_dynamic_key(struct iwl_priv
*priv
,
1156 struct iwl_rxon_context
*ctx
,
1157 struct ieee80211_key_conf
*keyconf
,
1158 struct ieee80211_sta
*sta
)
1160 struct iwl_addsta_cmd sta_cmd
;
1161 u8 sta_id
= iwlagn_key_sta_id(priv
, ctx
->vif
, sta
);
1164 /* if station isn't there, neither is the key */
1165 if (sta_id
== IWL_INVALID_STATION
)
1168 spin_lock_bh(&priv
->sta_lock
);
1169 memcpy(&sta_cmd
, &priv
->stations
[sta_id
].sta
, sizeof(sta_cmd
));
1170 if (!(priv
->stations
[sta_id
].used
& IWL_STA_UCODE_ACTIVE
))
1171 sta_id
= IWL_INVALID_STATION
;
1172 spin_unlock_bh(&priv
->sta_lock
);
1174 if (sta_id
== IWL_INVALID_STATION
)
1177 lockdep_assert_held(&priv
->shrd
->mutex
);
1179 ctx
->key_mapping_keys
--;
1181 IWL_DEBUG_WEP(priv
, "Remove dynamic key: idx=%d sta=%d\n",
1182 keyconf
->keyidx
, sta_id
);
1184 if (!test_and_clear_bit(keyconf
->hw_key_idx
, &priv
->ucode_key_table
))
1185 IWL_ERR(priv
, "offset %d not used in uCode key table.\n",
1186 keyconf
->hw_key_idx
);
1188 key_flags
= cpu_to_le16(keyconf
->keyidx
<< STA_KEY_FLG_KEYID_POS
);
1189 key_flags
|= STA_KEY_FLG_MAP_KEY_MSK
| STA_KEY_FLG_NO_ENC
|
1190 STA_KEY_FLG_INVALID
;
1192 if (!(keyconf
->flags
& IEEE80211_KEY_FLAG_PAIRWISE
))
1193 key_flags
|= STA_KEY_MULTICAST_MSK
;
1195 sta_cmd
.key
.key_flags
= key_flags
;
1196 sta_cmd
.key
.key_offset
= WEP_INVALID_OFFSET
;
1197 sta_cmd
.sta
.modify_mask
= STA_MODIFY_KEY_MASK
;
1198 sta_cmd
.mode
= STA_CONTROL_MODIFY_MSK
;
1200 return iwl_send_add_sta(priv
, &sta_cmd
, CMD_SYNC
);
1203 int iwl_set_dynamic_key(struct iwl_priv
*priv
,
1204 struct iwl_rxon_context
*ctx
,
1205 struct ieee80211_key_conf
*keyconf
,
1206 struct ieee80211_sta
*sta
)
1208 struct ieee80211_key_seq seq
;
1211 u8 sta_id
= iwlagn_key_sta_id(priv
, ctx
->vif
, sta
);
1214 if (sta_id
== IWL_INVALID_STATION
)
1217 lockdep_assert_held(&priv
->shrd
->mutex
);
1219 keyconf
->hw_key_idx
= iwl_get_free_ucode_key_offset(priv
);
1220 if (keyconf
->hw_key_idx
== WEP_INVALID_OFFSET
)
1223 ctx
->key_mapping_keys
++;
1225 switch (keyconf
->cipher
) {
1226 case WLAN_CIPHER_SUITE_TKIP
:
1229 else /* station mode case only */
1230 addr
= ctx
->active
.bssid_addr
;
1232 /* pre-fill phase 1 key into device cache */
1233 ieee80211_get_key_rx_seq(keyconf
, 0, &seq
);
1234 ieee80211_get_tkip_rx_p1k(keyconf
, addr
, seq
.tkip
.iv32
, p1k
);
1235 ret
= iwlagn_send_sta_key(priv
, keyconf
, sta_id
,
1236 seq
.tkip
.iv32
, p1k
, CMD_SYNC
);
1238 case WLAN_CIPHER_SUITE_CCMP
:
1239 case WLAN_CIPHER_SUITE_WEP40
:
1240 case WLAN_CIPHER_SUITE_WEP104
:
1241 ret
= iwlagn_send_sta_key(priv
, keyconf
, sta_id
,
1245 IWL_ERR(priv
, "Unknown cipher %x\n", keyconf
->cipher
);
1250 ctx
->key_mapping_keys
--;
1251 clear_bit(keyconf
->hw_key_idx
, &priv
->ucode_key_table
);
1254 IWL_DEBUG_WEP(priv
, "Set dynamic key: cipher=%x len=%d idx=%d sta=%pM ret=%d\n",
1255 keyconf
->cipher
, keyconf
->keylen
, keyconf
->keyidx
,
1256 sta
? sta
->addr
: NULL
, ret
);
1262 * iwlagn_alloc_bcast_station - add broadcast station into driver's station table.
1264 * This adds the broadcast station into the driver's station table
1265 * and marks it driver active, so that it will be restored to the
1266 * device at the next best time.
1268 int iwlagn_alloc_bcast_station(struct iwl_priv
*priv
,
1269 struct iwl_rxon_context
*ctx
)
1271 struct iwl_link_quality_cmd
*link_cmd
;
1274 spin_lock_bh(&priv
->sta_lock
);
1275 sta_id
= iwl_prep_station(priv
, ctx
, iwl_bcast_addr
, false, NULL
);
1276 if (sta_id
== IWL_INVALID_STATION
) {
1277 IWL_ERR(priv
, "Unable to prepare broadcast station\n");
1278 spin_unlock_bh(&priv
->sta_lock
);
1283 priv
->stations
[sta_id
].used
|= IWL_STA_DRIVER_ACTIVE
;
1284 priv
->stations
[sta_id
].used
|= IWL_STA_BCAST
;
1285 spin_unlock_bh(&priv
->sta_lock
);
1287 link_cmd
= iwl_sta_alloc_lq(priv
, ctx
, sta_id
);
1290 "Unable to initialize rate scaling for bcast station.\n");
1294 spin_lock_bh(&priv
->sta_lock
);
1295 priv
->stations
[sta_id
].lq
= link_cmd
;
1296 spin_unlock_bh(&priv
->sta_lock
);
1302 * iwl_update_bcast_station - update broadcast station's LQ command
1304 * Only used by iwlagn. Placed here to have all bcast station management
1307 int iwl_update_bcast_station(struct iwl_priv
*priv
,
1308 struct iwl_rxon_context
*ctx
)
1310 struct iwl_link_quality_cmd
*link_cmd
;
1311 u8 sta_id
= ctx
->bcast_sta_id
;
1313 link_cmd
= iwl_sta_alloc_lq(priv
, ctx
, sta_id
);
1315 IWL_ERR(priv
, "Unable to initialize rate scaling for bcast station.\n");
1319 spin_lock_bh(&priv
->sta_lock
);
1320 if (priv
->stations
[sta_id
].lq
)
1321 kfree(priv
->stations
[sta_id
].lq
);
1323 IWL_DEBUG_INFO(priv
, "Bcast station rate scaling has not been initialized yet.\n");
1324 priv
->stations
[sta_id
].lq
= link_cmd
;
1325 spin_unlock_bh(&priv
->sta_lock
);
1330 int iwl_update_bcast_stations(struct iwl_priv
*priv
)
1332 struct iwl_rxon_context
*ctx
;
1335 for_each_context(priv
, ctx
) {
1336 ret
= iwl_update_bcast_station(priv
, ctx
);
1345 * iwl_sta_tx_modify_enable_tid - Enable Tx for this TID in station table
1347 int iwl_sta_tx_modify_enable_tid(struct iwl_priv
*priv
, int sta_id
, int tid
)
1349 struct iwl_addsta_cmd sta_cmd
;
1351 lockdep_assert_held(&priv
->shrd
->mutex
);
1353 /* Remove "disable" flag, to enable Tx for this TID */
1354 spin_lock_bh(&priv
->sta_lock
);
1355 priv
->stations
[sta_id
].sta
.sta
.modify_mask
= STA_MODIFY_TID_DISABLE_TX
;
1356 priv
->stations
[sta_id
].sta
.tid_disable_tx
&= cpu_to_le16(~(1 << tid
));
1357 priv
->stations
[sta_id
].sta
.mode
= STA_CONTROL_MODIFY_MSK
;
1358 memcpy(&sta_cmd
, &priv
->stations
[sta_id
].sta
, sizeof(struct iwl_addsta_cmd
));
1359 spin_unlock_bh(&priv
->sta_lock
);
1361 return iwl_send_add_sta(priv
, &sta_cmd
, CMD_SYNC
);
1364 int iwl_sta_rx_agg_start(struct iwl_priv
*priv
, struct ieee80211_sta
*sta
,
1368 struct iwl_addsta_cmd sta_cmd
;
1370 lockdep_assert_held(&priv
->shrd
->mutex
);
1372 sta_id
= iwl_sta_id(sta
);
1373 if (sta_id
== IWL_INVALID_STATION
)
1376 spin_lock_bh(&priv
->sta_lock
);
1377 priv
->stations
[sta_id
].sta
.station_flags_msk
= 0;
1378 priv
->stations
[sta_id
].sta
.sta
.modify_mask
= STA_MODIFY_ADDBA_TID_MSK
;
1379 priv
->stations
[sta_id
].sta
.add_immediate_ba_tid
= (u8
)tid
;
1380 priv
->stations
[sta_id
].sta
.add_immediate_ba_ssn
= cpu_to_le16(ssn
);
1381 priv
->stations
[sta_id
].sta
.mode
= STA_CONTROL_MODIFY_MSK
;
1382 memcpy(&sta_cmd
, &priv
->stations
[sta_id
].sta
, sizeof(struct iwl_addsta_cmd
));
1383 spin_unlock_bh(&priv
->sta_lock
);
1385 return iwl_send_add_sta(priv
, &sta_cmd
, CMD_SYNC
);
1388 int iwl_sta_rx_agg_stop(struct iwl_priv
*priv
, struct ieee80211_sta
*sta
,
1392 struct iwl_addsta_cmd sta_cmd
;
1394 lockdep_assert_held(&priv
->shrd
->mutex
);
1396 sta_id
= iwl_sta_id(sta
);
1397 if (sta_id
== IWL_INVALID_STATION
) {
1398 IWL_ERR(priv
, "Invalid station for AGG tid %d\n", tid
);
1402 spin_lock_bh(&priv
->sta_lock
);
1403 priv
->stations
[sta_id
].sta
.station_flags_msk
= 0;
1404 priv
->stations
[sta_id
].sta
.sta
.modify_mask
= STA_MODIFY_DELBA_TID_MSK
;
1405 priv
->stations
[sta_id
].sta
.remove_immediate_ba_tid
= (u8
)tid
;
1406 priv
->stations
[sta_id
].sta
.mode
= STA_CONTROL_MODIFY_MSK
;
1407 memcpy(&sta_cmd
, &priv
->stations
[sta_id
].sta
, sizeof(struct iwl_addsta_cmd
));
1408 spin_unlock_bh(&priv
->sta_lock
);
1410 return iwl_send_add_sta(priv
, &sta_cmd
, CMD_SYNC
);
1415 void iwl_sta_modify_sleep_tx_count(struct iwl_priv
*priv
, int sta_id
, int cnt
)
1417 struct iwl_addsta_cmd cmd
= {
1418 .mode
= STA_CONTROL_MODIFY_MSK
,
1419 .station_flags
= STA_FLG_PWR_SAVE_MSK
,
1420 .station_flags_msk
= STA_FLG_PWR_SAVE_MSK
,
1421 .sta
.sta_id
= sta_id
,
1422 .sta
.modify_mask
= STA_MODIFY_SLEEP_TX_COUNT_MSK
,
1423 .sleep_tx_count
= cpu_to_le16(cnt
),
1426 iwl_send_add_sta(priv
, &cmd
, CMD_ASYNC
);