2 * mac80211 work implementation
4 * Copyright 2003-2008, Jouni Malinen <j@w1.fi>
5 * Copyright 2004, Instant802 Networks, Inc.
6 * Copyright 2005, Devicescape Software, Inc.
7 * Copyright 2006-2007 Jiri Benc <jbenc@suse.cz>
8 * Copyright 2007, Michael Wu <flamingice@sourmilk.net>
9 * Copyright 2009, Johannes Berg <johannes@sipsolutions.net>
11 * This program is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License version 2 as
13 * published by the Free Software Foundation.
16 #include <linux/delay.h>
17 #include <linux/if_ether.h>
18 #include <linux/skbuff.h>
19 #include <linux/if_arp.h>
20 #include <linux/etherdevice.h>
21 #include <linux/crc32.h>
22 #include <net/mac80211.h>
23 #include <asm/unaligned.h>
25 #include "ieee80211_i.h"
28 #define IEEE80211_AUTH_TIMEOUT (HZ / 5)
29 #define IEEE80211_AUTH_MAX_TRIES 3
30 #define IEEE80211_ASSOC_TIMEOUT (HZ / 5)
31 #define IEEE80211_ASSOC_MAX_TRIES 3
32 #define IEEE80211_MAX_PROBE_TRIES 5
42 static inline void ASSERT_WORK_MTX(struct ieee80211_local
*local
)
44 WARN_ON(!mutex_is_locked(&local
->work_mtx
));
48 * We can have multiple work items (and connection probing)
49 * scheduling this timer, but we need to take care to only
50 * reschedule it when it should fire _earlier_ than it was
51 * asked for before, or if it's not pending right now. This
52 * function ensures that. Note that it then is required to
53 * run this function for all timeouts after the first one
54 * has happened -- the work that runs from this timer will
57 static void run_again(struct ieee80211_local
*local
,
58 unsigned long timeout
)
60 ASSERT_WORK_MTX(local
);
62 if (!timer_pending(&local
->work_timer
) ||
63 time_before(timeout
, local
->work_timer
.expires
))
64 mod_timer(&local
->work_timer
, timeout
);
67 static void work_free_rcu(struct rcu_head
*head
)
69 struct ieee80211_work
*wk
=
70 container_of(head
, struct ieee80211_work
, rcu_head
);
75 void free_work(struct ieee80211_work
*wk
)
77 call_rcu(&wk
->rcu_head
, work_free_rcu
);
80 static int ieee80211_compatible_rates(const u8
*supp_rates
, int supp_rates_len
,
81 struct ieee80211_supported_band
*sband
,
87 for (i
= 0; i
< supp_rates_len
; i
++) {
88 int rate
= (supp_rates
[i
] & 0x7F) * 5;
90 for (j
= 0; j
< sband
->n_bitrates
; j
++)
91 if (sband
->bitrates
[j
].bitrate
== rate
) {
101 /* frame sending functions */
103 static void ieee80211_add_ht_ie(struct sk_buff
*skb
, const u8
*ht_info_ie
,
104 struct ieee80211_supported_band
*sband
,
105 struct ieee80211_channel
*channel
,
106 enum ieee80211_smps_mode smps
)
108 struct ieee80211_ht_info
*ht_info
;
110 u32 flags
= channel
->flags
;
111 u16 cap
= sband
->ht_cap
.cap
;
114 if (!sband
->ht_cap
.ht_supported
)
120 if (ht_info_ie
[1] < sizeof(struct ieee80211_ht_info
))
123 ht_info
= (struct ieee80211_ht_info
*)(ht_info_ie
+ 2);
125 /* determine capability flags */
127 if (ieee80211_disable_40mhz_24ghz
&&
128 sband
->band
== IEEE80211_BAND_2GHZ
) {
129 cap
&= ~IEEE80211_HT_CAP_SUP_WIDTH_20_40
;
130 cap
&= ~IEEE80211_HT_CAP_SGI_40
;
133 switch (ht_info
->ht_param
& IEEE80211_HT_PARAM_CHA_SEC_OFFSET
) {
134 case IEEE80211_HT_PARAM_CHA_SEC_ABOVE
:
135 if (flags
& IEEE80211_CHAN_NO_HT40PLUS
) {
136 cap
&= ~IEEE80211_HT_CAP_SUP_WIDTH_20_40
;
137 cap
&= ~IEEE80211_HT_CAP_SGI_40
;
140 case IEEE80211_HT_PARAM_CHA_SEC_BELOW
:
141 if (flags
& IEEE80211_CHAN_NO_HT40MINUS
) {
142 cap
&= ~IEEE80211_HT_CAP_SUP_WIDTH_20_40
;
143 cap
&= ~IEEE80211_HT_CAP_SGI_40
;
148 /* set SM PS mode properly */
149 cap
&= ~IEEE80211_HT_CAP_SM_PS
;
151 case IEEE80211_SMPS_AUTOMATIC
:
152 case IEEE80211_SMPS_NUM_MODES
:
154 case IEEE80211_SMPS_OFF
:
155 cap
|= WLAN_HT_CAP_SM_PS_DISABLED
<<
156 IEEE80211_HT_CAP_SM_PS_SHIFT
;
158 case IEEE80211_SMPS_STATIC
:
159 cap
|= WLAN_HT_CAP_SM_PS_STATIC
<<
160 IEEE80211_HT_CAP_SM_PS_SHIFT
;
162 case IEEE80211_SMPS_DYNAMIC
:
163 cap
|= WLAN_HT_CAP_SM_PS_DYNAMIC
<<
164 IEEE80211_HT_CAP_SM_PS_SHIFT
;
168 /* reserve and fill IE */
170 pos
= skb_put(skb
, sizeof(struct ieee80211_ht_cap
) + 2);
171 *pos
++ = WLAN_EID_HT_CAPABILITY
;
172 *pos
++ = sizeof(struct ieee80211_ht_cap
);
173 memset(pos
, 0, sizeof(struct ieee80211_ht_cap
));
175 /* capability flags */
176 tmp
= cpu_to_le16(cap
);
177 memcpy(pos
, &tmp
, sizeof(u16
));
180 /* AMPDU parameters */
181 *pos
++ = sband
->ht_cap
.ampdu_factor
|
182 (sband
->ht_cap
.ampdu_density
<<
183 IEEE80211_HT_AMPDU_PARM_DENSITY_SHIFT
);
186 memcpy(pos
, &sband
->ht_cap
.mcs
, sizeof(sband
->ht_cap
.mcs
));
187 pos
+= sizeof(sband
->ht_cap
.mcs
);
189 /* extended capabilities */
190 pos
+= sizeof(__le16
);
192 /* BF capabilities */
193 pos
+= sizeof(__le32
);
195 /* antenna selection */
199 static void ieee80211_send_assoc(struct ieee80211_sub_if_data
*sdata
,
200 struct ieee80211_work
*wk
)
202 struct ieee80211_local
*local
= sdata
->local
;
204 struct ieee80211_mgmt
*mgmt
;
207 size_t offset
= 0, noffset
;
208 int i
, len
, count
, rates_len
, supp_rates_len
;
210 struct ieee80211_supported_band
*sband
;
213 sband
= local
->hw
.wiphy
->bands
[wk
->chan
->band
];
216 * Get all rates supported by the device and the AP as
217 * some APs don't like getting a superset of their rates
218 * in the association request (e.g. D-Link DAP 1353 in
221 rates_len
= ieee80211_compatible_rates(wk
->assoc
.supp_rates
,
222 wk
->assoc
.supp_rates_len
,
225 skb
= alloc_skb(local
->hw
.extra_tx_headroom
+
226 sizeof(*mgmt
) + /* bit too much but doesn't matter */
227 2 + wk
->assoc
.ssid_len
+ /* SSID */
228 4 + rates_len
+ /* (extended) rates */
229 4 + /* power capability */
230 2 + 2 * sband
->n_channels
+ /* supported channels */
231 2 + sizeof(struct ieee80211_ht_cap
) + /* HT */
232 wk
->ie_len
+ /* extra IEs */
236 printk(KERN_DEBUG
"%s: failed to allocate buffer for assoc "
237 "frame\n", sdata
->name
);
240 skb_reserve(skb
, local
->hw
.extra_tx_headroom
);
242 capab
= WLAN_CAPABILITY_ESS
;
244 if (sband
->band
== IEEE80211_BAND_2GHZ
) {
245 if (!(local
->hw
.flags
& IEEE80211_HW_2GHZ_SHORT_SLOT_INCAPABLE
))
246 capab
|= WLAN_CAPABILITY_SHORT_SLOT_TIME
;
247 if (!(local
->hw
.flags
& IEEE80211_HW_2GHZ_SHORT_PREAMBLE_INCAPABLE
))
248 capab
|= WLAN_CAPABILITY_SHORT_PREAMBLE
;
251 if (wk
->assoc
.capability
& WLAN_CAPABILITY_PRIVACY
)
252 capab
|= WLAN_CAPABILITY_PRIVACY
;
254 if ((wk
->assoc
.capability
& WLAN_CAPABILITY_SPECTRUM_MGMT
) &&
255 (local
->hw
.flags
& IEEE80211_HW_SPECTRUM_MGMT
))
256 capab
|= WLAN_CAPABILITY_SPECTRUM_MGMT
;
258 mgmt
= (struct ieee80211_mgmt
*) skb_put(skb
, 24);
260 memcpy(mgmt
->da
, wk
->filter_ta
, ETH_ALEN
);
261 memcpy(mgmt
->sa
, sdata
->vif
.addr
, ETH_ALEN
);
262 memcpy(mgmt
->bssid
, wk
->filter_ta
, ETH_ALEN
);
264 if (!is_zero_ether_addr(wk
->assoc
.prev_bssid
)) {
266 mgmt
->frame_control
= cpu_to_le16(IEEE80211_FTYPE_MGMT
|
267 IEEE80211_STYPE_REASSOC_REQ
);
268 mgmt
->u
.reassoc_req
.capab_info
= cpu_to_le16(capab
);
269 mgmt
->u
.reassoc_req
.listen_interval
=
270 cpu_to_le16(local
->hw
.conf
.listen_interval
);
271 memcpy(mgmt
->u
.reassoc_req
.current_ap
, wk
->assoc
.prev_bssid
,
275 mgmt
->frame_control
= cpu_to_le16(IEEE80211_FTYPE_MGMT
|
276 IEEE80211_STYPE_ASSOC_REQ
);
277 mgmt
->u
.assoc_req
.capab_info
= cpu_to_le16(capab
);
278 mgmt
->u
.assoc_req
.listen_interval
=
279 cpu_to_le16(local
->hw
.conf
.listen_interval
);
283 ies
= pos
= skb_put(skb
, 2 + wk
->assoc
.ssid_len
);
284 *pos
++ = WLAN_EID_SSID
;
285 *pos
++ = wk
->assoc
.ssid_len
;
286 memcpy(pos
, wk
->assoc
.ssid
, wk
->assoc
.ssid_len
);
288 /* add all rates which were marked to be used above */
289 supp_rates_len
= rates_len
;
290 if (supp_rates_len
> 8)
293 len
= sband
->n_bitrates
;
294 pos
= skb_put(skb
, supp_rates_len
+ 2);
295 *pos
++ = WLAN_EID_SUPP_RATES
;
296 *pos
++ = supp_rates_len
;
299 for (i
= 0; i
< sband
->n_bitrates
; i
++) {
300 if (BIT(i
) & rates
) {
301 int rate
= sband
->bitrates
[i
].bitrate
;
302 *pos
++ = (u8
) (rate
/ 5);
308 if (rates_len
> count
) {
309 pos
= skb_put(skb
, rates_len
- count
+ 2);
310 *pos
++ = WLAN_EID_EXT_SUPP_RATES
;
311 *pos
++ = rates_len
- count
;
313 for (i
++; i
< sband
->n_bitrates
; i
++) {
314 if (BIT(i
) & rates
) {
315 int rate
= sband
->bitrates
[i
].bitrate
;
316 *pos
++ = (u8
) (rate
/ 5);
321 if (capab
& WLAN_CAPABILITY_SPECTRUM_MGMT
) {
322 /* 1. power capabilities */
323 pos
= skb_put(skb
, 4);
324 *pos
++ = WLAN_EID_PWR_CAPABILITY
;
326 *pos
++ = 0; /* min tx power */
327 *pos
++ = wk
->chan
->max_power
; /* max tx power */
329 /* 2. supported channels */
330 /* TODO: get this in reg domain format */
331 pos
= skb_put(skb
, 2 * sband
->n_channels
+ 2);
332 *pos
++ = WLAN_EID_SUPPORTED_CHANNELS
;
333 *pos
++ = 2 * sband
->n_channels
;
334 for (i
= 0; i
< sband
->n_channels
; i
++) {
335 *pos
++ = ieee80211_frequency_to_channel(
336 sband
->channels
[i
].center_freq
);
337 *pos
++ = 1; /* one channel in the subband*/
341 /* if present, add any custom IEs that go before HT */
342 if (wk
->ie_len
&& wk
->ie
) {
343 static const u8 before_ht
[] = {
346 WLAN_EID_EXT_SUPP_RATES
,
347 WLAN_EID_PWR_CAPABILITY
,
348 WLAN_EID_SUPPORTED_CHANNELS
,
351 WLAN_EID_RRM_ENABLED_CAPABILITIES
,
352 WLAN_EID_MOBILITY_DOMAIN
,
353 WLAN_EID_SUPPORTED_REGULATORY_CLASSES
,
355 noffset
= ieee80211_ie_split(wk
->ie
, wk
->ie_len
,
356 before_ht
, ARRAY_SIZE(before_ht
),
358 pos
= skb_put(skb
, noffset
- offset
);
359 memcpy(pos
, wk
->ie
+ offset
, noffset
- offset
);
363 if (wk
->assoc
.use_11n
&& wk
->assoc
.wmm_used
&&
364 local
->hw
.queues
>= 4)
365 ieee80211_add_ht_ie(skb
, wk
->assoc
.ht_information_ie
,
366 sband
, wk
->chan
, wk
->assoc
.smps
);
368 /* if present, add any custom non-vendor IEs that go after HT */
369 if (wk
->ie_len
&& wk
->ie
) {
370 noffset
= ieee80211_ie_split_vendor(wk
->ie
, wk
->ie_len
,
372 pos
= skb_put(skb
, noffset
- offset
);
373 memcpy(pos
, wk
->ie
+ offset
, noffset
- offset
);
377 if (wk
->assoc
.wmm_used
&& local
->hw
.queues
>= 4) {
378 pos
= skb_put(skb
, 9);
379 *pos
++ = WLAN_EID_VENDOR_SPECIFIC
;
380 *pos
++ = 7; /* len */
381 *pos
++ = 0x00; /* Microsoft OUI 00:50:F2 */
384 *pos
++ = 2; /* WME */
385 *pos
++ = 0; /* WME info */
386 *pos
++ = 1; /* WME ver */
390 /* add any remaining custom (i.e. vendor specific here) IEs */
391 if (wk
->ie_len
&& wk
->ie
) {
392 noffset
= wk
->ie_len
;
393 pos
= skb_put(skb
, noffset
- offset
);
394 memcpy(pos
, wk
->ie
+ offset
, noffset
- offset
);
397 IEEE80211_SKB_CB(skb
)->flags
|= IEEE80211_TX_INTFL_DONT_ENCRYPT
;
398 ieee80211_tx_skb(sdata
, skb
);
401 static void ieee80211_remove_auth_bss(struct ieee80211_local
*local
,
402 struct ieee80211_work
*wk
)
404 struct cfg80211_bss
*cbss
;
405 u16 capa_val
= WLAN_CAPABILITY_ESS
;
407 if (wk
->probe_auth
.privacy
)
408 capa_val
|= WLAN_CAPABILITY_PRIVACY
;
410 cbss
= cfg80211_get_bss(local
->hw
.wiphy
, wk
->chan
, wk
->filter_ta
,
411 wk
->probe_auth
.ssid
, wk
->probe_auth
.ssid_len
,
412 WLAN_CAPABILITY_ESS
| WLAN_CAPABILITY_PRIVACY
,
417 cfg80211_unlink_bss(local
->hw
.wiphy
, cbss
);
418 cfg80211_put_bss(cbss
);
421 static enum work_action __must_check
422 ieee80211_direct_probe(struct ieee80211_work
*wk
)
424 struct ieee80211_sub_if_data
*sdata
= wk
->sdata
;
425 struct ieee80211_local
*local
= sdata
->local
;
427 wk
->probe_auth
.tries
++;
428 if (wk
->probe_auth
.tries
> IEEE80211_AUTH_MAX_TRIES
) {
429 printk(KERN_DEBUG
"%s: direct probe to %pM timed out\n",
430 sdata
->name
, wk
->filter_ta
);
433 * Most likely AP is not in the range so remove the
434 * bss struct for that AP.
436 ieee80211_remove_auth_bss(local
, wk
);
439 * We might have a pending scan which had no chance to run yet
440 * due to work needing to be done. Hence, queue the STAs work
443 ieee80211_queue_work(&local
->hw
, &local
->work_work
);
444 return WORK_ACT_TIMEOUT
;
447 printk(KERN_DEBUG
"%s: direct probe to %pM (try %d)\n",
448 sdata
->name
, wk
->filter_ta
, wk
->probe_auth
.tries
);
451 * Direct probe is sent to broadcast address as some APs
452 * will not answer to direct packet in unassociated state.
454 ieee80211_send_probe_req(sdata
, NULL
, wk
->probe_auth
.ssid
,
455 wk
->probe_auth
.ssid_len
, NULL
, 0);
457 wk
->timeout
= jiffies
+ IEEE80211_AUTH_TIMEOUT
;
458 run_again(local
, wk
->timeout
);
460 return WORK_ACT_NONE
;
464 static enum work_action __must_check
465 ieee80211_authenticate(struct ieee80211_work
*wk
)
467 struct ieee80211_sub_if_data
*sdata
= wk
->sdata
;
468 struct ieee80211_local
*local
= sdata
->local
;
470 wk
->probe_auth
.tries
++;
471 if (wk
->probe_auth
.tries
> IEEE80211_AUTH_MAX_TRIES
) {
472 printk(KERN_DEBUG
"%s: authentication with %pM"
473 " timed out\n", sdata
->name
, wk
->filter_ta
);
476 * Most likely AP is not in the range so remove the
477 * bss struct for that AP.
479 ieee80211_remove_auth_bss(local
, wk
);
482 * We might have a pending scan which had no chance to run yet
483 * due to work needing to be done. Hence, queue the STAs work
486 ieee80211_queue_work(&local
->hw
, &local
->work_work
);
487 return WORK_ACT_TIMEOUT
;
490 printk(KERN_DEBUG
"%s: authenticate with %pM (try %d)\n",
491 sdata
->name
, wk
->filter_ta
, wk
->probe_auth
.tries
);
493 ieee80211_send_auth(sdata
, 1, wk
->probe_auth
.algorithm
, wk
->ie
,
494 wk
->ie_len
, wk
->filter_ta
, NULL
, 0, 0);
495 wk
->probe_auth
.transaction
= 2;
497 wk
->timeout
= jiffies
+ IEEE80211_AUTH_TIMEOUT
;
498 run_again(local
, wk
->timeout
);
500 return WORK_ACT_NONE
;
503 static enum work_action __must_check
504 ieee80211_associate(struct ieee80211_work
*wk
)
506 struct ieee80211_sub_if_data
*sdata
= wk
->sdata
;
507 struct ieee80211_local
*local
= sdata
->local
;
510 if (wk
->assoc
.tries
> IEEE80211_ASSOC_MAX_TRIES
) {
511 printk(KERN_DEBUG
"%s: association with %pM"
513 sdata
->name
, wk
->filter_ta
);
516 * Most likely AP is not in the range so remove the
517 * bss struct for that AP.
520 cfg80211_unlink_bss(local
->hw
.wiphy
, wk
->assoc
.bss
);
523 * We might have a pending scan which had no chance to run yet
524 * due to work needing to be done. Hence, queue the STAs work
527 ieee80211_queue_work(&local
->hw
, &local
->work_work
);
528 return WORK_ACT_TIMEOUT
;
531 printk(KERN_DEBUG
"%s: associate with %pM (try %d)\n",
532 sdata
->name
, wk
->filter_ta
, wk
->assoc
.tries
);
533 ieee80211_send_assoc(sdata
, wk
);
535 wk
->timeout
= jiffies
+ IEEE80211_ASSOC_TIMEOUT
;
536 run_again(local
, wk
->timeout
);
538 return WORK_ACT_NONE
;
541 static enum work_action __must_check
542 ieee80211_remain_on_channel_timeout(struct ieee80211_work
*wk
)
544 struct ieee80211_sub_if_data
*sdata
= wk
->sdata
;
545 struct ieee80211_local
*local
= sdata
->local
;
548 * First time we run, do nothing -- the generic code will
549 * have switched to the right channel etc.
551 if (wk
->timeout
!= wk
->remain
.timeout
) {
552 wk
->timeout
= wk
->remain
.timeout
;
553 return WORK_ACT_NONE
;
557 * We are done serving the remain-on-channel command; kill the work
558 * item to allow idle state to be entered again. In addition, clear the
559 * temporary channel information to allow operational channel to be
565 if (local
->tmp_channel
) {
566 cfg80211_remain_on_channel_expired(sdata
->dev
, (u64
)wk
,
568 local
->tmp_channel_type
,
571 local
->tmp_channel
= NULL
;
572 ieee80211_hw_config(local
, IEEE80211_CONF_CHANGE_CHANNEL
);
573 ieee80211_offchannel_return(local
, true);
576 return WORK_ACT_NONE
;
579 static void ieee80211_auth_challenge(struct ieee80211_work
*wk
,
580 struct ieee80211_mgmt
*mgmt
,
583 struct ieee80211_sub_if_data
*sdata
= wk
->sdata
;
585 struct ieee802_11_elems elems
;
587 pos
= mgmt
->u
.auth
.variable
;
588 ieee802_11_parse_elems(pos
, len
- (pos
- (u8
*) mgmt
), &elems
);
589 if (!elems
.challenge
)
591 ieee80211_send_auth(sdata
, 3, wk
->probe_auth
.algorithm
,
592 elems
.challenge
- 2, elems
.challenge_len
+ 2,
593 wk
->filter_ta
, wk
->probe_auth
.key
,
594 wk
->probe_auth
.key_len
, wk
->probe_auth
.key_idx
);
595 wk
->probe_auth
.transaction
= 4;
598 static enum work_action __must_check
599 ieee80211_rx_mgmt_auth(struct ieee80211_work
*wk
,
600 struct ieee80211_mgmt
*mgmt
, size_t len
)
602 u16 auth_alg
, auth_transaction
, status_code
;
604 if (wk
->type
!= IEEE80211_WORK_AUTH
)
605 return WORK_ACT_NONE
;
608 return WORK_ACT_NONE
;
610 auth_alg
= le16_to_cpu(mgmt
->u
.auth
.auth_alg
);
611 auth_transaction
= le16_to_cpu(mgmt
->u
.auth
.auth_transaction
);
612 status_code
= le16_to_cpu(mgmt
->u
.auth
.status_code
);
614 if (auth_alg
!= wk
->probe_auth
.algorithm
||
615 auth_transaction
!= wk
->probe_auth
.transaction
)
616 return WORK_ACT_NONE
;
618 if (status_code
!= WLAN_STATUS_SUCCESS
) {
619 printk(KERN_DEBUG
"%s: %pM denied authentication (status %d)\n",
620 wk
->sdata
->name
, mgmt
->sa
, status_code
);
621 return WORK_ACT_DONE
;
624 switch (wk
->probe_auth
.algorithm
) {
629 case WLAN_AUTH_SHARED_KEY
:
630 if (wk
->probe_auth
.transaction
!= 4) {
631 ieee80211_auth_challenge(wk
, mgmt
, len
);
632 /* need another frame */
633 return WORK_ACT_NONE
;
638 return WORK_ACT_NONE
;
641 printk(KERN_DEBUG
"%s: authenticated\n", wk
->sdata
->name
);
642 return WORK_ACT_DONE
;
645 static enum work_action __must_check
646 ieee80211_rx_mgmt_assoc_resp(struct ieee80211_work
*wk
,
647 struct ieee80211_mgmt
*mgmt
, size_t len
,
650 struct ieee80211_sub_if_data
*sdata
= wk
->sdata
;
651 struct ieee80211_local
*local
= sdata
->local
;
652 u16 capab_info
, status_code
, aid
;
653 struct ieee802_11_elems elems
;
657 * AssocResp and ReassocResp have identical structure, so process both
658 * of them in this function.
662 return WORK_ACT_NONE
;
664 capab_info
= le16_to_cpu(mgmt
->u
.assoc_resp
.capab_info
);
665 status_code
= le16_to_cpu(mgmt
->u
.assoc_resp
.status_code
);
666 aid
= le16_to_cpu(mgmt
->u
.assoc_resp
.aid
);
668 printk(KERN_DEBUG
"%s: RX %sssocResp from %pM (capab=0x%x "
669 "status=%d aid=%d)\n",
670 sdata
->name
, reassoc
? "Rea" : "A", mgmt
->sa
,
671 capab_info
, status_code
, (u16
)(aid
& ~(BIT(15) | BIT(14))));
673 pos
= mgmt
->u
.assoc_resp
.variable
;
674 ieee802_11_parse_elems(pos
, len
- (pos
- (u8
*) mgmt
), &elems
);
676 if (status_code
== WLAN_STATUS_ASSOC_REJECTED_TEMPORARILY
&&
677 elems
.timeout_int
&& elems
.timeout_int_len
== 5 &&
678 elems
.timeout_int
[0] == WLAN_TIMEOUT_ASSOC_COMEBACK
) {
680 tu
= get_unaligned_le32(elems
.timeout_int
+ 1);
681 ms
= tu
* 1024 / 1000;
682 printk(KERN_DEBUG
"%s: %pM rejected association temporarily; "
683 "comeback duration %u TU (%u ms)\n",
684 sdata
->name
, mgmt
->sa
, tu
, ms
);
685 wk
->timeout
= jiffies
+ msecs_to_jiffies(ms
);
686 if (ms
> IEEE80211_ASSOC_TIMEOUT
)
687 run_again(local
, wk
->timeout
);
688 return WORK_ACT_NONE
;
691 if (status_code
!= WLAN_STATUS_SUCCESS
)
692 printk(KERN_DEBUG
"%s: %pM denied association (code=%d)\n",
693 sdata
->name
, mgmt
->sa
, status_code
);
695 printk(KERN_DEBUG
"%s: associated\n", sdata
->name
);
697 return WORK_ACT_DONE
;
700 static enum work_action __must_check
701 ieee80211_rx_mgmt_probe_resp(struct ieee80211_work
*wk
,
702 struct ieee80211_mgmt
*mgmt
, size_t len
,
703 struct ieee80211_rx_status
*rx_status
)
705 struct ieee80211_sub_if_data
*sdata
= wk
->sdata
;
706 struct ieee80211_local
*local
= sdata
->local
;
709 ASSERT_WORK_MTX(local
);
711 baselen
= (u8
*) mgmt
->u
.probe_resp
.variable
- (u8
*) mgmt
;
713 return WORK_ACT_NONE
;
715 printk(KERN_DEBUG
"%s: direct probe responded\n", sdata
->name
);
716 return WORK_ACT_DONE
;
719 static void ieee80211_work_rx_queued_mgmt(struct ieee80211_local
*local
,
722 struct ieee80211_rx_status
*rx_status
;
723 struct ieee80211_mgmt
*mgmt
;
724 struct ieee80211_work
*wk
;
725 enum work_action rma
= WORK_ACT_NONE
;
728 rx_status
= (struct ieee80211_rx_status
*) skb
->cb
;
729 mgmt
= (struct ieee80211_mgmt
*) skb
->data
;
730 fc
= le16_to_cpu(mgmt
->frame_control
);
732 mutex_lock(&local
->work_mtx
);
734 list_for_each_entry(wk
, &local
->work_list
, list
) {
735 const u8
*bssid
= NULL
;
738 case IEEE80211_WORK_DIRECT_PROBE
:
739 case IEEE80211_WORK_AUTH
:
740 case IEEE80211_WORK_ASSOC
:
741 bssid
= wk
->filter_ta
;
748 * Before queuing, we already verified mgmt->sa,
749 * so this is needed just for matching.
751 if (compare_ether_addr(bssid
, mgmt
->bssid
))
754 switch (fc
& IEEE80211_FCTL_STYPE
) {
755 case IEEE80211_STYPE_PROBE_RESP
:
756 rma
= ieee80211_rx_mgmt_probe_resp(wk
, mgmt
, skb
->len
,
759 case IEEE80211_STYPE_AUTH
:
760 rma
= ieee80211_rx_mgmt_auth(wk
, mgmt
, skb
->len
);
762 case IEEE80211_STYPE_ASSOC_RESP
:
763 rma
= ieee80211_rx_mgmt_assoc_resp(wk
, mgmt
,
766 case IEEE80211_STYPE_REASSOC_RESP
:
767 rma
= ieee80211_rx_mgmt_assoc_resp(wk
, mgmt
,
774 * We've processed this frame for that work, so it can't
775 * belong to another work struct.
776 * NB: this is also required for correctness for 'rma'!
785 list_del_rcu(&wk
->list
);
788 WARN(1, "unexpected: %d", rma
);
791 mutex_unlock(&local
->work_mtx
);
793 if (rma
!= WORK_ACT_DONE
)
796 switch (wk
->done(wk
, skb
)) {
797 case WORK_DONE_DESTROY
:
800 case WORK_DONE_REQUEUE
:
802 wk
->timeout
= jiffies
; /* run again directly */
803 mutex_lock(&local
->work_mtx
);
804 list_add_tail(&wk
->list
, &local
->work_list
);
805 mutex_unlock(&local
->work_mtx
);
812 static void ieee80211_work_timer(unsigned long data
)
814 struct ieee80211_local
*local
= (void *) data
;
816 if (local
->quiescing
)
819 ieee80211_queue_work(&local
->hw
, &local
->work_work
);
822 static void ieee80211_work_work(struct work_struct
*work
)
824 struct ieee80211_local
*local
=
825 container_of(work
, struct ieee80211_local
, work_work
);
827 struct ieee80211_work
*wk
, *tmp
;
828 LIST_HEAD(free_work
);
829 enum work_action rma
;
835 * ieee80211_queue_work() should have picked up most cases,
836 * here we'll pick the the rest.
838 if (WARN(local
->suspended
, "work scheduled while going to suspend\n"))
841 /* first process frames to avoid timing out while a frame is pending */
842 while ((skb
= skb_dequeue(&local
->work_skb_queue
)))
843 ieee80211_work_rx_queued_mgmt(local
, skb
);
845 ieee80211_recalc_idle(local
);
847 mutex_lock(&local
->work_mtx
);
849 list_for_each_entry_safe(wk
, tmp
, &local
->work_list
, list
) {
850 if (time_is_after_jiffies(wk
->timeout
)) {
852 * This work item isn't supposed to be worked on
853 * right now, but take care to adjust the timer
856 run_again(local
, wk
->timeout
);
866 case IEEE80211_WORK_ABORT
:
867 rma
= WORK_ACT_TIMEOUT
;
868 case IEEE80211_WORK_DIRECT_PROBE
:
869 rma
= ieee80211_direct_probe(wk
);
871 case IEEE80211_WORK_AUTH
:
872 rma
= ieee80211_authenticate(wk
);
874 case IEEE80211_WORK_ASSOC
:
875 rma
= ieee80211_associate(wk
);
877 case IEEE80211_WORK_REMAIN_ON_CHANNEL
:
878 rma
= ieee80211_remain_on_channel_timeout(wk
);
884 /* no action required */
886 case WORK_ACT_TIMEOUT
:
887 list_del_rcu(&wk
->list
);
889 list_add(&wk
->list
, &free_work
);
892 WARN(1, "unexpected: %d", rma
);
896 if (list_empty(&local
->work_list
) && local
->scan_req
)
897 ieee80211_queue_delayed_work(&local
->hw
,
899 round_jiffies_relative(0));
901 mutex_unlock(&local
->work_mtx
);
903 list_for_each_entry_safe(wk
, tmp
, &free_work
, list
) {
910 void ieee80211_add_work(struct ieee80211_work
*wk
)
912 struct ieee80211_local
*local
;
914 if (WARN_ON(!wk
->chan
))
917 if (WARN_ON(!wk
->sdata
))
920 if (WARN_ON(!wk
->done
))
923 wk
->timeout
= jiffies
;
925 local
= wk
->sdata
->local
;
926 mutex_lock(&local
->work_mtx
);
927 list_add_tail(&wk
->list
, &local
->work_list
);
928 mutex_unlock(&local
->work_mtx
);
930 ieee80211_queue_work(&local
->hw
, &local
->work_work
);
933 void ieee80211_work_init(struct ieee80211_local
*local
)
935 mutex_init(&local
->work_mtx
);
936 INIT_LIST_HEAD(&local
->work_list
);
937 setup_timer(&local
->work_timer
, ieee80211_work_timer
,
938 (unsigned long)local
);
939 INIT_WORK(&local
->work_work
, ieee80211_work_work
);
940 skb_queue_head_init(&local
->work_skb_queue
);
943 void ieee80211_work_purge(struct ieee80211_sub_if_data
*sdata
)
945 struct ieee80211_local
*local
= sdata
->local
;
946 struct ieee80211_work
*wk
;
948 mutex_lock(&local
->work_mtx
);
949 list_for_each_entry(wk
, &local
->work_list
, list
) {
950 if (wk
->sdata
!= sdata
)
952 wk
->type
= IEEE80211_WORK_ABORT
;
954 mutex_unlock(&local
->work_mtx
);
956 /* run cleanups etc. */
957 ieee80211_work_work(&local
->work_work
);
959 mutex_lock(&local
->work_mtx
);
960 list_for_each_entry(wk
, &local
->work_list
, list
) {
961 if (wk
->sdata
!= sdata
)
966 mutex_unlock(&local
->work_mtx
);
969 ieee80211_rx_result
ieee80211_work_rx_mgmt(struct ieee80211_sub_if_data
*sdata
,
972 struct ieee80211_local
*local
= sdata
->local
;
973 struct ieee80211_mgmt
*mgmt
;
974 struct ieee80211_work
*wk
;
978 return RX_DROP_MONITOR
;
980 mgmt
= (struct ieee80211_mgmt
*) skb
->data
;
981 fc
= le16_to_cpu(mgmt
->frame_control
);
983 list_for_each_entry_rcu(wk
, &local
->work_list
, list
) {
984 if (sdata
!= wk
->sdata
)
986 if (compare_ether_addr(wk
->filter_ta
, mgmt
->sa
))
988 if (compare_ether_addr(wk
->filter_ta
, mgmt
->bssid
))
991 switch (fc
& IEEE80211_FCTL_STYPE
) {
992 case IEEE80211_STYPE_AUTH
:
993 case IEEE80211_STYPE_PROBE_RESP
:
994 case IEEE80211_STYPE_ASSOC_RESP
:
995 case IEEE80211_STYPE_REASSOC_RESP
:
996 case IEEE80211_STYPE_DEAUTH
:
997 case IEEE80211_STYPE_DISASSOC
:
998 skb_queue_tail(&local
->work_skb_queue
, skb
);
999 ieee80211_queue_work(&local
->hw
, &local
->work_work
);
1007 int ieee80211_wk_remain_on_channel(struct ieee80211_sub_if_data
*sdata
,
1008 struct ieee80211_channel
*chan
,
1009 enum nl80211_channel_type channel_type
,
1010 unsigned int duration
, u64
*cookie
)
1012 struct ieee80211_local
*local
= sdata
->local
;
1013 struct ieee80211_work
*wk
;
1015 wk
= kzalloc(sizeof(*wk
), GFP_KERNEL
);
1019 wk
->type
= IEEE80211_WORK_REMAIN_ON_CHANNEL
;
1023 wk
->remain
.timeout
= jiffies
+ msecs_to_jiffies(duration
);
1027 ieee80211_add_work(wk
);
1030 * TODO: could optimize this by leaving the station vifs in awake mode
1031 * if they happen to be on the same channel as the requested channel
1033 ieee80211_offchannel_stop_beaconing(local
);
1034 ieee80211_offchannel_stop_station(local
);
1036 sdata
->local
->tmp_channel
= chan
;
1037 sdata
->local
->tmp_channel_type
= channel_type
;
1038 ieee80211_hw_config(sdata
->local
, IEEE80211_CONF_CHANGE_CHANNEL
);
1040 cfg80211_ready_on_channel(sdata
->dev
, (u64
)wk
, chan
, channel_type
,
1041 duration
, GFP_KERNEL
);
1046 int ieee80211_wk_cancel_remain_on_channel(struct ieee80211_sub_if_data
*sdata
,
1049 struct ieee80211_local
*local
= sdata
->local
;
1050 struct ieee80211_work
*wk
, *tmp
;
1053 mutex_lock(&local
->work_mtx
);
1054 list_for_each_entry_safe(wk
, tmp
, &local
->work_list
, list
) {
1055 if ((u64
)wk
== cookie
) {
1057 list_del(&wk
->list
);
1062 mutex_unlock(&local
->work_mtx
);
1067 if (sdata
->local
->tmp_channel
) {
1068 sdata
->local
->tmp_channel
= NULL
;
1069 ieee80211_hw_config(sdata
->local
,
1070 IEEE80211_CONF_CHANGE_CHANNEL
);
1071 ieee80211_offchannel_return(sdata
->local
, true);
1074 ieee80211_recalc_idle(local
);