1 /******************************************************************************
3 * Copyright(c) 2003 - 2009 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>
31 #include <linux/etherdevice.h>
37 #define IWL_STA_DRIVER_ACTIVE BIT(0) /* driver entry is active */
38 #define IWL_STA_UCODE_ACTIVE BIT(1) /* ucode entry is active */
40 u8
iwl_find_station(struct iwl_priv
*priv
, const u8
*addr
)
44 int ret
= IWL_INVALID_STATION
;
47 if ((priv
->iw_mode
== NL80211_IFTYPE_ADHOC
) ||
48 (priv
->iw_mode
== NL80211_IFTYPE_AP
))
51 if (is_broadcast_ether_addr(addr
))
52 return priv
->hw_params
.bcast_sta_id
;
54 spin_lock_irqsave(&priv
->sta_lock
, flags
);
55 for (i
= start
; i
< priv
->hw_params
.max_stations
; i
++)
56 if (priv
->stations
[i
].used
&&
57 (!compare_ether_addr(priv
->stations
[i
].sta
.sta
.addr
,
63 IWL_DEBUG_ASSOC_LIMIT(priv
, "can not find STA %pM total %d\n",
64 addr
, priv
->num_stations
);
67 spin_unlock_irqrestore(&priv
->sta_lock
, flags
);
70 EXPORT_SYMBOL(iwl_find_station
);
72 int iwl_get_ra_sta_id(struct iwl_priv
*priv
, struct ieee80211_hdr
*hdr
)
74 if (priv
->iw_mode
== NL80211_IFTYPE_STATION
) {
77 u8
*da
= ieee80211_get_DA(hdr
);
78 return iwl_find_station(priv
, da
);
81 EXPORT_SYMBOL(iwl_get_ra_sta_id
);
83 static void iwl_sta_ucode_activate(struct iwl_priv
*priv
, u8 sta_id
)
87 spin_lock_irqsave(&priv
->sta_lock
, flags
);
89 if (!(priv
->stations
[sta_id
].used
& IWL_STA_DRIVER_ACTIVE
) &&
90 !(priv
->stations_39
[sta_id
].used
& IWL_STA_DRIVER_ACTIVE
))
91 IWL_ERR(priv
, "ACTIVATE a non DRIVER active station %d\n",
94 priv
->stations
[sta_id
].used
|= IWL_STA_UCODE_ACTIVE
;
95 IWL_DEBUG_ASSOC(priv
, "Added STA to Ucode: %pM\n",
96 priv
->stations
[sta_id
].sta
.sta
.addr
);
98 spin_unlock_irqrestore(&priv
->sta_lock
, flags
);
101 static int iwl_add_sta_callback(struct iwl_priv
*priv
,
102 struct iwl_cmd
*cmd
, struct sk_buff
*skb
)
104 struct iwl_rx_packet
*res
= NULL
;
105 struct iwl_addsta_cmd
*addsta
=
106 (struct iwl_addsta_cmd
*)cmd
->cmd
.payload
;
107 u8 sta_id
= addsta
->sta
.sta_id
;
110 IWL_ERR(priv
, "Error: Response NULL in REPLY_ADD_STA.\n");
114 res
= (struct iwl_rx_packet
*)skb
->data
;
115 if (res
->hdr
.flags
& IWL_CMD_FAILED_MSK
) {
116 IWL_ERR(priv
, "Bad return from REPLY_ADD_STA (0x%08X)\n",
121 switch (res
->u
.add_sta
.status
) {
122 case ADD_STA_SUCCESS_MSK
:
123 iwl_sta_ucode_activate(priv
, sta_id
);
126 IWL_DEBUG_HC(priv
, "Received REPLY_ADD_STA:(0x%08X)\n",
127 res
->u
.add_sta
.status
);
131 /* We didn't cache the SKB; let the caller free it */
135 int iwl_send_add_sta(struct iwl_priv
*priv
,
136 struct iwl_addsta_cmd
*sta
, u8 flags
)
138 struct iwl_rx_packet
*res
= NULL
;
140 u8 data
[sizeof(*sta
)];
141 struct iwl_host_cmd cmd
= {
147 if (flags
& CMD_ASYNC
)
148 cmd
.meta
.u
.callback
= iwl_add_sta_callback
;
150 cmd
.meta
.flags
|= CMD_WANT_SKB
;
152 cmd
.len
= priv
->cfg
->ops
->utils
->build_addsta_hcmd(sta
, data
);
153 ret
= iwl_send_cmd(priv
, &cmd
);
155 if (ret
|| (flags
& CMD_ASYNC
))
158 res
= (struct iwl_rx_packet
*)cmd
.meta
.u
.skb
->data
;
159 if (res
->hdr
.flags
& IWL_CMD_FAILED_MSK
) {
160 IWL_ERR(priv
, "Bad return from REPLY_ADD_STA (0x%08X)\n",
166 switch (res
->u
.add_sta
.status
) {
167 case ADD_STA_SUCCESS_MSK
:
168 iwl_sta_ucode_activate(priv
, sta
->sta
.sta_id
);
169 IWL_DEBUG_INFO(priv
, "REPLY_ADD_STA PASSED\n");
173 IWL_WARN(priv
, "REPLY_ADD_STA failed\n");
178 priv
->alloc_rxb_skb
--;
179 dev_kfree_skb_any(cmd
.meta
.u
.skb
);
183 EXPORT_SYMBOL(iwl_send_add_sta
);
185 static void iwl_set_ht_add_station(struct iwl_priv
*priv
, u8 index
,
186 struct ieee80211_sta_ht_cap
*sta_ht_inf
)
191 if (!sta_ht_inf
|| !sta_ht_inf
->ht_supported
)
194 mimo_ps_mode
= (sta_ht_inf
->cap
& IEEE80211_HT_CAP_SM_PS
) >> 2;
196 sta_flags
= priv
->stations
[index
].sta
.station_flags
;
198 sta_flags
&= ~(STA_FLG_RTS_MIMO_PROT_MSK
| STA_FLG_MIMO_DIS_MSK
);
200 switch (mimo_ps_mode
) {
201 case WLAN_HT_CAP_SM_PS_STATIC
:
202 sta_flags
|= STA_FLG_MIMO_DIS_MSK
;
204 case WLAN_HT_CAP_SM_PS_DYNAMIC
:
205 sta_flags
|= STA_FLG_RTS_MIMO_PROT_MSK
;
207 case WLAN_HT_CAP_SM_PS_DISABLED
:
210 IWL_WARN(priv
, "Invalid MIMO PS mode %d\n", mimo_ps_mode
);
214 sta_flags
|= cpu_to_le32(
215 (u32
)sta_ht_inf
->ampdu_factor
<< STA_FLG_MAX_AGG_SIZE_POS
);
217 sta_flags
|= cpu_to_le32(
218 (u32
)sta_ht_inf
->ampdu_density
<< STA_FLG_AGG_MPDU_DENSITY_POS
);
220 if (iwl_is_fat_tx_allowed(priv
, sta_ht_inf
))
221 sta_flags
|= STA_FLG_FAT_EN_MSK
;
223 sta_flags
&= ~STA_FLG_FAT_EN_MSK
;
225 priv
->stations
[index
].sta
.station_flags
= sta_flags
;
231 * iwl_add_station_flags - Add station to tables in driver and device
233 u8
iwl_add_station_flags(struct iwl_priv
*priv
, const u8
*addr
, int is_ap
,
234 u8 flags
, struct ieee80211_sta_ht_cap
*ht_info
)
237 int sta_id
= IWL_INVALID_STATION
;
238 struct iwl_station_entry
*station
;
239 unsigned long flags_spin
;
241 spin_lock_irqsave(&priv
->sta_lock
, flags_spin
);
244 else if (is_broadcast_ether_addr(addr
))
245 sta_id
= priv
->hw_params
.bcast_sta_id
;
247 for (i
= IWL_STA_ID
; i
< priv
->hw_params
.max_stations
; i
++) {
248 if (!compare_ether_addr(priv
->stations
[i
].sta
.sta
.addr
,
254 if (!priv
->stations
[i
].used
&&
255 sta_id
== IWL_INVALID_STATION
)
259 /* These two conditions have the same outcome, but keep them separate
260 since they have different meanings */
261 if (unlikely(sta_id
== IWL_INVALID_STATION
)) {
262 spin_unlock_irqrestore(&priv
->sta_lock
, flags_spin
);
266 if (priv
->stations
[sta_id
].used
&&
267 !compare_ether_addr(priv
->stations
[sta_id
].sta
.sta
.addr
, addr
)) {
268 spin_unlock_irqrestore(&priv
->sta_lock
, flags_spin
);
273 station
= &priv
->stations
[sta_id
];
274 station
->used
= IWL_STA_DRIVER_ACTIVE
;
275 IWL_DEBUG_ASSOC(priv
, "Add STA to driver ID %d: %pM\n",
277 priv
->num_stations
++;
279 /* Set up the REPLY_ADD_STA command to send to device */
280 memset(&station
->sta
, 0, sizeof(struct iwl_addsta_cmd
));
281 memcpy(station
->sta
.sta
.addr
, addr
, ETH_ALEN
);
282 station
->sta
.mode
= 0;
283 station
->sta
.sta
.sta_id
= sta_id
;
284 station
->sta
.station_flags
= 0;
286 /* BCAST station and IBSS stations do not work in HT mode */
287 if (sta_id
!= priv
->hw_params
.bcast_sta_id
&&
288 priv
->iw_mode
!= NL80211_IFTYPE_ADHOC
)
289 iwl_set_ht_add_station(priv
, sta_id
, ht_info
);
291 spin_unlock_irqrestore(&priv
->sta_lock
, flags_spin
);
293 /* Add station to device's station table */
294 iwl_send_add_sta(priv
, &station
->sta
, flags
);
298 EXPORT_SYMBOL(iwl_add_station_flags
);
300 static void iwl_sta_ucode_deactivate(struct iwl_priv
*priv
, const char *addr
)
303 u8 sta_id
= iwl_find_station(priv
, addr
);
305 BUG_ON(sta_id
== IWL_INVALID_STATION
);
307 IWL_DEBUG_ASSOC(priv
, "Removed STA from Ucode: %pM\n", addr
);
309 spin_lock_irqsave(&priv
->sta_lock
, flags
);
311 /* Ucode must be active and driver must be non active */
312 if (priv
->stations
[sta_id
].used
!= IWL_STA_UCODE_ACTIVE
)
313 IWL_ERR(priv
, "removed non active STA %d\n", sta_id
);
315 priv
->stations
[sta_id
].used
&= ~IWL_STA_UCODE_ACTIVE
;
317 memset(&priv
->stations
[sta_id
], 0, sizeof(struct iwl_station_entry
));
318 spin_unlock_irqrestore(&priv
->sta_lock
, flags
);
321 static int iwl_remove_sta_callback(struct iwl_priv
*priv
,
322 struct iwl_cmd
*cmd
, struct sk_buff
*skb
)
324 struct iwl_rx_packet
*res
= NULL
;
325 struct iwl_rem_sta_cmd
*rm_sta
=
326 (struct iwl_rem_sta_cmd
*)cmd
->cmd
.payload
;
327 const char *addr
= rm_sta
->addr
;
330 IWL_ERR(priv
, "Error: Response NULL in REPLY_REMOVE_STA.\n");
334 res
= (struct iwl_rx_packet
*)skb
->data
;
335 if (res
->hdr
.flags
& IWL_CMD_FAILED_MSK
) {
336 IWL_ERR(priv
, "Bad return from REPLY_REMOVE_STA (0x%08X)\n",
341 switch (res
->u
.rem_sta
.status
) {
342 case REM_STA_SUCCESS_MSK
:
343 iwl_sta_ucode_deactivate(priv
, addr
);
346 IWL_ERR(priv
, "REPLY_REMOVE_STA failed\n");
350 /* We didn't cache the SKB; let the caller free it */
354 static int iwl_send_remove_station(struct iwl_priv
*priv
, const u8
*addr
,
357 struct iwl_rx_packet
*res
= NULL
;
360 struct iwl_rem_sta_cmd rm_sta_cmd
;
362 struct iwl_host_cmd cmd
= {
363 .id
= REPLY_REMOVE_STA
,
364 .len
= sizeof(struct iwl_rem_sta_cmd
),
369 memset(&rm_sta_cmd
, 0, sizeof(rm_sta_cmd
));
370 rm_sta_cmd
.num_sta
= 1;
371 memcpy(&rm_sta_cmd
.addr
, addr
, ETH_ALEN
);
373 if (flags
& CMD_ASYNC
)
374 cmd
.meta
.u
.callback
= iwl_remove_sta_callback
;
376 cmd
.meta
.flags
|= CMD_WANT_SKB
;
377 ret
= iwl_send_cmd(priv
, &cmd
);
379 if (ret
|| (flags
& CMD_ASYNC
))
382 res
= (struct iwl_rx_packet
*)cmd
.meta
.u
.skb
->data
;
383 if (res
->hdr
.flags
& IWL_CMD_FAILED_MSK
) {
384 IWL_ERR(priv
, "Bad return from REPLY_REMOVE_STA (0x%08X)\n",
390 switch (res
->u
.rem_sta
.status
) {
391 case REM_STA_SUCCESS_MSK
:
392 iwl_sta_ucode_deactivate(priv
, addr
);
393 IWL_DEBUG_ASSOC(priv
, "REPLY_REMOVE_STA PASSED\n");
397 IWL_ERR(priv
, "REPLY_REMOVE_STA failed\n");
402 priv
->alloc_rxb_skb
--;
403 dev_kfree_skb_any(cmd
.meta
.u
.skb
);
409 * iwl_remove_station - Remove driver's knowledge of station.
411 int iwl_remove_station(struct iwl_priv
*priv
, const u8
*addr
, int is_ap
)
413 int sta_id
= IWL_INVALID_STATION
;
414 int i
, ret
= -EINVAL
;
417 spin_lock_irqsave(&priv
->sta_lock
, flags
);
421 else if (is_broadcast_ether_addr(addr
))
422 sta_id
= priv
->hw_params
.bcast_sta_id
;
424 for (i
= IWL_STA_ID
; i
< priv
->hw_params
.max_stations
; i
++)
425 if (priv
->stations
[i
].used
&&
426 !compare_ether_addr(priv
->stations
[i
].sta
.sta
.addr
,
432 if (unlikely(sta_id
== IWL_INVALID_STATION
))
435 IWL_DEBUG_ASSOC(priv
, "Removing STA from driver:%d %pM\n",
438 if (!(priv
->stations
[sta_id
].used
& IWL_STA_DRIVER_ACTIVE
)) {
439 IWL_ERR(priv
, "Removing %pM but non DRIVER active\n",
444 if (!(priv
->stations
[sta_id
].used
& IWL_STA_UCODE_ACTIVE
)) {
445 IWL_ERR(priv
, "Removing %pM but non UCODE active\n",
451 priv
->stations
[sta_id
].used
&= ~IWL_STA_DRIVER_ACTIVE
;
453 priv
->num_stations
--;
455 BUG_ON(priv
->num_stations
< 0);
457 spin_unlock_irqrestore(&priv
->sta_lock
, flags
);
459 ret
= iwl_send_remove_station(priv
, addr
, CMD_ASYNC
);
462 spin_unlock_irqrestore(&priv
->sta_lock
, flags
);
465 EXPORT_SYMBOL(iwl_remove_station
);
468 * iwl_clear_stations_table - Clear the driver's station table
470 * NOTE: This does not clear or otherwise alter the device's station table.
472 void iwl_clear_stations_table(struct iwl_priv
*priv
)
477 spin_lock_irqsave(&priv
->sta_lock
, flags
);
479 if (iwl_is_alive(priv
) &&
480 !test_bit(STATUS_EXIT_PENDING
, &priv
->status
) &&
481 iwl_send_cmd_pdu_async(priv
, REPLY_REMOVE_ALL_STA
, 0, NULL
, NULL
))
482 IWL_ERR(priv
, "Couldn't clear the station table\n");
484 priv
->num_stations
= 0;
485 memset(priv
->stations
, 0, sizeof(priv
->stations
));
487 /* clean ucode key table bit map */
488 priv
->ucode_key_table
= 0;
490 /* keep track of static keys */
491 for (i
= 0; i
< WEP_KEYS_MAX
; i
++) {
492 if (priv
->wep_keys
[i
].key_size
)
493 test_and_set_bit(i
, &priv
->ucode_key_table
);
496 spin_unlock_irqrestore(&priv
->sta_lock
, flags
);
498 EXPORT_SYMBOL(iwl_clear_stations_table
);
500 int iwl_get_free_ucode_key_index(struct iwl_priv
*priv
)
504 for (i
= 0; i
< STA_KEY_MAX_NUM
; i
++)
505 if (!test_and_set_bit(i
, &priv
->ucode_key_table
))
508 return WEP_INVALID_OFFSET
;
510 EXPORT_SYMBOL(iwl_get_free_ucode_key_index
);
512 int iwl_send_static_wepkey_cmd(struct iwl_priv
*priv
, u8 send_if_empty
)
514 int i
, not_empty
= 0;
515 u8 buff
[sizeof(struct iwl_wep_cmd
) +
516 sizeof(struct iwl_wep_key
) * WEP_KEYS_MAX
];
517 struct iwl_wep_cmd
*wep_cmd
= (struct iwl_wep_cmd
*)buff
;
518 size_t cmd_size
= sizeof(struct iwl_wep_cmd
);
519 struct iwl_host_cmd cmd
= {
522 .meta
.flags
= CMD_ASYNC
,
525 memset(wep_cmd
, 0, cmd_size
+
526 (sizeof(struct iwl_wep_key
) * WEP_KEYS_MAX
));
528 for (i
= 0; i
< WEP_KEYS_MAX
; i
++) {
529 wep_cmd
->key
[i
].key_index
= i
;
530 if (priv
->wep_keys
[i
].key_size
) {
531 wep_cmd
->key
[i
].key_offset
= i
;
534 wep_cmd
->key
[i
].key_offset
= WEP_INVALID_OFFSET
;
537 wep_cmd
->key
[i
].key_size
= priv
->wep_keys
[i
].key_size
;
538 memcpy(&wep_cmd
->key
[i
].key
[3], priv
->wep_keys
[i
].key
,
539 priv
->wep_keys
[i
].key_size
);
542 wep_cmd
->global_key_type
= WEP_KEY_WEP_TYPE
;
543 wep_cmd
->num_keys
= WEP_KEYS_MAX
;
545 cmd_size
+= sizeof(struct iwl_wep_key
) * WEP_KEYS_MAX
;
549 if (not_empty
|| send_if_empty
)
550 return iwl_send_cmd(priv
, &cmd
);
554 EXPORT_SYMBOL(iwl_send_static_wepkey_cmd
);
556 int iwl_remove_default_wep_key(struct iwl_priv
*priv
,
557 struct ieee80211_key_conf
*keyconf
)
562 spin_lock_irqsave(&priv
->sta_lock
, flags
);
564 if (!test_and_clear_bit(keyconf
->keyidx
, &priv
->ucode_key_table
))
565 IWL_ERR(priv
, "index %d not used in uCode key table.\n",
568 priv
->default_wep_key
--;
569 memset(&priv
->wep_keys
[keyconf
->keyidx
], 0, sizeof(priv
->wep_keys
[0]));
570 ret
= iwl_send_static_wepkey_cmd(priv
, 1);
571 IWL_DEBUG_WEP(priv
, "Remove default WEP key: idx=%d ret=%d\n",
572 keyconf
->keyidx
, ret
);
573 spin_unlock_irqrestore(&priv
->sta_lock
, flags
);
577 EXPORT_SYMBOL(iwl_remove_default_wep_key
);
579 int iwl_set_default_wep_key(struct iwl_priv
*priv
,
580 struct ieee80211_key_conf
*keyconf
)
585 if (keyconf
->keylen
!= WEP_KEY_LEN_128
&&
586 keyconf
->keylen
!= WEP_KEY_LEN_64
) {
587 IWL_DEBUG_WEP(priv
, "Bad WEP key length %d\n", keyconf
->keylen
);
591 keyconf
->flags
&= ~IEEE80211_KEY_FLAG_GENERATE_IV
;
592 keyconf
->hw_key_idx
= HW_KEY_DEFAULT
;
593 priv
->stations
[IWL_AP_ID
].keyinfo
.alg
= ALG_WEP
;
595 spin_lock_irqsave(&priv
->sta_lock
, flags
);
596 priv
->default_wep_key
++;
598 if (test_and_set_bit(keyconf
->keyidx
, &priv
->ucode_key_table
))
599 IWL_ERR(priv
, "index %d already used in uCode key table.\n",
602 priv
->wep_keys
[keyconf
->keyidx
].key_size
= keyconf
->keylen
;
603 memcpy(&priv
->wep_keys
[keyconf
->keyidx
].key
, &keyconf
->key
,
606 ret
= iwl_send_static_wepkey_cmd(priv
, 0);
607 IWL_DEBUG_WEP(priv
, "Set default WEP key: len=%d idx=%d ret=%d\n",
608 keyconf
->keylen
, keyconf
->keyidx
, ret
);
609 spin_unlock_irqrestore(&priv
->sta_lock
, flags
);
613 EXPORT_SYMBOL(iwl_set_default_wep_key
);
615 static int iwl_set_wep_dynamic_key_info(struct iwl_priv
*priv
,
616 struct ieee80211_key_conf
*keyconf
,
620 __le16 key_flags
= 0;
623 keyconf
->flags
&= ~IEEE80211_KEY_FLAG_GENERATE_IV
;
625 key_flags
|= (STA_KEY_FLG_WEP
| STA_KEY_FLG_MAP_KEY_MSK
);
626 key_flags
|= cpu_to_le16(keyconf
->keyidx
<< STA_KEY_FLG_KEYID_POS
);
627 key_flags
&= ~STA_KEY_FLG_INVALID
;
629 if (keyconf
->keylen
== WEP_KEY_LEN_128
)
630 key_flags
|= STA_KEY_FLG_KEY_SIZE_MSK
;
632 if (sta_id
== priv
->hw_params
.bcast_sta_id
)
633 key_flags
|= STA_KEY_MULTICAST_MSK
;
635 spin_lock_irqsave(&priv
->sta_lock
, flags
);
637 priv
->stations
[sta_id
].keyinfo
.alg
= keyconf
->alg
;
638 priv
->stations
[sta_id
].keyinfo
.keylen
= keyconf
->keylen
;
639 priv
->stations
[sta_id
].keyinfo
.keyidx
= keyconf
->keyidx
;
641 memcpy(priv
->stations
[sta_id
].keyinfo
.key
,
642 keyconf
->key
, keyconf
->keylen
);
644 memcpy(&priv
->stations
[sta_id
].sta
.key
.key
[3],
645 keyconf
->key
, keyconf
->keylen
);
647 if ((priv
->stations
[sta_id
].sta
.key
.key_flags
& STA_KEY_FLG_ENCRYPT_MSK
)
648 == STA_KEY_FLG_NO_ENC
)
649 priv
->stations
[sta_id
].sta
.key
.key_offset
=
650 iwl_get_free_ucode_key_index(priv
);
651 /* else, we are overriding an existing key => no need to allocated room
654 WARN(priv
->stations
[sta_id
].sta
.key
.key_offset
== WEP_INVALID_OFFSET
,
655 "no space for a new key");
657 priv
->stations
[sta_id
].sta
.key
.key_flags
= key_flags
;
658 priv
->stations
[sta_id
].sta
.sta
.modify_mask
= STA_MODIFY_KEY_MASK
;
659 priv
->stations
[sta_id
].sta
.mode
= STA_CONTROL_MODIFY_MSK
;
661 ret
= iwl_send_add_sta(priv
, &priv
->stations
[sta_id
].sta
, CMD_ASYNC
);
663 spin_unlock_irqrestore(&priv
->sta_lock
, flags
);
668 static int iwl_set_ccmp_dynamic_key_info(struct iwl_priv
*priv
,
669 struct ieee80211_key_conf
*keyconf
,
673 __le16 key_flags
= 0;
676 key_flags
|= (STA_KEY_FLG_CCMP
| STA_KEY_FLG_MAP_KEY_MSK
);
677 key_flags
|= cpu_to_le16(keyconf
->keyidx
<< STA_KEY_FLG_KEYID_POS
);
678 key_flags
&= ~STA_KEY_FLG_INVALID
;
680 if (sta_id
== priv
->hw_params
.bcast_sta_id
)
681 key_flags
|= STA_KEY_MULTICAST_MSK
;
683 keyconf
->flags
|= IEEE80211_KEY_FLAG_GENERATE_IV
;
685 spin_lock_irqsave(&priv
->sta_lock
, flags
);
686 priv
->stations
[sta_id
].keyinfo
.alg
= keyconf
->alg
;
687 priv
->stations
[sta_id
].keyinfo
.keylen
= keyconf
->keylen
;
689 memcpy(priv
->stations
[sta_id
].keyinfo
.key
, keyconf
->key
,
692 memcpy(priv
->stations
[sta_id
].sta
.key
.key
, keyconf
->key
,
695 if ((priv
->stations
[sta_id
].sta
.key
.key_flags
& STA_KEY_FLG_ENCRYPT_MSK
)
696 == STA_KEY_FLG_NO_ENC
)
697 priv
->stations
[sta_id
].sta
.key
.key_offset
=
698 iwl_get_free_ucode_key_index(priv
);
699 /* else, we are overriding an existing key => no need to allocated room
702 WARN(priv
->stations
[sta_id
].sta
.key
.key_offset
== WEP_INVALID_OFFSET
,
703 "no space for a new key");
705 priv
->stations
[sta_id
].sta
.key
.key_flags
= key_flags
;
706 priv
->stations
[sta_id
].sta
.sta
.modify_mask
= STA_MODIFY_KEY_MASK
;
707 priv
->stations
[sta_id
].sta
.mode
= STA_CONTROL_MODIFY_MSK
;
709 ret
= iwl_send_add_sta(priv
, &priv
->stations
[sta_id
].sta
, CMD_ASYNC
);
711 spin_unlock_irqrestore(&priv
->sta_lock
, flags
);
716 static int iwl_set_tkip_dynamic_key_info(struct iwl_priv
*priv
,
717 struct ieee80211_key_conf
*keyconf
,
723 keyconf
->flags
|= IEEE80211_KEY_FLAG_GENERATE_IV
;
724 keyconf
->flags
|= IEEE80211_KEY_FLAG_GENERATE_MMIC
;
726 spin_lock_irqsave(&priv
->sta_lock
, flags
);
728 priv
->stations
[sta_id
].keyinfo
.alg
= keyconf
->alg
;
729 priv
->stations
[sta_id
].keyinfo
.keylen
= 16;
731 if ((priv
->stations
[sta_id
].sta
.key
.key_flags
& STA_KEY_FLG_ENCRYPT_MSK
)
732 == STA_KEY_FLG_NO_ENC
)
733 priv
->stations
[sta_id
].sta
.key
.key_offset
=
734 iwl_get_free_ucode_key_index(priv
);
735 /* else, we are overriding an existing key => no need to allocated room
738 WARN(priv
->stations
[sta_id
].sta
.key
.key_offset
== WEP_INVALID_OFFSET
,
739 "no space for a new key");
741 /* This copy is acutally not needed: we get the key with each TX */
742 memcpy(priv
->stations
[sta_id
].keyinfo
.key
, keyconf
->key
, 16);
744 memcpy(priv
->stations
[sta_id
].sta
.key
.key
, keyconf
->key
, 16);
746 spin_unlock_irqrestore(&priv
->sta_lock
, flags
);
751 void iwl_update_tkip_key(struct iwl_priv
*priv
,
752 struct ieee80211_key_conf
*keyconf
,
753 const u8
*addr
, u32 iv32
, u16
*phase1key
)
755 u8 sta_id
= IWL_INVALID_STATION
;
757 __le16 key_flags
= 0;
759 DECLARE_MAC_BUF(mac
);
761 sta_id
= iwl_find_station(priv
, addr
);
762 if (sta_id
== IWL_INVALID_STATION
) {
763 IWL_DEBUG_MAC80211(priv
, "leave - %pM not in station map.\n",
768 if (iwl_scan_cancel(priv
)) {
769 /* cancel scan failed, just live w/ bad key and rely
770 briefly on SW decryption */
774 key_flags
|= (STA_KEY_FLG_TKIP
| STA_KEY_FLG_MAP_KEY_MSK
);
775 key_flags
|= cpu_to_le16(keyconf
->keyidx
<< STA_KEY_FLG_KEYID_POS
);
776 key_flags
&= ~STA_KEY_FLG_INVALID
;
778 if (sta_id
== priv
->hw_params
.bcast_sta_id
)
779 key_flags
|= STA_KEY_MULTICAST_MSK
;
781 spin_lock_irqsave(&priv
->sta_lock
, flags
);
783 priv
->stations
[sta_id
].sta
.key
.key_flags
= key_flags
;
784 priv
->stations
[sta_id
].sta
.key
.tkip_rx_tsc_byte2
= (u8
) iv32
;
786 for (i
= 0; i
< 5; i
++)
787 priv
->stations
[sta_id
].sta
.key
.tkip_rx_ttak
[i
] =
788 cpu_to_le16(phase1key
[i
]);
790 priv
->stations
[sta_id
].sta
.sta
.modify_mask
= STA_MODIFY_KEY_MASK
;
791 priv
->stations
[sta_id
].sta
.mode
= STA_CONTROL_MODIFY_MSK
;
793 iwl_send_add_sta(priv
, &priv
->stations
[sta_id
].sta
, CMD_ASYNC
);
795 spin_unlock_irqrestore(&priv
->sta_lock
, flags
);
798 EXPORT_SYMBOL(iwl_update_tkip_key
);
800 int iwl_remove_dynamic_key(struct iwl_priv
*priv
,
801 struct ieee80211_key_conf
*keyconf
,
809 priv
->key_mapping_key
--;
811 spin_lock_irqsave(&priv
->sta_lock
, flags
);
812 key_flags
= le16_to_cpu(priv
->stations
[sta_id
].sta
.key
.key_flags
);
813 keyidx
= (key_flags
>> STA_KEY_FLG_KEYID_POS
) & 0x3;
815 IWL_DEBUG_WEP(priv
, "Remove dynamic key: idx=%d sta=%d\n",
816 keyconf
->keyidx
, sta_id
);
818 if (keyconf
->keyidx
!= keyidx
) {
819 /* We need to remove a key with index different that the one
820 * in the uCode. This means that the key we need to remove has
821 * been replaced by another one with different index.
822 * Don't do anything and return ok
824 spin_unlock_irqrestore(&priv
->sta_lock
, flags
);
828 if (priv
->stations
[sta_id
].sta
.key
.key_offset
== WEP_INVALID_OFFSET
) {
829 IWL_WARN(priv
, "Removing wrong key %d 0x%x\n",
830 keyconf
->keyidx
, key_flags
);
831 spin_unlock_irqrestore(&priv
->sta_lock
, flags
);
835 if (!test_and_clear_bit(priv
->stations
[sta_id
].sta
.key
.key_offset
,
836 &priv
->ucode_key_table
))
837 IWL_ERR(priv
, "index %d not used in uCode key table.\n",
838 priv
->stations
[sta_id
].sta
.key
.key_offset
);
839 memset(&priv
->stations
[sta_id
].keyinfo
, 0,
840 sizeof(struct iwl_hw_key
));
841 memset(&priv
->stations
[sta_id
].sta
.key
, 0,
842 sizeof(struct iwl4965_keyinfo
));
843 priv
->stations
[sta_id
].sta
.key
.key_flags
=
844 STA_KEY_FLG_NO_ENC
| STA_KEY_FLG_INVALID
;
845 priv
->stations
[sta_id
].sta
.key
.key_offset
= WEP_INVALID_OFFSET
;
846 priv
->stations
[sta_id
].sta
.sta
.modify_mask
= STA_MODIFY_KEY_MASK
;
847 priv
->stations
[sta_id
].sta
.mode
= STA_CONTROL_MODIFY_MSK
;
849 ret
= iwl_send_add_sta(priv
, &priv
->stations
[sta_id
].sta
, CMD_ASYNC
);
850 spin_unlock_irqrestore(&priv
->sta_lock
, flags
);
853 EXPORT_SYMBOL(iwl_remove_dynamic_key
);
855 int iwl_set_dynamic_key(struct iwl_priv
*priv
,
856 struct ieee80211_key_conf
*keyconf
, u8 sta_id
)
860 priv
->key_mapping_key
++;
861 keyconf
->hw_key_idx
= HW_KEY_DYNAMIC
;
863 switch (keyconf
->alg
) {
865 ret
= iwl_set_ccmp_dynamic_key_info(priv
, keyconf
, sta_id
);
868 ret
= iwl_set_tkip_dynamic_key_info(priv
, keyconf
, sta_id
);
871 ret
= iwl_set_wep_dynamic_key_info(priv
, keyconf
, sta_id
);
875 "Unknown alg: %s alg = %d\n", __func__
, keyconf
->alg
);
879 IWL_DEBUG_WEP(priv
, "Set dynamic key: alg= %d len=%d idx=%d sta=%d ret=%d\n",
880 keyconf
->alg
, keyconf
->keylen
, keyconf
->keyidx
,
885 EXPORT_SYMBOL(iwl_set_dynamic_key
);
887 #ifdef CONFIG_IWLWIFI_DEBUG
888 static void iwl_dump_lq_cmd(struct iwl_priv
*priv
,
889 struct iwl_link_quality_cmd
*lq
)
892 IWL_DEBUG_RATE(priv
, "lq station id 0x%x\n", lq
->sta_id
);
893 IWL_DEBUG_RATE(priv
, "lq ant 0x%X 0x%X\n",
894 lq
->general_params
.single_stream_ant_msk
,
895 lq
->general_params
.dual_stream_ant_msk
);
897 for (i
= 0; i
< LINK_QUAL_MAX_RETRY_NUM
; i
++)
898 IWL_DEBUG_RATE(priv
, "lq index %d 0x%X\n",
899 i
, lq
->rs_table
[i
].rate_n_flags
);
902 static inline void iwl_dump_lq_cmd(struct iwl_priv
*priv
,
903 struct iwl_link_quality_cmd
*lq
)
908 int iwl_send_lq_cmd(struct iwl_priv
*priv
,
909 struct iwl_link_quality_cmd
*lq
, u8 flags
)
911 struct iwl_host_cmd cmd
= {
912 .id
= REPLY_TX_LINK_QUALITY_CMD
,
913 .len
= sizeof(struct iwl_link_quality_cmd
),
918 if ((lq
->sta_id
== 0xFF) &&
919 (priv
->iw_mode
== NL80211_IFTYPE_ADHOC
))
922 if (lq
->sta_id
== 0xFF)
923 lq
->sta_id
= IWL_AP_ID
;
925 iwl_dump_lq_cmd(priv
, lq
);
927 if (iwl_is_associated(priv
) && priv
->assoc_station_added
)
928 return iwl_send_cmd(priv
, &cmd
);
932 EXPORT_SYMBOL(iwl_send_lq_cmd
);
935 * iwl_sta_init_lq - Initialize a station's hardware rate table
937 * The uCode's station table contains a table of fallback rates
938 * for automatic fallback during transmission.
940 * NOTE: This sets up a default set of values. These will be replaced later
941 * if the driver's iwl-agn-rs rate scaling algorithm is used, instead of
944 * NOTE: Run REPLY_ADD_STA command to set up station table entry, before
945 * calling this function (which runs REPLY_TX_LINK_QUALITY_CMD,
946 * which requires station table entry to exist).
948 static void iwl_sta_init_lq(struct iwl_priv
*priv
, const u8
*addr
, int is_ap
)
951 struct iwl_link_quality_cmd link_cmd
= {
956 /* Set up the rate scaling to start at selected rate, fall back
957 * all the way down to 1M in IEEE order, and then spin on 1M */
959 r
= IWL_RATE_54M_INDEX
;
960 else if (priv
->band
== IEEE80211_BAND_5GHZ
)
961 r
= IWL_RATE_6M_INDEX
;
963 r
= IWL_RATE_1M_INDEX
;
965 for (i
= 0; i
< LINK_QUAL_MAX_RETRY_NUM
; i
++) {
967 if (r
>= IWL_FIRST_CCK_RATE
&& r
<= IWL_LAST_CCK_RATE
)
968 rate_flags
|= RATE_MCS_CCK_MSK
;
970 rate_flags
|= first_antenna(priv
->hw_params
.valid_tx_ant
) <<
973 link_cmd
.rs_table
[i
].rate_n_flags
=
974 iwl_hw_set_rate_n_flags(iwl_rates
[r
].plcp
, rate_flags
);
975 r
= iwl_get_prev_ieee_rate(r
);
978 link_cmd
.general_params
.single_stream_ant_msk
=
979 first_antenna(priv
->hw_params
.valid_tx_ant
);
980 link_cmd
.general_params
.dual_stream_ant_msk
= 3;
981 link_cmd
.agg_params
.agg_dis_start_th
= 3;
982 link_cmd
.agg_params
.agg_time_limit
= cpu_to_le16(4000);
984 /* Update the rate scaling for control frame Tx to AP */
985 link_cmd
.sta_id
= is_ap
? IWL_AP_ID
: priv
->hw_params
.bcast_sta_id
;
987 iwl_send_cmd_pdu_async(priv
, REPLY_TX_LINK_QUALITY_CMD
,
988 sizeof(link_cmd
), &link_cmd
, NULL
);
992 * iwl_rxon_add_station - add station into station table.
994 * there is only one AP station with id= IWL_AP_ID
995 * NOTE: mutex must be held before calling this function
997 int iwl_rxon_add_station(struct iwl_priv
*priv
, const u8
*addr
, int is_ap
)
999 struct ieee80211_sta
*sta
;
1000 struct ieee80211_sta_ht_cap ht_config
;
1001 struct ieee80211_sta_ht_cap
*cur_ht_config
= NULL
;
1004 /* Add station to device's station table */
1007 * XXX: This check is definitely not correct, if we're an AP
1008 * it'll always be false which is not what we want, but
1009 * it doesn't look like iwlagn is prepared to be an HT
1012 if (priv
->current_ht_config
.is_ht
) {
1014 sta
= ieee80211_find_sta(priv
->hw
, addr
);
1016 memcpy(&ht_config
, &sta
->ht_cap
, sizeof(ht_config
));
1017 cur_ht_config
= &ht_config
;
1022 sta_id
= iwl_add_station_flags(priv
, addr
, is_ap
,
1025 /* Set up default rate scaling table in device's station table */
1026 iwl_sta_init_lq(priv
, addr
, is_ap
);
1030 EXPORT_SYMBOL(iwl_rxon_add_station
);
1033 * iwl_get_sta_id - Find station's index within station table
1035 * If new IBSS station, create new entry in station table
1037 int iwl_get_sta_id(struct iwl_priv
*priv
, struct ieee80211_hdr
*hdr
)
1040 u16 fc
= le16_to_cpu(hdr
->frame_control
);
1042 /* If this frame is broadcast or management, use broadcast station id */
1043 if (((fc
& IEEE80211_FCTL_FTYPE
) != IEEE80211_FTYPE_DATA
) ||
1044 is_multicast_ether_addr(hdr
->addr1
))
1045 return priv
->hw_params
.bcast_sta_id
;
1047 switch (priv
->iw_mode
) {
1049 /* If we are a client station in a BSS network, use the special
1050 * AP station entry (that's the only station we communicate with) */
1051 case NL80211_IFTYPE_STATION
:
1054 /* If we are an AP, then find the station, or use BCAST */
1055 case NL80211_IFTYPE_AP
:
1056 sta_id
= iwl_find_station(priv
, hdr
->addr1
);
1057 if (sta_id
!= IWL_INVALID_STATION
)
1059 return priv
->hw_params
.bcast_sta_id
;
1061 /* If this frame is going out to an IBSS network, find the station,
1062 * or create a new station table entry */
1063 case NL80211_IFTYPE_ADHOC
:
1064 sta_id
= iwl_find_station(priv
, hdr
->addr1
);
1065 if (sta_id
!= IWL_INVALID_STATION
)
1068 /* Create new station table entry */
1069 sta_id
= iwl_add_station_flags(priv
, hdr
->addr1
,
1070 0, CMD_ASYNC
, NULL
);
1072 if (sta_id
!= IWL_INVALID_STATION
)
1075 IWL_DEBUG_DROP(priv
, "Station %pM not in station map. "
1076 "Defaulting to broadcast...\n",
1078 iwl_print_hex_dump(priv
, IWL_DL_DROP
, (u8
*) hdr
, sizeof(*hdr
));
1079 return priv
->hw_params
.bcast_sta_id
;
1081 /* If we are in monitor mode, use BCAST. This is required for
1082 * packet injection. */
1083 case NL80211_IFTYPE_MONITOR
:
1084 return priv
->hw_params
.bcast_sta_id
;
1087 IWL_WARN(priv
, "Unknown mode of operation: %d\n",
1089 return priv
->hw_params
.bcast_sta_id
;
1092 EXPORT_SYMBOL(iwl_get_sta_id
);
1095 * iwl_sta_tx_modify_enable_tid - Enable Tx for this TID in station table
1097 void iwl_sta_tx_modify_enable_tid(struct iwl_priv
*priv
, int sta_id
, int tid
)
1099 unsigned long flags
;
1101 /* Remove "disable" flag, to enable Tx for this TID */
1102 spin_lock_irqsave(&priv
->sta_lock
, flags
);
1103 priv
->stations
[sta_id
].sta
.sta
.modify_mask
= STA_MODIFY_TID_DISABLE_TX
;
1104 priv
->stations
[sta_id
].sta
.tid_disable_tx
&= cpu_to_le16(~(1 << tid
));
1105 priv
->stations
[sta_id
].sta
.mode
= STA_CONTROL_MODIFY_MSK
;
1106 spin_unlock_irqrestore(&priv
->sta_lock
, flags
);
1108 iwl_send_add_sta(priv
, &priv
->stations
[sta_id
].sta
, CMD_ASYNC
);
1110 EXPORT_SYMBOL(iwl_sta_tx_modify_enable_tid
);
1112 int iwl_sta_rx_agg_start(struct iwl_priv
*priv
,
1113 const u8
*addr
, int tid
, u16 ssn
)
1115 unsigned long flags
;
1118 sta_id
= iwl_find_station(priv
, addr
);
1119 if (sta_id
== IWL_INVALID_STATION
)
1122 spin_lock_irqsave(&priv
->sta_lock
, flags
);
1123 priv
->stations
[sta_id
].sta
.station_flags_msk
= 0;
1124 priv
->stations
[sta_id
].sta
.sta
.modify_mask
= STA_MODIFY_ADDBA_TID_MSK
;
1125 priv
->stations
[sta_id
].sta
.add_immediate_ba_tid
= (u8
)tid
;
1126 priv
->stations
[sta_id
].sta
.add_immediate_ba_ssn
= cpu_to_le16(ssn
);
1127 priv
->stations
[sta_id
].sta
.mode
= STA_CONTROL_MODIFY_MSK
;
1128 spin_unlock_irqrestore(&priv
->sta_lock
, flags
);
1130 return iwl_send_add_sta(priv
, &priv
->stations
[sta_id
].sta
,
1133 EXPORT_SYMBOL(iwl_sta_rx_agg_start
);
1135 int iwl_sta_rx_agg_stop(struct iwl_priv
*priv
, const u8
*addr
, int tid
)
1137 unsigned long flags
;
1140 sta_id
= iwl_find_station(priv
, addr
);
1141 if (sta_id
== IWL_INVALID_STATION
)
1144 spin_lock_irqsave(&priv
->sta_lock
, flags
);
1145 priv
->stations
[sta_id
].sta
.station_flags_msk
= 0;
1146 priv
->stations
[sta_id
].sta
.sta
.modify_mask
= STA_MODIFY_DELBA_TID_MSK
;
1147 priv
->stations
[sta_id
].sta
.remove_immediate_ba_tid
= (u8
)tid
;
1148 priv
->stations
[sta_id
].sta
.mode
= STA_CONTROL_MODIFY_MSK
;
1149 spin_unlock_irqrestore(&priv
->sta_lock
, flags
);
1151 return iwl_send_add_sta(priv
, &priv
->stations
[sta_id
].sta
,
1154 EXPORT_SYMBOL(iwl_sta_rx_agg_stop
);
1156 static void iwl_sta_modify_ps_wake(struct iwl_priv
*priv
, int sta_id
)
1158 unsigned long flags
;
1160 spin_lock_irqsave(&priv
->sta_lock
, flags
);
1161 priv
->stations
[sta_id
].sta
.station_flags
&= ~STA_FLG_PWR_SAVE_MSK
;
1162 priv
->stations
[sta_id
].sta
.station_flags_msk
= STA_FLG_PWR_SAVE_MSK
;
1163 priv
->stations
[sta_id
].sta
.sta
.modify_mask
= 0;
1164 priv
->stations
[sta_id
].sta
.mode
= STA_CONTROL_MODIFY_MSK
;
1165 spin_unlock_irqrestore(&priv
->sta_lock
, flags
);
1167 iwl_send_add_sta(priv
, &priv
->stations
[sta_id
].sta
, CMD_ASYNC
);
1170 void iwl_update_ps_mode(struct iwl_priv
*priv
, u16 ps_bit
, u8
*addr
)
1172 /* FIXME: need locking over ps_status ??? */
1173 u8 sta_id
= iwl_find_station(priv
, addr
);
1175 if (sta_id
!= IWL_INVALID_STATION
) {
1176 u8 sta_awake
= priv
->stations
[sta_id
].
1177 ps_status
== STA_PS_STATUS_WAKE
;
1179 if (sta_awake
&& ps_bit
)
1180 priv
->stations
[sta_id
].ps_status
= STA_PS_STATUS_SLEEP
;
1181 else if (!sta_awake
&& !ps_bit
) {
1182 iwl_sta_modify_ps_wake(priv
, sta_id
);
1183 priv
->stations
[sta_id
].ps_status
= STA_PS_STATUS_WAKE
;