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
,
521 &wk
->assoc
.bss
->cbss
);
524 * We might have a pending scan which had no chance to run yet
525 * due to work needing to be done. Hence, queue the STAs work
528 ieee80211_queue_work(&local
->hw
, &local
->work_work
);
529 return WORK_ACT_TIMEOUT
;
532 printk(KERN_DEBUG
"%s: associate with %pM (try %d)\n",
533 sdata
->name
, wk
->filter_ta
, wk
->assoc
.tries
);
534 ieee80211_send_assoc(sdata
, wk
);
536 wk
->timeout
= jiffies
+ IEEE80211_ASSOC_TIMEOUT
;
537 run_again(local
, wk
->timeout
);
539 return WORK_ACT_NONE
;
542 static void ieee80211_auth_challenge(struct ieee80211_work
*wk
,
543 struct ieee80211_mgmt
*mgmt
,
546 struct ieee80211_sub_if_data
*sdata
= wk
->sdata
;
548 struct ieee802_11_elems elems
;
550 pos
= mgmt
->u
.auth
.variable
;
551 ieee802_11_parse_elems(pos
, len
- (pos
- (u8
*) mgmt
), &elems
);
552 if (!elems
.challenge
)
554 ieee80211_send_auth(sdata
, 3, wk
->probe_auth
.algorithm
,
555 elems
.challenge
- 2, elems
.challenge_len
+ 2,
556 wk
->filter_ta
, wk
->probe_auth
.key
,
557 wk
->probe_auth
.key_len
, wk
->probe_auth
.key_idx
);
558 wk
->probe_auth
.transaction
= 4;
561 static enum work_action __must_check
562 ieee80211_rx_mgmt_auth(struct ieee80211_work
*wk
,
563 struct ieee80211_mgmt
*mgmt
, size_t len
)
565 u16 auth_alg
, auth_transaction
, status_code
;
567 if (wk
->type
!= IEEE80211_WORK_AUTH
)
568 return WORK_ACT_NONE
;
571 return WORK_ACT_NONE
;
573 auth_alg
= le16_to_cpu(mgmt
->u
.auth
.auth_alg
);
574 auth_transaction
= le16_to_cpu(mgmt
->u
.auth
.auth_transaction
);
575 status_code
= le16_to_cpu(mgmt
->u
.auth
.status_code
);
577 if (auth_alg
!= wk
->probe_auth
.algorithm
||
578 auth_transaction
!= wk
->probe_auth
.transaction
)
579 return WORK_ACT_NONE
;
581 if (status_code
!= WLAN_STATUS_SUCCESS
) {
582 printk(KERN_DEBUG
"%s: %pM denied authentication (status %d)\n",
583 wk
->sdata
->name
, mgmt
->sa
, status_code
);
584 return WORK_ACT_DONE
;
587 switch (wk
->probe_auth
.algorithm
) {
592 case WLAN_AUTH_SHARED_KEY
:
593 if (wk
->probe_auth
.transaction
!= 4) {
594 ieee80211_auth_challenge(wk
, mgmt
, len
);
595 /* need another frame */
596 return WORK_ACT_NONE
;
601 return WORK_ACT_NONE
;
604 printk(KERN_DEBUG
"%s: authenticated\n", wk
->sdata
->name
);
605 return WORK_ACT_DONE
;
608 static enum work_action __must_check
609 ieee80211_rx_mgmt_assoc_resp(struct ieee80211_work
*wk
,
610 struct ieee80211_mgmt
*mgmt
, size_t len
,
613 struct ieee80211_sub_if_data
*sdata
= wk
->sdata
;
614 struct ieee80211_local
*local
= sdata
->local
;
615 u16 capab_info
, status_code
, aid
;
616 struct ieee802_11_elems elems
;
620 * AssocResp and ReassocResp have identical structure, so process both
621 * of them in this function.
625 return WORK_ACT_NONE
;
627 capab_info
= le16_to_cpu(mgmt
->u
.assoc_resp
.capab_info
);
628 status_code
= le16_to_cpu(mgmt
->u
.assoc_resp
.status_code
);
629 aid
= le16_to_cpu(mgmt
->u
.assoc_resp
.aid
);
631 printk(KERN_DEBUG
"%s: RX %sssocResp from %pM (capab=0x%x "
632 "status=%d aid=%d)\n",
633 sdata
->name
, reassoc
? "Rea" : "A", mgmt
->sa
,
634 capab_info
, status_code
, (u16
)(aid
& ~(BIT(15) | BIT(14))));
636 pos
= mgmt
->u
.assoc_resp
.variable
;
637 ieee802_11_parse_elems(pos
, len
- (pos
- (u8
*) mgmt
), &elems
);
639 if (status_code
== WLAN_STATUS_ASSOC_REJECTED_TEMPORARILY
&&
640 elems
.timeout_int
&& elems
.timeout_int_len
== 5 &&
641 elems
.timeout_int
[0] == WLAN_TIMEOUT_ASSOC_COMEBACK
) {
643 tu
= get_unaligned_le32(elems
.timeout_int
+ 1);
644 ms
= tu
* 1024 / 1000;
645 printk(KERN_DEBUG
"%s: %pM rejected association temporarily; "
646 "comeback duration %u TU (%u ms)\n",
647 sdata
->name
, mgmt
->sa
, tu
, ms
);
648 wk
->timeout
= jiffies
+ msecs_to_jiffies(ms
);
649 if (ms
> IEEE80211_ASSOC_TIMEOUT
)
650 run_again(local
, wk
->timeout
);
651 return WORK_ACT_NONE
;
654 if (status_code
!= WLAN_STATUS_SUCCESS
)
655 printk(KERN_DEBUG
"%s: %pM denied association (code=%d)\n",
656 sdata
->name
, mgmt
->sa
, status_code
);
658 printk(KERN_DEBUG
"%s: associated\n", sdata
->name
);
660 return WORK_ACT_DONE
;
663 static enum work_action __must_check
664 ieee80211_rx_mgmt_probe_resp(struct ieee80211_work
*wk
,
665 struct ieee80211_mgmt
*mgmt
, size_t len
,
666 struct ieee80211_rx_status
*rx_status
)
668 struct ieee80211_sub_if_data
*sdata
= wk
->sdata
;
669 struct ieee80211_local
*local
= sdata
->local
;
672 ASSERT_WORK_MTX(local
);
674 baselen
= (u8
*) mgmt
->u
.probe_resp
.variable
- (u8
*) mgmt
;
676 return WORK_ACT_NONE
;
678 printk(KERN_DEBUG
"%s: direct probe responded\n", sdata
->name
);
679 return WORK_ACT_DONE
;
682 static void ieee80211_work_rx_queued_mgmt(struct ieee80211_local
*local
,
685 struct ieee80211_rx_status
*rx_status
;
686 struct ieee80211_mgmt
*mgmt
;
687 struct ieee80211_work
*wk
;
688 enum work_action rma
= WORK_ACT_NONE
;
691 rx_status
= (struct ieee80211_rx_status
*) skb
->cb
;
692 mgmt
= (struct ieee80211_mgmt
*) skb
->data
;
693 fc
= le16_to_cpu(mgmt
->frame_control
);
695 mutex_lock(&local
->work_mtx
);
697 list_for_each_entry(wk
, &local
->work_list
, list
) {
698 const u8
*bssid
= NULL
;
701 case IEEE80211_WORK_DIRECT_PROBE
:
702 case IEEE80211_WORK_AUTH
:
703 case IEEE80211_WORK_ASSOC
:
704 bssid
= wk
->filter_ta
;
711 * Before queuing, we already verified mgmt->sa,
712 * so this is needed just for matching.
714 if (compare_ether_addr(bssid
, mgmt
->bssid
))
717 switch (fc
& IEEE80211_FCTL_STYPE
) {
718 case IEEE80211_STYPE_PROBE_RESP
:
719 rma
= ieee80211_rx_mgmt_probe_resp(wk
, mgmt
, skb
->len
,
722 case IEEE80211_STYPE_AUTH
:
723 rma
= ieee80211_rx_mgmt_auth(wk
, mgmt
, skb
->len
);
725 case IEEE80211_STYPE_ASSOC_RESP
:
726 rma
= ieee80211_rx_mgmt_assoc_resp(wk
, mgmt
,
729 case IEEE80211_STYPE_REASSOC_RESP
:
730 rma
= ieee80211_rx_mgmt_assoc_resp(wk
, mgmt
,
737 * We've processed this frame for that work, so it can't
738 * belong to another work struct.
739 * NB: this is also required for correctness for 'rma'!
748 list_del_rcu(&wk
->list
);
751 WARN(1, "unexpected: %d", rma
);
754 mutex_unlock(&local
->work_mtx
);
756 if (rma
!= WORK_ACT_DONE
)
759 switch (wk
->done(wk
, skb
)) {
760 case WORK_DONE_DESTROY
:
763 case WORK_DONE_REQUEUE
:
765 wk
->timeout
= jiffies
; /* run again directly */
766 mutex_lock(&local
->work_mtx
);
767 list_add_tail(&wk
->list
, &local
->work_list
);
768 mutex_unlock(&local
->work_mtx
);
775 static void ieee80211_work_timer(unsigned long data
)
777 struct ieee80211_local
*local
= (void *) data
;
779 if (local
->quiescing
)
782 ieee80211_queue_work(&local
->hw
, &local
->work_work
);
785 static void ieee80211_work_work(struct work_struct
*work
)
787 struct ieee80211_local
*local
=
788 container_of(work
, struct ieee80211_local
, work_work
);
790 struct ieee80211_work
*wk
, *tmp
;
791 LIST_HEAD(free_work
);
792 enum work_action rma
;
798 * ieee80211_queue_work() should have picked up most cases,
799 * here we'll pick the the rest.
801 if (WARN(local
->suspended
, "work scheduled while going to suspend\n"))
804 /* first process frames to avoid timing out while a frame is pending */
805 while ((skb
= skb_dequeue(&local
->work_skb_queue
)))
806 ieee80211_work_rx_queued_mgmt(local
, skb
);
808 ieee80211_recalc_idle(local
);
810 mutex_lock(&local
->work_mtx
);
812 list_for_each_entry_safe(wk
, tmp
, &local
->work_list
, list
) {
813 if (time_is_after_jiffies(wk
->timeout
)) {
815 * This work item isn't supposed to be worked on
816 * right now, but take care to adjust the timer
819 run_again(local
, wk
->timeout
);
829 case IEEE80211_WORK_DIRECT_PROBE
:
830 rma
= ieee80211_direct_probe(wk
);
832 case IEEE80211_WORK_AUTH
:
833 rma
= ieee80211_authenticate(wk
);
835 case IEEE80211_WORK_ASSOC
:
836 rma
= ieee80211_associate(wk
);
842 /* no action required */
844 case WORK_ACT_TIMEOUT
:
845 list_del_rcu(&wk
->list
);
847 list_add(&wk
->list
, &free_work
);
850 WARN(1, "unexpected: %d", rma
);
854 if (list_empty(&local
->work_list
) && local
->scan_req
)
855 ieee80211_queue_delayed_work(&local
->hw
,
857 round_jiffies_relative(0));
859 mutex_unlock(&local
->work_mtx
);
861 list_for_each_entry_safe(wk
, tmp
, &free_work
, list
) {
868 void ieee80211_add_work(struct ieee80211_work
*wk
)
870 struct ieee80211_local
*local
;
872 if (WARN_ON(!wk
->chan
))
875 if (WARN_ON(!wk
->sdata
))
878 if (WARN_ON(!wk
->done
))
881 wk
->timeout
= jiffies
;
883 local
= wk
->sdata
->local
;
884 mutex_lock(&local
->work_mtx
);
885 list_add_tail(&wk
->list
, &local
->work_list
);
886 mutex_unlock(&local
->work_mtx
);
888 ieee80211_queue_work(&local
->hw
, &local
->work_work
);
891 void ieee80211_work_init(struct ieee80211_local
*local
)
893 mutex_init(&local
->work_mtx
);
894 INIT_LIST_HEAD(&local
->work_list
);
895 setup_timer(&local
->work_timer
, ieee80211_work_timer
,
896 (unsigned long)local
);
897 INIT_WORK(&local
->work_work
, ieee80211_work_work
);
898 skb_queue_head_init(&local
->work_skb_queue
);
901 void ieee80211_work_purge(struct ieee80211_sub_if_data
*sdata
)
903 struct ieee80211_local
*local
= sdata
->local
;
904 struct ieee80211_work
*wk
, *tmp
;
906 mutex_lock(&local
->work_mtx
);
907 list_for_each_entry_safe(wk
, tmp
, &local
->work_list
, list
) {
908 if (wk
->sdata
!= sdata
)
913 mutex_unlock(&local
->work_mtx
);
916 ieee80211_rx_result
ieee80211_work_rx_mgmt(struct ieee80211_sub_if_data
*sdata
,
919 struct ieee80211_local
*local
= sdata
->local
;
920 struct ieee80211_mgmt
*mgmt
;
921 struct ieee80211_work
*wk
;
925 return RX_DROP_MONITOR
;
927 mgmt
= (struct ieee80211_mgmt
*) skb
->data
;
928 fc
= le16_to_cpu(mgmt
->frame_control
);
930 list_for_each_entry_rcu(wk
, &local
->work_list
, list
) {
931 if (sdata
!= wk
->sdata
)
933 if (compare_ether_addr(wk
->filter_ta
, mgmt
->sa
))
935 if (compare_ether_addr(wk
->filter_ta
, mgmt
->bssid
))
938 switch (fc
& IEEE80211_FCTL_STYPE
) {
939 case IEEE80211_STYPE_AUTH
:
940 case IEEE80211_STYPE_PROBE_RESP
:
941 case IEEE80211_STYPE_ASSOC_RESP
:
942 case IEEE80211_STYPE_REASSOC_RESP
:
943 case IEEE80211_STYPE_DEAUTH
:
944 case IEEE80211_STYPE_DISASSOC
:
945 skb_queue_tail(&local
->work_skb_queue
, skb
);
946 ieee80211_queue_work(&local
->hw
, &local
->work_work
);