2 * BSS client mode implementation
3 * Copyright 2003-2008, Jouni Malinen <j@w1.fi>
4 * Copyright 2004, Instant802 Networks, Inc.
5 * Copyright 2005, Devicescape Software, Inc.
6 * Copyright 2006-2007 Jiri Benc <jbenc@suse.cz>
7 * Copyright 2007, Michael Wu <flamingice@sourmilk.net>
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License version 2 as
11 * published by the Free Software Foundation.
14 #include <linux/delay.h>
15 #include <linux/if_ether.h>
16 #include <linux/skbuff.h>
17 #include <linux/if_arp.h>
18 #include <linux/etherdevice.h>
19 #include <linux/rtnetlink.h>
20 #include <linux/pm_qos_params.h>
21 #include <linux/crc32.h>
22 #include <net/mac80211.h>
23 #include <asm/unaligned.h>
25 #include "ieee80211_i.h"
26 #include "driver-ops.h"
30 #define IEEE80211_ASSOC_SCANS_MAX_TRIES 2
31 #define IEEE80211_AUTH_TIMEOUT (HZ / 5)
32 #define IEEE80211_AUTH_MAX_TRIES 3
33 #define IEEE80211_ASSOC_TIMEOUT (HZ / 5)
34 #define IEEE80211_ASSOC_MAX_TRIES 3
35 #define IEEE80211_MONITORING_INTERVAL (2 * HZ)
36 #define IEEE80211_PROBE_WAIT (HZ / 5)
37 #define IEEE80211_PROBE_IDLE_TIME (60 * HZ)
38 #define IEEE80211_RETRY_AUTH_INTERVAL (1 * HZ)
40 #define TMR_RUNNING_TIMER 0
41 #define TMR_RUNNING_CHANSW 1
44 static int ecw2cw(int ecw
)
46 return (1 << ecw
) - 1;
49 static int ieee80211_compatible_rates(struct ieee80211_bss
*bss
,
50 struct ieee80211_supported_band
*sband
,
56 for (i
= 0; i
< bss
->supp_rates_len
; i
++) {
57 int rate
= (bss
->supp_rates
[i
] & 0x7F) * 5;
59 for (j
= 0; j
< sband
->n_bitrates
; j
++)
60 if (sband
->bitrates
[j
].bitrate
== rate
) {
71 * ieee80211_enable_ht should be called only after the operating band
72 * has been determined as ht configuration depends on the hw's
73 * HT abilities for a specific band.
75 static u32
ieee80211_enable_ht(struct ieee80211_sub_if_data
*sdata
,
76 struct ieee80211_ht_info
*hti
,
79 struct ieee80211_local
*local
= sdata
->local
;
80 struct ieee80211_supported_band
*sband
;
81 struct ieee80211_if_managed
*ifmgd
= &sdata
->u
.mgd
;
85 bool enable_ht
= true, ht_changed
;
86 enum nl80211_channel_type channel_type
= NL80211_CHAN_NO_HT
;
88 sband
= local
->hw
.wiphy
->bands
[local
->hw
.conf
.channel
->band
];
90 /* HT is not supported */
91 if (!sband
->ht_cap
.ht_supported
)
94 /* check that channel matches the right operating channel */
95 if (local
->hw
.conf
.channel
->center_freq
!=
96 ieee80211_channel_to_frequency(hti
->control_chan
))
100 channel_type
= NL80211_CHAN_HT20
;
102 if (!(ap_ht_cap_flags
& IEEE80211_HT_CAP_40MHZ_INTOLERANT
) &&
103 (sband
->ht_cap
.cap
& IEEE80211_HT_CAP_SUP_WIDTH_20_40
) &&
104 (hti
->ht_param
& IEEE80211_HT_PARAM_CHAN_WIDTH_ANY
)) {
105 switch(hti
->ht_param
& IEEE80211_HT_PARAM_CHA_SEC_OFFSET
) {
106 case IEEE80211_HT_PARAM_CHA_SEC_ABOVE
:
107 if (!(local
->hw
.conf
.channel
->flags
&
108 IEEE80211_CHAN_NO_HT40PLUS
))
109 channel_type
= NL80211_CHAN_HT40PLUS
;
111 case IEEE80211_HT_PARAM_CHA_SEC_BELOW
:
112 if (!(local
->hw
.conf
.channel
->flags
&
113 IEEE80211_CHAN_NO_HT40MINUS
))
114 channel_type
= NL80211_CHAN_HT40MINUS
;
120 ht_changed
= conf_is_ht(&local
->hw
.conf
) != enable_ht
||
121 channel_type
!= local
->hw
.conf
.channel_type
;
123 local
->oper_channel_type
= channel_type
;
126 /* channel_type change automatically detected */
127 ieee80211_hw_config(local
, 0);
131 sta
= sta_info_get(local
, ifmgd
->bssid
);
133 rate_control_rate_update(local
, sband
, sta
,
134 IEEE80211_RC_HT_CHANGED
);
143 ht_opmode
= le16_to_cpu(hti
->operation_mode
);
145 /* if bss configuration changed store the new one */
146 if (!sdata
->ht_opmode_valid
||
147 sdata
->vif
.bss_conf
.ht_operation_mode
!= ht_opmode
) {
148 changed
|= BSS_CHANGED_HT
;
149 sdata
->vif
.bss_conf
.ht_operation_mode
= ht_opmode
;
150 sdata
->ht_opmode_valid
= true;
156 /* frame sending functions */
158 static void ieee80211_send_assoc(struct ieee80211_sub_if_data
*sdata
)
160 struct ieee80211_if_managed
*ifmgd
= &sdata
->u
.mgd
;
161 struct ieee80211_local
*local
= sdata
->local
;
163 struct ieee80211_mgmt
*mgmt
;
165 const u8
*ies
, *ht_ie
;
166 int i
, len
, count
, rates_len
, supp_rates_len
;
168 struct ieee80211_bss
*bss
;
170 struct ieee80211_supported_band
*sband
;
173 skb
= dev_alloc_skb(local
->hw
.extra_tx_headroom
+
174 sizeof(*mgmt
) + 200 + ifmgd
->extra_ie_len
+
177 printk(KERN_DEBUG
"%s: failed to allocate buffer for assoc "
178 "frame\n", sdata
->dev
->name
);
181 skb_reserve(skb
, local
->hw
.extra_tx_headroom
);
183 sband
= local
->hw
.wiphy
->bands
[local
->hw
.conf
.channel
->band
];
185 capab
= ifmgd
->capab
;
187 if (local
->hw
.conf
.channel
->band
== IEEE80211_BAND_2GHZ
) {
188 if (!(local
->hw
.flags
& IEEE80211_HW_2GHZ_SHORT_SLOT_INCAPABLE
))
189 capab
|= WLAN_CAPABILITY_SHORT_SLOT_TIME
;
190 if (!(local
->hw
.flags
& IEEE80211_HW_2GHZ_SHORT_PREAMBLE_INCAPABLE
))
191 capab
|= WLAN_CAPABILITY_SHORT_PREAMBLE
;
194 bss
= ieee80211_rx_bss_get(local
, ifmgd
->bssid
,
195 local
->hw
.conf
.channel
->center_freq
,
196 ifmgd
->ssid
, ifmgd
->ssid_len
);
198 if (bss
->cbss
.capability
& WLAN_CAPABILITY_PRIVACY
)
199 capab
|= WLAN_CAPABILITY_PRIVACY
;
203 /* get all rates supported by the device and the AP as
204 * some APs don't like getting a superset of their rates
205 * in the association request (e.g. D-Link DAP 1353 in
207 rates_len
= ieee80211_compatible_rates(bss
, sband
, &rates
);
209 if ((bss
->cbss
.capability
& WLAN_CAPABILITY_SPECTRUM_MGMT
) &&
210 (local
->hw
.flags
& IEEE80211_HW_SPECTRUM_MGMT
))
211 capab
|= WLAN_CAPABILITY_SPECTRUM_MGMT
;
213 ieee80211_rx_bss_put(local
, bss
);
216 rates_len
= sband
->n_bitrates
;
219 mgmt
= (struct ieee80211_mgmt
*) skb_put(skb
, 24);
221 memcpy(mgmt
->da
, ifmgd
->bssid
, ETH_ALEN
);
222 memcpy(mgmt
->sa
, sdata
->dev
->dev_addr
, ETH_ALEN
);
223 memcpy(mgmt
->bssid
, ifmgd
->bssid
, ETH_ALEN
);
225 if (ifmgd
->flags
& IEEE80211_STA_PREV_BSSID_SET
) {
227 mgmt
->frame_control
= cpu_to_le16(IEEE80211_FTYPE_MGMT
|
228 IEEE80211_STYPE_REASSOC_REQ
);
229 mgmt
->u
.reassoc_req
.capab_info
= cpu_to_le16(capab
);
230 mgmt
->u
.reassoc_req
.listen_interval
=
231 cpu_to_le16(local
->hw
.conf
.listen_interval
);
232 memcpy(mgmt
->u
.reassoc_req
.current_ap
, ifmgd
->prev_bssid
,
236 mgmt
->frame_control
= cpu_to_le16(IEEE80211_FTYPE_MGMT
|
237 IEEE80211_STYPE_ASSOC_REQ
);
238 mgmt
->u
.assoc_req
.capab_info
= cpu_to_le16(capab
);
239 mgmt
->u
.assoc_req
.listen_interval
=
240 cpu_to_le16(local
->hw
.conf
.listen_interval
);
244 ies
= pos
= skb_put(skb
, 2 + ifmgd
->ssid_len
);
245 *pos
++ = WLAN_EID_SSID
;
246 *pos
++ = ifmgd
->ssid_len
;
247 memcpy(pos
, ifmgd
->ssid
, ifmgd
->ssid_len
);
249 /* add all rates which were marked to be used above */
250 supp_rates_len
= rates_len
;
251 if (supp_rates_len
> 8)
254 len
= sband
->n_bitrates
;
255 pos
= skb_put(skb
, supp_rates_len
+ 2);
256 *pos
++ = WLAN_EID_SUPP_RATES
;
257 *pos
++ = supp_rates_len
;
260 for (i
= 0; i
< sband
->n_bitrates
; i
++) {
261 if (BIT(i
) & rates
) {
262 int rate
= sband
->bitrates
[i
].bitrate
;
263 *pos
++ = (u8
) (rate
/ 5);
269 if (rates_len
> count
) {
270 pos
= skb_put(skb
, rates_len
- count
+ 2);
271 *pos
++ = WLAN_EID_EXT_SUPP_RATES
;
272 *pos
++ = rates_len
- count
;
274 for (i
++; i
< sband
->n_bitrates
; i
++) {
275 if (BIT(i
) & rates
) {
276 int rate
= sband
->bitrates
[i
].bitrate
;
277 *pos
++ = (u8
) (rate
/ 5);
282 if (capab
& WLAN_CAPABILITY_SPECTRUM_MGMT
) {
283 /* 1. power capabilities */
284 pos
= skb_put(skb
, 4);
285 *pos
++ = WLAN_EID_PWR_CAPABILITY
;
287 *pos
++ = 0; /* min tx power */
288 *pos
++ = local
->hw
.conf
.channel
->max_power
; /* max tx power */
290 /* 2. supported channels */
291 /* TODO: get this in reg domain format */
292 pos
= skb_put(skb
, 2 * sband
->n_channels
+ 2);
293 *pos
++ = WLAN_EID_SUPPORTED_CHANNELS
;
294 *pos
++ = 2 * sband
->n_channels
;
295 for (i
= 0; i
< sband
->n_channels
; i
++) {
296 *pos
++ = ieee80211_frequency_to_channel(
297 sband
->channels
[i
].center_freq
);
298 *pos
++ = 1; /* one channel in the subband*/
302 if (ifmgd
->extra_ie
) {
303 pos
= skb_put(skb
, ifmgd
->extra_ie_len
);
304 memcpy(pos
, ifmgd
->extra_ie
, ifmgd
->extra_ie_len
);
307 if (wmm
&& (ifmgd
->flags
& IEEE80211_STA_WMM_ENABLED
)) {
308 pos
= skb_put(skb
, 9);
309 *pos
++ = WLAN_EID_VENDOR_SPECIFIC
;
310 *pos
++ = 7; /* len */
311 *pos
++ = 0x00; /* Microsoft OUI 00:50:F2 */
314 *pos
++ = 2; /* WME */
315 *pos
++ = 0; /* WME info */
316 *pos
++ = 1; /* WME ver */
320 /* wmm support is a must to HT */
322 * IEEE802.11n does not allow TKIP/WEP as pairwise
323 * ciphers in HT mode. We still associate in non-ht
324 * mode (11a/b/g) if any one of these ciphers is
325 * configured as pairwise.
327 if (wmm
&& (ifmgd
->flags
& IEEE80211_STA_WMM_ENABLED
) &&
328 sband
->ht_cap
.ht_supported
&&
329 (ht_ie
= ieee80211_bss_get_ie(&bss
->cbss
, WLAN_EID_HT_INFORMATION
)) &&
330 ht_ie
[1] >= sizeof(struct ieee80211_ht_info
) &&
331 (!(ifmgd
->flags
& IEEE80211_STA_DISABLE_11N
))) {
332 struct ieee80211_ht_info
*ht_info
=
333 (struct ieee80211_ht_info
*)(ht_ie
+ 2);
334 u16 cap
= sband
->ht_cap
.cap
;
336 u32 flags
= local
->hw
.conf
.channel
->flags
;
338 switch (ht_info
->ht_param
& IEEE80211_HT_PARAM_CHA_SEC_OFFSET
) {
339 case IEEE80211_HT_PARAM_CHA_SEC_ABOVE
:
340 if (flags
& IEEE80211_CHAN_NO_HT40PLUS
) {
341 cap
&= ~IEEE80211_HT_CAP_SUP_WIDTH_20_40
;
342 cap
&= ~IEEE80211_HT_CAP_SGI_40
;
345 case IEEE80211_HT_PARAM_CHA_SEC_BELOW
:
346 if (flags
& IEEE80211_CHAN_NO_HT40MINUS
) {
347 cap
&= ~IEEE80211_HT_CAP_SUP_WIDTH_20_40
;
348 cap
&= ~IEEE80211_HT_CAP_SGI_40
;
353 tmp
= cpu_to_le16(cap
);
354 pos
= skb_put(skb
, sizeof(struct ieee80211_ht_cap
)+2);
355 *pos
++ = WLAN_EID_HT_CAPABILITY
;
356 *pos
++ = sizeof(struct ieee80211_ht_cap
);
357 memset(pos
, 0, sizeof(struct ieee80211_ht_cap
));
358 memcpy(pos
, &tmp
, sizeof(u16
));
360 /* TODO: needs a define here for << 2 */
361 *pos
++ = sband
->ht_cap
.ampdu_factor
|
362 (sband
->ht_cap
.ampdu_density
<< 2);
363 memcpy(pos
, &sband
->ht_cap
.mcs
, sizeof(sband
->ht_cap
.mcs
));
366 kfree(ifmgd
->assocreq_ies
);
367 ifmgd
->assocreq_ies_len
= (skb
->data
+ skb
->len
) - ies
;
368 ifmgd
->assocreq_ies
= kmalloc(ifmgd
->assocreq_ies_len
, GFP_KERNEL
);
369 if (ifmgd
->assocreq_ies
)
370 memcpy(ifmgd
->assocreq_ies
, ies
, ifmgd
->assocreq_ies_len
);
372 ieee80211_tx_skb(sdata
, skb
, 0);
376 static void ieee80211_send_deauth_disassoc(struct ieee80211_sub_if_data
*sdata
,
377 u16 stype
, u16 reason
)
379 struct ieee80211_local
*local
= sdata
->local
;
380 struct ieee80211_if_managed
*ifmgd
= &sdata
->u
.mgd
;
382 struct ieee80211_mgmt
*mgmt
;
384 skb
= dev_alloc_skb(local
->hw
.extra_tx_headroom
+ sizeof(*mgmt
));
386 printk(KERN_DEBUG
"%s: failed to allocate buffer for "
387 "deauth/disassoc frame\n", sdata
->dev
->name
);
390 skb_reserve(skb
, local
->hw
.extra_tx_headroom
);
392 mgmt
= (struct ieee80211_mgmt
*) skb_put(skb
, 24);
394 memcpy(mgmt
->da
, ifmgd
->bssid
, ETH_ALEN
);
395 memcpy(mgmt
->sa
, sdata
->dev
->dev_addr
, ETH_ALEN
);
396 memcpy(mgmt
->bssid
, ifmgd
->bssid
, ETH_ALEN
);
397 mgmt
->frame_control
= cpu_to_le16(IEEE80211_FTYPE_MGMT
| stype
);
399 /* u.deauth.reason_code == u.disassoc.reason_code */
400 mgmt
->u
.deauth
.reason_code
= cpu_to_le16(reason
);
402 if (stype
== IEEE80211_STYPE_DEAUTH
)
403 cfg80211_send_deauth(sdata
->dev
, (u8
*) mgmt
, skb
->len
,
406 cfg80211_send_disassoc(sdata
->dev
, (u8
*) mgmt
, skb
->len
,
408 ieee80211_tx_skb(sdata
, skb
, ifmgd
->flags
& IEEE80211_STA_MFP_ENABLED
);
411 void ieee80211_send_pspoll(struct ieee80211_local
*local
,
412 struct ieee80211_sub_if_data
*sdata
)
414 struct ieee80211_if_managed
*ifmgd
= &sdata
->u
.mgd
;
415 struct ieee80211_pspoll
*pspoll
;
419 skb
= dev_alloc_skb(local
->hw
.extra_tx_headroom
+ sizeof(*pspoll
));
421 printk(KERN_DEBUG
"%s: failed to allocate buffer for "
422 "pspoll frame\n", sdata
->dev
->name
);
425 skb_reserve(skb
, local
->hw
.extra_tx_headroom
);
427 pspoll
= (struct ieee80211_pspoll
*) skb_put(skb
, sizeof(*pspoll
));
428 memset(pspoll
, 0, sizeof(*pspoll
));
429 fc
= IEEE80211_FTYPE_CTL
| IEEE80211_STYPE_PSPOLL
| IEEE80211_FCTL_PM
;
430 pspoll
->frame_control
= cpu_to_le16(fc
);
431 pspoll
->aid
= cpu_to_le16(ifmgd
->aid
);
433 /* aid in PS-Poll has its two MSBs each set to 1 */
434 pspoll
->aid
|= cpu_to_le16(1 << 15 | 1 << 14);
436 memcpy(pspoll
->bssid
, ifmgd
->bssid
, ETH_ALEN
);
437 memcpy(pspoll
->ta
, sdata
->dev
->dev_addr
, ETH_ALEN
);
439 ieee80211_tx_skb(sdata
, skb
, 0);
442 void ieee80211_send_nullfunc(struct ieee80211_local
*local
,
443 struct ieee80211_sub_if_data
*sdata
,
447 struct ieee80211_hdr
*nullfunc
;
450 if (WARN_ON(sdata
->vif
.type
!= NL80211_IFTYPE_STATION
))
453 skb
= dev_alloc_skb(local
->hw
.extra_tx_headroom
+ 24);
455 printk(KERN_DEBUG
"%s: failed to allocate buffer for nullfunc "
456 "frame\n", sdata
->dev
->name
);
459 skb_reserve(skb
, local
->hw
.extra_tx_headroom
);
461 nullfunc
= (struct ieee80211_hdr
*) skb_put(skb
, 24);
462 memset(nullfunc
, 0, 24);
463 fc
= cpu_to_le16(IEEE80211_FTYPE_DATA
| IEEE80211_STYPE_NULLFUNC
|
464 IEEE80211_FCTL_TODS
);
466 fc
|= cpu_to_le16(IEEE80211_FCTL_PM
);
467 nullfunc
->frame_control
= fc
;
468 memcpy(nullfunc
->addr1
, sdata
->u
.mgd
.bssid
, ETH_ALEN
);
469 memcpy(nullfunc
->addr2
, sdata
->dev
->dev_addr
, ETH_ALEN
);
470 memcpy(nullfunc
->addr3
, sdata
->u
.mgd
.bssid
, ETH_ALEN
);
472 ieee80211_tx_skb(sdata
, skb
, 0);
475 /* spectrum management related things */
476 static void ieee80211_chswitch_work(struct work_struct
*work
)
478 struct ieee80211_sub_if_data
*sdata
=
479 container_of(work
, struct ieee80211_sub_if_data
, u
.mgd
.chswitch_work
);
480 struct ieee80211_bss
*bss
;
481 struct ieee80211_if_managed
*ifmgd
= &sdata
->u
.mgd
;
483 if (!netif_running(sdata
->dev
))
486 bss
= ieee80211_rx_bss_get(sdata
->local
, ifmgd
->bssid
,
487 sdata
->local
->hw
.conf
.channel
->center_freq
,
488 ifmgd
->ssid
, ifmgd
->ssid_len
);
492 sdata
->local
->oper_channel
= sdata
->local
->csa_channel
;
493 /* XXX: shouldn't really modify cfg80211-owned data! */
494 if (!ieee80211_hw_config(sdata
->local
, IEEE80211_CONF_CHANGE_CHANNEL
))
495 bss
->cbss
.channel
= sdata
->local
->oper_channel
;
497 ieee80211_rx_bss_put(sdata
->local
, bss
);
499 ifmgd
->flags
&= ~IEEE80211_STA_CSA_RECEIVED
;
500 ieee80211_wake_queues_by_reason(&sdata
->local
->hw
,
501 IEEE80211_QUEUE_STOP_REASON_CSA
);
504 static void ieee80211_chswitch_timer(unsigned long data
)
506 struct ieee80211_sub_if_data
*sdata
=
507 (struct ieee80211_sub_if_data
*) data
;
508 struct ieee80211_if_managed
*ifmgd
= &sdata
->u
.mgd
;
510 if (sdata
->local
->quiescing
) {
511 set_bit(TMR_RUNNING_CHANSW
, &ifmgd
->timers_running
);
515 queue_work(sdata
->local
->hw
.workqueue
, &ifmgd
->chswitch_work
);
518 void ieee80211_sta_process_chanswitch(struct ieee80211_sub_if_data
*sdata
,
519 struct ieee80211_channel_sw_ie
*sw_elem
,
520 struct ieee80211_bss
*bss
)
522 struct ieee80211_channel
*new_ch
;
523 struct ieee80211_if_managed
*ifmgd
= &sdata
->u
.mgd
;
524 int new_freq
= ieee80211_channel_to_frequency(sw_elem
->new_ch_num
);
526 if (ifmgd
->state
!= IEEE80211_STA_MLME_ASSOCIATED
)
529 if (sdata
->local
->sw_scanning
|| sdata
->local
->hw_scanning
)
532 /* Disregard subsequent beacons if we are already running a timer
535 if (ifmgd
->flags
& IEEE80211_STA_CSA_RECEIVED
)
538 new_ch
= ieee80211_get_channel(sdata
->local
->hw
.wiphy
, new_freq
);
539 if (!new_ch
|| new_ch
->flags
& IEEE80211_CHAN_DISABLED
)
542 sdata
->local
->csa_channel
= new_ch
;
544 if (sw_elem
->count
<= 1) {
545 queue_work(sdata
->local
->hw
.workqueue
, &ifmgd
->chswitch_work
);
547 ieee80211_stop_queues_by_reason(&sdata
->local
->hw
,
548 IEEE80211_QUEUE_STOP_REASON_CSA
);
549 ifmgd
->flags
|= IEEE80211_STA_CSA_RECEIVED
;
550 mod_timer(&ifmgd
->chswitch_timer
,
552 msecs_to_jiffies(sw_elem
->count
*
553 bss
->cbss
.beacon_interval
));
557 static void ieee80211_handle_pwr_constr(struct ieee80211_sub_if_data
*sdata
,
558 u16 capab_info
, u8
*pwr_constr_elem
,
559 u8 pwr_constr_elem_len
)
561 struct ieee80211_conf
*conf
= &sdata
->local
->hw
.conf
;
563 if (!(capab_info
& WLAN_CAPABILITY_SPECTRUM_MGMT
))
566 /* Power constraint IE length should be 1 octet */
567 if (pwr_constr_elem_len
!= 1)
570 if ((*pwr_constr_elem
<= conf
->channel
->max_power
) &&
571 (*pwr_constr_elem
!= sdata
->local
->power_constr_level
)) {
572 sdata
->local
->power_constr_level
= *pwr_constr_elem
;
573 ieee80211_hw_config(sdata
->local
, 0);
578 static void ieee80211_enable_ps(struct ieee80211_local
*local
,
579 struct ieee80211_sub_if_data
*sdata
)
581 struct ieee80211_conf
*conf
= &local
->hw
.conf
;
584 * If we are scanning right now then the parameters will
585 * take effect when scan finishes.
587 if (local
->hw_scanning
|| local
->sw_scanning
)
590 if (conf
->dynamic_ps_timeout
> 0 &&
591 !(local
->hw
.flags
& IEEE80211_HW_SUPPORTS_DYNAMIC_PS
)) {
592 mod_timer(&local
->dynamic_ps_timer
, jiffies
+
593 msecs_to_jiffies(conf
->dynamic_ps_timeout
));
595 if (local
->hw
.flags
& IEEE80211_HW_PS_NULLFUNC_STACK
)
596 ieee80211_send_nullfunc(local
, sdata
, 1);
597 conf
->flags
|= IEEE80211_CONF_PS
;
598 ieee80211_hw_config(local
, IEEE80211_CONF_CHANGE_PS
);
602 static void ieee80211_change_ps(struct ieee80211_local
*local
)
604 struct ieee80211_conf
*conf
= &local
->hw
.conf
;
606 if (local
->ps_sdata
) {
607 ieee80211_enable_ps(local
, local
->ps_sdata
);
608 } else if (conf
->flags
& IEEE80211_CONF_PS
) {
609 conf
->flags
&= ~IEEE80211_CONF_PS
;
610 ieee80211_hw_config(local
, IEEE80211_CONF_CHANGE_PS
);
611 del_timer_sync(&local
->dynamic_ps_timer
);
612 cancel_work_sync(&local
->dynamic_ps_enable_work
);
616 /* need to hold RTNL or interface lock */
617 void ieee80211_recalc_ps(struct ieee80211_local
*local
, s32 latency
)
619 struct ieee80211_sub_if_data
*sdata
, *found
= NULL
;
622 if (!(local
->hw
.flags
& IEEE80211_HW_SUPPORTS_PS
)) {
623 local
->ps_sdata
= NULL
;
627 list_for_each_entry(sdata
, &local
->interfaces
, list
) {
628 if (!netif_running(sdata
->dev
))
630 if (sdata
->vif
.type
!= NL80211_IFTYPE_STATION
)
636 if (count
== 1 && found
->u
.mgd
.powersave
&&
637 (found
->u
.mgd
.flags
& IEEE80211_STA_ASSOCIATED
) &&
638 !(found
->u
.mgd
.flags
& IEEE80211_STA_PROBEREQ_POLL
)) {
642 latency
= pm_qos_requirement(PM_QOS_NETWORK_LATENCY
);
644 beaconint_us
= ieee80211_tu_to_usec(
645 found
->vif
.bss_conf
.beacon_int
);
647 if (beaconint_us
> latency
) {
648 local
->ps_sdata
= NULL
;
650 u8 dtimper
= found
->vif
.bss_conf
.dtim_period
;
654 maxslp
= min_t(int, dtimper
,
655 latency
/ beaconint_us
);
657 local
->hw
.conf
.max_sleep_period
= maxslp
;
658 local
->ps_sdata
= found
;
661 local
->ps_sdata
= NULL
;
664 ieee80211_change_ps(local
);
667 void ieee80211_dynamic_ps_disable_work(struct work_struct
*work
)
669 struct ieee80211_local
*local
=
670 container_of(work
, struct ieee80211_local
,
671 dynamic_ps_disable_work
);
673 if (local
->hw
.conf
.flags
& IEEE80211_CONF_PS
) {
674 local
->hw
.conf
.flags
&= ~IEEE80211_CONF_PS
;
675 ieee80211_hw_config(local
, IEEE80211_CONF_CHANGE_PS
);
678 ieee80211_wake_queues_by_reason(&local
->hw
,
679 IEEE80211_QUEUE_STOP_REASON_PS
);
682 void ieee80211_dynamic_ps_enable_work(struct work_struct
*work
)
684 struct ieee80211_local
*local
=
685 container_of(work
, struct ieee80211_local
,
686 dynamic_ps_enable_work
);
687 struct ieee80211_sub_if_data
*sdata
= local
->ps_sdata
;
689 /* can only happen when PS was just disabled anyway */
693 if (local
->hw
.conf
.flags
& IEEE80211_CONF_PS
)
696 if (local
->hw
.flags
& IEEE80211_HW_PS_NULLFUNC_STACK
)
697 ieee80211_send_nullfunc(local
, sdata
, 1);
699 local
->hw
.conf
.flags
|= IEEE80211_CONF_PS
;
700 ieee80211_hw_config(local
, IEEE80211_CONF_CHANGE_PS
);
703 void ieee80211_dynamic_ps_timer(unsigned long data
)
705 struct ieee80211_local
*local
= (void *) data
;
707 if (local
->quiescing
)
710 queue_work(local
->hw
.workqueue
, &local
->dynamic_ps_enable_work
);
714 static void ieee80211_sta_wmm_params(struct ieee80211_local
*local
,
715 struct ieee80211_if_managed
*ifmgd
,
716 u8
*wmm_param
, size_t wmm_param_len
)
718 struct ieee80211_tx_queue_params params
;
723 if (!(ifmgd
->flags
& IEEE80211_STA_WMM_ENABLED
))
729 if (wmm_param_len
< 8 || wmm_param
[5] /* version */ != 1)
731 count
= wmm_param
[6] & 0x0f;
732 if (count
== ifmgd
->wmm_last_param_set
)
734 ifmgd
->wmm_last_param_set
= count
;
737 left
= wmm_param_len
- 8;
739 memset(¶ms
, 0, sizeof(params
));
742 for (; left
>= 4; left
-= 4, pos
+= 4) {
743 int aci
= (pos
[0] >> 5) & 0x03;
744 int acm
= (pos
[0] >> 4) & 0x01;
751 local
->wmm_acm
|= BIT(1) | BIT(2); /* BK/- */
756 local
->wmm_acm
|= BIT(4) | BIT(5); /* CL/VI */
761 local
->wmm_acm
|= BIT(6) | BIT(7); /* VO/NC */
767 local
->wmm_acm
|= BIT(0) | BIT(3); /* BE/EE */
771 params
.aifs
= pos
[0] & 0x0f;
772 params
.cw_max
= ecw2cw((pos
[1] & 0xf0) >> 4);
773 params
.cw_min
= ecw2cw(pos
[1] & 0x0f);
774 params
.txop
= get_unaligned_le16(pos
+ 2);
775 #ifdef CONFIG_MAC80211_VERBOSE_DEBUG
776 printk(KERN_DEBUG
"%s: WMM queue=%d aci=%d acm=%d aifs=%d "
777 "cWmin=%d cWmax=%d txop=%d\n",
778 wiphy_name(local
->hw
.wiphy
), queue
, aci
, acm
,
779 params
.aifs
, params
.cw_min
, params
.cw_max
, params
.txop
);
781 if (drv_conf_tx(local
, queue
, ¶ms
) && local
->ops
->conf_tx
)
782 printk(KERN_DEBUG
"%s: failed to set TX queue "
783 "parameters for queue %d\n",
784 wiphy_name(local
->hw
.wiphy
), queue
);
788 static u32
ieee80211_handle_bss_capability(struct ieee80211_sub_if_data
*sdata
,
789 u16 capab
, bool erp_valid
, u8 erp
)
791 struct ieee80211_bss_conf
*bss_conf
= &sdata
->vif
.bss_conf
;
792 #ifdef CONFIG_MAC80211_VERBOSE_DEBUG
793 struct ieee80211_if_managed
*ifmgd
= &sdata
->u
.mgd
;
797 bool use_short_preamble
;
801 use_protection
= (erp
& WLAN_ERP_USE_PROTECTION
) != 0;
802 use_short_preamble
= (erp
& WLAN_ERP_BARKER_PREAMBLE
) == 0;
804 use_protection
= false;
805 use_short_preamble
= !!(capab
& WLAN_CAPABILITY_SHORT_PREAMBLE
);
808 use_short_slot
= !!(capab
& WLAN_CAPABILITY_SHORT_SLOT_TIME
);
810 if (use_protection
!= bss_conf
->use_cts_prot
) {
811 #ifdef CONFIG_MAC80211_VERBOSE_DEBUG
812 if (net_ratelimit()) {
813 printk(KERN_DEBUG
"%s: CTS protection %s (BSSID=%pM)\n",
815 use_protection
? "enabled" : "disabled",
819 bss_conf
->use_cts_prot
= use_protection
;
820 changed
|= BSS_CHANGED_ERP_CTS_PROT
;
823 if (use_short_preamble
!= bss_conf
->use_short_preamble
) {
824 #ifdef CONFIG_MAC80211_VERBOSE_DEBUG
825 if (net_ratelimit()) {
826 printk(KERN_DEBUG
"%s: switched to %s barker preamble"
829 use_short_preamble
? "short" : "long",
833 bss_conf
->use_short_preamble
= use_short_preamble
;
834 changed
|= BSS_CHANGED_ERP_PREAMBLE
;
837 if (use_short_slot
!= bss_conf
->use_short_slot
) {
838 #ifdef CONFIG_MAC80211_VERBOSE_DEBUG
839 if (net_ratelimit()) {
840 printk(KERN_DEBUG
"%s: switched to %s slot time"
843 use_short_slot
? "short" : "long",
847 bss_conf
->use_short_slot
= use_short_slot
;
848 changed
|= BSS_CHANGED_ERP_SLOT
;
854 static void ieee80211_set_associated(struct ieee80211_sub_if_data
*sdata
,
855 u32 bss_info_changed
)
857 struct ieee80211_if_managed
*ifmgd
= &sdata
->u
.mgd
;
858 struct ieee80211_local
*local
= sdata
->local
;
859 struct ieee80211_conf
*conf
= &local_to_hw(local
)->conf
;
861 struct ieee80211_bss
*bss
;
863 bss_info_changed
|= BSS_CHANGED_ASSOC
;
864 ifmgd
->flags
|= IEEE80211_STA_ASSOCIATED
;
866 bss
= ieee80211_rx_bss_get(local
, ifmgd
->bssid
,
867 conf
->channel
->center_freq
,
868 ifmgd
->ssid
, ifmgd
->ssid_len
);
870 /* set timing information */
871 sdata
->vif
.bss_conf
.beacon_int
= bss
->cbss
.beacon_interval
;
872 sdata
->vif
.bss_conf
.timestamp
= bss
->cbss
.tsf
;
873 sdata
->vif
.bss_conf
.dtim_period
= bss
->dtim_period
;
875 bss_info_changed
|= BSS_CHANGED_BEACON_INT
;
876 bss_info_changed
|= ieee80211_handle_bss_capability(sdata
,
877 bss
->cbss
.capability
, bss
->has_erp_value
, bss
->erp_value
);
879 ieee80211_rx_bss_put(local
, bss
);
882 ifmgd
->flags
|= IEEE80211_STA_PREV_BSSID_SET
;
883 memcpy(ifmgd
->prev_bssid
, sdata
->u
.mgd
.bssid
, ETH_ALEN
);
885 ifmgd
->last_probe
= jiffies
;
886 ieee80211_led_assoc(local
, 1);
888 sdata
->vif
.bss_conf
.assoc
= 1;
890 * For now just always ask the driver to update the basic rateset
891 * when we have associated, we aren't checking whether it actually
894 bss_info_changed
|= BSS_CHANGED_BASIC_RATES
;
896 /* And the BSSID changed - we're associated now */
897 bss_info_changed
|= BSS_CHANGED_BSSID
;
899 ieee80211_bss_info_change_notify(sdata
, bss_info_changed
);
901 /* will be same as sdata */
902 if (local
->ps_sdata
) {
903 mutex_lock(&local
->iflist_mtx
);
904 ieee80211_recalc_ps(local
, -1);
905 mutex_unlock(&local
->iflist_mtx
);
908 netif_tx_start_all_queues(sdata
->dev
);
909 netif_carrier_on(sdata
->dev
);
912 static void ieee80211_direct_probe(struct ieee80211_sub_if_data
*sdata
)
914 struct ieee80211_if_managed
*ifmgd
= &sdata
->u
.mgd
;
915 struct ieee80211_local
*local
= sdata
->local
;
917 ifmgd
->direct_probe_tries
++;
918 if (ifmgd
->direct_probe_tries
> IEEE80211_AUTH_MAX_TRIES
) {
919 printk(KERN_DEBUG
"%s: direct probe to AP %pM timed out\n",
920 sdata
->dev
->name
, ifmgd
->bssid
);
921 ifmgd
->state
= IEEE80211_STA_MLME_DISABLED
;
922 ieee80211_recalc_idle(local
);
923 cfg80211_send_auth_timeout(sdata
->dev
, ifmgd
->bssid
,
927 * Most likely AP is not in the range so remove the
928 * bss information associated to the AP
930 ieee80211_rx_bss_remove(sdata
, ifmgd
->bssid
,
931 sdata
->local
->hw
.conf
.channel
->center_freq
,
932 ifmgd
->ssid
, ifmgd
->ssid_len
);
935 * We might have a pending scan which had no chance to run yet
936 * due to state == IEEE80211_STA_MLME_DIRECT_PROBE.
937 * Hence, queue the STAs work again
939 queue_work(local
->hw
.workqueue
, &ifmgd
->work
);
943 printk(KERN_DEBUG
"%s: direct probe to AP %pM try %d\n",
944 sdata
->dev
->name
, ifmgd
->bssid
,
945 ifmgd
->direct_probe_tries
);
947 ifmgd
->state
= IEEE80211_STA_MLME_DIRECT_PROBE
;
949 /* Direct probe is sent to broadcast address as some APs
950 * will not answer to direct packet in unassociated state.
952 ieee80211_send_probe_req(sdata
, NULL
,
953 ifmgd
->ssid
, ifmgd
->ssid_len
, NULL
, 0);
955 mod_timer(&ifmgd
->timer
, jiffies
+ IEEE80211_AUTH_TIMEOUT
);
959 static void ieee80211_authenticate(struct ieee80211_sub_if_data
*sdata
)
961 struct ieee80211_if_managed
*ifmgd
= &sdata
->u
.mgd
;
962 struct ieee80211_local
*local
= sdata
->local
;
965 if (ifmgd
->auth_tries
> IEEE80211_AUTH_MAX_TRIES
) {
966 printk(KERN_DEBUG
"%s: authentication with AP %pM"
968 sdata
->dev
->name
, ifmgd
->bssid
);
969 ifmgd
->state
= IEEE80211_STA_MLME_DISABLED
;
970 ieee80211_recalc_idle(local
);
971 cfg80211_send_auth_timeout(sdata
->dev
, ifmgd
->bssid
,
973 ieee80211_rx_bss_remove(sdata
, ifmgd
->bssid
,
974 sdata
->local
->hw
.conf
.channel
->center_freq
,
975 ifmgd
->ssid
, ifmgd
->ssid_len
);
978 * We might have a pending scan which had no chance to run yet
979 * due to state == IEEE80211_STA_MLME_AUTHENTICATE.
980 * Hence, queue the STAs work again
982 queue_work(local
->hw
.workqueue
, &ifmgd
->work
);
986 ifmgd
->state
= IEEE80211_STA_MLME_AUTHENTICATE
;
987 printk(KERN_DEBUG
"%s: authenticate with AP %pM\n",
988 sdata
->dev
->name
, ifmgd
->bssid
);
990 ieee80211_send_auth(sdata
, 1, ifmgd
->auth_alg
, ifmgd
->sme_auth_ie
,
991 ifmgd
->sme_auth_ie_len
, ifmgd
->bssid
, 0);
992 ifmgd
->auth_transaction
= 2;
994 mod_timer(&ifmgd
->timer
, jiffies
+ IEEE80211_AUTH_TIMEOUT
);
998 * The disassoc 'reason' argument can be either our own reason
999 * if self disconnected or a reason code from the AP.
1001 static void ieee80211_set_disassoc(struct ieee80211_sub_if_data
*sdata
,
1002 bool deauth
, bool self_disconnected
,
1005 struct ieee80211_if_managed
*ifmgd
= &sdata
->u
.mgd
;
1006 struct ieee80211_local
*local
= sdata
->local
;
1007 struct ieee80211_conf
*conf
= &local_to_hw(local
)->conf
;
1008 struct ieee80211_bss
*bss
;
1009 struct sta_info
*sta
;
1010 u32 changed
= 0, config_changed
= 0;
1013 ifmgd
->direct_probe_tries
= 0;
1014 ifmgd
->auth_tries
= 0;
1016 ifmgd
->assoc_scan_tries
= 0;
1017 ifmgd
->assoc_tries
= 0;
1019 netif_tx_stop_all_queues(sdata
->dev
);
1020 netif_carrier_off(sdata
->dev
);
1023 sta
= sta_info_get(local
, ifmgd
->bssid
);
1025 ieee80211_sta_tear_down_BA_sessions(sta
);
1028 bss
= ieee80211_rx_bss_get(local
, ifmgd
->bssid
,
1029 conf
->channel
->center_freq
,
1030 ifmgd
->ssid
, ifmgd
->ssid_len
);
1033 ieee80211_rx_bss_put(local
, bss
);
1035 if (self_disconnected
) {
1037 ieee80211_send_deauth_disassoc(sdata
,
1038 IEEE80211_STYPE_DEAUTH
, reason
);
1040 ieee80211_send_deauth_disassoc(sdata
,
1041 IEEE80211_STYPE_DISASSOC
, reason
);
1044 ifmgd
->flags
&= ~IEEE80211_STA_ASSOCIATED
;
1045 changed
|= ieee80211_reset_erp_info(sdata
);
1047 ieee80211_led_assoc(local
, 0);
1048 changed
|= BSS_CHANGED_ASSOC
;
1049 sdata
->vif
.bss_conf
.assoc
= false;
1051 if (self_disconnected
|| reason
== WLAN_REASON_DISASSOC_STA_HAS_LEFT
) {
1052 ifmgd
->state
= IEEE80211_STA_MLME_DISABLED
;
1053 ieee80211_rx_bss_remove(sdata
, ifmgd
->bssid
,
1054 sdata
->local
->hw
.conf
.channel
->center_freq
,
1055 ifmgd
->ssid
, ifmgd
->ssid_len
);
1058 ieee80211_set_wmm_default(sdata
);
1060 ieee80211_recalc_idle(local
);
1062 /* channel(_type) changes are handled by ieee80211_hw_config */
1063 local
->oper_channel_type
= NL80211_CHAN_NO_HT
;
1065 /* on the next assoc, re-program HT parameters */
1066 sdata
->ht_opmode_valid
= false;
1068 local
->power_constr_level
= 0;
1070 del_timer_sync(&local
->dynamic_ps_timer
);
1071 cancel_work_sync(&local
->dynamic_ps_enable_work
);
1073 if (local
->hw
.conf
.flags
& IEEE80211_CONF_PS
) {
1074 local
->hw
.conf
.flags
&= ~IEEE80211_CONF_PS
;
1075 config_changed
|= IEEE80211_CONF_CHANGE_PS
;
1078 ieee80211_hw_config(local
, config_changed
);
1080 /* And the BSSID changed -- not very interesting here */
1081 changed
|= BSS_CHANGED_BSSID
;
1082 ieee80211_bss_info_change_notify(sdata
, changed
);
1086 sta
= sta_info_get(local
, ifmgd
->bssid
);
1092 sta_info_unlink(&sta
);
1096 sta_info_destroy(sta
);
1099 static void ieee80211_associate(struct ieee80211_sub_if_data
*sdata
)
1101 struct ieee80211_if_managed
*ifmgd
= &sdata
->u
.mgd
;
1102 struct ieee80211_local
*local
= sdata
->local
;
1104 ifmgd
->assoc_tries
++;
1105 if (ifmgd
->assoc_tries
> IEEE80211_ASSOC_MAX_TRIES
) {
1106 printk(KERN_DEBUG
"%s: association with AP %pM"
1108 sdata
->dev
->name
, ifmgd
->bssid
);
1109 ifmgd
->state
= IEEE80211_STA_MLME_DISABLED
;
1110 ieee80211_recalc_idle(local
);
1111 cfg80211_send_assoc_timeout(sdata
->dev
, ifmgd
->bssid
,
1113 ieee80211_rx_bss_remove(sdata
, ifmgd
->bssid
,
1114 sdata
->local
->hw
.conf
.channel
->center_freq
,
1115 ifmgd
->ssid
, ifmgd
->ssid_len
);
1117 * We might have a pending scan which had no chance to run yet
1118 * due to state == IEEE80211_STA_MLME_ASSOCIATE.
1119 * Hence, queue the STAs work again
1121 queue_work(local
->hw
.workqueue
, &ifmgd
->work
);
1125 ifmgd
->state
= IEEE80211_STA_MLME_ASSOCIATE
;
1126 printk(KERN_DEBUG
"%s: associate with AP %pM\n",
1127 sdata
->dev
->name
, ifmgd
->bssid
);
1128 ieee80211_send_assoc(sdata
);
1130 mod_timer(&ifmgd
->timer
, jiffies
+ IEEE80211_ASSOC_TIMEOUT
);
1133 void ieee80211_sta_rx_notify(struct ieee80211_sub_if_data
*sdata
,
1134 struct ieee80211_hdr
*hdr
)
1137 * We can postpone the mgd.timer whenever receiving unicast frames
1138 * from AP because we know that the connection is working both ways
1139 * at that time. But multicast frames (and hence also beacons) must
1140 * be ignored here, because we need to trigger the timer during
1141 * data idle periods for sending the periodical probe request to
1144 if (!is_multicast_ether_addr(hdr
->addr1
))
1145 mod_timer(&sdata
->u
.mgd
.timer
,
1146 jiffies
+ IEEE80211_MONITORING_INTERVAL
);
1149 void ieee80211_beacon_loss_work(struct work_struct
*work
)
1151 struct ieee80211_sub_if_data
*sdata
=
1152 container_of(work
, struct ieee80211_sub_if_data
,
1153 u
.mgd
.beacon_loss_work
);
1154 struct ieee80211_if_managed
*ifmgd
= &sdata
->u
.mgd
;
1157 * The driver has already reported this event and we have
1158 * already sent a probe request. Maybe the AP died and the
1159 * driver keeps reporting until we disassociate... We have
1160 * to ignore that because otherwise we would continually
1161 * reset the timer and never check whether we received a
1164 if (ifmgd
->flags
& IEEE80211_STA_PROBEREQ_POLL
)
1167 #ifdef CONFIG_MAC80211_VERBOSE_DEBUG
1168 if (net_ratelimit()) {
1169 printk(KERN_DEBUG
"%s: driver reports beacon loss from AP %pM "
1170 "- sending probe request\n", sdata
->dev
->name
,
1171 sdata
->u
.mgd
.bssid
);
1175 ifmgd
->flags
|= IEEE80211_STA_PROBEREQ_POLL
;
1177 mutex_lock(&sdata
->local
->iflist_mtx
);
1178 ieee80211_recalc_ps(sdata
->local
, -1);
1179 mutex_unlock(&sdata
->local
->iflist_mtx
);
1181 ieee80211_send_probe_req(sdata
, ifmgd
->bssid
, ifmgd
->ssid
,
1182 ifmgd
->ssid_len
, NULL
, 0);
1184 mod_timer(&ifmgd
->timer
, jiffies
+ IEEE80211_PROBE_WAIT
);
1187 void ieee80211_beacon_loss(struct ieee80211_vif
*vif
)
1189 struct ieee80211_sub_if_data
*sdata
= vif_to_sdata(vif
);
1191 queue_work(sdata
->local
->hw
.workqueue
,
1192 &sdata
->u
.mgd
.beacon_loss_work
);
1194 EXPORT_SYMBOL(ieee80211_beacon_loss
);
1196 static void ieee80211_associated(struct ieee80211_sub_if_data
*sdata
)
1198 struct ieee80211_if_managed
*ifmgd
= &sdata
->u
.mgd
;
1199 struct ieee80211_local
*local
= sdata
->local
;
1200 struct sta_info
*sta
;
1201 unsigned long last_rx
;
1202 bool disassoc
= false;
1204 /* TODO: start monitoring current AP signal quality and number of
1205 * missed beacons. Scan other channels every now and then and search
1206 * for better APs. */
1207 /* TODO: remove expired BSSes */
1209 ifmgd
->state
= IEEE80211_STA_MLME_ASSOCIATED
;
1213 sta
= sta_info_get(local
, ifmgd
->bssid
);
1215 printk(KERN_DEBUG
"%s: No STA entry for own AP %pM\n",
1216 sdata
->dev
->name
, ifmgd
->bssid
);
1222 last_rx
= sta
->last_rx
;
1225 if ((ifmgd
->flags
& IEEE80211_STA_PROBEREQ_POLL
) &&
1226 time_after(jiffies
, last_rx
+ IEEE80211_PROBE_WAIT
)) {
1227 printk(KERN_DEBUG
"%s: no probe response from AP %pM "
1228 "- disassociating\n",
1229 sdata
->dev
->name
, ifmgd
->bssid
);
1231 ifmgd
->flags
&= ~IEEE80211_STA_PROBEREQ_POLL
;
1236 * Beacon filtering is only enabled with power save and then the
1237 * stack should not check for beacon loss.
1239 if (!((local
->hw
.flags
& IEEE80211_HW_BEACON_FILTER
) &&
1240 (local
->hw
.conf
.flags
& IEEE80211_CONF_PS
)) &&
1242 ifmgd
->last_beacon
+ IEEE80211_MONITORING_INTERVAL
)) {
1243 #ifdef CONFIG_MAC80211_VERBOSE_DEBUG
1244 if (net_ratelimit()) {
1245 printk(KERN_DEBUG
"%s: beacon loss from AP %pM "
1246 "- sending probe request\n",
1247 sdata
->dev
->name
, ifmgd
->bssid
);
1250 ifmgd
->flags
|= IEEE80211_STA_PROBEREQ_POLL
;
1251 mutex_lock(&local
->iflist_mtx
);
1252 ieee80211_recalc_ps(local
, -1);
1253 mutex_unlock(&local
->iflist_mtx
);
1254 ieee80211_send_probe_req(sdata
, ifmgd
->bssid
, ifmgd
->ssid
,
1255 ifmgd
->ssid_len
, NULL
, 0);
1256 mod_timer(&ifmgd
->timer
, jiffies
+ IEEE80211_PROBE_WAIT
);
1260 if (time_after(jiffies
, last_rx
+ IEEE80211_PROBE_IDLE_TIME
)) {
1261 ifmgd
->flags
|= IEEE80211_STA_PROBEREQ_POLL
;
1262 mutex_lock(&local
->iflist_mtx
);
1263 ieee80211_recalc_ps(local
, -1);
1264 mutex_unlock(&local
->iflist_mtx
);
1265 ieee80211_send_probe_req(sdata
, ifmgd
->bssid
, ifmgd
->ssid
,
1266 ifmgd
->ssid_len
, NULL
, 0);
1271 mod_timer(&ifmgd
->timer
,
1272 jiffies
+ IEEE80211_MONITORING_INTERVAL
);
1274 ieee80211_set_disassoc(sdata
, true, true,
1275 WLAN_REASON_PREV_AUTH_NOT_VALID
);
1279 static void ieee80211_auth_completed(struct ieee80211_sub_if_data
*sdata
)
1281 struct ieee80211_if_managed
*ifmgd
= &sdata
->u
.mgd
;
1283 printk(KERN_DEBUG
"%s: authenticated\n", sdata
->dev
->name
);
1284 ifmgd
->flags
|= IEEE80211_STA_AUTHENTICATED
;
1285 /* Wait for SME to request association */
1286 ifmgd
->state
= IEEE80211_STA_MLME_DISABLED
;
1287 ieee80211_recalc_idle(sdata
->local
);
1291 static void ieee80211_auth_challenge(struct ieee80211_sub_if_data
*sdata
,
1292 struct ieee80211_mgmt
*mgmt
,
1296 struct ieee802_11_elems elems
;
1298 pos
= mgmt
->u
.auth
.variable
;
1299 ieee802_11_parse_elems(pos
, len
- (pos
- (u8
*) mgmt
), &elems
);
1300 if (!elems
.challenge
)
1302 ieee80211_send_auth(sdata
, 3, sdata
->u
.mgd
.auth_alg
,
1303 elems
.challenge
- 2, elems
.challenge_len
+ 2,
1304 sdata
->u
.mgd
.bssid
, 1);
1305 sdata
->u
.mgd
.auth_transaction
= 4;
1308 static void ieee80211_rx_mgmt_auth(struct ieee80211_sub_if_data
*sdata
,
1309 struct ieee80211_mgmt
*mgmt
,
1312 struct ieee80211_if_managed
*ifmgd
= &sdata
->u
.mgd
;
1313 u16 auth_alg
, auth_transaction
, status_code
;
1315 if (ifmgd
->state
!= IEEE80211_STA_MLME_AUTHENTICATE
)
1321 if (memcmp(ifmgd
->bssid
, mgmt
->sa
, ETH_ALEN
) != 0)
1324 if (memcmp(ifmgd
->bssid
, mgmt
->bssid
, ETH_ALEN
) != 0)
1327 auth_alg
= le16_to_cpu(mgmt
->u
.auth
.auth_alg
);
1328 auth_transaction
= le16_to_cpu(mgmt
->u
.auth
.auth_transaction
);
1329 status_code
= le16_to_cpu(mgmt
->u
.auth
.status_code
);
1331 if (auth_alg
!= ifmgd
->auth_alg
||
1332 auth_transaction
!= ifmgd
->auth_transaction
)
1335 if (status_code
!= WLAN_STATUS_SUCCESS
) {
1336 cfg80211_send_rx_auth(sdata
->dev
, (u8
*) mgmt
, len
,
1338 ifmgd
->state
= IEEE80211_STA_MLME_DISABLED
;
1339 ieee80211_recalc_idle(sdata
->local
);
1343 switch (ifmgd
->auth_alg
) {
1344 case WLAN_AUTH_OPEN
:
1345 case WLAN_AUTH_LEAP
:
1347 ieee80211_auth_completed(sdata
);
1348 cfg80211_send_rx_auth(sdata
->dev
, (u8
*) mgmt
, len
,
1351 case WLAN_AUTH_SHARED_KEY
:
1352 if (ifmgd
->auth_transaction
== 4) {
1353 ieee80211_auth_completed(sdata
);
1354 cfg80211_send_rx_auth(sdata
->dev
, (u8
*) mgmt
, len
,
1357 ieee80211_auth_challenge(sdata
, mgmt
, len
);
1363 static void ieee80211_rx_mgmt_deauth(struct ieee80211_sub_if_data
*sdata
,
1364 struct ieee80211_mgmt
*mgmt
,
1367 struct ieee80211_if_managed
*ifmgd
= &sdata
->u
.mgd
;
1373 if (memcmp(ifmgd
->bssid
, mgmt
->sa
, ETH_ALEN
))
1376 reason_code
= le16_to_cpu(mgmt
->u
.deauth
.reason_code
);
1378 if (ifmgd
->flags
& IEEE80211_STA_AUTHENTICATED
)
1379 printk(KERN_DEBUG
"%s: deauthenticated (Reason: %u)\n",
1380 sdata
->dev
->name
, reason_code
);
1382 ieee80211_set_disassoc(sdata
, true, false, 0);
1383 ifmgd
->flags
&= ~IEEE80211_STA_AUTHENTICATED
;
1384 cfg80211_send_deauth(sdata
->dev
, (u8
*) mgmt
, len
, GFP_KERNEL
);
1388 static void ieee80211_rx_mgmt_disassoc(struct ieee80211_sub_if_data
*sdata
,
1389 struct ieee80211_mgmt
*mgmt
,
1392 struct ieee80211_if_managed
*ifmgd
= &sdata
->u
.mgd
;
1398 if (memcmp(ifmgd
->bssid
, mgmt
->sa
, ETH_ALEN
))
1401 reason_code
= le16_to_cpu(mgmt
->u
.disassoc
.reason_code
);
1403 if (ifmgd
->flags
& IEEE80211_STA_ASSOCIATED
)
1404 printk(KERN_DEBUG
"%s: disassociated (Reason: %u)\n",
1405 sdata
->dev
->name
, reason_code
);
1407 ieee80211_set_disassoc(sdata
, false, false, reason_code
);
1408 cfg80211_send_disassoc(sdata
->dev
, (u8
*) mgmt
, len
, GFP_KERNEL
);
1412 static void ieee80211_rx_mgmt_assoc_resp(struct ieee80211_sub_if_data
*sdata
,
1413 struct ieee80211_mgmt
*mgmt
,
1417 struct ieee80211_if_managed
*ifmgd
= &sdata
->u
.mgd
;
1418 struct ieee80211_local
*local
= sdata
->local
;
1419 struct ieee80211_supported_band
*sband
;
1420 struct sta_info
*sta
;
1421 u32 rates
, basic_rates
;
1422 u16 capab_info
, status_code
, aid
;
1423 struct ieee802_11_elems elems
;
1424 struct ieee80211_bss_conf
*bss_conf
= &sdata
->vif
.bss_conf
;
1428 bool have_higher_than_11mbit
= false, newsta
= false;
1429 u16 ap_ht_cap_flags
;
1431 /* AssocResp and ReassocResp have identical structure, so process both
1432 * of them in this function. */
1434 if (ifmgd
->state
!= IEEE80211_STA_MLME_ASSOCIATE
)
1440 if (memcmp(ifmgd
->bssid
, mgmt
->sa
, ETH_ALEN
) != 0)
1443 capab_info
= le16_to_cpu(mgmt
->u
.assoc_resp
.capab_info
);
1444 status_code
= le16_to_cpu(mgmt
->u
.assoc_resp
.status_code
);
1445 aid
= le16_to_cpu(mgmt
->u
.assoc_resp
.aid
);
1447 printk(KERN_DEBUG
"%s: RX %sssocResp from %pM (capab=0x%x "
1448 "status=%d aid=%d)\n",
1449 sdata
->dev
->name
, reassoc
? "Rea" : "A", mgmt
->sa
,
1450 capab_info
, status_code
, (u16
)(aid
& ~(BIT(15) | BIT(14))));
1452 pos
= mgmt
->u
.assoc_resp
.variable
;
1453 ieee802_11_parse_elems(pos
, len
- (pos
- (u8
*) mgmt
), &elems
);
1455 if (status_code
== WLAN_STATUS_ASSOC_REJECTED_TEMPORARILY
&&
1456 elems
.timeout_int
&& elems
.timeout_int_len
== 5 &&
1457 elems
.timeout_int
[0] == WLAN_TIMEOUT_ASSOC_COMEBACK
) {
1459 tu
= get_unaligned_le32(elems
.timeout_int
+ 1);
1460 ms
= tu
* 1024 / 1000;
1461 printk(KERN_DEBUG
"%s: AP rejected association temporarily; "
1462 "comeback duration %u TU (%u ms)\n",
1463 sdata
->dev
->name
, tu
, ms
);
1464 if (ms
> IEEE80211_ASSOC_TIMEOUT
)
1465 mod_timer(&ifmgd
->timer
,
1466 jiffies
+ msecs_to_jiffies(ms
));
1470 if (status_code
!= WLAN_STATUS_SUCCESS
) {
1471 printk(KERN_DEBUG
"%s: AP denied association (code=%d)\n",
1472 sdata
->dev
->name
, status_code
);
1473 /* if this was a reassociation, ensure we try a "full"
1474 * association next time. This works around some broken APs
1475 * which do not correctly reject reassociation requests. */
1476 ifmgd
->flags
&= ~IEEE80211_STA_PREV_BSSID_SET
;
1477 cfg80211_send_rx_assoc(sdata
->dev
, (u8
*) mgmt
, len
,
1479 /* Wait for SME to decide what to do next */
1480 ifmgd
->state
= IEEE80211_STA_MLME_DISABLED
;
1481 ieee80211_recalc_idle(local
);
1485 if ((aid
& (BIT(15) | BIT(14))) != (BIT(15) | BIT(14)))
1486 printk(KERN_DEBUG
"%s: invalid aid value %d; bits 15:14 not "
1487 "set\n", sdata
->dev
->name
, aid
);
1488 aid
&= ~(BIT(15) | BIT(14));
1490 if (!elems
.supp_rates
) {
1491 printk(KERN_DEBUG
"%s: no SuppRates element in AssocResp\n",
1496 printk(KERN_DEBUG
"%s: associated\n", sdata
->dev
->name
);
1498 ifmgd
->ap_capab
= capab_info
;
1500 kfree(ifmgd
->assocresp_ies
);
1501 ifmgd
->assocresp_ies_len
= len
- (pos
- (u8
*) mgmt
);
1502 ifmgd
->assocresp_ies
= kmalloc(ifmgd
->assocresp_ies_len
, GFP_KERNEL
);
1503 if (ifmgd
->assocresp_ies
)
1504 memcpy(ifmgd
->assocresp_ies
, pos
, ifmgd
->assocresp_ies_len
);
1508 /* Add STA entry for the AP */
1509 sta
= sta_info_get(local
, ifmgd
->bssid
);
1513 sta
= sta_info_alloc(sdata
, ifmgd
->bssid
, GFP_ATOMIC
);
1515 printk(KERN_DEBUG
"%s: failed to alloc STA entry for"
1516 " the AP\n", sdata
->dev
->name
);
1521 /* update new sta with its last rx activity */
1522 sta
->last_rx
= jiffies
;
1526 * FIXME: Do we really need to update the sta_info's information here?
1527 * We already know about the AP (we found it in our list) so it
1528 * should already be filled with the right info, no?
1529 * As is stands, all this is racy because typically we assume
1530 * the information that is filled in here (except flags) doesn't
1531 * change while a STA structure is alive. As such, it should move
1532 * to between the sta_info_alloc() and sta_info_insert() above.
1535 set_sta_flags(sta
, WLAN_STA_AUTH
| WLAN_STA_ASSOC
| WLAN_STA_ASSOC_AP
);
1536 if (!(ifmgd
->flags
& IEEE80211_STA_CONTROL_PORT
))
1537 set_sta_flags(sta
, WLAN_STA_AUTHORIZED
);
1541 sband
= local
->hw
.wiphy
->bands
[local
->hw
.conf
.channel
->band
];
1543 for (i
= 0; i
< elems
.supp_rates_len
; i
++) {
1544 int rate
= (elems
.supp_rates
[i
] & 0x7f) * 5;
1545 bool is_basic
= !!(elems
.supp_rates
[i
] & 0x80);
1548 have_higher_than_11mbit
= true;
1550 for (j
= 0; j
< sband
->n_bitrates
; j
++) {
1551 if (sband
->bitrates
[j
].bitrate
== rate
) {
1554 basic_rates
|= BIT(j
);
1560 for (i
= 0; i
< elems
.ext_supp_rates_len
; i
++) {
1561 int rate
= (elems
.ext_supp_rates
[i
] & 0x7f) * 5;
1562 bool is_basic
= !!(elems
.ext_supp_rates
[i
] & 0x80);
1565 have_higher_than_11mbit
= true;
1567 for (j
= 0; j
< sband
->n_bitrates
; j
++) {
1568 if (sband
->bitrates
[j
].bitrate
== rate
) {
1571 basic_rates
|= BIT(j
);
1577 sta
->sta
.supp_rates
[local
->hw
.conf
.channel
->band
] = rates
;
1578 sdata
->vif
.bss_conf
.basic_rates
= basic_rates
;
1580 /* cf. IEEE 802.11 9.2.12 */
1581 if (local
->hw
.conf
.channel
->band
== IEEE80211_BAND_2GHZ
&&
1582 have_higher_than_11mbit
)
1583 sdata
->flags
|= IEEE80211_SDATA_OPERATING_GMODE
;
1585 sdata
->flags
&= ~IEEE80211_SDATA_OPERATING_GMODE
;
1587 if (elems
.ht_cap_elem
&& !(ifmgd
->flags
& IEEE80211_STA_DISABLE_11N
))
1588 ieee80211_ht_cap_ie_to_sta_ht_cap(sband
,
1589 elems
.ht_cap_elem
, &sta
->sta
.ht_cap
);
1591 ap_ht_cap_flags
= sta
->sta
.ht_cap
.cap
;
1593 rate_control_rate_init(sta
);
1595 if (ifmgd
->flags
& IEEE80211_STA_MFP_ENABLED
)
1596 set_sta_flags(sta
, WLAN_STA_MFP
);
1598 if (elems
.wmm_param
)
1599 set_sta_flags(sta
, WLAN_STA_WME
);
1602 int err
= sta_info_insert(sta
);
1604 printk(KERN_DEBUG
"%s: failed to insert STA entry for"
1605 " the AP (error %d)\n", sdata
->dev
->name
, err
);
1613 if (elems
.wmm_param
)
1614 ieee80211_sta_wmm_params(local
, ifmgd
, elems
.wmm_param
,
1615 elems
.wmm_param_len
);
1617 ieee80211_set_wmm_default(sdata
);
1619 if (elems
.ht_info_elem
&& elems
.wmm_param
&&
1620 (ifmgd
->flags
& IEEE80211_STA_WMM_ENABLED
) &&
1621 !(ifmgd
->flags
& IEEE80211_STA_DISABLE_11N
))
1622 changed
|= ieee80211_enable_ht(sdata
, elems
.ht_info_elem
,
1625 /* set AID and assoc capability,
1626 * ieee80211_set_associated() will tell the driver */
1627 bss_conf
->aid
= aid
;
1628 bss_conf
->assoc_capability
= capab_info
;
1629 ieee80211_set_associated(sdata
, changed
);
1632 * initialise the time of last beacon to be the association time,
1633 * otherwise beacon loss check will trigger immediately
1635 ifmgd
->last_beacon
= jiffies
;
1637 ieee80211_associated(sdata
);
1638 cfg80211_send_rx_assoc(sdata
->dev
, (u8
*) mgmt
, len
, GFP_KERNEL
);
1642 static void ieee80211_rx_bss_info(struct ieee80211_sub_if_data
*sdata
,
1643 struct ieee80211_mgmt
*mgmt
,
1645 struct ieee80211_rx_status
*rx_status
,
1646 struct ieee802_11_elems
*elems
,
1649 struct ieee80211_local
*local
= sdata
->local
;
1651 struct ieee80211_bss
*bss
;
1652 struct ieee80211_channel
*channel
;
1654 if (elems
->ds_params
&& elems
->ds_params_len
== 1)
1655 freq
= ieee80211_channel_to_frequency(elems
->ds_params
[0]);
1657 freq
= rx_status
->freq
;
1659 channel
= ieee80211_get_channel(local
->hw
.wiphy
, freq
);
1661 if (!channel
|| channel
->flags
& IEEE80211_CHAN_DISABLED
)
1664 bss
= ieee80211_bss_info_update(local
, rx_status
, mgmt
, len
, elems
,
1669 if (elems
->ch_switch_elem
&& (elems
->ch_switch_elem_len
== 3) &&
1670 (memcmp(mgmt
->bssid
, sdata
->u
.mgd
.bssid
, ETH_ALEN
) == 0)) {
1671 struct ieee80211_channel_sw_ie
*sw_elem
=
1672 (struct ieee80211_channel_sw_ie
*)elems
->ch_switch_elem
;
1673 ieee80211_sta_process_chanswitch(sdata
, sw_elem
, bss
);
1676 ieee80211_rx_bss_put(local
, bss
);
1680 static void ieee80211_rx_mgmt_probe_resp(struct ieee80211_sub_if_data
*sdata
,
1681 struct ieee80211_mgmt
*mgmt
,
1683 struct ieee80211_rx_status
*rx_status
)
1685 struct ieee80211_if_managed
*ifmgd
;
1687 struct ieee802_11_elems elems
;
1689 ifmgd
= &sdata
->u
.mgd
;
1691 if (memcmp(mgmt
->da
, sdata
->dev
->dev_addr
, ETH_ALEN
))
1692 return; /* ignore ProbeResp to foreign address */
1694 baselen
= (u8
*) mgmt
->u
.probe_resp
.variable
- (u8
*) mgmt
;
1698 ieee802_11_parse_elems(mgmt
->u
.probe_resp
.variable
, len
- baselen
,
1701 ieee80211_rx_bss_info(sdata
, mgmt
, len
, rx_status
, &elems
, false);
1703 /* direct probe may be part of the association flow */
1704 if (ifmgd
->state
== IEEE80211_STA_MLME_DIRECT_PROBE
) {
1705 printk(KERN_DEBUG
"%s direct probe responded\n",
1707 ieee80211_authenticate(sdata
);
1710 if (ifmgd
->flags
& IEEE80211_STA_PROBEREQ_POLL
) {
1711 ifmgd
->flags
&= ~IEEE80211_STA_PROBEREQ_POLL
;
1712 mutex_lock(&sdata
->local
->iflist_mtx
);
1713 ieee80211_recalc_ps(sdata
->local
, -1);
1714 mutex_unlock(&sdata
->local
->iflist_mtx
);
1719 * This is the canonical list of information elements we care about,
1720 * the filter code also gives us all changes to the Microsoft OUI
1721 * (00:50:F2) vendor IE which is used for WMM which we need to track.
1723 * We implement beacon filtering in software since that means we can
1724 * avoid processing the frame here and in cfg80211, and userspace
1725 * will not be able to tell whether the hardware supports it or not.
1727 * XXX: This list needs to be dynamic -- userspace needs to be able to
1728 * add items it requires. It also needs to be able to tell us to
1729 * look out for other vendor IEs.
1731 static const u64 care_about_ies
=
1732 (1ULL << WLAN_EID_COUNTRY
) |
1733 (1ULL << WLAN_EID_ERP_INFO
) |
1734 (1ULL << WLAN_EID_CHANNEL_SWITCH
) |
1735 (1ULL << WLAN_EID_PWR_CONSTRAINT
) |
1736 (1ULL << WLAN_EID_HT_CAPABILITY
) |
1737 (1ULL << WLAN_EID_HT_INFORMATION
);
1739 static void ieee80211_rx_mgmt_beacon(struct ieee80211_sub_if_data
*sdata
,
1740 struct ieee80211_mgmt
*mgmt
,
1742 struct ieee80211_rx_status
*rx_status
)
1744 struct ieee80211_if_managed
*ifmgd
= &sdata
->u
.mgd
;
1746 struct ieee802_11_elems elems
;
1747 struct ieee80211_local
*local
= sdata
->local
;
1749 bool erp_valid
, directed_tim
= false;
1753 /* Process beacon from the current BSS */
1754 baselen
= (u8
*) mgmt
->u
.beacon
.variable
- (u8
*) mgmt
;
1758 if (rx_status
->freq
!= local
->hw
.conf
.channel
->center_freq
)
1761 if (!(ifmgd
->flags
& IEEE80211_STA_ASSOCIATED
) ||
1762 memcmp(ifmgd
->bssid
, mgmt
->bssid
, ETH_ALEN
) != 0)
1765 if (ifmgd
->flags
& IEEE80211_STA_PROBEREQ_POLL
) {
1766 #ifdef CONFIG_MAC80211_VERBOSE_DEBUG
1767 if (net_ratelimit()) {
1768 printk(KERN_DEBUG
"%s: cancelling probereq poll due "
1769 "to a received beacon\n", sdata
->dev
->name
);
1772 ifmgd
->flags
&= ~IEEE80211_STA_PROBEREQ_POLL
;
1773 mutex_lock(&local
->iflist_mtx
);
1774 ieee80211_recalc_ps(local
, -1);
1775 mutex_unlock(&local
->iflist_mtx
);
1778 ncrc
= crc32_be(0, (void *)&mgmt
->u
.beacon
.beacon_int
, 4);
1779 ncrc
= ieee802_11_parse_elems_crc(mgmt
->u
.beacon
.variable
,
1780 len
- baselen
, &elems
,
1781 care_about_ies
, ncrc
);
1783 if (local
->hw
.flags
& IEEE80211_HW_PS_NULLFUNC_STACK
)
1784 directed_tim
= ieee80211_check_tim(elems
.tim
, elems
.tim_len
,
1787 if (ncrc
!= ifmgd
->beacon_crc
) {
1788 ieee80211_rx_bss_info(sdata
, mgmt
, len
, rx_status
, &elems
,
1791 ieee80211_sta_wmm_params(local
, ifmgd
, elems
.wmm_param
,
1792 elems
.wmm_param_len
);
1795 if (local
->hw
.flags
& IEEE80211_HW_PS_NULLFUNC_STACK
) {
1797 if (local
->hw
.conf
.dynamic_ps_timeout
> 0) {
1798 local
->hw
.conf
.flags
&= ~IEEE80211_CONF_PS
;
1799 ieee80211_hw_config(local
,
1800 IEEE80211_CONF_CHANGE_PS
);
1801 ieee80211_send_nullfunc(local
, sdata
, 0);
1803 local
->pspolling
= true;
1806 * Here is assumed that the driver will be
1807 * able to send ps-poll frame and receive a
1808 * response even though power save mode is
1809 * enabled, but some drivers might require
1810 * to disable power save here. This needs
1811 * to be investigated.
1813 ieee80211_send_pspoll(local
, sdata
);
1818 if (ncrc
== ifmgd
->beacon_crc
)
1820 ifmgd
->beacon_crc
= ncrc
;
1822 if (elems
.erp_info
&& elems
.erp_info_len
>= 1) {
1824 erp_value
= elems
.erp_info
[0];
1828 changed
|= ieee80211_handle_bss_capability(sdata
,
1829 le16_to_cpu(mgmt
->u
.beacon
.capab_info
),
1830 erp_valid
, erp_value
);
1833 if (elems
.ht_cap_elem
&& elems
.ht_info_elem
&& elems
.wmm_param
&&
1834 !(ifmgd
->flags
& IEEE80211_STA_DISABLE_11N
)) {
1835 struct sta_info
*sta
;
1836 struct ieee80211_supported_band
*sband
;
1837 u16 ap_ht_cap_flags
;
1841 sta
= sta_info_get(local
, ifmgd
->bssid
);
1847 sband
= local
->hw
.wiphy
->bands
[local
->hw
.conf
.channel
->band
];
1849 ieee80211_ht_cap_ie_to_sta_ht_cap(sband
,
1850 elems
.ht_cap_elem
, &sta
->sta
.ht_cap
);
1852 ap_ht_cap_flags
= sta
->sta
.ht_cap
.cap
;
1856 changed
|= ieee80211_enable_ht(sdata
, elems
.ht_info_elem
,
1860 if (elems
.country_elem
) {
1861 /* Note we are only reviewing this on beacons
1862 * for the BSSID we are associated to */
1863 regulatory_hint_11d(local
->hw
.wiphy
,
1864 elems
.country_elem
, elems
.country_elem_len
);
1866 /* TODO: IBSS also needs this */
1867 if (elems
.pwr_constr_elem
)
1868 ieee80211_handle_pwr_constr(sdata
,
1869 le16_to_cpu(mgmt
->u
.probe_resp
.capab_info
),
1870 elems
.pwr_constr_elem
,
1871 elems
.pwr_constr_elem_len
);
1874 ieee80211_bss_info_change_notify(sdata
, changed
);
1877 ieee80211_rx_result
ieee80211_sta_rx_mgmt(struct ieee80211_sub_if_data
*sdata
,
1878 struct sk_buff
*skb
)
1880 struct ieee80211_local
*local
= sdata
->local
;
1881 struct ieee80211_mgmt
*mgmt
;
1885 return RX_DROP_MONITOR
;
1887 mgmt
= (struct ieee80211_mgmt
*) skb
->data
;
1888 fc
= le16_to_cpu(mgmt
->frame_control
);
1890 switch (fc
& IEEE80211_FCTL_STYPE
) {
1891 case IEEE80211_STYPE_PROBE_REQ
:
1892 case IEEE80211_STYPE_PROBE_RESP
:
1893 case IEEE80211_STYPE_BEACON
:
1894 case IEEE80211_STYPE_AUTH
:
1895 case IEEE80211_STYPE_ASSOC_RESP
:
1896 case IEEE80211_STYPE_REASSOC_RESP
:
1897 case IEEE80211_STYPE_DEAUTH
:
1898 case IEEE80211_STYPE_DISASSOC
:
1899 skb_queue_tail(&sdata
->u
.mgd
.skb_queue
, skb
);
1900 queue_work(local
->hw
.workqueue
, &sdata
->u
.mgd
.work
);
1904 return RX_DROP_MONITOR
;
1907 static void ieee80211_sta_rx_queued_mgmt(struct ieee80211_sub_if_data
*sdata
,
1908 struct sk_buff
*skb
)
1910 struct ieee80211_rx_status
*rx_status
;
1911 struct ieee80211_mgmt
*mgmt
;
1914 rx_status
= (struct ieee80211_rx_status
*) skb
->cb
;
1915 mgmt
= (struct ieee80211_mgmt
*) skb
->data
;
1916 fc
= le16_to_cpu(mgmt
->frame_control
);
1918 switch (fc
& IEEE80211_FCTL_STYPE
) {
1919 case IEEE80211_STYPE_PROBE_RESP
:
1920 ieee80211_rx_mgmt_probe_resp(sdata
, mgmt
, skb
->len
,
1923 case IEEE80211_STYPE_BEACON
:
1924 ieee80211_rx_mgmt_beacon(sdata
, mgmt
, skb
->len
,
1927 case IEEE80211_STYPE_AUTH
:
1928 ieee80211_rx_mgmt_auth(sdata
, mgmt
, skb
->len
);
1930 case IEEE80211_STYPE_ASSOC_RESP
:
1931 ieee80211_rx_mgmt_assoc_resp(sdata
, mgmt
, skb
->len
, 0);
1933 case IEEE80211_STYPE_REASSOC_RESP
:
1934 ieee80211_rx_mgmt_assoc_resp(sdata
, mgmt
, skb
->len
, 1);
1936 case IEEE80211_STYPE_DEAUTH
:
1937 ieee80211_rx_mgmt_deauth(sdata
, mgmt
, skb
->len
);
1939 case IEEE80211_STYPE_DISASSOC
:
1940 ieee80211_rx_mgmt_disassoc(sdata
, mgmt
, skb
->len
);
1947 static void ieee80211_sta_timer(unsigned long data
)
1949 struct ieee80211_sub_if_data
*sdata
=
1950 (struct ieee80211_sub_if_data
*) data
;
1951 struct ieee80211_if_managed
*ifmgd
= &sdata
->u
.mgd
;
1952 struct ieee80211_local
*local
= sdata
->local
;
1954 if (local
->quiescing
) {
1955 set_bit(TMR_RUNNING_TIMER
, &ifmgd
->timers_running
);
1959 set_bit(IEEE80211_STA_REQ_RUN
, &ifmgd
->request
);
1960 queue_work(local
->hw
.workqueue
, &ifmgd
->work
);
1963 static void ieee80211_sta_reset_auth(struct ieee80211_sub_if_data
*sdata
)
1965 struct ieee80211_if_managed
*ifmgd
= &sdata
->u
.mgd
;
1966 struct ieee80211_local
*local
= sdata
->local
;
1968 /* Reset own TSF to allow time synchronization work. */
1969 drv_reset_tsf(local
);
1971 ifmgd
->wmm_last_param_set
= -1; /* allow any WMM update */
1972 ifmgd
->auth_transaction
= -1;
1973 ifmgd
->flags
&= ~IEEE80211_STA_ASSOCIATED
;
1974 ifmgd
->assoc_scan_tries
= 0;
1975 ifmgd
->direct_probe_tries
= 0;
1976 ifmgd
->auth_tries
= 0;
1977 ifmgd
->assoc_tries
= 0;
1978 netif_tx_stop_all_queues(sdata
->dev
);
1979 netif_carrier_off(sdata
->dev
);
1982 static int ieee80211_sta_config_auth(struct ieee80211_sub_if_data
*sdata
)
1984 struct ieee80211_if_managed
*ifmgd
= &sdata
->u
.mgd
;
1985 struct ieee80211_local
*local
= sdata
->local
;
1986 struct ieee80211_bss
*bss
;
1987 u8
*bssid
= ifmgd
->bssid
, *ssid
= ifmgd
->ssid
;
1988 u8 ssid_len
= ifmgd
->ssid_len
;
1989 u16 capa_mask
= WLAN_CAPABILITY_ESS
;
1990 u16 capa_val
= WLAN_CAPABILITY_ESS
;
1991 struct ieee80211_channel
*chan
= local
->oper_channel
;
1993 bss
= (void *)cfg80211_get_bss(local
->hw
.wiphy
, chan
,
1994 bssid
, ssid
, ssid_len
,
1995 capa_mask
, capa_val
);
1998 local
->oper_channel
= bss
->cbss
.channel
;
1999 local
->oper_channel_type
= NL80211_CHAN_NO_HT
;
2000 ieee80211_hw_config(local
, 0);
2002 ieee80211_sta_def_wmm_params(sdata
, bss
->supp_rates_len
,
2004 if (sdata
->u
.mgd
.mfp
== IEEE80211_MFP_REQUIRED
)
2005 sdata
->u
.mgd
.flags
|= IEEE80211_STA_MFP_ENABLED
;
2007 sdata
->u
.mgd
.flags
&= ~IEEE80211_STA_MFP_ENABLED
;
2009 /* Send out direct probe if no probe resp was received or
2010 * the one we have is outdated
2012 if (!bss
->last_probe_resp
||
2013 time_after(jiffies
, bss
->last_probe_resp
2014 + IEEE80211_SCAN_RESULT_EXPIRE
))
2015 ifmgd
->state
= IEEE80211_STA_MLME_DIRECT_PROBE
;
2017 ifmgd
->state
= IEEE80211_STA_MLME_AUTHENTICATE
;
2019 ieee80211_rx_bss_put(local
, bss
);
2020 ieee80211_sta_reset_auth(sdata
);
2023 if (ifmgd
->assoc_scan_tries
< IEEE80211_ASSOC_SCANS_MAX_TRIES
) {
2025 ifmgd
->assoc_scan_tries
++;
2027 ieee80211_request_internal_scan(sdata
, ifmgd
->ssid
,
2030 ifmgd
->state
= IEEE80211_STA_MLME_AUTHENTICATE
;
2031 set_bit(IEEE80211_STA_REQ_AUTH
, &ifmgd
->request
);
2033 ifmgd
->assoc_scan_tries
= 0;
2034 ifmgd
->state
= IEEE80211_STA_MLME_DISABLED
;
2035 ieee80211_recalc_idle(local
);
2042 static void ieee80211_sta_work(struct work_struct
*work
)
2044 struct ieee80211_sub_if_data
*sdata
=
2045 container_of(work
, struct ieee80211_sub_if_data
, u
.mgd
.work
);
2046 struct ieee80211_local
*local
= sdata
->local
;
2047 struct ieee80211_if_managed
*ifmgd
;
2048 struct sk_buff
*skb
;
2050 if (!netif_running(sdata
->dev
))
2053 if (local
->sw_scanning
|| local
->hw_scanning
)
2056 if (WARN_ON(sdata
->vif
.type
!= NL80211_IFTYPE_STATION
))
2060 * Nothing should have been stuffed into the workqueue during
2061 * the suspend->resume cycle. If this WARN is seen then there
2062 * is a bug with either the driver suspend or something in
2063 * mac80211 stuffing into the workqueue which we haven't yet
2064 * cleared during mac80211's suspend cycle.
2066 if (WARN_ON(local
->suspended
))
2069 ifmgd
= &sdata
->u
.mgd
;
2071 while ((skb
= skb_dequeue(&ifmgd
->skb_queue
)))
2072 ieee80211_sta_rx_queued_mgmt(sdata
, skb
);
2074 if (ifmgd
->state
!= IEEE80211_STA_MLME_DIRECT_PROBE
&&
2075 ifmgd
->state
!= IEEE80211_STA_MLME_AUTHENTICATE
&&
2076 ifmgd
->state
!= IEEE80211_STA_MLME_ASSOCIATE
&&
2077 test_and_clear_bit(IEEE80211_STA_REQ_SCAN
, &ifmgd
->request
)) {
2078 queue_delayed_work(local
->hw
.workqueue
, &local
->scan_work
,
2079 round_jiffies_relative(0));
2083 if (test_and_clear_bit(IEEE80211_STA_REQ_AUTH
, &ifmgd
->request
)) {
2084 if (ieee80211_sta_config_auth(sdata
))
2086 clear_bit(IEEE80211_STA_REQ_RUN
, &ifmgd
->request
);
2087 } else if (!test_and_clear_bit(IEEE80211_STA_REQ_RUN
, &ifmgd
->request
))
2090 ieee80211_recalc_idle(local
);
2092 switch (ifmgd
->state
) {
2093 case IEEE80211_STA_MLME_DISABLED
:
2095 case IEEE80211_STA_MLME_DIRECT_PROBE
:
2096 ieee80211_direct_probe(sdata
);
2098 case IEEE80211_STA_MLME_AUTHENTICATE
:
2099 ieee80211_authenticate(sdata
);
2101 case IEEE80211_STA_MLME_ASSOCIATE
:
2102 ieee80211_associate(sdata
);
2104 case IEEE80211_STA_MLME_ASSOCIATED
:
2105 ieee80211_associated(sdata
);
2113 static void ieee80211_restart_sta_timer(struct ieee80211_sub_if_data
*sdata
)
2115 if (sdata
->vif
.type
== NL80211_IFTYPE_STATION
) {
2117 * Need to update last_beacon to avoid beacon loss
2120 sdata
->u
.mgd
.last_beacon
= jiffies
;
2123 queue_work(sdata
->local
->hw
.workqueue
,
2124 &sdata
->u
.mgd
.work
);
2129 void ieee80211_sta_quiesce(struct ieee80211_sub_if_data
*sdata
)
2131 struct ieee80211_if_managed
*ifmgd
= &sdata
->u
.mgd
;
2134 * we need to use atomic bitops for the running bits
2135 * only because both timers might fire at the same
2136 * time -- the code here is properly synchronised.
2139 cancel_work_sync(&ifmgd
->work
);
2140 cancel_work_sync(&ifmgd
->beacon_loss_work
);
2141 if (del_timer_sync(&ifmgd
->timer
))
2142 set_bit(TMR_RUNNING_TIMER
, &ifmgd
->timers_running
);
2144 cancel_work_sync(&ifmgd
->chswitch_work
);
2145 if (del_timer_sync(&ifmgd
->chswitch_timer
))
2146 set_bit(TMR_RUNNING_CHANSW
, &ifmgd
->timers_running
);
2149 void ieee80211_sta_restart(struct ieee80211_sub_if_data
*sdata
)
2151 struct ieee80211_if_managed
*ifmgd
= &sdata
->u
.mgd
;
2153 if (test_and_clear_bit(TMR_RUNNING_TIMER
, &ifmgd
->timers_running
))
2154 add_timer(&ifmgd
->timer
);
2155 if (test_and_clear_bit(TMR_RUNNING_CHANSW
, &ifmgd
->timers_running
))
2156 add_timer(&ifmgd
->chswitch_timer
);
2160 /* interface setup */
2161 void ieee80211_sta_setup_sdata(struct ieee80211_sub_if_data
*sdata
)
2163 struct ieee80211_if_managed
*ifmgd
;
2166 ifmgd
= &sdata
->u
.mgd
;
2167 INIT_WORK(&ifmgd
->work
, ieee80211_sta_work
);
2168 INIT_WORK(&ifmgd
->chswitch_work
, ieee80211_chswitch_work
);
2169 INIT_WORK(&ifmgd
->beacon_loss_work
, ieee80211_beacon_loss_work
);
2170 setup_timer(&ifmgd
->timer
, ieee80211_sta_timer
,
2171 (unsigned long) sdata
);
2172 setup_timer(&ifmgd
->chswitch_timer
, ieee80211_chswitch_timer
,
2173 (unsigned long) sdata
);
2174 skb_queue_head_init(&ifmgd
->skb_queue
);
2176 ifmgd
->capab
= WLAN_CAPABILITY_ESS
;
2178 if (sdata
->local
->hw
.queues
>= 4)
2179 ifmgd
->flags
|= IEEE80211_STA_WMM_ENABLED
;
2181 hw_flags
= sdata
->local
->hw
.flags
;
2184 /* configuration hooks */
2185 void ieee80211_sta_req_auth(struct ieee80211_sub_if_data
*sdata
)
2187 struct ieee80211_if_managed
*ifmgd
= &sdata
->u
.mgd
;
2188 struct ieee80211_local
*local
= sdata
->local
;
2190 if (WARN_ON(sdata
->vif
.type
!= NL80211_IFTYPE_STATION
))
2193 if (WARN_ON(ifmgd
->state
== IEEE80211_STA_MLME_ASSOCIATED
))
2194 ieee80211_set_disassoc(sdata
, true, true,
2195 WLAN_REASON_DEAUTH_LEAVING
);
2197 if (WARN_ON(ifmgd
->ssid_len
== 0)) {
2199 * Only allow association to be started if a valid SSID
2205 set_bit(IEEE80211_STA_REQ_RUN
, &ifmgd
->request
);
2206 queue_work(local
->hw
.workqueue
, &ifmgd
->work
);
2209 int ieee80211_sta_set_extra_ie(struct ieee80211_sub_if_data
*sdata
,
2210 const char *ie
, size_t len
)
2212 struct ieee80211_if_managed
*ifmgd
= &sdata
->u
.mgd
;
2214 if (len
== 0 && ifmgd
->extra_ie_len
== 0)
2217 if (len
== ifmgd
->extra_ie_len
&& ifmgd
->extra_ie
&&
2218 memcmp(ifmgd
->extra_ie
, ie
, len
) == 0)
2221 kfree(ifmgd
->extra_ie
);
2223 ifmgd
->extra_ie
= NULL
;
2224 ifmgd
->extra_ie_len
= 0;
2227 ifmgd
->extra_ie
= kmalloc(len
, GFP_KERNEL
);
2228 if (!ifmgd
->extra_ie
) {
2229 ifmgd
->extra_ie_len
= 0;
2232 memcpy(ifmgd
->extra_ie
, ie
, len
);
2233 ifmgd
->extra_ie_len
= len
;
2237 int ieee80211_sta_deauthenticate(struct ieee80211_sub_if_data
*sdata
, u16 reason
)
2239 printk(KERN_DEBUG
"%s: deauthenticating by local choice (reason=%d)\n",
2240 sdata
->dev
->name
, reason
);
2242 ieee80211_set_disassoc(sdata
, true, true, reason
);
2246 int ieee80211_sta_disassociate(struct ieee80211_sub_if_data
*sdata
, u16 reason
)
2248 struct ieee80211_if_managed
*ifmgd
= &sdata
->u
.mgd
;
2250 printk(KERN_DEBUG
"%s: disassociating by local choice (reason=%d)\n",
2251 sdata
->dev
->name
, reason
);
2253 if (!(ifmgd
->flags
& IEEE80211_STA_ASSOCIATED
))
2256 ieee80211_set_disassoc(sdata
, false, true, reason
);
2260 /* scan finished notification */
2261 void ieee80211_mlme_notify_scan_completed(struct ieee80211_local
*local
)
2263 struct ieee80211_sub_if_data
*sdata
= local
->scan_sdata
;
2265 /* Restart STA timers */
2267 list_for_each_entry_rcu(sdata
, &local
->interfaces
, list
)
2268 ieee80211_restart_sta_timer(sdata
);
2272 int ieee80211_max_network_latency(struct notifier_block
*nb
,
2273 unsigned long data
, void *dummy
)
2275 s32 latency_usec
= (s32
) data
;
2276 struct ieee80211_local
*local
=
2277 container_of(nb
, struct ieee80211_local
,
2278 network_latency_notifier
);
2280 mutex_lock(&local
->iflist_mtx
);
2281 ieee80211_recalc_ps(local
, latency_usec
);
2282 mutex_unlock(&local
->iflist_mtx
);