?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
mac80211: Retry null data frame for power save
[linux-2.6/linux-acpi-2.6/ibm-acpi-2.6.git] / net / mac80211 / mlme.c
blob1a209ac67ffa1f4444342007c58b0ce415016422
1 /*
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>
8 *
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.
12 */
13
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>
24
25 #include "ieee80211_i.h"
26 #include "driver-ops.h"
27 #include "rate.h"
28 #include "led.h"
29
30 #define IEEE80211_AUTH_TIMEOUT (HZ / 5)
31 #define IEEE80211_AUTH_MAX_TRIES 3
32 #define IEEE80211_ASSOC_TIMEOUT (HZ / 5)
33 #define IEEE80211_ASSOC_MAX_TRIES 3
34 #define IEEE80211_MAX_PROBE_TRIES 5
35
36 /*
37 * beacon loss detection timeout
38 * XXX: should depend on beacon interval
39 */
40 #define IEEE80211_BEACON_LOSS_TIME (2 * HZ)
41 /*
42 * Time the connection can be idle before we probe
43 * it to see if we can still talk to the AP.
44 */
45 #define IEEE80211_CONNECTION_IDLE_TIME (30 * HZ)
46 /*
47 * Time we wait for a probe response after sending
48 * a probe request because of beacon loss or for
49 * checking the connection still works.
50 */
51 #define IEEE80211_PROBE_WAIT (HZ / 2)
52
53 #define TMR_RUNNING_TIMER 0
54 #define TMR_RUNNING_CHANSW 1
55
56 /*
57 * All cfg80211 functions have to be called outside a locked
58 * section so that they can acquire a lock themselves... This
59 * is much simpler than queuing up things in cfg80211, but we
60 * do need some indirection for that here.
61 */
62 enum rx_mgmt_action {
63 /* no action required */
64 RX_MGMT_NONE,
65
66 /* caller must call cfg80211_send_rx_auth() */
67 RX_MGMT_CFG80211_AUTH,
68
69 /* caller must call cfg80211_send_rx_assoc() */
70 RX_MGMT_CFG80211_ASSOC,
71
72 /* caller must call cfg80211_send_deauth() */
73 RX_MGMT_CFG80211_DEAUTH,
74
75 /* caller must call cfg80211_send_disassoc() */
76 RX_MGMT_CFG80211_DISASSOC,
77
78 /* caller must call cfg80211_auth_timeout() & free work */
79 RX_MGMT_CFG80211_AUTH_TO,
80
81 /* caller must call cfg80211_assoc_timeout() & free work */
82 RX_MGMT_CFG80211_ASSOC_TO,
83 };
84
85 /* utils */
86 static inline void ASSERT_MGD_MTX(struct ieee80211_if_managed *ifmgd)
87 {
88 WARN_ON(!mutex_is_locked(&ifmgd->mtx));
89 }
90
91 /*
92 * We can have multiple work items (and connection probing)
93 * scheduling this timer, but we need to take care to only
94 * reschedule it when it should fire _earlier_ than it was
95 * asked for before, or if it's not pending right now. This
96 * function ensures that. Note that it then is required to
97 * run this function for all timeouts after the first one
98 * has happened -- the work that runs from this timer will
99 * do that.
100 */
101 static void run_again(struct ieee80211_if_managed *ifmgd,
102 unsigned long timeout)
103 {
104 ASSERT_MGD_MTX(ifmgd);
105
106 if (!timer_pending(&ifmgd->timer) ||
107 time_before(timeout, ifmgd->timer.expires))
108 mod_timer(&ifmgd->timer, timeout);
109 }
110
111 static void mod_beacon_timer(struct ieee80211_sub_if_data *sdata)
112 {
113 if (sdata->local->hw.flags & IEEE80211_HW_BEACON_FILTER)
114 return;
115
116 mod_timer(&sdata->u.mgd.bcn_mon_timer,
117 round_jiffies_up(jiffies + IEEE80211_BEACON_LOSS_TIME));
118 }
119
120 static int ecw2cw(int ecw)
121 {
122 return (1 << ecw) - 1;
123 }
124
125 static int ieee80211_compatible_rates(struct ieee80211_bss *bss,
126 struct ieee80211_supported_band *sband,
127 u32 *rates)
128 {
129 int i, j, count;
130 *rates = 0;
131 count = 0;
132 for (i = 0; i < bss->supp_rates_len; i++) {
133 int rate = (bss->supp_rates[i] & 0x7F) * 5;
134
135 for (j = 0; j < sband->n_bitrates; j++)
136 if (sband->bitrates[j].bitrate == rate) {
137 *rates |= BIT(j);
138 count++;
139 break;
140 }
141 }
142
143 return count;
144 }
145
146 /*
147 * ieee80211_enable_ht should be called only after the operating band
148 * has been determined as ht configuration depends on the hw's
149 * HT abilities for a specific band.
150 */
151 static u32 ieee80211_enable_ht(struct ieee80211_sub_if_data *sdata,
152 struct ieee80211_ht_info *hti,
153 const u8 *bssid, u16 ap_ht_cap_flags)
154 {
155 struct ieee80211_local *local = sdata->local;
156 struct ieee80211_supported_band *sband;
157 struct sta_info *sta;
158 u32 changed = 0;
159 u16 ht_opmode;
160 bool enable_ht = true, ht_changed;
161 enum nl80211_channel_type channel_type = NL80211_CHAN_NO_HT;
162
163 sband = local->hw.wiphy->bands[local->hw.conf.channel->band];
164
165 /* HT is not supported */
166 if (!sband->ht_cap.ht_supported)
167 enable_ht = false;
168
169 /* check that channel matches the right operating channel */
170 if (local->hw.conf.channel->center_freq !=
171 ieee80211_channel_to_frequency(hti->control_chan))
172 enable_ht = false;
173
174 if (enable_ht) {
175 channel_type = NL80211_CHAN_HT20;
176
177 if (!(ap_ht_cap_flags & IEEE80211_HT_CAP_40MHZ_INTOLERANT) &&
178 (sband->ht_cap.cap & IEEE80211_HT_CAP_SUP_WIDTH_20_40) &&
179 (hti->ht_param & IEEE80211_HT_PARAM_CHAN_WIDTH_ANY)) {
180 switch(hti->ht_param & IEEE80211_HT_PARAM_CHA_SEC_OFFSET) {
181 case IEEE80211_HT_PARAM_CHA_SEC_ABOVE:
182 if (!(local->hw.conf.channel->flags &
183 IEEE80211_CHAN_NO_HT40PLUS))
184 channel_type = NL80211_CHAN_HT40PLUS;
185 break;
186 case IEEE80211_HT_PARAM_CHA_SEC_BELOW:
187 if (!(local->hw.conf.channel->flags &
188 IEEE80211_CHAN_NO_HT40MINUS))
189 channel_type = NL80211_CHAN_HT40MINUS;
190 break;
191 }
192 }
193 }
194
195 ht_changed = conf_is_ht(&local->hw.conf) != enable_ht ||
196 channel_type != local->hw.conf.channel_type;
197
198 local->oper_channel_type = channel_type;
199
200 if (ht_changed) {
201 /* channel_type change automatically detected */
202 ieee80211_hw_config(local, 0);
203
204 rcu_read_lock();
205 sta = sta_info_get(local, bssid);
206 if (sta)
207 rate_control_rate_update(local, sband, sta,
208 IEEE80211_RC_HT_CHANGED,
209 local->oper_channel_type);
210 rcu_read_unlock();
211 }
212
213 /* disable HT */
214 if (!enable_ht)
215 return 0;
216
217 ht_opmode = le16_to_cpu(hti->operation_mode);
218
219 /* if bss configuration changed store the new one */
220 if (!sdata->ht_opmode_valid ||
221 sdata->vif.bss_conf.ht_operation_mode != ht_opmode) {
222 changed |= BSS_CHANGED_HT;
223 sdata->vif.bss_conf.ht_operation_mode = ht_opmode;
224 sdata->ht_opmode_valid = true;
225 }
226
227 return changed;
228 }
229
230 /* frame sending functions */
231
232 static void ieee80211_send_assoc(struct ieee80211_sub_if_data *sdata,
233 struct ieee80211_mgd_work *wk)
234 {
235 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
236 struct ieee80211_local *local = sdata->local;
237 struct sk_buff *skb;
238 struct ieee80211_mgmt *mgmt;
239 u8 *pos;
240 const u8 *ies, *ht_ie;
241 int i, len, count, rates_len, supp_rates_len;
242 u16 capab;
243 int wmm = 0;
244 struct ieee80211_supported_band *sband;
245 u32 rates = 0;
246
247 skb = dev_alloc_skb(local->hw.extra_tx_headroom +
248 sizeof(*mgmt) + 200 + wk->ie_len +
249 wk->ssid_len);
250 if (!skb) {
251 printk(KERN_DEBUG "%s: failed to allocate buffer for assoc "
252 "frame\n", sdata->dev->name);
253 return;
254 }
255 skb_reserve(skb, local->hw.extra_tx_headroom);
256
257 sband = local->hw.wiphy->bands[local->hw.conf.channel->band];
258
259 capab = ifmgd->capab;
260
261 if (local->hw.conf.channel->band == IEEE80211_BAND_2GHZ) {
262 if (!(local->hw.flags & IEEE80211_HW_2GHZ_SHORT_SLOT_INCAPABLE))
263 capab |= WLAN_CAPABILITY_SHORT_SLOT_TIME;
264 if (!(local->hw.flags & IEEE80211_HW_2GHZ_SHORT_PREAMBLE_INCAPABLE))
265 capab |= WLAN_CAPABILITY_SHORT_PREAMBLE;
266 }
267
268 if (wk->bss->cbss.capability & WLAN_CAPABILITY_PRIVACY)
269 capab |= WLAN_CAPABILITY_PRIVACY;
270 if (wk->bss->wmm_used)
271 wmm = 1;
272
273 /* get all rates supported by the device and the AP as
274 * some APs don't like getting a superset of their rates
275 * in the association request (e.g. D-Link DAP 1353 in
276 * b-only mode) */
277 rates_len = ieee80211_compatible_rates(wk->bss, sband, &rates);
278
279 if ((wk->bss->cbss.capability & WLAN_CAPABILITY_SPECTRUM_MGMT) &&
280 (local->hw.flags & IEEE80211_HW_SPECTRUM_MGMT))
281 capab |= WLAN_CAPABILITY_SPECTRUM_MGMT;
282
283 mgmt = (struct ieee80211_mgmt *) skb_put(skb, 24);
284 memset(mgmt, 0, 24);
285 memcpy(mgmt->da, wk->bss->cbss.bssid, ETH_ALEN);
286 memcpy(mgmt->sa, sdata->dev->dev_addr, ETH_ALEN);
287 memcpy(mgmt->bssid, wk->bss->cbss.bssid, ETH_ALEN);
288
289 if (!is_zero_ether_addr(wk->prev_bssid)) {
290 skb_put(skb, 10);
291 mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
292 IEEE80211_STYPE_REASSOC_REQ);
293 mgmt->u.reassoc_req.capab_info = cpu_to_le16(capab);
294 mgmt->u.reassoc_req.listen_interval =
295 cpu_to_le16(local->hw.conf.listen_interval);
296 memcpy(mgmt->u.reassoc_req.current_ap, wk->prev_bssid,
297 ETH_ALEN);
298 } else {
299 skb_put(skb, 4);
300 mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
301 IEEE80211_STYPE_ASSOC_REQ);
302 mgmt->u.assoc_req.capab_info = cpu_to_le16(capab);
303 mgmt->u.assoc_req.listen_interval =
304 cpu_to_le16(local->hw.conf.listen_interval);
305 }
306
307 /* SSID */
308 ies = pos = skb_put(skb, 2 + wk->ssid_len);
309 *pos++ = WLAN_EID_SSID;
310 *pos++ = wk->ssid_len;
311 memcpy(pos, wk->ssid, wk->ssid_len);
312
313 /* add all rates which were marked to be used above */
314 supp_rates_len = rates_len;
315 if (supp_rates_len > 8)
316 supp_rates_len = 8;
317
318 len = sband->n_bitrates;
319 pos = skb_put(skb, supp_rates_len + 2);
320 *pos++ = WLAN_EID_SUPP_RATES;
321 *pos++ = supp_rates_len;
322
323 count = 0;
324 for (i = 0; i < sband->n_bitrates; i++) {
325 if (BIT(i) & rates) {
326 int rate = sband->bitrates[i].bitrate;
327 *pos++ = (u8) (rate / 5);
328 if (++count == 8)
329 break;
330 }
331 }
332
333 if (rates_len > count) {
334 pos = skb_put(skb, rates_len - count + 2);
335 *pos++ = WLAN_EID_EXT_SUPP_RATES;
336 *pos++ = rates_len - count;
337
338 for (i++; i < sband->n_bitrates; i++) {
339 if (BIT(i) & rates) {
340 int rate = sband->bitrates[i].bitrate;
341 *pos++ = (u8) (rate / 5);
342 }
343 }
344 }
345
346 if (capab & WLAN_CAPABILITY_SPECTRUM_MGMT) {
347 /* 1. power capabilities */
348 pos = skb_put(skb, 4);
349 *pos++ = WLAN_EID_PWR_CAPABILITY;
350 *pos++ = 2;
351 *pos++ = 0; /* min tx power */
352 *pos++ = local->hw.conf.channel->max_power; /* max tx power */
353
354 /* 2. supported channels */
355 /* TODO: get this in reg domain format */
356 pos = skb_put(skb, 2 * sband->n_channels + 2);
357 *pos++ = WLAN_EID_SUPPORTED_CHANNELS;
358 *pos++ = 2 * sband->n_channels;
359 for (i = 0; i < sband->n_channels; i++) {
360 *pos++ = ieee80211_frequency_to_channel(
361 sband->channels[i].center_freq);
362 *pos++ = 1; /* one channel in the subband*/
363 }
364 }
365
366 if (wk->ie_len && wk->ie) {
367 pos = skb_put(skb, wk->ie_len);
368 memcpy(pos, wk->ie, wk->ie_len);
369 }
370
371 if (wmm && (ifmgd->flags & IEEE80211_STA_WMM_ENABLED)) {
372 pos = skb_put(skb, 9);
373 *pos++ = WLAN_EID_VENDOR_SPECIFIC;
374 *pos++ = 7; /* len */
375 *pos++ = 0x00; /* Microsoft OUI 00:50:F2 */
376 *pos++ = 0x50;
377 *pos++ = 0xf2;
378 *pos++ = 2; /* WME */
379 *pos++ = 0; /* WME info */
380 *pos++ = 1; /* WME ver */
381 *pos++ = 0;
382 }
383
384 /* wmm support is a must to HT */
385 /*
386 * IEEE802.11n does not allow TKIP/WEP as pairwise
387 * ciphers in HT mode. We still associate in non-ht
388 * mode (11a/b/g) if any one of these ciphers is
389 * configured as pairwise.
390 */
391 if (wmm && (ifmgd->flags & IEEE80211_STA_WMM_ENABLED) &&
392 sband->ht_cap.ht_supported &&
393 (ht_ie = ieee80211_bss_get_ie(&wk->bss->cbss, WLAN_EID_HT_INFORMATION)) &&
394 ht_ie[1] >= sizeof(struct ieee80211_ht_info) &&
395 (!(ifmgd->flags & IEEE80211_STA_DISABLE_11N))) {
396 struct ieee80211_ht_info *ht_info =
397 (struct ieee80211_ht_info *)(ht_ie + 2);
398 u16 cap = sband->ht_cap.cap;
399 __le16 tmp;
400 u32 flags = local->hw.conf.channel->flags;
401
402 switch (ht_info->ht_param & IEEE80211_HT_PARAM_CHA_SEC_OFFSET) {
403 case IEEE80211_HT_PARAM_CHA_SEC_ABOVE:
404 if (flags & IEEE80211_CHAN_NO_HT40PLUS) {
405 cap &= ~IEEE80211_HT_CAP_SUP_WIDTH_20_40;
406 cap &= ~IEEE80211_HT_CAP_SGI_40;
407 }
408 break;
409 case IEEE80211_HT_PARAM_CHA_SEC_BELOW:
410 if (flags & IEEE80211_CHAN_NO_HT40MINUS) {
411 cap &= ~IEEE80211_HT_CAP_SUP_WIDTH_20_40;
412 cap &= ~IEEE80211_HT_CAP_SGI_40;
413 }
414 break;
415 }
416
417 tmp = cpu_to_le16(cap);
418 pos = skb_put(skb, sizeof(struct ieee80211_ht_cap)+2);
419 *pos++ = WLAN_EID_HT_CAPABILITY;
420 *pos++ = sizeof(struct ieee80211_ht_cap);
421 memset(pos, 0, sizeof(struct ieee80211_ht_cap));
422 memcpy(pos, &tmp, sizeof(u16));
423 pos += sizeof(u16);
424 /* TODO: needs a define here for << 2 */
425 *pos++ = sband->ht_cap.ampdu_factor |
426 (sband->ht_cap.ampdu_density << 2);
427 memcpy(pos, &sband->ht_cap.mcs, sizeof(sband->ht_cap.mcs));
428 }
429
430 IEEE80211_SKB_CB(skb)->flags |= IEEE80211_TX_INTFL_DONT_ENCRYPT;
431 ieee80211_tx_skb(sdata, skb);
432 }
433
434
435 static void ieee80211_send_deauth_disassoc(struct ieee80211_sub_if_data *sdata,
436 const u8 *bssid, u16 stype, u16 reason,
437 void *cookie)
438 {
439 struct ieee80211_local *local = sdata->local;
440 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
441 struct sk_buff *skb;
442 struct ieee80211_mgmt *mgmt;
443
444 skb = dev_alloc_skb(local->hw.extra_tx_headroom + sizeof(*mgmt));
445 if (!skb) {
446 printk(KERN_DEBUG "%s: failed to allocate buffer for "
447 "deauth/disassoc frame\n", sdata->dev->name);
448 return;
449 }
450 skb_reserve(skb, local->hw.extra_tx_headroom);
451
452 mgmt = (struct ieee80211_mgmt *) skb_put(skb, 24);
453 memset(mgmt, 0, 24);
454 memcpy(mgmt->da, bssid, ETH_ALEN);
455 memcpy(mgmt->sa, sdata->dev->dev_addr, ETH_ALEN);
456 memcpy(mgmt->bssid, bssid, ETH_ALEN);
457 mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT | stype);
458 skb_put(skb, 2);
459 /* u.deauth.reason_code == u.disassoc.reason_code */
460 mgmt->u.deauth.reason_code = cpu_to_le16(reason);
461
462 if (stype == IEEE80211_STYPE_DEAUTH)
463 if (cookie)
464 __cfg80211_send_deauth(sdata->dev, (u8 *)mgmt, skb->len);
465 else
466 cfg80211_send_deauth(sdata->dev, (u8 *)mgmt, skb->len);
467 else
468 if (cookie)
469 __cfg80211_send_disassoc(sdata->dev, (u8 *)mgmt, skb->len);
470 else
471 cfg80211_send_disassoc(sdata->dev, (u8 *)mgmt, skb->len);
472 if (!(ifmgd->flags & IEEE80211_STA_MFP_ENABLED))
473 IEEE80211_SKB_CB(skb)->flags |= IEEE80211_TX_INTFL_DONT_ENCRYPT;
474 ieee80211_tx_skb(sdata, skb);
475 }
476
477 void ieee80211_send_pspoll(struct ieee80211_local *local,
478 struct ieee80211_sub_if_data *sdata)
479 {
480 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
481 struct ieee80211_pspoll *pspoll;
482 struct sk_buff *skb;
483 u16 fc;
484
485 skb = dev_alloc_skb(local->hw.extra_tx_headroom + sizeof(*pspoll));
486 if (!skb) {
487 printk(KERN_DEBUG "%s: failed to allocate buffer for "
488 "pspoll frame\n", sdata->dev->name);
489 return;
490 }
491 skb_reserve(skb, local->hw.extra_tx_headroom);
492
493 pspoll = (struct ieee80211_pspoll *) skb_put(skb, sizeof(*pspoll));
494 memset(pspoll, 0, sizeof(*pspoll));
495 fc = IEEE80211_FTYPE_CTL | IEEE80211_STYPE_PSPOLL | IEEE80211_FCTL_PM;
496 pspoll->frame_control = cpu_to_le16(fc);
497 pspoll->aid = cpu_to_le16(ifmgd->aid);
498
499 /* aid in PS-Poll has its two MSBs each set to 1 */
500 pspoll->aid |= cpu_to_le16(1 << 15 | 1 << 14);
501
502 memcpy(pspoll->bssid, ifmgd->bssid, ETH_ALEN);
503 memcpy(pspoll->ta, sdata->dev->dev_addr, ETH_ALEN);
504
505 IEEE80211_SKB_CB(skb)->flags |= IEEE80211_TX_INTFL_DONT_ENCRYPT;
506 ieee80211_tx_skb(sdata, skb);
507 }
508
509 void ieee80211_send_nullfunc(struct ieee80211_local *local,
510 struct ieee80211_sub_if_data *sdata,
511 int powersave)
512 {
513 struct sk_buff *skb;
514 struct ieee80211_hdr *nullfunc;
515 __le16 fc;
516
517 if (WARN_ON(sdata->vif.type != NL80211_IFTYPE_STATION))
518 return;
519
520 skb = dev_alloc_skb(local->hw.extra_tx_headroom + 24);
521 if (!skb) {
522 printk(KERN_DEBUG "%s: failed to allocate buffer for nullfunc "
523 "frame\n", sdata->dev->name);
524 return;
525 }
526 skb_reserve(skb, local->hw.extra_tx_headroom);
527
528 nullfunc = (struct ieee80211_hdr *) skb_put(skb, 24);
529 memset(nullfunc, 0, 24);
530 fc = cpu_to_le16(IEEE80211_FTYPE_DATA | IEEE80211_STYPE_NULLFUNC |
531 IEEE80211_FCTL_TODS);
532 if (powersave)
533 fc |= cpu_to_le16(IEEE80211_FCTL_PM);
534 nullfunc->frame_control = fc;
535 memcpy(nullfunc->addr1, sdata->u.mgd.bssid, ETH_ALEN);
536 memcpy(nullfunc->addr2, sdata->dev->dev_addr, ETH_ALEN);
537 memcpy(nullfunc->addr3, sdata->u.mgd.bssid, ETH_ALEN);
538
539 IEEE80211_SKB_CB(skb)->flags |= IEEE80211_TX_INTFL_DONT_ENCRYPT;
540 ieee80211_tx_skb(sdata, skb);
541 }
542
543 /* spectrum management related things */
544 static void ieee80211_chswitch_work(struct work_struct *work)
545 {
546 struct ieee80211_sub_if_data *sdata =
547 container_of(work, struct ieee80211_sub_if_data, u.mgd.chswitch_work);
548 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
549
550 if (!netif_running(sdata->dev))
551 return;
552
553 mutex_lock(&ifmgd->mtx);
554 if (!ifmgd->associated)
555 goto out;
556
557 sdata->local->oper_channel = sdata->local->csa_channel;
558 ieee80211_hw_config(sdata->local, IEEE80211_CONF_CHANGE_CHANNEL);
559
560 /* XXX: shouldn't really modify cfg80211-owned data! */
561 ifmgd->associated->cbss.channel = sdata->local->oper_channel;
562
563 ieee80211_wake_queues_by_reason(&sdata->local->hw,
564 IEEE80211_QUEUE_STOP_REASON_CSA);
565 out:
566 ifmgd->flags &= ~IEEE80211_STA_CSA_RECEIVED;
567 mutex_unlock(&ifmgd->mtx);
568 }
569
570 static void ieee80211_chswitch_timer(unsigned long data)
571 {
572 struct ieee80211_sub_if_data *sdata =
573 (struct ieee80211_sub_if_data *) data;
574 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
575
576 if (sdata->local->quiescing) {
577 set_bit(TMR_RUNNING_CHANSW, &ifmgd->timers_running);
578 return;
579 }
580
581 ieee80211_queue_work(&sdata->local->hw, &ifmgd->chswitch_work);
582 }
583
584 void ieee80211_sta_process_chanswitch(struct ieee80211_sub_if_data *sdata,
585 struct ieee80211_channel_sw_ie *sw_elem,
586 struct ieee80211_bss *bss)
587 {
588 struct ieee80211_channel *new_ch;
589 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
590 int new_freq = ieee80211_channel_to_frequency(sw_elem->new_ch_num);
591
592 ASSERT_MGD_MTX(ifmgd);
593
594 if (!ifmgd->associated)
595 return;
596
597 if (sdata->local->scanning)
598 return;
599
600 /* Disregard subsequent beacons if we are already running a timer
601 processing a CSA */
602
603 if (ifmgd->flags & IEEE80211_STA_CSA_RECEIVED)
604 return;
605
606 new_ch = ieee80211_get_channel(sdata->local->hw.wiphy, new_freq);
607 if (!new_ch || new_ch->flags & IEEE80211_CHAN_DISABLED)
608 return;
609
610 sdata->local->csa_channel = new_ch;
611
612 if (sw_elem->count <= 1) {
613 ieee80211_queue_work(&sdata->local->hw, &ifmgd->chswitch_work);
614 } else {
615 ieee80211_stop_queues_by_reason(&sdata->local->hw,
616 IEEE80211_QUEUE_STOP_REASON_CSA);
617 ifmgd->flags |= IEEE80211_STA_CSA_RECEIVED;
618 mod_timer(&ifmgd->chswitch_timer,
619 jiffies +
620 msecs_to_jiffies(sw_elem->count *
621 bss->cbss.beacon_interval));
622 }
623 }
624
625 static void ieee80211_handle_pwr_constr(struct ieee80211_sub_if_data *sdata,
626 u16 capab_info, u8 *pwr_constr_elem,
627 u8 pwr_constr_elem_len)
628 {
629 struct ieee80211_conf *conf = &sdata->local->hw.conf;
630
631 if (!(capab_info & WLAN_CAPABILITY_SPECTRUM_MGMT))
632 return;
633
634 /* Power constraint IE length should be 1 octet */
635 if (pwr_constr_elem_len != 1)
636 return;
637
638 if ((*pwr_constr_elem <= conf->channel->max_power) &&
639 (*pwr_constr_elem != sdata->local->power_constr_level)) {
640 sdata->local->power_constr_level = *pwr_constr_elem;
641 ieee80211_hw_config(sdata->local, 0);
642 }
643 }
644
645 /* powersave */
646 static void ieee80211_enable_ps(struct ieee80211_local *local,
647 struct ieee80211_sub_if_data *sdata)
648 {
649 struct ieee80211_conf *conf = &local->hw.conf;
650
651 /*
652 * If we are scanning right now then the parameters will
653 * take effect when scan finishes.
654 */
655 if (local->scanning)
656 return;
657
658 if (conf->dynamic_ps_timeout > 0 &&
659 !(local->hw.flags & IEEE80211_HW_SUPPORTS_DYNAMIC_PS)) {
660 mod_timer(&local->dynamic_ps_timer, jiffies +
661 msecs_to_jiffies(conf->dynamic_ps_timeout));
662 } else {
663 if (local->hw.flags & IEEE80211_HW_PS_NULLFUNC_STACK)
664 ieee80211_send_nullfunc(local, sdata, 1);
665
666 if (!(local->hw.flags & IEEE80211_HW_REPORTS_TX_ACK_STATUS)) {
667 conf->flags |= IEEE80211_CONF_PS;
668 ieee80211_hw_config(local, IEEE80211_CONF_CHANGE_PS);
669 }
670 }
671 }
672
673 static void ieee80211_change_ps(struct ieee80211_local *local)
674 {
675 struct ieee80211_conf *conf = &local->hw.conf;
676
677 if (local->ps_sdata) {
678 ieee80211_enable_ps(local, local->ps_sdata);
679 } else if (conf->flags & IEEE80211_CONF_PS) {
680 conf->flags &= ~IEEE80211_CONF_PS;
681 ieee80211_hw_config(local, IEEE80211_CONF_CHANGE_PS);
682 del_timer_sync(&local->dynamic_ps_timer);
683 cancel_work_sync(&local->dynamic_ps_enable_work);
684 }
685 }
686
687 /* need to hold RTNL or interface lock */
688 void ieee80211_recalc_ps(struct ieee80211_local *local, s32 latency)
689 {
690 struct ieee80211_sub_if_data *sdata, *found = NULL;
691 int count = 0;
692
693 if (!(local->hw.flags & IEEE80211_HW_SUPPORTS_PS)) {
694 local->ps_sdata = NULL;
695 return;
696 }
697
698 list_for_each_entry(sdata, &local->interfaces, list) {
699 if (!netif_running(sdata->dev))
700 continue;
701 if (sdata->vif.type != NL80211_IFTYPE_STATION)
702 continue;
703 found = sdata;
704 count++;
705 }
706
707 if (count == 1 && found->u.mgd.powersave &&
708 found->u.mgd.associated && list_empty(&found->u.mgd.work_list) &&
709 !(found->u.mgd.flags & (IEEE80211_STA_BEACON_POLL |
710 IEEE80211_STA_CONNECTION_POLL))) {
711 s32 beaconint_us;
712
713 if (latency < 0)
714 latency = pm_qos_requirement(PM_QOS_NETWORK_LATENCY);
715
716 beaconint_us = ieee80211_tu_to_usec(
717 found->vif.bss_conf.beacon_int);
718
719 if (beaconint_us > latency) {
720 local->ps_sdata = NULL;
721 } else {
722 u8 dtimper = found->vif.bss_conf.dtim_period;
723 int maxslp = 1;
724
725 if (dtimper > 1)
726 maxslp = min_t(int, dtimper,
727 latency / beaconint_us);
728
729 local->hw.conf.max_sleep_period = maxslp;
730 local->ps_sdata = found;
731 }
732 } else {
733 local->ps_sdata = NULL;
734 }
735
736 ieee80211_change_ps(local);
737 }
738
739 void ieee80211_dynamic_ps_disable_work(struct work_struct *work)
740 {
741 struct ieee80211_local *local =
742 container_of(work, struct ieee80211_local,
743 dynamic_ps_disable_work);
744
745 if (local->hw.conf.flags & IEEE80211_CONF_PS) {
746 local->hw.conf.flags &= ~IEEE80211_CONF_PS;
747 ieee80211_hw_config(local, IEEE80211_CONF_CHANGE_PS);
748 }
749
750 ieee80211_wake_queues_by_reason(&local->hw,
751 IEEE80211_QUEUE_STOP_REASON_PS);
752 }
753
754 void ieee80211_dynamic_ps_enable_work(struct work_struct *work)
755 {
756 struct ieee80211_local *local =
757 container_of(work, struct ieee80211_local,
758 dynamic_ps_enable_work);
759 struct ieee80211_sub_if_data *sdata = local->ps_sdata;
760 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
761
762 /* can only happen when PS was just disabled anyway */
763 if (!sdata)
764 return;
765
766 if (local->hw.conf.flags & IEEE80211_CONF_PS)
767 return;
768
769 if ((local->hw.flags & IEEE80211_HW_PS_NULLFUNC_STACK) &&
770 (!(ifmgd->flags & IEEE80211_STA_NULLFUNC_ACKED)))
771 ieee80211_send_nullfunc(local, sdata, 1);
772
773 if (!(local->hw.flags & IEEE80211_HW_REPORTS_TX_ACK_STATUS) ||
774 (ifmgd->flags & IEEE80211_STA_NULLFUNC_ACKED)) {
775 ifmgd->flags &= ~IEEE80211_STA_NULLFUNC_ACKED;
776 local->hw.conf.flags |= IEEE80211_CONF_PS;
777 ieee80211_hw_config(local, IEEE80211_CONF_CHANGE_PS);
778 }
779 }
780
781 void ieee80211_dynamic_ps_timer(unsigned long data)
782 {
783 struct ieee80211_local *local = (void *) data;
784
785 if (local->quiescing || local->suspended)
786 return;
787
788 ieee80211_queue_work(&local->hw, &local->dynamic_ps_enable_work);
789 }
790
791 /* MLME */
792 static void ieee80211_sta_wmm_params(struct ieee80211_local *local,
793 struct ieee80211_if_managed *ifmgd,
794 u8 *wmm_param, size_t wmm_param_len)
795 {
796 struct ieee80211_tx_queue_params params;
797 size_t left;
798 int count;
799 u8 *pos;
800
801 if (!(ifmgd->flags & IEEE80211_STA_WMM_ENABLED))
802 return;
803
804 if (!wmm_param)
805 return;
806
807 if (wmm_param_len < 8 || wmm_param[5] /* version */ != 1)
808 return;
809 count = wmm_param[6] & 0x0f;
810 if (count == ifmgd->wmm_last_param_set)
811 return;
812 ifmgd->wmm_last_param_set = count;
813
814 pos = wmm_param + 8;
815 left = wmm_param_len - 8;
816
817 memset(&params, 0, sizeof(params));
818
819 local->wmm_acm = 0;
820 for (; left >= 4; left -= 4, pos += 4) {
821 int aci = (pos[0] >> 5) & 0x03;
822 int acm = (pos[0] >> 4) & 0x01;
823 int queue;
824
825 switch (aci) {
826 case 1: /* AC_BK */
827 queue = 3;
828 if (acm)
829 local->wmm_acm |= BIT(1) | BIT(2); /* BK/- */
830 break;
831 case 2: /* AC_VI */
832 queue = 1;
833 if (acm)
834 local->wmm_acm |= BIT(4) | BIT(5); /* CL/VI */
835 break;
836 case 3: /* AC_VO */
837 queue = 0;
838 if (acm)
839 local->wmm_acm |= BIT(6) | BIT(7); /* VO/NC */
840 break;
841 case 0: /* AC_BE */
842 default:
843 queue = 2;
844 if (acm)
845 local->wmm_acm |= BIT(0) | BIT(3); /* BE/EE */
846 break;
847 }
848
849 params.aifs = pos[0] & 0x0f;
850 params.cw_max = ecw2cw((pos[1] & 0xf0) >> 4);
851 params.cw_min = ecw2cw(pos[1] & 0x0f);
852 params.txop = get_unaligned_le16(pos + 2);
853 #ifdef CONFIG_MAC80211_VERBOSE_DEBUG
854 printk(KERN_DEBUG "%s: WMM queue=%d aci=%d acm=%d aifs=%d "
855 "cWmin=%d cWmax=%d txop=%d\n",
856 wiphy_name(local->hw.wiphy), queue, aci, acm,
857 params.aifs, params.cw_min, params.cw_max, params.txop);
858 #endif
859 if (drv_conf_tx(local, queue, &params) && local->ops->conf_tx)
860 printk(KERN_DEBUG "%s: failed to set TX queue "
861 "parameters for queue %d\n",
862 wiphy_name(local->hw.wiphy), queue);
863 }
864 }
865
866 static u32 ieee80211_handle_bss_capability(struct ieee80211_sub_if_data *sdata,
867 u16 capab, bool erp_valid, u8 erp)
868 {
869 struct ieee80211_bss_conf *bss_conf = &sdata->vif.bss_conf;
870 u32 changed = 0;
871 bool use_protection;
872 bool use_short_preamble;
873 bool use_short_slot;
874
875 if (erp_valid) {
876 use_protection = (erp & WLAN_ERP_USE_PROTECTION) != 0;
877 use_short_preamble = (erp & WLAN_ERP_BARKER_PREAMBLE) == 0;
878 } else {
879 use_protection = false;
880 use_short_preamble = !!(capab & WLAN_CAPABILITY_SHORT_PREAMBLE);
881 }
882
883 use_short_slot = !!(capab & WLAN_CAPABILITY_SHORT_SLOT_TIME);
884
885 if (use_protection != bss_conf->use_cts_prot) {
886 bss_conf->use_cts_prot = use_protection;
887 changed |= BSS_CHANGED_ERP_CTS_PROT;
888 }
889
890 if (use_short_preamble != bss_conf->use_short_preamble) {
891 bss_conf->use_short_preamble = use_short_preamble;
892 changed |= BSS_CHANGED_ERP_PREAMBLE;
893 }
894
895 if (use_short_slot != bss_conf->use_short_slot) {
896 bss_conf->use_short_slot = use_short_slot;
897 changed |= BSS_CHANGED_ERP_SLOT;
898 }
899
900 return changed;
901 }
902
903 static void ieee80211_set_associated(struct ieee80211_sub_if_data *sdata,
904 struct ieee80211_mgd_work *wk,
905 u32 bss_info_changed)
906 {
907 struct ieee80211_local *local = sdata->local;
908 struct ieee80211_bss *bss = wk->bss;
909
910 bss_info_changed |= BSS_CHANGED_ASSOC;
911 /* set timing information */
912 sdata->vif.bss_conf.beacon_int = bss->cbss.beacon_interval;
913 sdata->vif.bss_conf.timestamp = bss->cbss.tsf;
914 sdata->vif.bss_conf.dtim_period = bss->dtim_period;
915
916 bss_info_changed |= BSS_CHANGED_BEACON_INT;
917 bss_info_changed |= ieee80211_handle_bss_capability(sdata,
918 bss->cbss.capability, bss->has_erp_value, bss->erp_value);
919
920 sdata->u.mgd.associated = bss;
921 sdata->u.mgd.old_associate_work = wk;
922 memcpy(sdata->u.mgd.bssid, bss->cbss.bssid, ETH_ALEN);
923
924 /* just to be sure */
925 sdata->u.mgd.flags &= ~(IEEE80211_STA_CONNECTION_POLL |
926 IEEE80211_STA_BEACON_POLL);
927
928 /*
929 * Always handle WMM once after association regardless
930 * of the first value the AP uses. Setting -1 here has
931 * that effect because the AP values is an unsigned
932 * 4-bit value.
933 */
934 sdata->u.mgd.wmm_last_param_set = -1;
935
936 ieee80211_led_assoc(local, 1);
937
938 sdata->vif.bss_conf.assoc = 1;
939 /*
940 * For now just always ask the driver to update the basic rateset
941 * when we have associated, we aren't checking whether it actually
942 * changed or not.
943 */
944 bss_info_changed |= BSS_CHANGED_BASIC_RATES;
945
946 /* And the BSSID changed - we're associated now */
947 bss_info_changed |= BSS_CHANGED_BSSID;
948
949 ieee80211_bss_info_change_notify(sdata, bss_info_changed);
950
951 mutex_lock(&local->iflist_mtx);
952 ieee80211_recalc_ps(local, -1);
953 mutex_unlock(&local->iflist_mtx);
954
955 netif_tx_start_all_queues(sdata->dev);
956 netif_carrier_on(sdata->dev);
957 }
958
959 static enum rx_mgmt_action __must_check
960 ieee80211_direct_probe(struct ieee80211_sub_if_data *sdata,
961 struct ieee80211_mgd_work *wk)
962 {
963 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
964 struct ieee80211_local *local = sdata->local;
965
966 wk->tries++;
967 if (wk->tries > IEEE80211_AUTH_MAX_TRIES) {
968 printk(KERN_DEBUG "%s: direct probe to AP %pM timed out\n",
969 sdata->dev->name, wk->bss->cbss.bssid);
970
971 /*
972 * Most likely AP is not in the range so remove the
973 * bss struct for that AP.
974 */
975 cfg80211_unlink_bss(local->hw.wiphy, &wk->bss->cbss);
976
977 /*
978 * We might have a pending scan which had no chance to run yet
979 * due to work needing to be done. Hence, queue the STAs work
980 * again for that.
981 */
982 ieee80211_queue_work(&local->hw, &ifmgd->work);
983 return RX_MGMT_CFG80211_AUTH_TO;
984 }
985
986 printk(KERN_DEBUG "%s: direct probe to AP %pM (try %d)\n",
987 sdata->dev->name, wk->bss->cbss.bssid,
988 wk->tries);
989
990 /*
991 * Direct probe is sent to broadcast address as some APs
992 * will not answer to direct packet in unassociated state.
993 */
994 ieee80211_send_probe_req(sdata, NULL, wk->ssid, wk->ssid_len, NULL, 0);
995
996 wk->timeout = jiffies + IEEE80211_AUTH_TIMEOUT;
997 run_again(ifmgd, wk->timeout);
998
999 return RX_MGMT_NONE;
1000 }
1001
1002
1003 static enum rx_mgmt_action __must_check
1004 ieee80211_authenticate(struct ieee80211_sub_if_data *sdata,
1005 struct ieee80211_mgd_work *wk)
1006 {
1007 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
1008 struct ieee80211_local *local = sdata->local;
1009
1010 wk->tries++;
1011 if (wk->tries > IEEE80211_AUTH_MAX_TRIES) {
1012 printk(KERN_DEBUG "%s: authentication with AP %pM"
1013 " timed out\n",
1014 sdata->dev->name, wk->bss->cbss.bssid);
1015
1016 /*
1017 * Most likely AP is not in the range so remove the
1018 * bss struct for that AP.
1019 */
1020 cfg80211_unlink_bss(local->hw.wiphy, &wk->bss->cbss);
1021
1022 /*
1023 * We might have a pending scan which had no chance to run yet
1024 * due to work needing to be done. Hence, queue the STAs work
1025 * again for that.
1026 */
1027 ieee80211_queue_work(&local->hw, &ifmgd->work);
1028 return RX_MGMT_CFG80211_AUTH_TO;
1029 }
1030
1031 printk(KERN_DEBUG "%s: authenticate with AP %pM (try %d)\n",
1032 sdata->dev->name, wk->bss->cbss.bssid, wk->tries);
1033
1034 ieee80211_send_auth(sdata, 1, wk->auth_alg, wk->ie, wk->ie_len,
1035 wk->bss->cbss.bssid, NULL, 0, 0);
1036 wk->auth_transaction = 2;
1037
1038 wk->timeout = jiffies + IEEE80211_AUTH_TIMEOUT;
1039 run_again(ifmgd, wk->timeout);
1040
1041 return RX_MGMT_NONE;
1042 }
1043
1044 static void ieee80211_set_disassoc(struct ieee80211_sub_if_data *sdata,
1045 bool deauth)
1046 {
1047 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
1048 struct ieee80211_local *local = sdata->local;
1049 struct sta_info *sta;
1050 u32 changed = 0, config_changed = 0;
1051 u8 bssid[ETH_ALEN];
1052
1053 ASSERT_MGD_MTX(ifmgd);
1054
1055 if (WARN_ON(!ifmgd->associated))
1056 return;
1057
1058 memcpy(bssid, ifmgd->associated->cbss.bssid, ETH_ALEN);
1059
1060 ifmgd->associated = NULL;
1061 memset(ifmgd->bssid, 0, ETH_ALEN);
1062
1063 if (deauth) {
1064 kfree(ifmgd->old_associate_work);
1065 ifmgd->old_associate_work = NULL;
1066 } else {
1067 struct ieee80211_mgd_work *wk = ifmgd->old_associate_work;
1068
1069 wk->state = IEEE80211_MGD_STATE_IDLE;
1070 list_add(&wk->list, &ifmgd->work_list);
1071 }
1072
1073 /*
1074 * we need to commit the associated = NULL change because the
1075 * scan code uses that to determine whether this iface should
1076 * go to/wake up from powersave or not -- and could otherwise
1077 * wake the queues erroneously.
1078 */
1079 smp_mb();
1080
1081 /*
1082 * Thus, we can only afterwards stop the queues -- to account
1083 * for the case where another CPU is finishing a scan at this
1084 * time -- we don't want the scan code to enable queues.
1085 */
1086
1087 netif_tx_stop_all_queues(sdata->dev);
1088 netif_carrier_off(sdata->dev);
1089
1090 rcu_read_lock();
1091 sta = sta_info_get(local, bssid);
1092 if (sta)
1093 ieee80211_sta_tear_down_BA_sessions(sta);
1094 rcu_read_unlock();
1095
1096 changed |= ieee80211_reset_erp_info(sdata);
1097
1098 ieee80211_led_assoc(local, 0);
1099 changed |= BSS_CHANGED_ASSOC;
1100 sdata->vif.bss_conf.assoc = false;
1101
1102 ieee80211_set_wmm_default(sdata);
1103
1104 /* channel(_type) changes are handled by ieee80211_hw_config */
1105 local->oper_channel_type = NL80211_CHAN_NO_HT;
1106
1107 /* on the next assoc, re-program HT parameters */
1108 sdata->ht_opmode_valid = false;
1109
1110 local->power_constr_level = 0;
1111
1112 del_timer_sync(&local->dynamic_ps_timer);
1113 cancel_work_sync(&local->dynamic_ps_enable_work);
1114
1115 if (local->hw.conf.flags & IEEE80211_CONF_PS) {
1116 local->hw.conf.flags &= ~IEEE80211_CONF_PS;
1117 config_changed |= IEEE80211_CONF_CHANGE_PS;
1118 }
1119
1120 ieee80211_hw_config(local, config_changed);
1121
1122 /* And the BSSID changed -- not very interesting here */
1123 changed |= BSS_CHANGED_BSSID;
1124 ieee80211_bss_info_change_notify(sdata, changed);
1125
1126 rcu_read_lock();
1127
1128 sta = sta_info_get(local, bssid);
1129 if (!sta) {
1130 rcu_read_unlock();
1131 return;
1132 }
1133
1134 sta_info_unlink(&sta);
1135
1136 rcu_read_unlock();
1137
1138 sta_info_destroy(sta);
1139 }
1140
1141 static enum rx_mgmt_action __must_check
1142 ieee80211_associate(struct ieee80211_sub_if_data *sdata,
1143 struct ieee80211_mgd_work *wk)
1144 {
1145 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
1146 struct ieee80211_local *local = sdata->local;
1147
1148 wk->tries++;
1149 if (wk->tries > IEEE80211_ASSOC_MAX_TRIES) {
1150 printk(KERN_DEBUG "%s: association with AP %pM"
1151 " timed out\n",
1152 sdata->dev->name, wk->bss->cbss.bssid);
1153
1154 /*
1155 * Most likely AP is not in the range so remove the
1156 * bss struct for that AP.
1157 */
1158 cfg80211_unlink_bss(local->hw.wiphy, &wk->bss->cbss);
1159
1160 /*
1161 * We might have a pending scan which had no chance to run yet
1162 * due to work needing to be done. Hence, queue the STAs work
1163 * again for that.
1164 */
1165 ieee80211_queue_work(&local->hw, &ifmgd->work);
1166 return RX_MGMT_CFG80211_ASSOC_TO;
1167 }
1168
1169 printk(KERN_DEBUG "%s: associate with AP %pM (try %d)\n",
1170 sdata->dev->name, wk->bss->cbss.bssid, wk->tries);
1171 ieee80211_send_assoc(sdata, wk);
1172
1173 wk->timeout = jiffies + IEEE80211_ASSOC_TIMEOUT;
1174 run_again(ifmgd, wk->timeout);
1175
1176 return RX_MGMT_NONE;
1177 }
1178
1179 void ieee80211_sta_rx_notify(struct ieee80211_sub_if_data *sdata,
1180 struct ieee80211_hdr *hdr)
1181 {
1182 /*
1183 * We can postpone the mgd.timer whenever receiving unicast frames
1184 * from AP because we know that the connection is working both ways
1185 * at that time. But multicast frames (and hence also beacons) must
1186 * be ignored here, because we need to trigger the timer during
1187 * data idle periods for sending the periodic probe request to the
1188 * AP we're connected to.
1189 */
1190 if (is_multicast_ether_addr(hdr->addr1))
1191 return;
1192
1193 mod_timer(&sdata->u.mgd.conn_mon_timer,
1194 round_jiffies_up(jiffies + IEEE80211_CONNECTION_IDLE_TIME));
1195 }
1196
1197 static void ieee80211_mgd_probe_ap_send(struct ieee80211_sub_if_data *sdata)
1198 {
1199 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
1200 const u8 *ssid;
1201
1202 ssid = ieee80211_bss_get_ie(&ifmgd->associated->cbss, WLAN_EID_SSID);
1203 ieee80211_send_probe_req(sdata, ifmgd->associated->cbss.bssid,
1204 ssid + 2, ssid[1], NULL, 0);
1205
1206 ifmgd->probe_send_count++;
1207 ifmgd->probe_timeout = jiffies + IEEE80211_PROBE_WAIT;
1208 run_again(ifmgd, ifmgd->probe_timeout);
1209 }
1210
1211 static void ieee80211_mgd_probe_ap(struct ieee80211_sub_if_data *sdata,
1212 bool beacon)
1213 {
1214 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
1215 bool already = false;
1216
1217 if (!netif_running(sdata->dev))
1218 return;
1219
1220 if (sdata->local->scanning)
1221 return;
1222
1223 mutex_lock(&ifmgd->mtx);
1224
1225 if (!ifmgd->associated)
1226 goto out;
1227
1228 #ifdef CONFIG_MAC80211_VERBOSE_DEBUG
1229 if (beacon && net_ratelimit())
1230 printk(KERN_DEBUG "%s: detected beacon loss from AP "
1231 "- sending probe request\n", sdata->dev->name);
1232 #endif
1233
1234 /*
1235 * The driver/our work has already reported this event or the
1236 * connection monitoring has kicked in and we have already sent
1237 * a probe request. Or maybe the AP died and the driver keeps
1238 * reporting until we disassociate...
1239 *
1240 * In either case we have to ignore the current call to this
1241 * function (except for setting the correct probe reason bit)
1242 * because otherwise we would reset the timer every time and
1243 * never check whether we received a probe response!
1244 */
1245 if (ifmgd->flags & (IEEE80211_STA_BEACON_POLL |
1246 IEEE80211_STA_CONNECTION_POLL))
1247 already = true;
1248
1249 if (beacon)
1250 ifmgd->flags |= IEEE80211_STA_BEACON_POLL;
1251 else
1252 ifmgd->flags |= IEEE80211_STA_CONNECTION_POLL;
1253
1254 if (already)
1255 goto out;
1256
1257 mutex_lock(&sdata->local->iflist_mtx);
1258 ieee80211_recalc_ps(sdata->local, -1);
1259 mutex_unlock(&sdata->local->iflist_mtx);
1260
1261 ifmgd->probe_send_count = 0;
1262 ieee80211_mgd_probe_ap_send(sdata);
1263 out:
1264 mutex_unlock(&ifmgd->mtx);
1265 }
1266
1267 void ieee80211_beacon_loss_work(struct work_struct *work)
1268 {
1269 struct ieee80211_sub_if_data *sdata =
1270 container_of(work, struct ieee80211_sub_if_data,
1271 u.mgd.beacon_loss_work);
1272
1273 ieee80211_mgd_probe_ap(sdata, true);
1274 }
1275
1276 void ieee80211_beacon_loss(struct ieee80211_vif *vif)
1277 {
1278 struct ieee80211_sub_if_data *sdata = vif_to_sdata(vif);
1279
1280 ieee80211_queue_work(&sdata->local->hw, &sdata->u.mgd.beacon_loss_work);
1281 }
1282 EXPORT_SYMBOL(ieee80211_beacon_loss);
1283
1284 static void ieee80211_auth_completed(struct ieee80211_sub_if_data *sdata,
1285 struct ieee80211_mgd_work *wk)
1286 {
1287 wk->state = IEEE80211_MGD_STATE_IDLE;
1288 printk(KERN_DEBUG "%s: authenticated\n", sdata->dev->name);
1289 }
1290
1291
1292 static void ieee80211_auth_challenge(struct ieee80211_sub_if_data *sdata,
1293 struct ieee80211_mgd_work *wk,
1294 struct ieee80211_mgmt *mgmt,
1295 size_t len)
1296 {
1297 u8 *pos;
1298 struct ieee802_11_elems elems;
1299
1300 pos = mgmt->u.auth.variable;
1301 ieee802_11_parse_elems(pos, len - (pos - (u8 *) mgmt), &elems);
1302 if (!elems.challenge)
1303 return;
1304 ieee80211_send_auth(sdata, 3, wk->auth_alg,
1305 elems.challenge - 2, elems.challenge_len + 2,
1306 wk->bss->cbss.bssid,
1307 wk->key, wk->key_len, wk->key_idx);
1308 wk->auth_transaction = 4;
1309 }
1310
1311 static enum rx_mgmt_action __must_check
1312 ieee80211_rx_mgmt_auth(struct ieee80211_sub_if_data *sdata,
1313 struct ieee80211_mgd_work *wk,
1314 struct ieee80211_mgmt *mgmt, size_t len)
1315 {
1316 u16 auth_alg, auth_transaction, status_code;
1317
1318 if (wk->state != IEEE80211_MGD_STATE_AUTH)
1319 return RX_MGMT_NONE;
1320
1321 if (len < 24 + 6)
1322 return RX_MGMT_NONE;
1323
1324 if (memcmp(wk->bss->cbss.bssid, mgmt->sa, ETH_ALEN) != 0)
1325 return RX_MGMT_NONE;
1326
1327 if (memcmp(wk->bss->cbss.bssid, mgmt->bssid, ETH_ALEN) != 0)
1328 return RX_MGMT_NONE;
1329
1330 auth_alg = le16_to_cpu(mgmt->u.auth.auth_alg);
1331 auth_transaction = le16_to_cpu(mgmt->u.auth.auth_transaction);
1332 status_code = le16_to_cpu(mgmt->u.auth.status_code);
1333
1334 if (auth_alg != wk->auth_alg ||
1335 auth_transaction != wk->auth_transaction)
1336 return RX_MGMT_NONE;
1337
1338 if (status_code != WLAN_STATUS_SUCCESS) {
1339 list_del(&wk->list);
1340 kfree(wk);
1341 return RX_MGMT_CFG80211_AUTH;
1342 }
1343
1344 switch (wk->auth_alg) {
1345 case WLAN_AUTH_OPEN:
1346 case WLAN_AUTH_LEAP:
1347 case WLAN_AUTH_FT:
1348 ieee80211_auth_completed(sdata, wk);
1349 return RX_MGMT_CFG80211_AUTH;
1350 case WLAN_AUTH_SHARED_KEY:
1351 if (wk->auth_transaction == 4) {
1352 ieee80211_auth_completed(sdata, wk);
1353 return RX_MGMT_CFG80211_AUTH;
1354 } else
1355 ieee80211_auth_challenge(sdata, wk, mgmt, len);
1356 break;
1357 }
1358
1359 return RX_MGMT_NONE;
1360 }
1361
1362
1363 static enum rx_mgmt_action __must_check
1364 ieee80211_rx_mgmt_deauth(struct ieee80211_sub_if_data *sdata,
1365 struct ieee80211_mgd_work *wk,
1366 struct ieee80211_mgmt *mgmt, size_t len)
1367 {
1368 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
1369 const u8 *bssid = NULL;
1370 u16 reason_code;
1371
1372 if (len < 24 + 2)
1373 return RX_MGMT_NONE;
1374
1375 ASSERT_MGD_MTX(ifmgd);
1376
1377 if (wk)
1378 bssid = wk->bss->cbss.bssid;
1379 else
1380 bssid = ifmgd->associated->cbss.bssid;
1381
1382 reason_code = le16_to_cpu(mgmt->u.deauth.reason_code);
1383
1384 printk(KERN_DEBUG "%s: deauthenticated from %pM (Reason: %u)\n",
1385 sdata->dev->name, bssid, reason_code);
1386
1387 if (!wk) {
1388 ieee80211_set_disassoc(sdata, true);
1389 ieee80211_recalc_idle(sdata->local);
1390 } else {
1391 list_del(&wk->list);
1392 kfree(wk);
1393 }
1394
1395 return RX_MGMT_CFG80211_DEAUTH;
1396 }
1397
1398
1399 static enum rx_mgmt_action __must_check
1400 ieee80211_rx_mgmt_disassoc(struct ieee80211_sub_if_data *sdata,
1401 struct ieee80211_mgmt *mgmt, size_t len)
1402 {
1403 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
1404 u16 reason_code;
1405
1406 if (len < 24 + 2)
1407 return RX_MGMT_NONE;
1408
1409 ASSERT_MGD_MTX(ifmgd);
1410
1411 if (WARN_ON(!ifmgd->associated))
1412 return RX_MGMT_NONE;
1413
1414 if (WARN_ON(memcmp(ifmgd->associated->cbss.bssid, mgmt->sa, ETH_ALEN)))
1415 return RX_MGMT_NONE;
1416
1417 reason_code = le16_to_cpu(mgmt->u.disassoc.reason_code);
1418
1419 printk(KERN_DEBUG "%s: disassociated from %pM (Reason: %u)\n",
1420 sdata->dev->name, mgmt->sa, reason_code);
1421
1422 ieee80211_set_disassoc(sdata, false);
1423 ieee80211_recalc_idle(sdata->local);
1424 return RX_MGMT_CFG80211_DISASSOC;
1425 }
1426
1427
1428 static enum rx_mgmt_action __must_check
1429 ieee80211_rx_mgmt_assoc_resp(struct ieee80211_sub_if_data *sdata,
1430 struct ieee80211_mgd_work *wk,
1431 struct ieee80211_mgmt *mgmt, size_t len,
1432 bool reassoc)
1433 {
1434 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
1435 struct ieee80211_local *local = sdata->local;
1436 struct ieee80211_supported_band *sband;
1437 struct sta_info *sta;
1438 u32 rates, basic_rates;
1439 u16 capab_info, status_code, aid;
1440 struct ieee802_11_elems elems;
1441 struct ieee80211_bss_conf *bss_conf = &sdata->vif.bss_conf;
1442 u8 *pos;
1443 u32 changed = 0;
1444 int i, j;
1445 bool have_higher_than_11mbit = false, newsta = false;
1446 u16 ap_ht_cap_flags;
1447
1448 /*
1449 * AssocResp and ReassocResp have identical structure, so process both
1450 * of them in this function.
1451 */
1452
1453 if (len < 24 + 6)
1454 return RX_MGMT_NONE;
1455
1456 if (memcmp(wk->bss->cbss.bssid, mgmt->sa, ETH_ALEN) != 0)
1457 return RX_MGMT_NONE;
1458
1459 capab_info = le16_to_cpu(mgmt->u.assoc_resp.capab_info);
1460 status_code = le16_to_cpu(mgmt->u.assoc_resp.status_code);
1461 aid = le16_to_cpu(mgmt->u.assoc_resp.aid);
1462
1463 printk(KERN_DEBUG "%s: RX %sssocResp from %pM (capab=0x%x "
1464 "status=%d aid=%d)\n",
1465 sdata->dev->name, reassoc ? "Rea" : "A", mgmt->sa,
1466 capab_info, status_code, (u16)(aid & ~(BIT(15) | BIT(14))));
1467
1468 pos = mgmt->u.assoc_resp.variable;
1469 ieee802_11_parse_elems(pos, len - (pos - (u8 *) mgmt), &elems);
1470
1471 if (status_code == WLAN_STATUS_ASSOC_REJECTED_TEMPORARILY &&
1472 elems.timeout_int && elems.timeout_int_len == 5 &&
1473 elems.timeout_int[0] == WLAN_TIMEOUT_ASSOC_COMEBACK) {
1474 u32 tu, ms;
1475 tu = get_unaligned_le32(elems.timeout_int + 1);
1476 ms = tu * 1024 / 1000;
1477 printk(KERN_DEBUG "%s: AP rejected association temporarily; "
1478 "comeback duration %u TU (%u ms)\n",
1479 sdata->dev->name, tu, ms);
1480 wk->timeout = jiffies + msecs_to_jiffies(ms);
1481 if (ms > IEEE80211_ASSOC_TIMEOUT)
1482 run_again(ifmgd, jiffies + msecs_to_jiffies(ms));
1483 return RX_MGMT_NONE;
1484 }
1485
1486 if (status_code != WLAN_STATUS_SUCCESS) {
1487 printk(KERN_DEBUG "%s: AP denied association (code=%d)\n",
1488 sdata->dev->name, status_code);
1489 wk->state = IEEE80211_MGD_STATE_IDLE;
1490 return RX_MGMT_CFG80211_ASSOC;
1491 }
1492
1493 if ((aid & (BIT(15) | BIT(14))) != (BIT(15) | BIT(14)))
1494 printk(KERN_DEBUG "%s: invalid aid value %d; bits 15:14 not "
1495 "set\n", sdata->dev->name, aid);
1496 aid &= ~(BIT(15) | BIT(14));
1497
1498 if (!elems.supp_rates) {
1499 printk(KERN_DEBUG "%s: no SuppRates element in AssocResp\n",
1500 sdata->dev->name);
1501 return RX_MGMT_NONE;
1502 }
1503
1504 printk(KERN_DEBUG "%s: associated\n", sdata->dev->name);
1505 ifmgd->aid = aid;
1506
1507 rcu_read_lock();
1508
1509 /* Add STA entry for the AP */
1510 sta = sta_info_get(local, wk->bss->cbss.bssid);
1511 if (!sta) {
1512 newsta = true;
1513
1514 rcu_read_unlock();
1515
1516 sta = sta_info_alloc(sdata, wk->bss->cbss.bssid, GFP_KERNEL);
1517 if (!sta) {
1518 printk(KERN_DEBUG "%s: failed to alloc STA entry for"
1519 " the AP\n", sdata->dev->name);
1520 return RX_MGMT_NONE;
1521 }
1522
1523 set_sta_flags(sta, WLAN_STA_AUTH | WLAN_STA_ASSOC |
1524 WLAN_STA_ASSOC_AP);
1525 if (!(ifmgd->flags & IEEE80211_STA_CONTROL_PORT))
1526 set_sta_flags(sta, WLAN_STA_AUTHORIZED);
1527
1528 rcu_read_lock();
1529 }
1530
1531 rates = 0;
1532 basic_rates = 0;
1533 sband = local->hw.wiphy->bands[local->hw.conf.channel->band];
1534
1535 for (i = 0; i < elems.supp_rates_len; i++) {
1536 int rate = (elems.supp_rates[i] & 0x7f) * 5;
1537 bool is_basic = !!(elems.supp_rates[i] & 0x80);
1538
1539 if (rate > 110)
1540 have_higher_than_11mbit = true;
1541
1542 for (j = 0; j < sband->n_bitrates; j++) {
1543 if (sband->bitrates[j].bitrate == rate) {
1544 rates |= BIT(j);
1545 if (is_basic)
1546 basic_rates |= BIT(j);
1547 break;
1548 }
1549 }
1550 }
1551
1552 for (i = 0; i < elems.ext_supp_rates_len; i++) {
1553 int rate = (elems.ext_supp_rates[i] & 0x7f) * 5;
1554 bool is_basic = !!(elems.ext_supp_rates[i] & 0x80);
1555
1556 if (rate > 110)
1557 have_higher_than_11mbit = true;
1558
1559 for (j = 0; j < sband->n_bitrates; j++) {
1560 if (sband->bitrates[j].bitrate == rate) {
1561 rates |= BIT(j);
1562 if (is_basic)
1563 basic_rates |= BIT(j);
1564 break;
1565 }
1566 }
1567 }
1568
1569 sta->sta.supp_rates[local->hw.conf.channel->band] = rates;
1570 sdata->vif.bss_conf.basic_rates = basic_rates;
1571
1572 /* cf. IEEE 802.11 9.2.12 */
1573 if (local->hw.conf.channel->band == IEEE80211_BAND_2GHZ &&
1574 have_higher_than_11mbit)
1575 sdata->flags |= IEEE80211_SDATA_OPERATING_GMODE;
1576 else
1577 sdata->flags &= ~IEEE80211_SDATA_OPERATING_GMODE;
1578
1579 if (elems.ht_cap_elem && !(ifmgd->flags & IEEE80211_STA_DISABLE_11N))
1580 ieee80211_ht_cap_ie_to_sta_ht_cap(sband,
1581 elems.ht_cap_elem, &sta->sta.ht_cap);
1582
1583 ap_ht_cap_flags = sta->sta.ht_cap.cap;
1584
1585 rate_control_rate_init(sta);
1586
1587 if (ifmgd->flags & IEEE80211_STA_MFP_ENABLED)
1588 set_sta_flags(sta, WLAN_STA_MFP);
1589
1590 if (elems.wmm_param)
1591 set_sta_flags(sta, WLAN_STA_WME);
1592
1593 if (newsta) {
1594 int err = sta_info_insert(sta);
1595 if (err) {
1596 printk(KERN_DEBUG "%s: failed to insert STA entry for"
1597 " the AP (error %d)\n", sdata->dev->name, err);
1598 rcu_read_unlock();
1599 return RX_MGMT_NONE;
1600 }
1601 }
1602
1603 rcu_read_unlock();
1604
1605 if (elems.wmm_param)
1606 ieee80211_sta_wmm_params(local, ifmgd, elems.wmm_param,
1607 elems.wmm_param_len);
1608 else
1609 ieee80211_set_wmm_default(sdata);
1610
1611 if (elems.ht_info_elem && elems.wmm_param &&
1612 (ifmgd->flags & IEEE80211_STA_WMM_ENABLED) &&
1613 !(ifmgd->flags & IEEE80211_STA_DISABLE_11N))
1614 changed |= ieee80211_enable_ht(sdata, elems.ht_info_elem,
1615 wk->bss->cbss.bssid,
1616 ap_ht_cap_flags);
1617
1618 /* delete work item -- must be before set_associated for PS */
1619 list_del(&wk->list);
1620
1621 /* set AID and assoc capability,
1622 * ieee80211_set_associated() will tell the driver */
1623 bss_conf->aid = aid;
1624 bss_conf->assoc_capability = capab_info;
1625 /* this will take ownership of wk */
1626 ieee80211_set_associated(sdata, wk, changed);
1627
1628 /*
1629 * Start timer to probe the connection to the AP now.
1630 * Also start the timer that will detect beacon loss.
1631 */
1632 ieee80211_sta_rx_notify(sdata, (struct ieee80211_hdr *)mgmt);
1633 mod_beacon_timer(sdata);
1634
1635 return RX_MGMT_CFG80211_ASSOC;
1636 }
1637
1638
1639 static void ieee80211_rx_bss_info(struct ieee80211_sub_if_data *sdata,
1640 struct ieee80211_mgmt *mgmt,
1641 size_t len,
1642 struct ieee80211_rx_status *rx_status,
1643 struct ieee802_11_elems *elems,
1644 bool beacon)
1645 {
1646 struct ieee80211_local *local = sdata->local;
1647 int freq;
1648 struct ieee80211_bss *bss;
1649 struct ieee80211_channel *channel;
1650
1651 if (elems->ds_params && elems->ds_params_len == 1)
1652 freq = ieee80211_channel_to_frequency(elems->ds_params[0]);
1653 else
1654 freq = rx_status->freq;
1655
1656 channel = ieee80211_get_channel(local->hw.wiphy, freq);
1657
1658 if (!channel || channel->flags & IEEE80211_CHAN_DISABLED)
1659 return;
1660
1661 bss = ieee80211_bss_info_update(local, rx_status, mgmt, len, elems,
1662 channel, beacon);
1663 if (bss)
1664 ieee80211_rx_bss_put(local, bss);
1665
1666 if (!sdata->u.mgd.associated)
1667 return;
1668
1669 if (elems->ch_switch_elem && (elems->ch_switch_elem_len == 3) &&
1670 (memcmp(mgmt->bssid, sdata->u.mgd.associated->cbss.bssid,
1671 ETH_ALEN) == 0)) {
1672 struct ieee80211_channel_sw_ie *sw_elem =
1673 (struct ieee80211_channel_sw_ie *)elems->ch_switch_elem;
1674 ieee80211_sta_process_chanswitch(sdata, sw_elem, bss);
1675 }
1676 }
1677
1678
1679 static void ieee80211_rx_mgmt_probe_resp(struct ieee80211_sub_if_data *sdata,
1680 struct ieee80211_mgd_work *wk,
1681 struct ieee80211_mgmt *mgmt, size_t len,
1682 struct ieee80211_rx_status *rx_status)
1683 {
1684 struct ieee80211_if_managed *ifmgd;
1685 size_t baselen;
1686 struct ieee802_11_elems elems;
1687
1688 ifmgd = &sdata->u.mgd;
1689
1690 ASSERT_MGD_MTX(ifmgd);
1691
1692 if (memcmp(mgmt->da, sdata->dev->dev_addr, ETH_ALEN))
1693 return; /* ignore ProbeResp to foreign address */
1694
1695 baselen = (u8 *) mgmt->u.probe_resp.variable - (u8 *) mgmt;
1696 if (baselen > len)
1697 return;
1698
1699 ieee802_11_parse_elems(mgmt->u.probe_resp.variable, len - baselen,
1700 &elems);
1701
1702 ieee80211_rx_bss_info(sdata, mgmt, len, rx_status, &elems, false);
1703
1704 /* direct probe may be part of the association flow */
1705 if (wk && wk->state == IEEE80211_MGD_STATE_PROBE) {
1706 printk(KERN_DEBUG "%s: direct probe responded\n",
1707 sdata->dev->name);
1708 wk->tries = 0;
1709 wk->state = IEEE80211_MGD_STATE_AUTH;
1710 WARN_ON(ieee80211_authenticate(sdata, wk) != RX_MGMT_NONE);
1711 }
1712
1713 if (ifmgd->associated &&
1714 memcmp(mgmt->bssid, ifmgd->associated->cbss.bssid, ETH_ALEN) == 0 &&
1715 ifmgd->flags & (IEEE80211_STA_BEACON_POLL |
1716 IEEE80211_STA_CONNECTION_POLL)) {
1717 ifmgd->flags &= ~(IEEE80211_STA_CONNECTION_POLL |
1718 IEEE80211_STA_BEACON_POLL);
1719 mutex_lock(&sdata->local->iflist_mtx);
1720 ieee80211_recalc_ps(sdata->local, -1);
1721 mutex_unlock(&sdata->local->iflist_mtx);
1722 /*
1723 * We've received a probe response, but are not sure whether
1724 * we have or will be receiving any beacons or data, so let's
1725 * schedule the timers again, just in case.
1726 */
1727 mod_beacon_timer(sdata);
1728 mod_timer(&ifmgd->conn_mon_timer,
1729 round_jiffies_up(jiffies +
1730 IEEE80211_CONNECTION_IDLE_TIME));
1731 }
1732 }
1733
1734 /*
1735 * This is the canonical list of information elements we care about,
1736 * the filter code also gives us all changes to the Microsoft OUI
1737 * (00:50:F2) vendor IE which is used for WMM which we need to track.
1738 *
1739 * We implement beacon filtering in software since that means we can
1740 * avoid processing the frame here and in cfg80211, and userspace
1741 * will not be able to tell whether the hardware supports it or not.
1742 *
1743 * XXX: This list needs to be dynamic -- userspace needs to be able to
1744 * add items it requires. It also needs to be able to tell us to
1745 * look out for other vendor IEs.
1746 */
1747 static const u64 care_about_ies =
1748 (1ULL << WLAN_EID_COUNTRY) |
1749 (1ULL << WLAN_EID_ERP_INFO) |
1750 (1ULL << WLAN_EID_CHANNEL_SWITCH) |
1751 (1ULL << WLAN_EID_PWR_CONSTRAINT) |
1752 (1ULL << WLAN_EID_HT_CAPABILITY) |
1753 (1ULL << WLAN_EID_HT_INFORMATION);
1754
1755 static void ieee80211_rx_mgmt_beacon(struct ieee80211_sub_if_data *sdata,
1756 struct ieee80211_mgmt *mgmt,
1757 size_t len,
1758 struct ieee80211_rx_status *rx_status)
1759 {
1760 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
1761 size_t baselen;
1762 struct ieee802_11_elems elems;
1763 struct ieee80211_local *local = sdata->local;
1764 u32 changed = 0;
1765 bool erp_valid, directed_tim = false;
1766 u8 erp_value = 0;
1767 u32 ncrc;
1768 u8 *bssid;
1769
1770 ASSERT_MGD_MTX(ifmgd);
1771
1772 /* Process beacon from the current BSS */
1773 baselen = (u8 *) mgmt->u.beacon.variable - (u8 *) mgmt;
1774 if (baselen > len)
1775 return;
1776
1777 if (rx_status->freq != local->hw.conf.channel->center_freq)
1778 return;
1779
1780 /*
1781 * We might have received a number of frames, among them a
1782 * disassoc frame and a beacon...
1783 */
1784 if (!ifmgd->associated)
1785 return;
1786
1787 bssid = ifmgd->associated->cbss.bssid;
1788
1789 /*
1790 * And in theory even frames from a different AP we were just
1791 * associated to a split-second ago!
1792 */
1793 if (memcmp(bssid, mgmt->bssid, ETH_ALEN) != 0)
1794 return;
1795
1796 if (ifmgd->flags & IEEE80211_STA_BEACON_POLL) {
1797 #ifdef CONFIG_MAC80211_VERBOSE_DEBUG
1798 if (net_ratelimit()) {
1799 printk(KERN_DEBUG "%s: cancelling probereq poll due "
1800 "to a received beacon\n", sdata->dev->name);
1801 }
1802 #endif
1803 ifmgd->flags &= ~IEEE80211_STA_BEACON_POLL;
1804 mutex_lock(&local->iflist_mtx);
1805 ieee80211_recalc_ps(local, -1);
1806 mutex_unlock(&local->iflist_mtx);
1807 }
1808
1809 /*
1810 * Push the beacon loss detection into the future since
1811 * we are processing a beacon from the AP just now.
1812 */
1813 mod_beacon_timer(sdata);
1814
1815 ncrc = crc32_be(0, (void *)&mgmt->u.beacon.beacon_int, 4);
1816 ncrc = ieee802_11_parse_elems_crc(mgmt->u.beacon.variable,
1817 len - baselen, &elems,
1818 care_about_ies, ncrc);
1819
1820 if (local->hw.flags & IEEE80211_HW_PS_NULLFUNC_STACK)
1821 directed_tim = ieee80211_check_tim(elems.tim, elems.tim_len,
1822 ifmgd->aid);
1823
1824 if (ncrc != ifmgd->beacon_crc) {
1825 ieee80211_rx_bss_info(sdata, mgmt, len, rx_status, &elems,
1826 true);
1827
1828 ieee80211_sta_wmm_params(local, ifmgd, elems.wmm_param,
1829 elems.wmm_param_len);
1830 }
1831
1832 if (local->hw.flags & IEEE80211_HW_PS_NULLFUNC_STACK) {
1833 if (directed_tim) {
1834 if (local->hw.conf.dynamic_ps_timeout > 0) {
1835 local->hw.conf.flags &= ~IEEE80211_CONF_PS;
1836 ieee80211_hw_config(local,
1837 IEEE80211_CONF_CHANGE_PS);
1838 ieee80211_send_nullfunc(local, sdata, 0);
1839 } else {
1840 local->pspolling = true;
1841
1842 /*
1843 * Here is assumed that the driver will be
1844 * able to send ps-poll frame and receive a
1845 * response even though power save mode is
1846 * enabled, but some drivers might require
1847 * to disable power save here. This needs
1848 * to be investigated.
1849 */
1850 ieee80211_send_pspoll(local, sdata);
1851 }
1852 }
1853 }
1854
1855 if (ncrc == ifmgd->beacon_crc)
1856 return;
1857 ifmgd->beacon_crc = ncrc;
1858
1859 if (elems.erp_info && elems.erp_info_len >= 1) {
1860 erp_valid = true;
1861 erp_value = elems.erp_info[0];
1862 } else {
1863 erp_valid = false;
1864 }
1865 changed |= ieee80211_handle_bss_capability(sdata,
1866 le16_to_cpu(mgmt->u.beacon.capab_info),
1867 erp_valid, erp_value);
1868
1869
1870 if (elems.ht_cap_elem && elems.ht_info_elem && elems.wmm_param &&
1871 !(ifmgd->flags & IEEE80211_STA_DISABLE_11N)) {
1872 struct sta_info *sta;
1873 struct ieee80211_supported_band *sband;
1874 u16 ap_ht_cap_flags;
1875
1876 rcu_read_lock();
1877
1878 sta = sta_info_get(local, bssid);
1879 if (WARN_ON(!sta)) {
1880 rcu_read_unlock();
1881 return;
1882 }
1883
1884 sband = local->hw.wiphy->bands[local->hw.conf.channel->band];
1885
1886 ieee80211_ht_cap_ie_to_sta_ht_cap(sband,
1887 elems.ht_cap_elem, &sta->sta.ht_cap);
1888
1889 ap_ht_cap_flags = sta->sta.ht_cap.cap;
1890
1891 rcu_read_unlock();
1892
1893 changed |= ieee80211_enable_ht(sdata, elems.ht_info_elem,
1894 bssid, ap_ht_cap_flags);
1895 }
1896
1897 /* Note: country IE parsing is done for us by cfg80211 */
1898 if (elems.country_elem) {
1899 /* TODO: IBSS also needs this */
1900 if (elems.pwr_constr_elem)
1901 ieee80211_handle_pwr_constr(sdata,
1902 le16_to_cpu(mgmt->u.probe_resp.capab_info),
1903 elems.pwr_constr_elem,
1904 elems.pwr_constr_elem_len);
1905 }
1906
1907 ieee80211_bss_info_change_notify(sdata, changed);
1908 }
1909
1910 ieee80211_rx_result ieee80211_sta_rx_mgmt(struct ieee80211_sub_if_data *sdata,
1911 struct sk_buff *skb)
1912 {
1913 struct ieee80211_local *local = sdata->local;
1914 struct ieee80211_mgmt *mgmt;
1915 u16 fc;
1916
1917 if (skb->len < 24)
1918 return RX_DROP_MONITOR;
1919
1920 mgmt = (struct ieee80211_mgmt *) skb->data;
1921 fc = le16_to_cpu(mgmt->frame_control);
1922
1923 switch (fc & IEEE80211_FCTL_STYPE) {
1924 case IEEE80211_STYPE_PROBE_RESP:
1925 case IEEE80211_STYPE_BEACON:
1926 case IEEE80211_STYPE_AUTH:
1927 case IEEE80211_STYPE_ASSOC_RESP:
1928 case IEEE80211_STYPE_REASSOC_RESP:
1929 case IEEE80211_STYPE_DEAUTH:
1930 case IEEE80211_STYPE_DISASSOC:
1931 case IEEE80211_STYPE_ACTION:
1932 skb_queue_tail(&sdata->u.mgd.skb_queue, skb);
1933 ieee80211_queue_work(&local->hw, &sdata->u.mgd.work);
1934 return RX_QUEUED;
1935 }
1936
1937 return RX_DROP_MONITOR;
1938 }
1939
1940 static void ieee80211_sta_rx_queued_mgmt(struct ieee80211_sub_if_data *sdata,
1941 struct sk_buff *skb)
1942 {
1943 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
1944 struct ieee80211_rx_status *rx_status;
1945 struct ieee80211_mgmt *mgmt;
1946 struct ieee80211_mgd_work *wk;
1947 enum rx_mgmt_action rma = RX_MGMT_NONE;
1948 u16 fc;
1949
1950 rx_status = (struct ieee80211_rx_status *) skb->cb;
1951 mgmt = (struct ieee80211_mgmt *) skb->data;
1952 fc = le16_to_cpu(mgmt->frame_control);
1953
1954 mutex_lock(&ifmgd->mtx);
1955
1956 if (ifmgd->associated &&
1957 memcmp(ifmgd->associated->cbss.bssid, mgmt->bssid,
1958 ETH_ALEN) == 0) {
1959 switch (fc & IEEE80211_FCTL_STYPE) {
1960 case IEEE80211_STYPE_BEACON:
1961 ieee80211_rx_mgmt_beacon(sdata, mgmt, skb->len,
1962 rx_status);
1963 break;
1964 case IEEE80211_STYPE_PROBE_RESP:
1965 ieee80211_rx_mgmt_probe_resp(sdata, NULL, mgmt,
1966 skb->len, rx_status);
1967 break;
1968 case IEEE80211_STYPE_DEAUTH:
1969 rma = ieee80211_rx_mgmt_deauth(sdata, NULL,
1970 mgmt, skb->len);
1971 break;
1972 case IEEE80211_STYPE_DISASSOC:
1973 rma = ieee80211_rx_mgmt_disassoc(sdata, mgmt, skb->len);
1974 break;
1975 case IEEE80211_STYPE_ACTION:
1976 if (mgmt->u.action.category != WLAN_CATEGORY_SPECTRUM_MGMT)
1977 break;
1978
1979 ieee80211_sta_process_chanswitch(sdata,
1980 &mgmt->u.action.u.chan_switch.sw_elem,
1981 ifmgd->associated);
1982 break;
1983 }
1984 mutex_unlock(&ifmgd->mtx);
1985
1986 switch (rma) {
1987 case RX_MGMT_NONE:
1988 /* no action */
1989 break;
1990 case RX_MGMT_CFG80211_DEAUTH:
1991 cfg80211_send_deauth(sdata->dev, (u8 *)mgmt, skb->len);
1992 break;
1993 case RX_MGMT_CFG80211_DISASSOC:
1994 cfg80211_send_disassoc(sdata->dev, (u8 *)mgmt, skb->len);
1995 break;
1996 default:
1997 WARN(1, "unexpected: %d", rma);
1998 }
1999 goto out;
2000 }
2001
2002 list_for_each_entry(wk, &ifmgd->work_list, list) {
2003 if (memcmp(wk->bss->cbss.bssid, mgmt->bssid, ETH_ALEN) != 0)
2004 continue;
2005
2006 switch (fc & IEEE80211_FCTL_STYPE) {
2007 case IEEE80211_STYPE_PROBE_RESP:
2008 ieee80211_rx_mgmt_probe_resp(sdata, wk, mgmt, skb->len,
2009 rx_status);
2010 break;
2011 case IEEE80211_STYPE_AUTH:
2012 rma = ieee80211_rx_mgmt_auth(sdata, wk, mgmt, skb->len);
2013 break;
2014 case IEEE80211_STYPE_ASSOC_RESP:
2015 rma = ieee80211_rx_mgmt_assoc_resp(sdata, wk, mgmt,
2016 skb->len, false);
2017 break;
2018 case IEEE80211_STYPE_REASSOC_RESP:
2019 rma = ieee80211_rx_mgmt_assoc_resp(sdata, wk, mgmt,
2020 skb->len, true);
2021 break;
2022 case IEEE80211_STYPE_DEAUTH:
2023 rma = ieee80211_rx_mgmt_deauth(sdata, wk, mgmt,
2024 skb->len);
2025 break;
2026 }
2027 /*
2028 * We've processed this frame for that work, so it can't
2029 * belong to another work struct.
2030 * NB: this is also required for correctness because the
2031 * called functions can free 'wk', and for 'rma'!
2032 */
2033 break;
2034 }
2035
2036 mutex_unlock(&ifmgd->mtx);
2037
2038 switch (rma) {
2039 case RX_MGMT_NONE:
2040 /* no action */
2041 break;
2042 case RX_MGMT_CFG80211_AUTH:
2043 cfg80211_send_rx_auth(sdata->dev, (u8 *) mgmt, skb->len);
2044 break;
2045 case RX_MGMT_CFG80211_ASSOC:
2046 cfg80211_send_rx_assoc(sdata->dev, (u8 *) mgmt, skb->len);
2047 break;
2048 case RX_MGMT_CFG80211_DEAUTH:
2049 cfg80211_send_deauth(sdata->dev, (u8 *)mgmt, skb->len);
2050 break;
2051 default:
2052 WARN(1, "unexpected: %d", rma);
2053 }
2054
2055 out:
2056 kfree_skb(skb);
2057 }
2058
2059 static void ieee80211_sta_timer(unsigned long data)
2060 {
2061 struct ieee80211_sub_if_data *sdata =
2062 (struct ieee80211_sub_if_data *) data;
2063 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
2064 struct ieee80211_local *local = sdata->local;
2065
2066 if (local->quiescing) {
2067 set_bit(TMR_RUNNING_TIMER, &ifmgd->timers_running);
2068 return;
2069 }
2070
2071 ieee80211_queue_work(&local->hw, &ifmgd->work);
2072 }
2073
2074 static void ieee80211_sta_work(struct work_struct *work)
2075 {
2076 struct ieee80211_sub_if_data *sdata =
2077 container_of(work, struct ieee80211_sub_if_data, u.mgd.work);
2078 struct ieee80211_local *local = sdata->local;
2079 struct ieee80211_if_managed *ifmgd;
2080 struct sk_buff *skb;
2081 struct ieee80211_mgd_work *wk, *tmp;
2082 LIST_HEAD(free_work);
2083 enum rx_mgmt_action rma;
2084 bool anybusy = false;
2085
2086 if (!netif_running(sdata->dev))
2087 return;
2088
2089 if (local->scanning)
2090 return;
2091
2092 if (WARN_ON(sdata->vif.type != NL80211_IFTYPE_STATION))
2093 return;
2094
2095 /*
2096 * ieee80211_queue_work() should have picked up most cases,
2097 * here we'll pick the the rest.
2098 */
2099 if (WARN(local->suspended, "STA MLME work scheduled while "
2100 "going to suspend\n"))
2101 return;
2102
2103 ifmgd = &sdata->u.mgd;
2104
2105 /* first process frames to avoid timing out while a frame is pending */
2106 while ((skb = skb_dequeue(&ifmgd->skb_queue)))
2107 ieee80211_sta_rx_queued_mgmt(sdata, skb);
2108
2109 /* then process the rest of the work */
2110 mutex_lock(&ifmgd->mtx);
2111
2112 if (ifmgd->flags & (IEEE80211_STA_BEACON_POLL |
2113 IEEE80211_STA_CONNECTION_POLL) &&
2114 ifmgd->associated) {
2115 u8 bssid[ETH_ALEN];
2116
2117 memcpy(bssid, ifmgd->associated->cbss.bssid, ETH_ALEN);
2118 if (time_is_after_jiffies(ifmgd->probe_timeout))
2119 run_again(ifmgd, ifmgd->probe_timeout);
2120
2121 else if (ifmgd->probe_send_count < IEEE80211_MAX_PROBE_TRIES) {
2122 #ifdef CONFIG_MAC80211_VERBOSE_DEBUG
2123 printk(KERN_DEBUG "No probe response from AP %pM"
2124 " after %dms, try %d\n", bssid,
2125 (1000 * IEEE80211_PROBE_WAIT)/HZ,
2126 ifmgd->probe_send_count);
2127 #endif
2128 ieee80211_mgd_probe_ap_send(sdata);
2129 } else {
2130 /*
2131 * We actually lost the connection ... or did we?
2132 * Let's make sure!
2133 */
2134 ifmgd->flags &= ~(IEEE80211_STA_CONNECTION_POLL |
2135 IEEE80211_STA_BEACON_POLL);
2136 printk(KERN_DEBUG "No probe response from AP %pM"
2137 " after %dms, disconnecting.\n",
2138 bssid, (1000 * IEEE80211_PROBE_WAIT)/HZ);
2139 ieee80211_set_disassoc(sdata, true);
2140 ieee80211_recalc_idle(local);
2141 mutex_unlock(&ifmgd->mtx);
2142 /*
2143 * must be outside lock due to cfg80211,
2144 * but that's not a problem.
2145 */
2146 ieee80211_send_deauth_disassoc(sdata, bssid,
2147 IEEE80211_STYPE_DEAUTH,
2148 WLAN_REASON_DISASSOC_DUE_TO_INACTIVITY,
2149 NULL);
2150 mutex_lock(&ifmgd->mtx);
2151 }
2152 }
2153
2154
2155 ieee80211_recalc_idle(local);
2156
2157 list_for_each_entry_safe(wk, tmp, &ifmgd->work_list, list) {
2158 if (time_is_after_jiffies(wk->timeout)) {
2159 /*
2160 * This work item isn't supposed to be worked on
2161 * right now, but take care to adjust the timer
2162 * properly.
2163 */
2164 run_again(ifmgd, wk->timeout);
2165 continue;
2166 }
2167
2168 switch (wk->state) {
2169 default:
2170 WARN_ON(1);
2171 /* fall through */
2172 case IEEE80211_MGD_STATE_IDLE:
2173 /* nothing */
2174 rma = RX_MGMT_NONE;
2175 break;
2176 case IEEE80211_MGD_STATE_PROBE:
2177 rma = ieee80211_direct_probe(sdata, wk);
2178 break;
2179 case IEEE80211_MGD_STATE_AUTH:
2180 rma = ieee80211_authenticate(sdata, wk);
2181 break;
2182 case IEEE80211_MGD_STATE_ASSOC:
2183 rma = ieee80211_associate(sdata, wk);
2184 break;
2185 }
2186
2187 switch (rma) {
2188 case RX_MGMT_NONE:
2189 /* no action required */
2190 break;
2191 case RX_MGMT_CFG80211_AUTH_TO:
2192 case RX_MGMT_CFG80211_ASSOC_TO:
2193 list_del(&wk->list);
2194 list_add(&wk->list, &free_work);
2195 wk->tries = rma; /* small abuse but only local */
2196 break;
2197 default:
2198 WARN(1, "unexpected: %d", rma);
2199 }
2200 }
2201
2202 list_for_each_entry(wk, &ifmgd->work_list, list) {
2203 if (wk->state != IEEE80211_MGD_STATE_IDLE) {
2204 anybusy = true;
2205 break;
2206 }
2207 }
2208 if (!anybusy &&
2209 test_and_clear_bit(IEEE80211_STA_REQ_SCAN, &ifmgd->request))
2210 ieee80211_queue_delayed_work(&local->hw,
2211 &local->scan_work,
2212 round_jiffies_relative(0));
2213
2214 mutex_unlock(&ifmgd->mtx);
2215
2216 list_for_each_entry_safe(wk, tmp, &free_work, list) {
2217 switch (wk->tries) {
2218 case RX_MGMT_CFG80211_AUTH_TO:
2219 cfg80211_send_auth_timeout(sdata->dev,
2220 wk->bss->cbss.bssid);
2221 break;
2222 case RX_MGMT_CFG80211_ASSOC_TO:
2223 cfg80211_send_assoc_timeout(sdata->dev,
2224 wk->bss->cbss.bssid);
2225 break;
2226 default:
2227 WARN(1, "unexpected: %d", wk->tries);
2228 }
2229
2230 list_del(&wk->list);
2231 kfree(wk);
2232 }
2233
2234 ieee80211_recalc_idle(local);
2235 }
2236
2237 static void ieee80211_sta_bcn_mon_timer(unsigned long data)
2238 {
2239 struct ieee80211_sub_if_data *sdata =
2240 (struct ieee80211_sub_if_data *) data;
2241 struct ieee80211_local *local = sdata->local;
2242
2243 if (local->quiescing)
2244 return;
2245
2246 ieee80211_queue_work(&sdata->local->hw, &sdata->u.mgd.beacon_loss_work);
2247 }
2248
2249 static void ieee80211_sta_conn_mon_timer(unsigned long data)
2250 {
2251 struct ieee80211_sub_if_data *sdata =
2252 (struct ieee80211_sub_if_data *) data;
2253 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
2254 struct ieee80211_local *local = sdata->local;
2255
2256 if (local->quiescing)
2257 return;
2258
2259 ieee80211_queue_work(&local->hw, &ifmgd->monitor_work);
2260 }
2261
2262 static void ieee80211_sta_monitor_work(struct work_struct *work)
2263 {
2264 struct ieee80211_sub_if_data *sdata =
2265 container_of(work, struct ieee80211_sub_if_data,
2266 u.mgd.monitor_work);
2267
2268 ieee80211_mgd_probe_ap(sdata, false);
2269 }
2270
2271 static void ieee80211_restart_sta_timer(struct ieee80211_sub_if_data *sdata)
2272 {
2273 if (sdata->vif.type == NL80211_IFTYPE_STATION) {
2274 sdata->u.mgd.flags &= ~(IEEE80211_STA_BEACON_POLL |
2275 IEEE80211_STA_CONNECTION_POLL);
2276
2277 /* let's probe the connection once */
2278 ieee80211_queue_work(&sdata->local->hw,
2279 &sdata->u.mgd.monitor_work);
2280 /* and do all the other regular work too */
2281 ieee80211_queue_work(&sdata->local->hw,
2282 &sdata->u.mgd.work);
2283 }
2284 }
2285
2286 #ifdef CONFIG_PM
2287 void ieee80211_sta_quiesce(struct ieee80211_sub_if_data *sdata)
2288 {
2289 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
2290
2291 /*
2292 * we need to use atomic bitops for the running bits
2293 * only because both timers might fire at the same
2294 * time -- the code here is properly synchronised.
2295 */
2296
2297 cancel_work_sync(&ifmgd->work);
2298 cancel_work_sync(&ifmgd->beacon_loss_work);
2299 if (del_timer_sync(&ifmgd->timer))
2300 set_bit(TMR_RUNNING_TIMER, &ifmgd->timers_running);
2301
2302 cancel_work_sync(&ifmgd->chswitch_work);
2303 if (del_timer_sync(&ifmgd->chswitch_timer))
2304 set_bit(TMR_RUNNING_CHANSW, &ifmgd->timers_running);
2305
2306 cancel_work_sync(&ifmgd->monitor_work);
2307 /* these will just be re-established on connection */
2308 del_timer_sync(&ifmgd->conn_mon_timer);
2309 del_timer_sync(&ifmgd->bcn_mon_timer);
2310 }
2311
2312 void ieee80211_sta_restart(struct ieee80211_sub_if_data *sdata)
2313 {
2314 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
2315
2316 if (test_and_clear_bit(TMR_RUNNING_TIMER, &ifmgd->timers_running))
2317 add_timer(&ifmgd->timer);
2318 if (test_and_clear_bit(TMR_RUNNING_CHANSW, &ifmgd->timers_running))
2319 add_timer(&ifmgd->chswitch_timer);
2320 }
2321 #endif
2322
2323 /* interface setup */
2324 void ieee80211_sta_setup_sdata(struct ieee80211_sub_if_data *sdata)
2325 {
2326 struct ieee80211_if_managed *ifmgd;
2327
2328 ifmgd = &sdata->u.mgd;
2329 INIT_WORK(&ifmgd->work, ieee80211_sta_work);
2330 INIT_WORK(&ifmgd->monitor_work, ieee80211_sta_monitor_work);
2331 INIT_WORK(&ifmgd->chswitch_work, ieee80211_chswitch_work);
2332 INIT_WORK(&ifmgd->beacon_loss_work, ieee80211_beacon_loss_work);
2333 setup_timer(&ifmgd->timer, ieee80211_sta_timer,
2334 (unsigned long) sdata);
2335 setup_timer(&ifmgd->bcn_mon_timer, ieee80211_sta_bcn_mon_timer,
2336 (unsigned long) sdata);
2337 setup_timer(&ifmgd->conn_mon_timer, ieee80211_sta_conn_mon_timer,
2338 (unsigned long) sdata);
2339 setup_timer(&ifmgd->chswitch_timer, ieee80211_chswitch_timer,
2340 (unsigned long) sdata);
2341 skb_queue_head_init(&ifmgd->skb_queue);
2342
2343 INIT_LIST_HEAD(&ifmgd->work_list);
2344
2345 ifmgd->capab = WLAN_CAPABILITY_ESS;
2346 ifmgd->flags = 0;
2347 if (sdata->local->hw.queues >= 4)
2348 ifmgd->flags |= IEEE80211_STA_WMM_ENABLED;
2349
2350 mutex_init(&ifmgd->mtx);
2351 }
2352
2353 /* scan finished notification */
2354 void ieee80211_mlme_notify_scan_completed(struct ieee80211_local *local)
2355 {
2356 struct ieee80211_sub_if_data *sdata = local->scan_sdata;
2357
2358 /* Restart STA timers */
2359 rcu_read_lock();
2360 list_for_each_entry_rcu(sdata, &local->interfaces, list)
2361 ieee80211_restart_sta_timer(sdata);
2362 rcu_read_unlock();
2363 }
2364
2365 int ieee80211_max_network_latency(struct notifier_block *nb,
2366 unsigned long data, void *dummy)
2367 {
2368 s32 latency_usec = (s32) data;
2369 struct ieee80211_local *local =
2370 container_of(nb, struct ieee80211_local,
2371 network_latency_notifier);
2372
2373 mutex_lock(&local->iflist_mtx);
2374 ieee80211_recalc_ps(local, latency_usec);
2375 mutex_unlock(&local->iflist_mtx);
2376
2377 return 0;
2378 }
2379
2380 /* config hooks */
2381 int ieee80211_mgd_auth(struct ieee80211_sub_if_data *sdata,
2382 struct cfg80211_auth_request *req)
2383 {
2384 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
2385 const u8 *ssid;
2386 struct ieee80211_mgd_work *wk;
2387 u16 auth_alg;
2388
2389 switch (req->auth_type) {
2390 case NL80211_AUTHTYPE_OPEN_SYSTEM:
2391 auth_alg = WLAN_AUTH_OPEN;
2392 break;
2393 case NL80211_AUTHTYPE_SHARED_KEY:
2394 auth_alg = WLAN_AUTH_SHARED_KEY;
2395 break;
2396 case NL80211_AUTHTYPE_FT:
2397 auth_alg = WLAN_AUTH_FT;
2398 break;
2399 case NL80211_AUTHTYPE_NETWORK_EAP:
2400 auth_alg = WLAN_AUTH_LEAP;
2401 break;
2402 default:
2403 return -EOPNOTSUPP;
2404 }
2405
2406 wk = kzalloc(sizeof(*wk) + req->ie_len, GFP_KERNEL);
2407 if (!wk)
2408 return -ENOMEM;
2409
2410 wk->bss = (void *)req->bss;
2411
2412 if (req->ie && req->ie_len) {
2413 memcpy(wk->ie, req->ie, req->ie_len);
2414 wk->ie_len = req->ie_len;
2415 }
2416
2417 if (req->key && req->key_len) {
2418 wk->key_len = req->key_len;
2419 wk->key_idx = req->key_idx;
2420 memcpy(wk->key, req->key, req->key_len);
2421 }
2422
2423 ssid = ieee80211_bss_get_ie(req->bss, WLAN_EID_SSID);
2424 memcpy(wk->ssid, ssid + 2, ssid[1]);
2425 wk->ssid_len = ssid[1];
2426
2427 wk->state = IEEE80211_MGD_STATE_PROBE;
2428 wk->auth_alg = auth_alg;
2429 wk->timeout = jiffies; /* run right away */
2430
2431 /*
2432 * XXX: if still associated need to tell AP that we're going
2433 * to sleep and then change channel etc.
2434 */
2435 sdata->local->oper_channel = req->bss->channel;
2436 ieee80211_hw_config(sdata->local, 0);
2437
2438 mutex_lock(&ifmgd->mtx);
2439 list_add(&wk->list, &sdata->u.mgd.work_list);
2440 mutex_unlock(&ifmgd->mtx);
2441
2442 ieee80211_queue_work(&sdata->local->hw, &sdata->u.mgd.work);
2443 return 0;
2444 }
2445
2446 int ieee80211_mgd_assoc(struct ieee80211_sub_if_data *sdata,
2447 struct cfg80211_assoc_request *req)
2448 {
2449 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
2450 struct ieee80211_mgd_work *wk, *found = NULL;
2451 int i, err;
2452
2453 mutex_lock(&ifmgd->mtx);
2454
2455 list_for_each_entry(wk, &ifmgd->work_list, list) {
2456 if (&wk->bss->cbss == req->bss &&
2457 wk->state == IEEE80211_MGD_STATE_IDLE) {
2458 found = wk;
2459 break;
2460 }
2461 }
2462
2463 if (!found) {
2464 err = -ENOLINK;
2465 goto out;
2466 }
2467
2468 list_del(&found->list);
2469
2470 wk = krealloc(found, sizeof(*wk) + req->ie_len, GFP_KERNEL);
2471 if (!wk) {
2472 list_add(&found->list, &ifmgd->work_list);
2473 err = -ENOMEM;
2474 goto out;
2475 }
2476
2477 list_add(&wk->list, &ifmgd->work_list);
2478
2479 ifmgd->flags &= ~IEEE80211_STA_DISABLE_11N;
2480 ifmgd->flags &= ~IEEE80211_STA_NULLFUNC_ACKED;
2481
2482 for (i = 0; i < req->crypto.n_ciphers_pairwise; i++)
2483 if (req->crypto.ciphers_pairwise[i] == WLAN_CIPHER_SUITE_WEP40 ||
2484 req->crypto.ciphers_pairwise[i] == WLAN_CIPHER_SUITE_TKIP ||
2485 req->crypto.ciphers_pairwise[i] == WLAN_CIPHER_SUITE_WEP104)
2486 ifmgd->flags |= IEEE80211_STA_DISABLE_11N;
2487
2488 sdata->local->oper_channel = req->bss->channel;
2489 ieee80211_hw_config(sdata->local, 0);
2490
2491 if (req->ie && req->ie_len) {
2492 memcpy(wk->ie, req->ie, req->ie_len);
2493 wk->ie_len = req->ie_len;
2494 } else
2495 wk->ie_len = 0;
2496
2497 if (req->prev_bssid)
2498 memcpy(wk->prev_bssid, req->prev_bssid, ETH_ALEN);
2499
2500 wk->state = IEEE80211_MGD_STATE_ASSOC;
2501 wk->tries = 0;
2502 wk->timeout = jiffies; /* run right away */
2503
2504 if (req->use_mfp) {
2505 ifmgd->mfp = IEEE80211_MFP_REQUIRED;
2506 ifmgd->flags |= IEEE80211_STA_MFP_ENABLED;
2507 } else {
2508 ifmgd->mfp = IEEE80211_MFP_DISABLED;
2509 ifmgd->flags &= ~IEEE80211_STA_MFP_ENABLED;
2510 }
2511
2512 if (req->crypto.control_port)
2513 ifmgd->flags |= IEEE80211_STA_CONTROL_PORT;
2514 else
2515 ifmgd->flags &= ~IEEE80211_STA_CONTROL_PORT;
2516
2517 ieee80211_queue_work(&sdata->local->hw, &sdata->u.mgd.work);
2518
2519 err = 0;
2520
2521 out:
2522 mutex_unlock(&ifmgd->mtx);
2523 return err;
2524 }
2525
2526 int ieee80211_mgd_deauth(struct ieee80211_sub_if_data *sdata,
2527 struct cfg80211_deauth_request *req,
2528 void *cookie)
2529 {
2530 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
2531 struct ieee80211_mgd_work *wk;
2532 const u8 *bssid = NULL;
2533 bool not_auth_yet = false;
2534
2535 mutex_lock(&ifmgd->mtx);
2536
2537 if (ifmgd->associated && &ifmgd->associated->cbss == req->bss) {
2538 bssid = req->bss->bssid;
2539 ieee80211_set_disassoc(sdata, true);
2540 } else list_for_each_entry(wk, &ifmgd->work_list, list) {
2541 if (&wk->bss->cbss == req->bss) {
2542 bssid = req->bss->bssid;
2543 if (wk->state == IEEE80211_MGD_STATE_PROBE)
2544 not_auth_yet = true;
2545 list_del(&wk->list);
2546 kfree(wk);
2547 break;
2548 }
2549 }
2550
2551 /*
2552 * If somebody requests authentication and we haven't
2553 * sent out an auth frame yet there's no need to send
2554 * out a deauth frame either. If the state was PROBE,
2555 * then this is the case. If it's AUTH we have sent a
2556 * frame, and if it's IDLE we have completed the auth
2557 * process already.
2558 */
2559 if (not_auth_yet) {
2560 mutex_unlock(&ifmgd->mtx);
2561 __cfg80211_auth_canceled(sdata->dev, bssid);
2562 return 0;
2563 }
2564
2565 /*
2566 * cfg80211 should catch this ... but it's racy since
2567 * we can receive a deauth frame, process it, hand it
2568 * to cfg80211 while that's in a locked section already
2569 * trying to tell us that the user wants to disconnect.
2570 */
2571 if (!bssid) {
2572 mutex_unlock(&ifmgd->mtx);
2573 return -ENOLINK;
2574 }
2575
2576 mutex_unlock(&ifmgd->mtx);
2577
2578 printk(KERN_DEBUG "%s: deauthenticating from %pM by local choice (reason=%d)\n",
2579 sdata->dev->name, bssid, req->reason_code);
2580
2581 ieee80211_send_deauth_disassoc(sdata, bssid,
2582 IEEE80211_STYPE_DEAUTH, req->reason_code,
2583 cookie);
2584
2585 ieee80211_recalc_idle(sdata->local);
2586
2587 return 0;
2588 }
2589
2590 int ieee80211_mgd_disassoc(struct ieee80211_sub_if_data *sdata,
2591 struct cfg80211_disassoc_request *req,
2592 void *cookie)
2593 {
2594 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
2595
2596 mutex_lock(&ifmgd->mtx);
2597
2598 /*
2599 * cfg80211 should catch this ... but it's racy since
2600 * we can receive a disassoc frame, process it, hand it
2601 * to cfg80211 while that's in a locked section already
2602 * trying to tell us that the user wants to disconnect.
2603 */
2604 if (&ifmgd->associated->cbss != req->bss) {
2605 mutex_unlock(&ifmgd->mtx);
2606 return -ENOLINK;
2607 }
2608
2609 printk(KERN_DEBUG "%s: disassociating from %pM by local choice (reason=%d)\n",
2610 sdata->dev->name, req->bss->bssid, req->reason_code);
2611
2612 ieee80211_set_disassoc(sdata, false);
2613
2614 mutex_unlock(&ifmgd->mtx);
2615
2616 ieee80211_send_deauth_disassoc(sdata, req->bss->bssid,
2617 IEEE80211_STYPE_DISASSOC, req->reason_code,
2618 cookie);
2619
2620 ieee80211_recalc_idle(sdata->local);
2621
2622 return 0;
2623 }
Linux 2.6 ibm-acpi/thinkpad-acpi driver git tree