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 /* priv->shrd->sta_lock must be held */
38 static int iwl_sta_ucode_activate(struct iwl_priv
*priv
, u8 sta_id
)
40 if (sta_id
>= IWLAGN_STATION_COUNT
) {
41 IWL_ERR(priv
, "invalid sta_id %u", sta_id
);
44 if (!(priv
->stations
[sta_id
].used
& IWL_STA_DRIVER_ACTIVE
))
45 IWL_ERR(priv
, "ACTIVATE a non DRIVER active station id %u "
47 sta_id
, priv
->stations
[sta_id
].sta
.sta
.addr
);
49 if (priv
->stations
[sta_id
].used
& IWL_STA_UCODE_ACTIVE
) {
51 "STA id %u addr %pM already present in uCode "
52 "(according to driver)\n",
53 sta_id
, priv
->stations
[sta_id
].sta
.sta
.addr
);
55 priv
->stations
[sta_id
].used
|= IWL_STA_UCODE_ACTIVE
;
56 IWL_DEBUG_ASSOC(priv
, "Added STA id %u addr %pM to uCode\n",
57 sta_id
, priv
->stations
[sta_id
].sta
.sta
.addr
);
62 static int iwl_process_add_sta_resp(struct iwl_priv
*priv
,
63 struct iwl_addsta_cmd
*addsta
,
64 struct iwl_rx_packet
*pkt
)
66 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_irqsave(&priv
->shrd
->sta_lock
, flags
);
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_irqrestore(&priv
->shrd
->sta_lock
, flags
);
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
)
320 unsigned long flags_spin
;
323 struct iwl_addsta_cmd sta_cmd
;
326 spin_lock_irqsave(&priv
->shrd
->sta_lock
, flags_spin
);
327 sta_id
= iwl_prep_station(priv
, ctx
, addr
, is_ap
, sta
);
328 if (sta_id
== IWL_INVALID_STATION
) {
329 IWL_ERR(priv
, "Unable to prepare station %pM for addition\n",
331 spin_unlock_irqrestore(&priv
->shrd
->sta_lock
, flags_spin
);
336 * uCode is not able to deal with multiple requests to add a
337 * station. Keep track if one is in progress so that we do not send
340 if (priv
->stations
[sta_id
].used
& IWL_STA_UCODE_INPROGRESS
) {
341 IWL_DEBUG_INFO(priv
, "STA %d already in process of being "
343 spin_unlock_irqrestore(&priv
->shrd
->sta_lock
, flags_spin
);
347 if ((priv
->stations
[sta_id
].used
& IWL_STA_DRIVER_ACTIVE
) &&
348 (priv
->stations
[sta_id
].used
& IWL_STA_UCODE_ACTIVE
)) {
349 IWL_DEBUG_ASSOC(priv
, "STA %d (%pM) already added, not "
350 "adding again.\n", sta_id
, addr
);
351 spin_unlock_irqrestore(&priv
->shrd
->sta_lock
, flags_spin
);
355 priv
->stations
[sta_id
].used
|= IWL_STA_UCODE_INPROGRESS
;
356 memcpy(&sta_cmd
, &priv
->stations
[sta_id
].sta
,
357 sizeof(struct iwl_addsta_cmd
));
358 spin_unlock_irqrestore(&priv
->shrd
->sta_lock
, flags_spin
);
360 /* Add station to device's station table */
361 ret
= iwl_send_add_sta(priv
, &sta_cmd
, CMD_SYNC
);
363 spin_lock_irqsave(&priv
->shrd
->sta_lock
, flags_spin
);
364 IWL_ERR(priv
, "Adding station %pM failed.\n",
365 priv
->stations
[sta_id
].sta
.sta
.addr
);
366 priv
->stations
[sta_id
].used
&= ~IWL_STA_DRIVER_ACTIVE
;
367 priv
->stations
[sta_id
].used
&= ~IWL_STA_UCODE_INPROGRESS
;
368 spin_unlock_irqrestore(&priv
->shrd
->sta_lock
, flags_spin
);
375 * iwl_sta_ucode_deactivate - deactivate ucode status for a station
377 * priv->shrd->sta_lock must be held
379 static void iwl_sta_ucode_deactivate(struct iwl_priv
*priv
, u8 sta_id
)
381 /* Ucode must be active and driver must be non active */
382 if ((priv
->stations
[sta_id
].used
&
383 (IWL_STA_UCODE_ACTIVE
| IWL_STA_DRIVER_ACTIVE
)) !=
384 IWL_STA_UCODE_ACTIVE
)
385 IWL_ERR(priv
, "removed non active STA %u\n", sta_id
);
387 priv
->stations
[sta_id
].used
&= ~IWL_STA_UCODE_ACTIVE
;
389 memset(&priv
->stations
[sta_id
], 0, sizeof(struct iwl_station_entry
));
390 IWL_DEBUG_ASSOC(priv
, "Removed STA %u\n", sta_id
);
393 static int iwl_send_remove_station(struct iwl_priv
*priv
,
394 const u8
*addr
, int sta_id
,
397 struct iwl_rx_packet
*pkt
;
400 unsigned long flags_spin
;
401 struct iwl_rem_sta_cmd rm_sta_cmd
;
403 struct iwl_host_cmd cmd
= {
404 .id
= REPLY_REMOVE_STA
,
405 .len
= { sizeof(struct iwl_rem_sta_cmd
), },
407 .data
= { &rm_sta_cmd
, },
410 memset(&rm_sta_cmd
, 0, sizeof(rm_sta_cmd
));
411 rm_sta_cmd
.num_sta
= 1;
412 memcpy(&rm_sta_cmd
.addr
, addr
, ETH_ALEN
);
414 cmd
.flags
|= CMD_WANT_SKB
;
416 ret
= iwl_trans_send_cmd(trans(priv
), &cmd
);
421 pkt
= (struct iwl_rx_packet
*)cmd
.reply_page
;
422 if (pkt
->hdr
.flags
& IWL_CMD_FAILED_MSK
) {
423 IWL_ERR(priv
, "Bad return from REPLY_REMOVE_STA (0x%08X)\n",
429 switch (pkt
->u
.rem_sta
.status
) {
430 case REM_STA_SUCCESS_MSK
:
432 spin_lock_irqsave(&priv
->shrd
->sta_lock
,
434 iwl_sta_ucode_deactivate(priv
, sta_id
);
435 spin_unlock_irqrestore(&priv
->shrd
->sta_lock
,
438 IWL_DEBUG_ASSOC(priv
, "REPLY_REMOVE_STA PASSED\n");
442 IWL_ERR(priv
, "REPLY_REMOVE_STA failed\n");
446 iwl_free_pages(priv
->shrd
, cmd
.reply_page
);
452 * iwl_remove_station - Remove driver's knowledge of station.
454 int iwl_remove_station(struct iwl_priv
*priv
, const u8 sta_id
,
460 if (!iwl_is_ready(priv
->shrd
)) {
462 "Unable to remove station %pM, device not ready.\n",
465 * It is typical for stations to be removed when we are
466 * going down. Return success since device will be down
472 IWL_DEBUG_ASSOC(priv
, "Removing STA from driver:%d %pM\n",
475 if (WARN_ON(sta_id
== IWL_INVALID_STATION
))
478 spin_lock_irqsave(&priv
->shrd
->sta_lock
, flags
);
480 if (!(priv
->stations
[sta_id
].used
& IWL_STA_DRIVER_ACTIVE
)) {
481 IWL_DEBUG_INFO(priv
, "Removing %pM but non DRIVER active\n",
486 if (!(priv
->stations
[sta_id
].used
& IWL_STA_UCODE_ACTIVE
)) {
487 IWL_DEBUG_INFO(priv
, "Removing %pM but non UCODE active\n",
492 if (priv
->stations
[sta_id
].used
& IWL_STA_LOCAL
) {
493 kfree(priv
->stations
[sta_id
].lq
);
494 priv
->stations
[sta_id
].lq
= NULL
;
497 for (tid
= 0; tid
< IWL_MAX_TID_COUNT
; tid
++)
498 memset(&priv
->tid_data
[sta_id
][tid
], 0,
499 sizeof(priv
->tid_data
[sta_id
][tid
]));
501 priv
->stations
[sta_id
].used
&= ~IWL_STA_DRIVER_ACTIVE
;
503 priv
->num_stations
--;
505 if (WARN_ON(priv
->num_stations
< 0))
506 priv
->num_stations
= 0;
508 spin_unlock_irqrestore(&priv
->shrd
->sta_lock
, flags
);
510 return iwl_send_remove_station(priv
, addr
, sta_id
, false);
512 spin_unlock_irqrestore(&priv
->shrd
->sta_lock
, flags
);
517 * iwl_clear_ucode_stations - clear ucode station table bits
519 * This function clears all the bits in the driver indicating
520 * which stations are active in the ucode. Call when something
521 * other than explicit station management would cause this in
522 * the ucode, e.g. unassociated RXON.
524 void iwl_clear_ucode_stations(struct iwl_priv
*priv
,
525 struct iwl_rxon_context
*ctx
)
528 unsigned long flags_spin
;
529 bool cleared
= false;
531 IWL_DEBUG_INFO(priv
, "Clearing ucode stations in driver\n");
533 spin_lock_irqsave(&priv
->shrd
->sta_lock
, flags_spin
);
534 for (i
= 0; i
< IWLAGN_STATION_COUNT
; i
++) {
535 if (ctx
&& ctx
->ctxid
!= priv
->stations
[i
].ctxid
)
538 if (priv
->stations
[i
].used
& IWL_STA_UCODE_ACTIVE
) {
540 "Clearing ucode active for station %d\n", i
);
541 priv
->stations
[i
].used
&= ~IWL_STA_UCODE_ACTIVE
;
545 spin_unlock_irqrestore(&priv
->shrd
->sta_lock
, flags_spin
);
549 "No active stations found to be cleared\n");
553 * iwl_restore_stations() - Restore driver known stations to device
555 * All stations considered active by driver, but not present in ucode, is
560 void iwl_restore_stations(struct iwl_priv
*priv
, struct iwl_rxon_context
*ctx
)
562 struct iwl_addsta_cmd sta_cmd
;
563 struct iwl_link_quality_cmd lq
;
564 unsigned long flags_spin
;
570 if (!iwl_is_ready(priv
->shrd
)) {
572 "Not ready yet, not restoring any stations.\n");
576 IWL_DEBUG_ASSOC(priv
, "Restoring all known stations ... start.\n");
577 spin_lock_irqsave(&priv
->shrd
->sta_lock
, flags_spin
);
578 for (i
= 0; i
< IWLAGN_STATION_COUNT
; i
++) {
579 if (ctx
->ctxid
!= priv
->stations
[i
].ctxid
)
581 if ((priv
->stations
[i
].used
& IWL_STA_DRIVER_ACTIVE
) &&
582 !(priv
->stations
[i
].used
& IWL_STA_UCODE_ACTIVE
)) {
583 IWL_DEBUG_ASSOC(priv
, "Restoring sta %pM\n",
584 priv
->stations
[i
].sta
.sta
.addr
);
585 priv
->stations
[i
].sta
.mode
= 0;
586 priv
->stations
[i
].used
|= IWL_STA_UCODE_INPROGRESS
;
591 for (i
= 0; i
< IWLAGN_STATION_COUNT
; i
++) {
592 if ((priv
->stations
[i
].used
& IWL_STA_UCODE_INPROGRESS
)) {
593 memcpy(&sta_cmd
, &priv
->stations
[i
].sta
,
594 sizeof(struct iwl_addsta_cmd
));
596 if (priv
->stations
[i
].lq
) {
597 if (priv
->shrd
->wowlan
)
598 iwl_sta_fill_lq(priv
, ctx
, i
, &lq
);
600 memcpy(&lq
, priv
->stations
[i
].lq
,
601 sizeof(struct iwl_link_quality_cmd
));
604 spin_unlock_irqrestore(&priv
->shrd
->sta_lock
,
606 ret
= iwl_send_add_sta(priv
, &sta_cmd
, CMD_SYNC
);
608 spin_lock_irqsave(&priv
->shrd
->sta_lock
,
610 IWL_ERR(priv
, "Adding station %pM failed.\n",
611 priv
->stations
[i
].sta
.sta
.addr
);
612 priv
->stations
[i
].used
&=
613 ~IWL_STA_DRIVER_ACTIVE
;
614 priv
->stations
[i
].used
&=
615 ~IWL_STA_UCODE_INPROGRESS
;
616 spin_unlock_irqrestore(&priv
->shrd
->sta_lock
,
620 * Rate scaling has already been initialized, send
624 iwl_send_lq_cmd(priv
, ctx
, &lq
,
626 spin_lock_irqsave(&priv
->shrd
->sta_lock
, flags_spin
);
627 priv
->stations
[i
].used
&= ~IWL_STA_UCODE_INPROGRESS
;
631 spin_unlock_irqrestore(&priv
->shrd
->sta_lock
, flags_spin
);
633 IWL_DEBUG_INFO(priv
, "Restoring all known stations .... "
634 "no stations to be restored.\n");
636 IWL_DEBUG_INFO(priv
, "Restoring all known stations .... "
640 void iwl_reprogram_ap_sta(struct iwl_priv
*priv
, struct iwl_rxon_context
*ctx
)
643 int sta_id
= ctx
->ap_sta_id
;
645 struct iwl_addsta_cmd sta_cmd
;
646 struct iwl_link_quality_cmd lq
;
647 bool active
, have_lq
= false;
649 spin_lock_irqsave(&priv
->shrd
->sta_lock
, flags
);
650 if (!(priv
->stations
[sta_id
].used
& IWL_STA_DRIVER_ACTIVE
)) {
651 spin_unlock_irqrestore(&priv
->shrd
->sta_lock
, flags
);
655 memcpy(&sta_cmd
, &priv
->stations
[sta_id
].sta
, sizeof(sta_cmd
));
657 if (priv
->stations
[sta_id
].lq
) {
658 memcpy(&lq
, priv
->stations
[sta_id
].lq
, sizeof(lq
));
662 active
= priv
->stations
[sta_id
].used
& IWL_STA_UCODE_ACTIVE
;
663 priv
->stations
[sta_id
].used
&= ~IWL_STA_DRIVER_ACTIVE
;
664 spin_unlock_irqrestore(&priv
->shrd
->sta_lock
, flags
);
667 ret
= iwl_send_remove_station(
668 priv
, priv
->stations
[sta_id
].sta
.sta
.addr
,
671 IWL_ERR(priv
, "failed to remove STA %pM (%d)\n",
672 priv
->stations
[sta_id
].sta
.sta
.addr
, ret
);
674 spin_lock_irqsave(&priv
->shrd
->sta_lock
, flags
);
675 priv
->stations
[sta_id
].used
|= IWL_STA_DRIVER_ACTIVE
;
676 spin_unlock_irqrestore(&priv
->shrd
->sta_lock
, flags
);
678 ret
= iwl_send_add_sta(priv
, &sta_cmd
, CMD_SYNC
);
680 IWL_ERR(priv
, "failed to re-add STA %pM (%d)\n",
681 priv
->stations
[sta_id
].sta
.sta
.addr
, ret
);
683 iwl_send_lq_cmd(priv
, ctx
, &lq
, CMD_SYNC
, true);
686 int iwl_get_free_ucode_key_offset(struct iwl_priv
*priv
)
690 for (i
= 0; i
< priv
->sta_key_max_num
; i
++)
691 if (!test_and_set_bit(i
, &priv
->ucode_key_table
))
694 return WEP_INVALID_OFFSET
;
697 void iwl_dealloc_bcast_stations(struct iwl_priv
*priv
)
702 spin_lock_irqsave(&priv
->shrd
->sta_lock
, flags
);
703 for (i
= 0; i
< IWLAGN_STATION_COUNT
; i
++) {
704 if (!(priv
->stations
[i
].used
& IWL_STA_BCAST
))
707 priv
->stations
[i
].used
&= ~IWL_STA_UCODE_ACTIVE
;
708 priv
->num_stations
--;
709 if (WARN_ON(priv
->num_stations
< 0))
710 priv
->num_stations
= 0;
711 kfree(priv
->stations
[i
].lq
);
712 priv
->stations
[i
].lq
= NULL
;
714 spin_unlock_irqrestore(&priv
->shrd
->sta_lock
, flags
);
717 #ifdef CONFIG_IWLWIFI_DEBUG
718 static void iwl_dump_lq_cmd(struct iwl_priv
*priv
,
719 struct iwl_link_quality_cmd
*lq
)
722 IWL_DEBUG_RATE(priv
, "lq station id 0x%x\n", lq
->sta_id
);
723 IWL_DEBUG_RATE(priv
, "lq ant 0x%X 0x%X\n",
724 lq
->general_params
.single_stream_ant_msk
,
725 lq
->general_params
.dual_stream_ant_msk
);
727 for (i
= 0; i
< LINK_QUAL_MAX_RETRY_NUM
; i
++)
728 IWL_DEBUG_RATE(priv
, "lq index %d 0x%X\n",
729 i
, lq
->rs_table
[i
].rate_n_flags
);
732 static inline void iwl_dump_lq_cmd(struct iwl_priv
*priv
,
733 struct iwl_link_quality_cmd
*lq
)
739 * is_lq_table_valid() - Test one aspect of LQ cmd for validity
741 * It sometimes happens when a HT rate has been in use and we
742 * loose connectivity with AP then mac80211 will first tell us that the
743 * current channel is not HT anymore before removing the station. In such a
744 * scenario the RXON flags will be updated to indicate we are not
745 * communicating HT anymore, but the LQ command may still contain HT rates.
746 * Test for this to prevent driver from sending LQ command between the time
747 * RXON flags are updated and when LQ command is updated.
749 static bool is_lq_table_valid(struct iwl_priv
*priv
,
750 struct iwl_rxon_context
*ctx
,
751 struct iwl_link_quality_cmd
*lq
)
758 IWL_DEBUG_INFO(priv
, "Channel %u is not an HT channel\n",
759 ctx
->active
.channel
);
760 for (i
= 0; i
< LINK_QUAL_MAX_RETRY_NUM
; i
++) {
761 if (le32_to_cpu(lq
->rs_table
[i
].rate_n_flags
) &
764 "index %d of LQ expects HT channel\n",
773 * iwl_send_lq_cmd() - Send link quality command
774 * @init: This command is sent as part of station initialization right
775 * after station has been added.
777 * The link quality command is sent as the last step of station creation.
778 * This is the special case in which init is set and we call a callback in
779 * this case to clear the state indicating that station creation is in
782 int iwl_send_lq_cmd(struct iwl_priv
*priv
, struct iwl_rxon_context
*ctx
,
783 struct iwl_link_quality_cmd
*lq
, u8 flags
, bool init
)
786 unsigned long flags_spin
;
788 struct iwl_host_cmd cmd
= {
789 .id
= REPLY_TX_LINK_QUALITY_CMD
,
790 .len
= { sizeof(struct iwl_link_quality_cmd
), },
795 if (WARN_ON(lq
->sta_id
== IWL_INVALID_STATION
))
799 spin_lock_irqsave(&priv
->shrd
->sta_lock
, flags_spin
);
800 if (!(priv
->stations
[lq
->sta_id
].used
& IWL_STA_DRIVER_ACTIVE
)) {
801 spin_unlock_irqrestore(&priv
->shrd
->sta_lock
, flags_spin
);
804 spin_unlock_irqrestore(&priv
->shrd
->sta_lock
, flags_spin
);
806 iwl_dump_lq_cmd(priv
, lq
);
807 if (WARN_ON(init
&& (cmd
.flags
& CMD_ASYNC
)))
810 if (is_lq_table_valid(priv
, ctx
, lq
))
811 ret
= iwl_trans_send_cmd(trans(priv
), &cmd
);
815 if (cmd
.flags
& CMD_ASYNC
)
819 IWL_DEBUG_INFO(priv
, "init LQ command complete, "
820 "clearing sta addition status for sta %d\n",
822 spin_lock_irqsave(&priv
->shrd
->sta_lock
, flags_spin
);
823 priv
->stations
[lq
->sta_id
].used
&= ~IWL_STA_UCODE_INPROGRESS
;
824 spin_unlock_irqrestore(&priv
->shrd
->sta_lock
, flags_spin
);
830 void iwl_sta_fill_lq(struct iwl_priv
*priv
, struct iwl_rxon_context
*ctx
,
831 u8 sta_id
, struct iwl_link_quality_cmd
*link_cmd
)
837 lockdep_assert_held(&priv
->shrd
->mutex
);
839 memset(link_cmd
, 0, sizeof(*link_cmd
));
841 /* Set up the rate scaling to start at selected rate, fall back
842 * all the way down to 1M in IEEE order, and then spin on 1M */
843 if (priv
->band
== IEEE80211_BAND_5GHZ
)
844 r
= IWL_RATE_6M_INDEX
;
845 else if (ctx
&& ctx
->vif
&& ctx
->vif
->p2p
)
846 r
= IWL_RATE_6M_INDEX
;
848 r
= IWL_RATE_1M_INDEX
;
850 if (r
>= IWL_FIRST_CCK_RATE
&& r
<= IWL_LAST_CCK_RATE
)
851 rate_flags
|= RATE_MCS_CCK_MSK
;
853 rate_flags
|= first_antenna(hw_params(priv
).valid_tx_ant
) <<
855 rate_n_flags
= iwl_hw_set_rate_n_flags(iwl_rates
[r
].plcp
, rate_flags
);
856 for (i
= 0; i
< LINK_QUAL_MAX_RETRY_NUM
; i
++)
857 link_cmd
->rs_table
[i
].rate_n_flags
= rate_n_flags
;
859 link_cmd
->general_params
.single_stream_ant_msk
=
860 first_antenna(hw_params(priv
).valid_tx_ant
);
862 link_cmd
->general_params
.dual_stream_ant_msk
=
863 hw_params(priv
).valid_tx_ant
&
864 ~first_antenna(hw_params(priv
).valid_tx_ant
);
865 if (!link_cmd
->general_params
.dual_stream_ant_msk
) {
866 link_cmd
->general_params
.dual_stream_ant_msk
= ANT_AB
;
867 } else if (num_of_ant(hw_params(priv
).valid_tx_ant
) == 2) {
868 link_cmd
->general_params
.dual_stream_ant_msk
=
869 hw_params(priv
).valid_tx_ant
;
872 link_cmd
->agg_params
.agg_dis_start_th
=
873 LINK_QUAL_AGG_DISABLE_START_DEF
;
874 link_cmd
->agg_params
.agg_time_limit
=
875 cpu_to_le16(LINK_QUAL_AGG_TIME_LIMIT_DEF
);
877 link_cmd
->sta_id
= sta_id
;
880 static struct iwl_link_quality_cmd
*
881 iwl_sta_alloc_lq(struct iwl_priv
*priv
, struct iwl_rxon_context
*ctx
,
884 struct iwl_link_quality_cmd
*link_cmd
;
886 link_cmd
= kzalloc(sizeof(struct iwl_link_quality_cmd
), GFP_KERNEL
);
888 IWL_ERR(priv
, "Unable to allocate memory for LQ cmd.\n");
892 iwl_sta_fill_lq(priv
, ctx
, sta_id
, link_cmd
);
898 * iwlagn_add_bssid_station - Add the special IBSS BSSID station
902 int iwlagn_add_bssid_station(struct iwl_priv
*priv
,
903 struct iwl_rxon_context
*ctx
,
904 const u8
*addr
, u8
*sta_id_r
)
908 struct iwl_link_quality_cmd
*link_cmd
;
912 *sta_id_r
= IWL_INVALID_STATION
;
914 ret
= iwl_add_station_common(priv
, ctx
, addr
, 0, NULL
, &sta_id
);
916 IWL_ERR(priv
, "Unable to add station %pM\n", addr
);
923 spin_lock_irqsave(&priv
->shrd
->sta_lock
, flags
);
924 priv
->stations
[sta_id
].used
|= IWL_STA_LOCAL
;
925 spin_unlock_irqrestore(&priv
->shrd
->sta_lock
, flags
);
927 /* Set up default rate scaling table in device's station table */
928 link_cmd
= iwl_sta_alloc_lq(priv
, ctx
, sta_id
);
931 "Unable to initialize rate scaling for station %pM.\n",
936 ret
= iwl_send_lq_cmd(priv
, ctx
, link_cmd
, CMD_SYNC
, true);
938 IWL_ERR(priv
, "Link quality command failed (%d)\n", ret
);
940 spin_lock_irqsave(&priv
->shrd
->sta_lock
, flags
);
941 priv
->stations
[sta_id
].lq
= link_cmd
;
942 spin_unlock_irqrestore(&priv
->shrd
->sta_lock
, flags
);
950 * For each context, the device has a table of 4 static WEP keys
951 * (one for each key index) that is updated with the following
955 static int iwl_send_static_wepkey_cmd(struct iwl_priv
*priv
,
956 struct iwl_rxon_context
*ctx
,
959 int i
, not_empty
= 0;
960 u8 buff
[sizeof(struct iwl_wep_cmd
) +
961 sizeof(struct iwl_wep_key
) * WEP_KEYS_MAX
];
962 struct iwl_wep_cmd
*wep_cmd
= (struct iwl_wep_cmd
*)buff
;
963 size_t cmd_size
= sizeof(struct iwl_wep_cmd
);
964 struct iwl_host_cmd cmd
= {
965 .id
= ctx
->wep_key_cmd
,
966 .data
= { wep_cmd
, },
972 memset(wep_cmd
, 0, cmd_size
+
973 (sizeof(struct iwl_wep_key
) * WEP_KEYS_MAX
));
975 for (i
= 0; i
< WEP_KEYS_MAX
; i
++) {
976 wep_cmd
->key
[i
].key_index
= i
;
977 if (ctx
->wep_keys
[i
].key_size
) {
978 wep_cmd
->key
[i
].key_offset
= i
;
981 wep_cmd
->key
[i
].key_offset
= WEP_INVALID_OFFSET
;
984 wep_cmd
->key
[i
].key_size
= ctx
->wep_keys
[i
].key_size
;
985 memcpy(&wep_cmd
->key
[i
].key
[3], ctx
->wep_keys
[i
].key
,
986 ctx
->wep_keys
[i
].key_size
);
989 wep_cmd
->global_key_type
= WEP_KEY_WEP_TYPE
;
990 wep_cmd
->num_keys
= WEP_KEYS_MAX
;
992 cmd_size
+= sizeof(struct iwl_wep_key
) * WEP_KEYS_MAX
;
994 cmd
.len
[0] = cmd_size
;
996 if (not_empty
|| send_if_empty
)
997 return iwl_trans_send_cmd(trans(priv
), &cmd
);
1002 int iwl_restore_default_wep_keys(struct iwl_priv
*priv
,
1003 struct iwl_rxon_context
*ctx
)
1005 lockdep_assert_held(&priv
->shrd
->mutex
);
1007 return iwl_send_static_wepkey_cmd(priv
, ctx
, false);
1010 int iwl_remove_default_wep_key(struct iwl_priv
*priv
,
1011 struct iwl_rxon_context
*ctx
,
1012 struct ieee80211_key_conf
*keyconf
)
1016 lockdep_assert_held(&priv
->shrd
->mutex
);
1018 IWL_DEBUG_WEP(priv
, "Removing default WEP key: idx=%d\n",
1021 memset(&ctx
->wep_keys
[keyconf
->keyidx
], 0, sizeof(ctx
->wep_keys
[0]));
1022 if (iwl_is_rfkill(priv
->shrd
)) {
1024 "Not sending REPLY_WEPKEY command due to RFKILL.\n");
1025 /* but keys in device are clear anyway so return success */
1028 ret
= iwl_send_static_wepkey_cmd(priv
, ctx
, 1);
1029 IWL_DEBUG_WEP(priv
, "Remove default WEP key: idx=%d ret=%d\n",
1030 keyconf
->keyidx
, ret
);
1035 int iwl_set_default_wep_key(struct iwl_priv
*priv
,
1036 struct iwl_rxon_context
*ctx
,
1037 struct ieee80211_key_conf
*keyconf
)
1041 lockdep_assert_held(&priv
->shrd
->mutex
);
1043 if (keyconf
->keylen
!= WEP_KEY_LEN_128
&&
1044 keyconf
->keylen
!= WEP_KEY_LEN_64
) {
1046 "Bad WEP key length %d\n", keyconf
->keylen
);
1050 keyconf
->hw_key_idx
= IWLAGN_HW_KEY_DEFAULT
;
1052 ctx
->wep_keys
[keyconf
->keyidx
].key_size
= keyconf
->keylen
;
1053 memcpy(&ctx
->wep_keys
[keyconf
->keyidx
].key
, &keyconf
->key
,
1056 ret
= iwl_send_static_wepkey_cmd(priv
, ctx
, false);
1057 IWL_DEBUG_WEP(priv
, "Set default WEP key: len=%d idx=%d ret=%d\n",
1058 keyconf
->keylen
, keyconf
->keyidx
, ret
);
1064 * dynamic (per-station) keys
1066 * The dynamic keys are a little more complicated. The device has
1067 * a key cache of up to STA_KEY_MAX_NUM/STA_KEY_MAX_NUM_PAN keys.
1068 * These are linked to stations by a table that contains an index
1069 * into the key table for each station/key index/{mcast,unicast},
1070 * i.e. it's basically an array of pointers like this:
1071 * key_offset_t key_mapping[NUM_STATIONS][4][2];
1072 * (it really works differently, but you can think of it as such)
1074 * The key uploading and linking happens in the same command, the
1075 * add station command with STA_MODIFY_KEY_MASK.
1078 static u8
iwlagn_key_sta_id(struct iwl_priv
*priv
,
1079 struct ieee80211_vif
*vif
,
1080 struct ieee80211_sta
*sta
)
1082 struct iwl_vif_priv
*vif_priv
= (void *)vif
->drv_priv
;
1083 u8 sta_id
= IWL_INVALID_STATION
;
1086 sta_id
= iwl_sta_id(sta
);
1089 * The device expects GTKs for station interfaces to be
1090 * installed as GTKs for the AP station. If we have no
1091 * station ID, then use the ap_sta_id in that case.
1093 if (!sta
&& vif
&& vif_priv
->ctx
) {
1094 switch (vif
->type
) {
1095 case NL80211_IFTYPE_STATION
:
1096 sta_id
= vif_priv
->ctx
->ap_sta_id
;
1100 * In all other cases, the key will be
1101 * used either for TX only or is bound
1102 * to a station already.
1111 static int iwlagn_send_sta_key(struct iwl_priv
*priv
,
1112 struct ieee80211_key_conf
*keyconf
,
1113 u8 sta_id
, u32 tkip_iv32
, u16
*tkip_p1k
,
1116 unsigned long flags
;
1118 struct iwl_addsta_cmd sta_cmd
;
1121 spin_lock_irqsave(&priv
->shrd
->sta_lock
, flags
);
1122 memcpy(&sta_cmd
, &priv
->stations
[sta_id
].sta
, sizeof(sta_cmd
));
1123 spin_unlock_irqrestore(&priv
->shrd
->sta_lock
, flags
);
1125 key_flags
= cpu_to_le16(keyconf
->keyidx
<< STA_KEY_FLG_KEYID_POS
);
1126 key_flags
|= STA_KEY_FLG_MAP_KEY_MSK
;
1128 switch (keyconf
->cipher
) {
1129 case WLAN_CIPHER_SUITE_CCMP
:
1130 key_flags
|= STA_KEY_FLG_CCMP
;
1131 memcpy(sta_cmd
.key
.key
, keyconf
->key
, keyconf
->keylen
);
1133 case WLAN_CIPHER_SUITE_TKIP
:
1134 key_flags
|= STA_KEY_FLG_TKIP
;
1135 sta_cmd
.key
.tkip_rx_tsc_byte2
= tkip_iv32
;
1136 for (i
= 0; i
< 5; i
++)
1137 sta_cmd
.key
.tkip_rx_ttak
[i
] = cpu_to_le16(tkip_p1k
[i
]);
1138 memcpy(sta_cmd
.key
.key
, keyconf
->key
, keyconf
->keylen
);
1140 case WLAN_CIPHER_SUITE_WEP104
:
1141 key_flags
|= STA_KEY_FLG_KEY_SIZE_MSK
;
1143 case WLAN_CIPHER_SUITE_WEP40
:
1144 key_flags
|= STA_KEY_FLG_WEP
;
1145 memcpy(&sta_cmd
.key
.key
[3], keyconf
->key
, keyconf
->keylen
);
1152 if (!(keyconf
->flags
& IEEE80211_KEY_FLAG_PAIRWISE
))
1153 key_flags
|= STA_KEY_MULTICAST_MSK
;
1155 /* key pointer (offset) */
1156 sta_cmd
.key
.key_offset
= keyconf
->hw_key_idx
;
1158 sta_cmd
.key
.key_flags
= key_flags
;
1159 sta_cmd
.mode
= STA_CONTROL_MODIFY_MSK
;
1160 sta_cmd
.sta
.modify_mask
= STA_MODIFY_KEY_MASK
;
1162 return iwl_send_add_sta(priv
, &sta_cmd
, cmd_flags
);
1165 void iwl_update_tkip_key(struct iwl_priv
*priv
,
1166 struct ieee80211_vif
*vif
,
1167 struct ieee80211_key_conf
*keyconf
,
1168 struct ieee80211_sta
*sta
, u32 iv32
, u16
*phase1key
)
1170 u8 sta_id
= iwlagn_key_sta_id(priv
, vif
, sta
);
1172 if (sta_id
== IWL_INVALID_STATION
)
1175 if (iwl_scan_cancel(priv
)) {
1176 /* cancel scan failed, just live w/ bad key and rely
1177 briefly on SW decryption */
1181 iwlagn_send_sta_key(priv
, keyconf
, sta_id
,
1182 iv32
, phase1key
, CMD_ASYNC
);
1185 int iwl_remove_dynamic_key(struct iwl_priv
*priv
,
1186 struct iwl_rxon_context
*ctx
,
1187 struct ieee80211_key_conf
*keyconf
,
1188 struct ieee80211_sta
*sta
)
1190 unsigned long flags
;
1191 struct iwl_addsta_cmd sta_cmd
;
1192 u8 sta_id
= iwlagn_key_sta_id(priv
, ctx
->vif
, sta
);
1194 /* if station isn't there, neither is the key */
1195 if (sta_id
== IWL_INVALID_STATION
)
1198 spin_lock_irqsave(&priv
->shrd
->sta_lock
, flags
);
1199 memcpy(&sta_cmd
, &priv
->stations
[sta_id
].sta
, sizeof(sta_cmd
));
1200 if (!(priv
->stations
[sta_id
].used
& IWL_STA_UCODE_ACTIVE
))
1201 sta_id
= IWL_INVALID_STATION
;
1202 spin_unlock_irqrestore(&priv
->shrd
->sta_lock
, flags
);
1204 if (sta_id
== IWL_INVALID_STATION
)
1207 lockdep_assert_held(&priv
->shrd
->mutex
);
1209 ctx
->key_mapping_keys
--;
1211 IWL_DEBUG_WEP(priv
, "Remove dynamic key: idx=%d sta=%d\n",
1212 keyconf
->keyidx
, sta_id
);
1214 if (!test_and_clear_bit(keyconf
->hw_key_idx
, &priv
->ucode_key_table
))
1215 IWL_ERR(priv
, "offset %d not used in uCode key table.\n",
1216 keyconf
->hw_key_idx
);
1218 sta_cmd
.key
.key_flags
= STA_KEY_FLG_NO_ENC
| STA_KEY_FLG_INVALID
;
1219 sta_cmd
.key
.key_offset
= WEP_INVALID_OFFSET
;
1220 sta_cmd
.sta
.modify_mask
= STA_MODIFY_KEY_MASK
;
1221 sta_cmd
.mode
= STA_CONTROL_MODIFY_MSK
;
1223 return iwl_send_add_sta(priv
, &sta_cmd
, CMD_SYNC
);
1226 int iwl_set_dynamic_key(struct iwl_priv
*priv
,
1227 struct iwl_rxon_context
*ctx
,
1228 struct ieee80211_key_conf
*keyconf
,
1229 struct ieee80211_sta
*sta
)
1231 struct ieee80211_key_seq seq
;
1234 u8 sta_id
= iwlagn_key_sta_id(priv
, ctx
->vif
, sta
);
1237 if (sta_id
== IWL_INVALID_STATION
)
1240 lockdep_assert_held(&priv
->shrd
->mutex
);
1242 keyconf
->hw_key_idx
= iwl_get_free_ucode_key_offset(priv
);
1243 if (keyconf
->hw_key_idx
== WEP_INVALID_OFFSET
)
1246 ctx
->key_mapping_keys
++;
1248 switch (keyconf
->cipher
) {
1249 case WLAN_CIPHER_SUITE_TKIP
:
1252 else /* station mode case only */
1253 addr
= ctx
->active
.bssid_addr
;
1255 /* pre-fill phase 1 key into device cache */
1256 ieee80211_get_key_rx_seq(keyconf
, 0, &seq
);
1257 ieee80211_get_tkip_rx_p1k(keyconf
, addr
, seq
.tkip
.iv32
, p1k
);
1258 ret
= iwlagn_send_sta_key(priv
, keyconf
, sta_id
,
1259 seq
.tkip
.iv32
, p1k
, CMD_SYNC
);
1261 case WLAN_CIPHER_SUITE_CCMP
:
1262 case WLAN_CIPHER_SUITE_WEP40
:
1263 case WLAN_CIPHER_SUITE_WEP104
:
1264 ret
= iwlagn_send_sta_key(priv
, keyconf
, sta_id
,
1268 IWL_ERR(priv
, "Unknown cipher %x\n", keyconf
->cipher
);
1273 ctx
->key_mapping_keys
--;
1274 clear_bit(keyconf
->hw_key_idx
, &priv
->ucode_key_table
);
1277 IWL_DEBUG_WEP(priv
, "Set dynamic key: cipher=%x len=%d idx=%d sta=%pM ret=%d\n",
1278 keyconf
->cipher
, keyconf
->keylen
, keyconf
->keyidx
,
1279 sta
? sta
->addr
: NULL
, ret
);
1285 * iwlagn_alloc_bcast_station - add broadcast station into driver's station table.
1287 * This adds the broadcast station into the driver's station table
1288 * and marks it driver active, so that it will be restored to the
1289 * device at the next best time.
1291 int iwlagn_alloc_bcast_station(struct iwl_priv
*priv
,
1292 struct iwl_rxon_context
*ctx
)
1294 struct iwl_link_quality_cmd
*link_cmd
;
1295 unsigned long flags
;
1298 spin_lock_irqsave(&priv
->shrd
->sta_lock
, flags
);
1299 sta_id
= iwl_prep_station(priv
, ctx
, iwl_bcast_addr
, false, NULL
);
1300 if (sta_id
== IWL_INVALID_STATION
) {
1301 IWL_ERR(priv
, "Unable to prepare broadcast station\n");
1302 spin_unlock_irqrestore(&priv
->shrd
->sta_lock
, flags
);
1307 priv
->stations
[sta_id
].used
|= IWL_STA_DRIVER_ACTIVE
;
1308 priv
->stations
[sta_id
].used
|= IWL_STA_BCAST
;
1309 spin_unlock_irqrestore(&priv
->shrd
->sta_lock
, flags
);
1311 link_cmd
= iwl_sta_alloc_lq(priv
, ctx
, sta_id
);
1314 "Unable to initialize rate scaling for bcast station.\n");
1318 spin_lock_irqsave(&priv
->shrd
->sta_lock
, flags
);
1319 priv
->stations
[sta_id
].lq
= link_cmd
;
1320 spin_unlock_irqrestore(&priv
->shrd
->sta_lock
, flags
);
1326 * iwl_update_bcast_station - update broadcast station's LQ command
1328 * Only used by iwlagn. Placed here to have all bcast station management
1331 int iwl_update_bcast_station(struct iwl_priv
*priv
,
1332 struct iwl_rxon_context
*ctx
)
1334 unsigned long flags
;
1335 struct iwl_link_quality_cmd
*link_cmd
;
1336 u8 sta_id
= ctx
->bcast_sta_id
;
1338 link_cmd
= iwl_sta_alloc_lq(priv
, ctx
, sta_id
);
1340 IWL_ERR(priv
, "Unable to initialize rate scaling for bcast station.\n");
1344 spin_lock_irqsave(&priv
->shrd
->sta_lock
, flags
);
1345 if (priv
->stations
[sta_id
].lq
)
1346 kfree(priv
->stations
[sta_id
].lq
);
1348 IWL_DEBUG_INFO(priv
, "Bcast station rate scaling has not been initialized yet.\n");
1349 priv
->stations
[sta_id
].lq
= link_cmd
;
1350 spin_unlock_irqrestore(&priv
->shrd
->sta_lock
, flags
);
1355 int iwl_update_bcast_stations(struct iwl_priv
*priv
)
1357 struct iwl_rxon_context
*ctx
;
1360 for_each_context(priv
, ctx
) {
1361 ret
= iwl_update_bcast_station(priv
, ctx
);
1370 * iwl_sta_tx_modify_enable_tid - Enable Tx for this TID in station table
1372 int iwl_sta_tx_modify_enable_tid(struct iwl_priv
*priv
, int sta_id
, int tid
)
1374 unsigned long flags
;
1375 struct iwl_addsta_cmd sta_cmd
;
1377 lockdep_assert_held(&priv
->shrd
->mutex
);
1379 /* Remove "disable" flag, to enable Tx for this TID */
1380 spin_lock_irqsave(&priv
->shrd
->sta_lock
, flags
);
1381 priv
->stations
[sta_id
].sta
.sta
.modify_mask
= STA_MODIFY_TID_DISABLE_TX
;
1382 priv
->stations
[sta_id
].sta
.tid_disable_tx
&= cpu_to_le16(~(1 << tid
));
1383 priv
->stations
[sta_id
].sta
.mode
= STA_CONTROL_MODIFY_MSK
;
1384 memcpy(&sta_cmd
, &priv
->stations
[sta_id
].sta
, sizeof(struct iwl_addsta_cmd
));
1385 spin_unlock_irqrestore(&priv
->shrd
->sta_lock
, flags
);
1387 return iwl_send_add_sta(priv
, &sta_cmd
, CMD_SYNC
);
1390 int iwl_sta_rx_agg_start(struct iwl_priv
*priv
, struct ieee80211_sta
*sta
,
1393 unsigned long flags
;
1395 struct iwl_addsta_cmd sta_cmd
;
1397 lockdep_assert_held(&priv
->shrd
->mutex
);
1399 sta_id
= iwl_sta_id(sta
);
1400 if (sta_id
== IWL_INVALID_STATION
)
1403 spin_lock_irqsave(&priv
->shrd
->sta_lock
, flags
);
1404 priv
->stations
[sta_id
].sta
.station_flags_msk
= 0;
1405 priv
->stations
[sta_id
].sta
.sta
.modify_mask
= STA_MODIFY_ADDBA_TID_MSK
;
1406 priv
->stations
[sta_id
].sta
.add_immediate_ba_tid
= (u8
)tid
;
1407 priv
->stations
[sta_id
].sta
.add_immediate_ba_ssn
= cpu_to_le16(ssn
);
1408 priv
->stations
[sta_id
].sta
.mode
= STA_CONTROL_MODIFY_MSK
;
1409 memcpy(&sta_cmd
, &priv
->stations
[sta_id
].sta
, sizeof(struct iwl_addsta_cmd
));
1410 spin_unlock_irqrestore(&priv
->shrd
->sta_lock
, flags
);
1412 return iwl_send_add_sta(priv
, &sta_cmd
, CMD_SYNC
);
1415 int iwl_sta_rx_agg_stop(struct iwl_priv
*priv
, struct ieee80211_sta
*sta
,
1418 unsigned long flags
;
1420 struct iwl_addsta_cmd sta_cmd
;
1422 lockdep_assert_held(&priv
->shrd
->mutex
);
1424 sta_id
= iwl_sta_id(sta
);
1425 if (sta_id
== IWL_INVALID_STATION
) {
1426 IWL_ERR(priv
, "Invalid station for AGG tid %d\n", tid
);
1430 spin_lock_irqsave(&priv
->shrd
->sta_lock
, flags
);
1431 priv
->stations
[sta_id
].sta
.station_flags_msk
= 0;
1432 priv
->stations
[sta_id
].sta
.sta
.modify_mask
= STA_MODIFY_DELBA_TID_MSK
;
1433 priv
->stations
[sta_id
].sta
.remove_immediate_ba_tid
= (u8
)tid
;
1434 priv
->stations
[sta_id
].sta
.mode
= STA_CONTROL_MODIFY_MSK
;
1435 memcpy(&sta_cmd
, &priv
->stations
[sta_id
].sta
, sizeof(struct iwl_addsta_cmd
));
1436 spin_unlock_irqrestore(&priv
->shrd
->sta_lock
, flags
);
1438 return iwl_send_add_sta(priv
, &sta_cmd
, CMD_SYNC
);
1443 void iwl_sta_modify_sleep_tx_count(struct iwl_priv
*priv
, int sta_id
, int cnt
)
1445 unsigned long flags
;
1447 spin_lock_irqsave(&priv
->shrd
->sta_lock
, flags
);
1448 priv
->stations
[sta_id
].sta
.station_flags
|= STA_FLG_PWR_SAVE_MSK
;
1449 priv
->stations
[sta_id
].sta
.station_flags_msk
= STA_FLG_PWR_SAVE_MSK
;
1450 priv
->stations
[sta_id
].sta
.sta
.modify_mask
=
1451 STA_MODIFY_SLEEP_TX_COUNT_MSK
;
1452 priv
->stations
[sta_id
].sta
.sleep_tx_count
= cpu_to_le16(cnt
);
1453 priv
->stations
[sta_id
].sta
.mode
= STA_CONTROL_MODIFY_MSK
;
1454 iwl_send_add_sta(priv
, &priv
->stations
[sta_id
].sta
, CMD_ASYNC
);
1455 spin_unlock_irqrestore(&priv
->shrd
->sta_lock
, flags
);