1 /******************************************************************************
3 * Copyright(c) 2003 - 2008 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 * James P. Ketrenos <ipw2100-admin@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>
33 #include "iwl-eeprom.h"
38 #include "iwl-helpers.h"
40 u8
iwl_find_station(struct iwl_priv
*priv
, const u8
*addr
)
44 int ret
= IWL_INVALID_STATION
;
48 if ((priv
->iw_mode
== IEEE80211_IF_TYPE_IBSS
) ||
49 (priv
->iw_mode
== IEEE80211_IF_TYPE_AP
))
52 if (is_broadcast_ether_addr(addr
))
53 return priv
->hw_params
.bcast_sta_id
;
55 spin_lock_irqsave(&priv
->sta_lock
, flags
);
56 for (i
= start
; i
< priv
->hw_params
.max_stations
; i
++)
57 if (priv
->stations
[i
].used
&&
58 (!compare_ether_addr(priv
->stations
[i
].sta
.sta
.addr
,
64 IWL_DEBUG_ASSOC_LIMIT("can not find STA %s total %d\n",
65 print_mac(mac
, addr
), priv
->num_stations
);
68 spin_unlock_irqrestore(&priv
->sta_lock
, flags
);
71 EXPORT_SYMBOL(iwl_find_station
);
73 int iwl_send_add_sta(struct iwl_priv
*priv
,
74 struct iwl_addsta_cmd
*sta
, u8 flags
)
76 struct iwl_rx_packet
*res
= NULL
;
78 u8 data
[sizeof(*sta
)];
79 struct iwl_host_cmd cmd
= {
85 if (!(flags
& CMD_ASYNC
))
86 cmd
.meta
.flags
|= CMD_WANT_SKB
;
88 cmd
.len
= priv
->cfg
->ops
->utils
->build_addsta_hcmd(sta
, data
);
89 ret
= iwl_send_cmd(priv
, &cmd
);
91 if (ret
|| (flags
& CMD_ASYNC
))
94 res
= (struct iwl_rx_packet
*)cmd
.meta
.u
.skb
->data
;
95 if (res
->hdr
.flags
& IWL_CMD_FAILED_MSK
) {
96 IWL_ERROR("Bad return from REPLY_ADD_STA (0x%08X)\n",
102 switch (res
->u
.add_sta
.status
) {
103 case ADD_STA_SUCCESS_MSK
:
104 IWL_DEBUG_INFO("REPLY_ADD_STA PASSED\n");
108 IWL_WARNING("REPLY_ADD_STA failed\n");
113 priv
->alloc_rxb_skb
--;
114 dev_kfree_skb_any(cmd
.meta
.u
.skb
);
118 EXPORT_SYMBOL(iwl_send_add_sta
);
120 #ifdef CONFIG_IWL4965_HT
122 static void iwl_set_ht_add_station(struct iwl_priv
*priv
, u8 index
,
123 struct ieee80211_ht_info
*sta_ht_inf
)
128 if (!sta_ht_inf
|| !sta_ht_inf
->ht_supported
)
131 mimo_ps_mode
= (sta_ht_inf
->cap
& IEEE80211_HT_CAP_MIMO_PS
) >> 2;
133 sta_flags
= priv
->stations
[index
].sta
.station_flags
;
135 sta_flags
&= ~(STA_FLG_RTS_MIMO_PROT_MSK
| STA_FLG_MIMO_DIS_MSK
);
137 switch (mimo_ps_mode
) {
138 case WLAN_HT_CAP_MIMO_PS_STATIC
:
139 sta_flags
|= STA_FLG_MIMO_DIS_MSK
;
141 case WLAN_HT_CAP_MIMO_PS_DYNAMIC
:
142 sta_flags
|= STA_FLG_RTS_MIMO_PROT_MSK
;
144 case WLAN_HT_CAP_MIMO_PS_DISABLED
:
147 IWL_WARNING("Invalid MIMO PS mode %d", mimo_ps_mode
);
151 sta_flags
|= cpu_to_le32(
152 (u32
)sta_ht_inf
->ampdu_factor
<< STA_FLG_MAX_AGG_SIZE_POS
);
154 sta_flags
|= cpu_to_le32(
155 (u32
)sta_ht_inf
->ampdu_density
<< STA_FLG_AGG_MPDU_DENSITY_POS
);
157 if (iwl_is_fat_tx_allowed(priv
, sta_ht_inf
))
158 sta_flags
|= STA_FLG_FAT_EN_MSK
;
160 sta_flags
&= ~STA_FLG_FAT_EN_MSK
;
162 priv
->stations
[index
].sta
.station_flags
= sta_flags
;
167 static inline void iwl_set_ht_add_station(struct iwl_priv
*priv
, u8 index
,
168 struct ieee80211_ht_info
*sta_ht_info
)
174 * iwl_add_station_flags - Add station to tables in driver and device
176 u8
iwl_add_station_flags(struct iwl_priv
*priv
, const u8
*addr
, int is_ap
,
177 u8 flags
, struct ieee80211_ht_info
*ht_info
)
180 int index
= IWL_INVALID_STATION
;
181 struct iwl_station_entry
*station
;
182 unsigned long flags_spin
;
183 DECLARE_MAC_BUF(mac
);
185 spin_lock_irqsave(&priv
->sta_lock
, flags_spin
);
188 else if (is_broadcast_ether_addr(addr
))
189 index
= priv
->hw_params
.bcast_sta_id
;
191 for (i
= IWL_STA_ID
; i
< priv
->hw_params
.max_stations
; i
++) {
192 if (!compare_ether_addr(priv
->stations
[i
].sta
.sta
.addr
,
198 if (!priv
->stations
[i
].used
&&
199 index
== IWL_INVALID_STATION
)
204 /* These two conditions have the same outcome, but keep them separate
205 since they have different meanings */
206 if (unlikely(index
== IWL_INVALID_STATION
)) {
207 spin_unlock_irqrestore(&priv
->sta_lock
, flags_spin
);
211 if (priv
->stations
[index
].used
&&
212 !compare_ether_addr(priv
->stations
[index
].sta
.sta
.addr
, addr
)) {
213 spin_unlock_irqrestore(&priv
->sta_lock
, flags_spin
);
218 IWL_DEBUG_ASSOC("Add STA ID %d: %s\n", index
, print_mac(mac
, addr
));
219 station
= &priv
->stations
[index
];
221 priv
->num_stations
++;
223 /* Set up the REPLY_ADD_STA command to send to device */
224 memset(&station
->sta
, 0, sizeof(struct iwl_addsta_cmd
));
225 memcpy(station
->sta
.sta
.addr
, addr
, ETH_ALEN
);
226 station
->sta
.mode
= 0;
227 station
->sta
.sta
.sta_id
= index
;
228 station
->sta
.station_flags
= 0;
230 /* BCAST station and IBSS stations do not work in HT mode */
231 if (index
!= priv
->hw_params
.bcast_sta_id
&&
232 priv
->iw_mode
!= IEEE80211_IF_TYPE_IBSS
)
233 iwl_set_ht_add_station(priv
, index
, ht_info
);
235 spin_unlock_irqrestore(&priv
->sta_lock
, flags_spin
);
237 /* Add station to device's station table */
238 iwl_send_add_sta(priv
, &station
->sta
, flags
);
242 EXPORT_SYMBOL(iwl_add_station_flags
);
244 int iwl_get_free_ucode_key_index(struct iwl_priv
*priv
)
248 for (i
= 0; i
< STA_KEY_MAX_NUM
; i
++)
249 if (!test_and_set_bit(i
, &priv
->ucode_key_table
))
255 int iwl_send_static_wepkey_cmd(struct iwl_priv
*priv
, u8 send_if_empty
)
257 int i
, not_empty
= 0;
258 u8 buff
[sizeof(struct iwl_wep_cmd
) +
259 sizeof(struct iwl_wep_key
) * WEP_KEYS_MAX
];
260 struct iwl_wep_cmd
*wep_cmd
= (struct iwl_wep_cmd
*)buff
;
261 size_t cmd_size
= sizeof(struct iwl_wep_cmd
);
262 struct iwl_host_cmd cmd
= {
265 .meta
.flags
= CMD_ASYNC
,
268 memset(wep_cmd
, 0, cmd_size
+
269 (sizeof(struct iwl_wep_key
) * WEP_KEYS_MAX
));
271 for (i
= 0; i
< WEP_KEYS_MAX
; i
++) {
272 wep_cmd
->key
[i
].key_index
= i
;
273 if (priv
->wep_keys
[i
].key_size
) {
274 wep_cmd
->key
[i
].key_offset
= i
;
277 wep_cmd
->key
[i
].key_offset
= WEP_INVALID_OFFSET
;
280 wep_cmd
->key
[i
].key_size
= priv
->wep_keys
[i
].key_size
;
281 memcpy(&wep_cmd
->key
[i
].key
[3], priv
->wep_keys
[i
].key
,
282 priv
->wep_keys
[i
].key_size
);
285 wep_cmd
->global_key_type
= WEP_KEY_WEP_TYPE
;
286 wep_cmd
->num_keys
= WEP_KEYS_MAX
;
288 cmd_size
+= sizeof(struct iwl_wep_key
) * WEP_KEYS_MAX
;
292 if (not_empty
|| send_if_empty
)
293 return iwl_send_cmd(priv
, &cmd
);
297 EXPORT_SYMBOL(iwl_send_static_wepkey_cmd
);
299 int iwl_remove_default_wep_key(struct iwl_priv
*priv
,
300 struct ieee80211_key_conf
*keyconf
)
305 spin_lock_irqsave(&priv
->sta_lock
, flags
);
307 if (!test_and_clear_bit(keyconf
->keyidx
, &priv
->ucode_key_table
))
308 IWL_ERROR("index %d not used in uCode key table.\n",
311 priv
->default_wep_key
--;
312 memset(&priv
->wep_keys
[keyconf
->keyidx
], 0, sizeof(priv
->wep_keys
[0]));
313 ret
= iwl_send_static_wepkey_cmd(priv
, 1);
314 spin_unlock_irqrestore(&priv
->sta_lock
, flags
);
318 EXPORT_SYMBOL(iwl_remove_default_wep_key
);
320 int iwl_set_default_wep_key(struct iwl_priv
*priv
,
321 struct ieee80211_key_conf
*keyconf
)
326 keyconf
->flags
&= ~IEEE80211_KEY_FLAG_GENERATE_IV
;
327 keyconf
->hw_key_idx
= HW_KEY_DEFAULT
;
328 priv
->stations
[IWL_AP_ID
].keyinfo
.alg
= ALG_WEP
;
330 spin_lock_irqsave(&priv
->sta_lock
, flags
);
331 priv
->default_wep_key
++;
333 if (test_and_set_bit(keyconf
->keyidx
, &priv
->ucode_key_table
))
334 IWL_ERROR("index %d already used in uCode key table.\n",
337 priv
->wep_keys
[keyconf
->keyidx
].key_size
= keyconf
->keylen
;
338 memcpy(&priv
->wep_keys
[keyconf
->keyidx
].key
, &keyconf
->key
,
341 ret
= iwl_send_static_wepkey_cmd(priv
, 0);
342 spin_unlock_irqrestore(&priv
->sta_lock
, flags
);
346 EXPORT_SYMBOL(iwl_set_default_wep_key
);
348 static int iwl_set_wep_dynamic_key_info(struct iwl_priv
*priv
,
349 struct ieee80211_key_conf
*keyconf
,
353 __le16 key_flags
= 0;
356 keyconf
->flags
&= ~IEEE80211_KEY_FLAG_GENERATE_IV
;
358 key_flags
|= (STA_KEY_FLG_WEP
| STA_KEY_FLG_MAP_KEY_MSK
);
359 key_flags
|= cpu_to_le16(keyconf
->keyidx
<< STA_KEY_FLG_KEYID_POS
);
360 key_flags
&= ~STA_KEY_FLG_INVALID
;
362 if (keyconf
->keylen
== WEP_KEY_LEN_128
)
363 key_flags
|= STA_KEY_FLG_KEY_SIZE_MSK
;
365 if (sta_id
== priv
->hw_params
.bcast_sta_id
)
366 key_flags
|= STA_KEY_MULTICAST_MSK
;
368 spin_lock_irqsave(&priv
->sta_lock
, flags
);
370 priv
->stations
[sta_id
].keyinfo
.alg
= keyconf
->alg
;
371 priv
->stations
[sta_id
].keyinfo
.keylen
= keyconf
->keylen
;
372 priv
->stations
[sta_id
].keyinfo
.keyidx
= keyconf
->keyidx
;
374 memcpy(priv
->stations
[sta_id
].keyinfo
.key
,
375 keyconf
->key
, keyconf
->keylen
);
377 memcpy(&priv
->stations
[sta_id
].sta
.key
.key
[3],
378 keyconf
->key
, keyconf
->keylen
);
380 if ((priv
->stations
[sta_id
].sta
.key
.key_flags
& STA_KEY_FLG_ENCRYPT_MSK
)
381 == STA_KEY_FLG_NO_ENC
)
382 priv
->stations
[sta_id
].sta
.key
.key_offset
=
383 iwl_get_free_ucode_key_index(priv
);
384 /* else, we are overriding an existing key => no need to allocated room
387 priv
->stations
[sta_id
].sta
.key
.key_flags
= key_flags
;
388 priv
->stations
[sta_id
].sta
.sta
.modify_mask
= STA_MODIFY_KEY_MASK
;
389 priv
->stations
[sta_id
].sta
.mode
= STA_CONTROL_MODIFY_MSK
;
391 ret
= iwl_send_add_sta(priv
, &priv
->stations
[sta_id
].sta
, CMD_ASYNC
);
393 spin_unlock_irqrestore(&priv
->sta_lock
, flags
);
398 static int iwl_set_ccmp_dynamic_key_info(struct iwl_priv
*priv
,
399 struct ieee80211_key_conf
*keyconf
,
403 __le16 key_flags
= 0;
405 key_flags
|= (STA_KEY_FLG_CCMP
| STA_KEY_FLG_MAP_KEY_MSK
);
406 key_flags
|= cpu_to_le16(keyconf
->keyidx
<< STA_KEY_FLG_KEYID_POS
);
407 key_flags
&= ~STA_KEY_FLG_INVALID
;
409 if (sta_id
== priv
->hw_params
.bcast_sta_id
)
410 key_flags
|= STA_KEY_MULTICAST_MSK
;
412 keyconf
->flags
|= IEEE80211_KEY_FLAG_GENERATE_IV
;
414 spin_lock_irqsave(&priv
->sta_lock
, flags
);
415 priv
->stations
[sta_id
].keyinfo
.alg
= keyconf
->alg
;
416 priv
->stations
[sta_id
].keyinfo
.keylen
= keyconf
->keylen
;
418 memcpy(priv
->stations
[sta_id
].keyinfo
.key
, keyconf
->key
,
421 memcpy(priv
->stations
[sta_id
].sta
.key
.key
, keyconf
->key
,
424 if ((priv
->stations
[sta_id
].sta
.key
.key_flags
& STA_KEY_FLG_ENCRYPT_MSK
)
425 == STA_KEY_FLG_NO_ENC
)
426 priv
->stations
[sta_id
].sta
.key
.key_offset
=
427 iwl_get_free_ucode_key_index(priv
);
428 /* else, we are overriding an existing key => no need to allocated room
431 priv
->stations
[sta_id
].sta
.key
.key_flags
= key_flags
;
432 priv
->stations
[sta_id
].sta
.sta
.modify_mask
= STA_MODIFY_KEY_MASK
;
433 priv
->stations
[sta_id
].sta
.mode
= STA_CONTROL_MODIFY_MSK
;
435 spin_unlock_irqrestore(&priv
->sta_lock
, flags
);
437 IWL_DEBUG_INFO("hwcrypto: modify ucode station key info\n");
438 return iwl_send_add_sta(priv
, &priv
->stations
[sta_id
].sta
, CMD_ASYNC
);
441 static int iwl_set_tkip_dynamic_key_info(struct iwl_priv
*priv
,
442 struct ieee80211_key_conf
*keyconf
,
448 keyconf
->flags
|= IEEE80211_KEY_FLAG_GENERATE_IV
;
449 keyconf
->flags
|= IEEE80211_KEY_FLAG_GENERATE_MMIC
;
451 spin_lock_irqsave(&priv
->sta_lock
, flags
);
453 priv
->stations
[sta_id
].keyinfo
.alg
= keyconf
->alg
;
454 priv
->stations
[sta_id
].keyinfo
.keylen
= 16;
456 if ((priv
->stations
[sta_id
].sta
.key
.key_flags
& STA_KEY_FLG_ENCRYPT_MSK
)
457 == STA_KEY_FLG_NO_ENC
)
458 priv
->stations
[sta_id
].sta
.key
.key_offset
=
459 iwl_get_free_ucode_key_index(priv
);
460 /* else, we are overriding an existing key => no need to allocated room
463 /* This copy is acutally not needed: we get the key with each TX */
464 memcpy(priv
->stations
[sta_id
].keyinfo
.key
, keyconf
->key
, 16);
466 memcpy(priv
->stations
[sta_id
].sta
.key
.key
, keyconf
->key
, 16);
468 spin_unlock_irqrestore(&priv
->sta_lock
, flags
);
473 int iwl_remove_dynamic_key(struct iwl_priv
*priv
,
474 struct ieee80211_key_conf
*keyconf
,
482 priv
->key_mapping_key
--;
484 spin_lock_irqsave(&priv
->sta_lock
, flags
);
485 key_flags
= le16_to_cpu(priv
->stations
[sta_id
].sta
.key
.key_flags
);
486 keyidx
= (key_flags
>> STA_KEY_FLG_KEYID_POS
) & 0x3;
488 if (keyconf
->keyidx
!= keyidx
) {
489 /* We need to remove a key with index different that the one
490 * in the uCode. This means that the key we need to remove has
491 * been replaced by another one with different index.
492 * Don't do anything and return ok
494 spin_unlock_irqrestore(&priv
->sta_lock
, flags
);
498 if (!test_and_clear_bit(priv
->stations
[sta_id
].sta
.key
.key_offset
,
499 &priv
->ucode_key_table
))
500 IWL_ERROR("index %d not used in uCode key table.\n",
501 priv
->stations
[sta_id
].sta
.key
.key_offset
);
502 memset(&priv
->stations
[sta_id
].keyinfo
, 0,
503 sizeof(struct iwl_hw_key
));
504 memset(&priv
->stations
[sta_id
].sta
.key
, 0,
505 sizeof(struct iwl4965_keyinfo
));
506 priv
->stations
[sta_id
].sta
.key
.key_flags
=
507 STA_KEY_FLG_NO_ENC
| STA_KEY_FLG_INVALID
;
508 priv
->stations
[sta_id
].sta
.key
.key_offset
= WEP_INVALID_OFFSET
;
509 priv
->stations
[sta_id
].sta
.sta
.modify_mask
= STA_MODIFY_KEY_MASK
;
510 priv
->stations
[sta_id
].sta
.mode
= STA_CONTROL_MODIFY_MSK
;
512 IWL_DEBUG_INFO("hwcrypto: clear ucode station key info\n");
513 ret
= iwl_send_add_sta(priv
, &priv
->stations
[sta_id
].sta
, CMD_ASYNC
);
514 spin_unlock_irqrestore(&priv
->sta_lock
, flags
);
517 EXPORT_SYMBOL(iwl_remove_dynamic_key
);
519 int iwl_set_dynamic_key(struct iwl_priv
*priv
,
520 struct ieee80211_key_conf
*keyconf
, u8 sta_id
)
524 priv
->key_mapping_key
++;
525 keyconf
->hw_key_idx
= HW_KEY_DYNAMIC
;
527 switch (keyconf
->alg
) {
529 ret
= iwl_set_ccmp_dynamic_key_info(priv
, keyconf
, sta_id
);
532 ret
= iwl_set_tkip_dynamic_key_info(priv
, keyconf
, sta_id
);
535 ret
= iwl_set_wep_dynamic_key_info(priv
, keyconf
, sta_id
);
538 IWL_ERROR("Unknown alg: %s alg = %d\n", __func__
, keyconf
->alg
);
544 EXPORT_SYMBOL(iwl_set_dynamic_key
);
546 #ifdef CONFIG_IWLWIFI_DEBUG
547 static void iwl_dump_lq_cmd(struct iwl_priv
*priv
,
548 struct iwl_link_quality_cmd
*lq
)
551 IWL_DEBUG_RATE("lq station id 0x%x\n", lq
->sta_id
);
552 IWL_DEBUG_RATE("lq dta 0x%X 0x%X\n",
553 lq
->general_params
.single_stream_ant_msk
,
554 lq
->general_params
.dual_stream_ant_msk
);
556 for (i
= 0; i
< LINK_QUAL_MAX_RETRY_NUM
; i
++)
557 IWL_DEBUG_RATE("lq index %d 0x%X\n",
558 i
, lq
->rs_table
[i
].rate_n_flags
);
561 static inline void iwl_dump_lq_cmd(struct iwl_priv
*priv
,
562 struct iwl_link_quality_cmd
*lq
)
567 int iwl_send_lq_cmd(struct iwl_priv
*priv
,
568 struct iwl_link_quality_cmd
*lq
, u8 flags
)
570 struct iwl_host_cmd cmd
= {
571 .id
= REPLY_TX_LINK_QUALITY_CMD
,
572 .len
= sizeof(struct iwl_link_quality_cmd
),
577 if ((lq
->sta_id
== 0xFF) &&
578 (priv
->iw_mode
== IEEE80211_IF_TYPE_IBSS
))
581 if (lq
->sta_id
== 0xFF)
582 lq
->sta_id
= IWL_AP_ID
;
584 iwl_dump_lq_cmd(priv
,lq
);
586 if (iwl_is_associated(priv
) && priv
->assoc_station_added
&&
587 priv
->lq_mngr
.lq_ready
)
588 return iwl_send_cmd(priv
, &cmd
);
592 EXPORT_SYMBOL(iwl_send_lq_cmd
);
595 * iwl_sta_init_lq - Initialize a station's hardware rate table
597 * The uCode's station table contains a table of fallback rates
598 * for automatic fallback during transmission.
600 * NOTE: This sets up a default set of values. These will be replaced later
601 * if the driver's iwl-4965-rs rate scaling algorithm is used, instead of
604 * NOTE: Run REPLY_ADD_STA command to set up station table entry, before
605 * calling this function (which runs REPLY_TX_LINK_QUALITY_CMD,
606 * which requires station table entry to exist).
608 static void iwl_sta_init_lq(struct iwl_priv
*priv
, const u8
*addr
, int is_ap
)
611 struct iwl_link_quality_cmd link_cmd
= {
616 /* Set up the rate scaling to start at selected rate, fall back
617 * all the way down to 1M in IEEE order, and then spin on 1M */
619 r
= IWL_RATE_54M_INDEX
;
620 else if (priv
->band
== IEEE80211_BAND_5GHZ
)
621 r
= IWL_RATE_6M_INDEX
;
623 r
= IWL_RATE_1M_INDEX
;
625 for (i
= 0; i
< LINK_QUAL_MAX_RETRY_NUM
; i
++) {
627 if (r
>= IWL_FIRST_CCK_RATE
&& r
<= IWL_LAST_CCK_RATE
)
628 rate_flags
|= RATE_MCS_CCK_MSK
;
630 /* Use Tx antenna B only */
631 rate_flags
|= RATE_MCS_ANT_B_MSK
; /*FIXME:RS*/
633 link_cmd
.rs_table
[i
].rate_n_flags
=
634 iwl4965_hw_set_rate_n_flags(iwl_rates
[r
].plcp
, rate_flags
);
635 r
= iwl4965_get_prev_ieee_rate(r
);
638 link_cmd
.general_params
.single_stream_ant_msk
= 2;
639 link_cmd
.general_params
.dual_stream_ant_msk
= 3;
640 link_cmd
.agg_params
.agg_dis_start_th
= 3;
641 link_cmd
.agg_params
.agg_time_limit
= cpu_to_le16(4000);
643 /* Update the rate scaling for control frame Tx to AP */
644 link_cmd
.sta_id
= is_ap
? IWL_AP_ID
: priv
->hw_params
.bcast_sta_id
;
646 iwl_send_cmd_pdu_async(priv
, REPLY_TX_LINK_QUALITY_CMD
,
647 sizeof(link_cmd
), &link_cmd
, NULL
);
650 * iwl_rxon_add_station - add station into station table.
652 * there is only one AP station with id= IWL_AP_ID
653 * NOTE: mutex must be held before calling this fnction
655 int iwl_rxon_add_station(struct iwl_priv
*priv
, const u8
*addr
, int is_ap
)
659 /* Add station to device's station table */
660 #ifdef CONFIG_IWL4965_HT
661 struct ieee80211_conf
*conf
= &priv
->hw
->conf
;
662 struct ieee80211_ht_info
*cur_ht_config
= &conf
->ht_conf
;
665 (conf
->flags
& IEEE80211_CONF_SUPPORT_HT_MODE
) &&
666 (priv
->iw_mode
== IEEE80211_IF_TYPE_STA
))
667 sta_id
= iwl_add_station_flags(priv
, addr
, is_ap
,
670 #endif /* CONFIG_IWL4965_HT */
671 sta_id
= iwl_add_station_flags(priv
, addr
, is_ap
,
674 /* Set up default rate scaling table in device's station table */
675 iwl_sta_init_lq(priv
, addr
, is_ap
);
679 EXPORT_SYMBOL(iwl_rxon_add_station
);
683 * iwl_get_sta_id - Find station's index within station table
685 * If new IBSS station, create new entry in station table
687 int iwl_get_sta_id(struct iwl_priv
*priv
, struct ieee80211_hdr
*hdr
)
690 u16 fc
= le16_to_cpu(hdr
->frame_control
);
691 DECLARE_MAC_BUF(mac
);
693 /* If this frame is broadcast or management, use broadcast station id */
694 if (((fc
& IEEE80211_FCTL_FTYPE
) != IEEE80211_FTYPE_DATA
) ||
695 is_multicast_ether_addr(hdr
->addr1
))
696 return priv
->hw_params
.bcast_sta_id
;
698 switch (priv
->iw_mode
) {
700 /* If we are a client station in a BSS network, use the special
701 * AP station entry (that's the only station we communicate with) */
702 case IEEE80211_IF_TYPE_STA
:
705 /* If we are an AP, then find the station, or use BCAST */
706 case IEEE80211_IF_TYPE_AP
:
707 sta_id
= iwl_find_station(priv
, hdr
->addr1
);
708 if (sta_id
!= IWL_INVALID_STATION
)
710 return priv
->hw_params
.bcast_sta_id
;
712 /* If this frame is going out to an IBSS network, find the station,
713 * or create a new station table entry */
714 case IEEE80211_IF_TYPE_IBSS
:
715 sta_id
= iwl_find_station(priv
, hdr
->addr1
);
716 if (sta_id
!= IWL_INVALID_STATION
)
719 /* Create new station table entry */
720 sta_id
= iwl_add_station_flags(priv
, hdr
->addr1
,
723 if (sta_id
!= IWL_INVALID_STATION
)
726 IWL_DEBUG_DROP("Station %s not in station map. "
727 "Defaulting to broadcast...\n",
728 print_mac(mac
, hdr
->addr1
));
729 iwl_print_hex_dump(priv
, IWL_DL_DROP
, (u8
*) hdr
, sizeof(*hdr
));
730 return priv
->hw_params
.bcast_sta_id
;
733 IWL_WARNING("Unknown mode of operation: %d", priv
->iw_mode
);
734 return priv
->hw_params
.bcast_sta_id
;
737 EXPORT_SYMBOL(iwl_get_sta_id
);