2 * BSS client mode implementation
3 * Copyright 2003-2008, Jouni Malinen <j@w1.fi>
4 * Copyright 2004, Instant802 Networks, Inc.
5 * Copyright 2005, Devicescape Software, Inc.
6 * Copyright 2006-2007 Jiri Benc <jbenc@suse.cz>
7 * Copyright 2007, Michael Wu <flamingice@sourmilk.net>
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License version 2 as
11 * published by the Free Software Foundation.
14 #include <linux/delay.h>
15 #include <linux/if_ether.h>
16 #include <linux/skbuff.h>
17 #include <linux/if_arp.h>
18 #include <linux/etherdevice.h>
19 #include <linux/moduleparam.h>
20 #include <linux/rtnetlink.h>
21 #include <linux/pm_qos.h>
22 #include <linux/crc32.h>
23 #include <linux/slab.h>
24 #include <linux/export.h>
25 #include <net/mac80211.h>
26 #include <asm/unaligned.h>
28 #include "ieee80211_i.h"
29 #include "driver-ops.h"
33 static int max_nullfunc_tries = 2;
34 module_param(max_nullfunc_tries, int, 0644);
35 MODULE_PARM_DESC(max_nullfunc_tries,
36 "Maximum nullfunc tx tries before disconnecting (reason 4).");
38 static int max_probe_tries = 5;
39 module_param(max_probe_tries, int, 0644);
40 MODULE_PARM_DESC(max_probe_tries,
41 "Maximum probe tries before disconnecting (reason 4).");
44 * Beacon loss timeout is calculated as N frames times the
45 * advertised beacon interval. This may need to be somewhat
46 * higher than what hardware might detect to account for
47 * delays in the host processing frames. But since we also
48 * probe on beacon miss before declaring the connection lost
49 * default to what we want.
51 #define IEEE80211_BEACON_LOSS_COUNT 7
54 * Time the connection can be idle before we probe
55 * it to see if we can still talk to the AP.
57 #define IEEE80211_CONNECTION_IDLE_TIME (30 * HZ)
59 * Time we wait for a probe response after sending
60 * a probe request because of beacon loss or for
61 * checking the connection still works.
63 static int probe_wait_ms = 500;
64 module_param(probe_wait_ms, int, 0644);
65 MODULE_PARM_DESC(probe_wait_ms,
66 "Maximum time(ms) to wait for probe response"
67 " before disconnecting (reason 4).");
70 * Weight given to the latest Beacon frame when calculating average signal
71 * strength for Beacon frames received in the current BSS. This must be
74 #define IEEE80211_SIGNAL_AVE_WEIGHT 3
77 * How many Beacon frames need to have been used in average signal strength
78 * before starting to indicate signal change events.
80 #define IEEE80211_SIGNAL_AVE_MIN_COUNT 4
82 #define TMR_RUNNING_TIMER 0
83 #define TMR_RUNNING_CHANSW 1
86 * All cfg80211 functions have to be called outside a locked
87 * section so that they can acquire a lock themselves... This
88 * is much simpler than queuing up things in cfg80211, but we
89 * do need some indirection for that here.
92 /* no action required */
95 /* caller must call cfg80211_send_deauth() */
96 RX_MGMT_CFG80211_DEAUTH,
98 /* caller must call cfg80211_send_disassoc() */
99 RX_MGMT_CFG80211_DISASSOC,
103 static inline void ASSERT_MGD_MTX(struct ieee80211_if_managed *ifmgd)
105 lockdep_assert_held(&ifmgd->mtx);
109 * We can have multiple work items (and connection probing)
110 * scheduling this timer, but we need to take care to only
111 * reschedule it when it should fire _earlier_ than it was
112 * asked for before, or if it's not pending right now. This
113 * function ensures that. Note that it then is required to
114 * run this function for all timeouts after the first one
115 * has happened -- the work that runs from this timer will
118 static void run_again(struct ieee80211_if_managed *ifmgd,
119 unsigned long timeout)
121 ASSERT_MGD_MTX(ifmgd);
123 if (!timer_pending(&ifmgd->timer) ||
124 time_before(timeout, ifmgd->timer.expires))
125 mod_timer(&ifmgd->timer, timeout);
128 void ieee80211_sta_reset_beacon_monitor(struct ieee80211_sub_if_data *sdata)
130 if (sdata->local->hw.flags & IEEE80211_HW_BEACON_FILTER)
133 mod_timer(&sdata->u.mgd.bcn_mon_timer,
134 round_jiffies_up(jiffies + sdata->u.mgd.beacon_timeout));
137 void ieee80211_sta_reset_conn_monitor(struct ieee80211_sub_if_data *sdata)
139 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
141 if (unlikely(!sdata->u.mgd.associated))
144 if (sdata->local->hw.flags & IEEE80211_HW_CONNECTION_MONITOR)
147 mod_timer(&sdata->u.mgd.conn_mon_timer,
148 round_jiffies_up(jiffies + IEEE80211_CONNECTION_IDLE_TIME));
150 ifmgd->probe_send_count = 0;
153 static int ecw2cw(int ecw)
155 return (1 << ecw) - 1;
159 * ieee80211_enable_ht should be called only after the operating band
160 * has been determined as ht configuration depends on the hw's
161 * HT abilities for a specific band.
163 static u32 ieee80211_enable_ht(struct ieee80211_sub_if_data *sdata,
164 struct ieee80211_ht_info *hti,
165 const u8 *bssid, u16 ap_ht_cap_flags,
166 bool beacon_htcap_ie)
168 struct ieee80211_local *local = sdata->local;
169 struct ieee80211_supported_band *sband;
170 struct sta_info *sta;
174 bool enable_ht = true;
175 enum nl80211_channel_type prev_chantype;
176 enum nl80211_channel_type channel_type = NL80211_CHAN_NO_HT;
178 sband = local->hw.wiphy->bands[local->hw.conf.channel->band];
180 prev_chantype = sdata->vif.bss_conf.channel_type;
182 /* HT is not supported */
183 if (!sband->ht_cap.ht_supported)
187 hti_cfreq = ieee80211_channel_to_frequency(hti->control_chan,
189 /* check that channel matches the right operating channel */
190 if (local->hw.conf.channel->center_freq != hti_cfreq) {
191 /* Some APs mess this up, evidently.
192 * Netgear WNDR3700 sometimes reports 4 higher than
193 * the actual channel, for instance.
196 "%s: Wrong control channel in association"
197 " response: configured center-freq: %d"
198 " hti-cfreq: %d hti->control_chan: %d"
199 " band: %d. Disabling HT.\n",
201 local->hw.conf.channel->center_freq,
202 hti_cfreq, hti->control_chan,
209 channel_type = NL80211_CHAN_HT20;
211 if (!(ap_ht_cap_flags & IEEE80211_HT_CAP_40MHZ_INTOLERANT) &&
212 !ieee80111_cfg_override_disables_ht40(sdata) &&
213 (sband->ht_cap.cap & IEEE80211_HT_CAP_SUP_WIDTH_20_40) &&
214 (hti->ht_param & IEEE80211_HT_PARAM_CHAN_WIDTH_ANY)) {
215 switch(hti->ht_param & IEEE80211_HT_PARAM_CHA_SEC_OFFSET) {
216 case IEEE80211_HT_PARAM_CHA_SEC_ABOVE:
217 if (!(local->hw.conf.channel->flags &
218 IEEE80211_CHAN_NO_HT40PLUS))
219 channel_type = NL80211_CHAN_HT40PLUS;
221 case IEEE80211_HT_PARAM_CHA_SEC_BELOW:
222 if (!(local->hw.conf.channel->flags &
223 IEEE80211_CHAN_NO_HT40MINUS))
224 channel_type = NL80211_CHAN_HT40MINUS;
230 if (local->tmp_channel)
231 local->tmp_channel_type = channel_type;
233 if (!ieee80211_set_channel_type(local, sdata, channel_type)) {
234 /* can only fail due to HT40+/- mismatch */
235 channel_type = NL80211_CHAN_HT20;
236 WARN_ON(!ieee80211_set_channel_type(local, sdata, channel_type));
239 if (beacon_htcap_ie && (prev_chantype != channel_type)) {
241 * Whenever the AP announces the HT mode change that can be
242 * 40MHz intolerant or etc., it would be safer to stop tx
243 * queues before doing hw config to avoid buffer overflow.
245 ieee80211_stop_queues_by_reason(&sdata->local->hw,
246 IEEE80211_QUEUE_STOP_REASON_CHTYPE_CHANGE);
248 /* flush out all packets */
251 drv_flush(local, false);
254 /* channel_type change automatically detected */
255 ieee80211_hw_config(local, 0);
257 if (prev_chantype != channel_type) {
259 sta = sta_info_get(sdata, bssid);
261 rate_control_rate_update(local, sband, sta,
262 IEEE80211_RC_HT_CHANGED,
267 ieee80211_wake_queues_by_reason(&sdata->local->hw,
268 IEEE80211_QUEUE_STOP_REASON_CHTYPE_CHANGE);
271 ht_opmode = le16_to_cpu(hti->operation_mode);
273 /* if bss configuration changed store the new one */
274 if (sdata->ht_opmode_valid != enable_ht ||
275 sdata->vif.bss_conf.ht_operation_mode != ht_opmode ||
276 prev_chantype != channel_type) {
277 changed |= BSS_CHANGED_HT;
278 sdata->vif.bss_conf.ht_operation_mode = ht_opmode;
279 sdata->ht_opmode_valid = enable_ht;
285 /* frame sending functions */
287 static void ieee80211_send_deauth_disassoc(struct ieee80211_sub_if_data *sdata,
288 const u8 *bssid, u16 stype, u16 reason,
289 void *cookie, bool send_frame)
291 struct ieee80211_local *local = sdata->local;
292 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
294 struct ieee80211_mgmt *mgmt;
296 skb = dev_alloc_skb(local->hw.extra_tx_headroom + sizeof(*mgmt));
300 skb_reserve(skb, local->hw.extra_tx_headroom);
302 mgmt = (struct ieee80211_mgmt *) skb_put(skb, 24);
304 memcpy(mgmt->da, bssid, ETH_ALEN);
305 memcpy(mgmt->sa, sdata->vif.addr, ETH_ALEN);
306 memcpy(mgmt->bssid, bssid, ETH_ALEN);
307 mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT | stype);
309 /* u.deauth.reason_code == u.disassoc.reason_code */
310 mgmt->u.deauth.reason_code = cpu_to_le16(reason);
312 if (stype == IEEE80211_STYPE_DEAUTH)
314 __cfg80211_send_deauth(sdata->dev, (u8 *)mgmt, skb->len);
316 cfg80211_send_deauth(sdata->dev, (u8 *)mgmt, skb->len);
319 __cfg80211_send_disassoc(sdata->dev, (u8 *)mgmt, skb->len);
321 cfg80211_send_disassoc(sdata->dev, (u8 *)mgmt, skb->len);
322 if (!(ifmgd->flags & IEEE80211_STA_MFP_ENABLED))
323 IEEE80211_SKB_CB(skb)->flags |= IEEE80211_TX_INTFL_DONT_ENCRYPT;
326 ieee80211_tx_skb(sdata, skb);
331 void ieee80211_send_pspoll(struct ieee80211_local *local,
332 struct ieee80211_sub_if_data *sdata)
334 struct ieee80211_pspoll *pspoll;
337 skb = ieee80211_pspoll_get(&local->hw, &sdata->vif);
341 pspoll = (struct ieee80211_pspoll *) skb->data;
342 pspoll->frame_control |= cpu_to_le16(IEEE80211_FCTL_PM);
344 IEEE80211_SKB_CB(skb)->flags |= IEEE80211_TX_INTFL_DONT_ENCRYPT;
345 ieee80211_tx_skb(sdata, skb);
348 void ieee80211_send_nullfunc(struct ieee80211_local *local,
349 struct ieee80211_sub_if_data *sdata,
353 struct ieee80211_hdr_3addr *nullfunc;
354 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
356 skb = ieee80211_nullfunc_get(&local->hw, &sdata->vif);
360 nullfunc = (struct ieee80211_hdr_3addr *) skb->data;
362 nullfunc->frame_control |= cpu_to_le16(IEEE80211_FCTL_PM);
364 IEEE80211_SKB_CB(skb)->flags |= IEEE80211_TX_INTFL_DONT_ENCRYPT;
365 if (ifmgd->flags & (IEEE80211_STA_BEACON_POLL |
366 IEEE80211_STA_CONNECTION_POLL))
367 IEEE80211_SKB_CB(skb)->flags |= IEEE80211_TX_CTL_USE_MINRATE;
369 ieee80211_tx_skb(sdata, skb);
372 static void ieee80211_send_4addr_nullfunc(struct ieee80211_local *local,
373 struct ieee80211_sub_if_data *sdata)
376 struct ieee80211_hdr *nullfunc;
379 if (WARN_ON(sdata->vif.type != NL80211_IFTYPE_STATION))
382 skb = dev_alloc_skb(local->hw.extra_tx_headroom + 30);
386 skb_reserve(skb, local->hw.extra_tx_headroom);
388 nullfunc = (struct ieee80211_hdr *) skb_put(skb, 30);
389 memset(nullfunc, 0, 30);
390 fc = cpu_to_le16(IEEE80211_FTYPE_DATA | IEEE80211_STYPE_NULLFUNC |
391 IEEE80211_FCTL_FROMDS | IEEE80211_FCTL_TODS);
392 nullfunc->frame_control = fc;
393 memcpy(nullfunc->addr1, sdata->u.mgd.bssid, ETH_ALEN);
394 memcpy(nullfunc->addr2, sdata->vif.addr, ETH_ALEN);
395 memcpy(nullfunc->addr3, sdata->u.mgd.bssid, ETH_ALEN);
396 memcpy(nullfunc->addr4, sdata->vif.addr, ETH_ALEN);
398 IEEE80211_SKB_CB(skb)->flags |= IEEE80211_TX_INTFL_DONT_ENCRYPT;
399 ieee80211_tx_skb(sdata, skb);
402 /* spectrum management related things */
403 static void ieee80211_chswitch_work(struct work_struct *work)
405 struct ieee80211_sub_if_data *sdata =
406 container_of(work, struct ieee80211_sub_if_data, u.mgd.chswitch_work);
407 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
409 if (!ieee80211_sdata_running(sdata))
412 mutex_lock(&ifmgd->mtx);
413 if (!ifmgd->associated)
416 sdata->local->oper_channel = sdata->local->csa_channel;
417 if (!sdata->local->ops->channel_switch) {
418 /* call "hw_config" only if doing sw channel switch */
419 ieee80211_hw_config(sdata->local,
420 IEEE80211_CONF_CHANGE_CHANNEL);
422 /* update the device channel directly */
423 sdata->local->hw.conf.channel = sdata->local->oper_channel;
426 /* XXX: shouldn't really modify cfg80211-owned data! */
427 ifmgd->associated->channel = sdata->local->oper_channel;
429 ieee80211_wake_queues_by_reason(&sdata->local->hw,
430 IEEE80211_QUEUE_STOP_REASON_CSA);
432 ifmgd->flags &= ~IEEE80211_STA_CSA_RECEIVED;
433 mutex_unlock(&ifmgd->mtx);
436 void ieee80211_chswitch_done(struct ieee80211_vif *vif, bool success)
438 struct ieee80211_sub_if_data *sdata;
439 struct ieee80211_if_managed *ifmgd;
441 sdata = vif_to_sdata(vif);
442 ifmgd = &sdata->u.mgd;
444 trace_api_chswitch_done(sdata, success);
447 * If the channel switch was not successful, stay
448 * around on the old channel. We currently lack
449 * good handling of this situation, possibly we
450 * should just drop the association.
452 sdata->local->csa_channel = sdata->local->oper_channel;
455 ieee80211_queue_work(&sdata->local->hw, &ifmgd->chswitch_work);
457 EXPORT_SYMBOL(ieee80211_chswitch_done);
459 static void ieee80211_chswitch_timer(unsigned long data)
461 struct ieee80211_sub_if_data *sdata =
462 (struct ieee80211_sub_if_data *) data;
463 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
465 if (sdata->local->quiescing) {
466 set_bit(TMR_RUNNING_CHANSW, &ifmgd->timers_running);
470 ieee80211_queue_work(&sdata->local->hw, &ifmgd->chswitch_work);
473 void ieee80211_sta_process_chanswitch(struct ieee80211_sub_if_data *sdata,
474 struct ieee80211_channel_sw_ie *sw_elem,
475 struct ieee80211_bss *bss,
478 struct cfg80211_bss *cbss =
479 container_of((void *)bss, struct cfg80211_bss, priv);
480 struct ieee80211_channel *new_ch;
481 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
482 int new_freq = ieee80211_channel_to_frequency(sw_elem->new_ch_num,
483 cbss->channel->band);
485 ASSERT_MGD_MTX(ifmgd);
487 if (!ifmgd->associated)
490 if (sdata->local->scanning)
493 /* Disregard subsequent beacons if we are already running a timer
496 if (ifmgd->flags & IEEE80211_STA_CSA_RECEIVED)
499 new_ch = ieee80211_get_channel(sdata->local->hw.wiphy, new_freq);
500 if (!new_ch || new_ch->flags & IEEE80211_CHAN_DISABLED)
503 sdata->local->csa_channel = new_ch;
505 if (sdata->local->ops->channel_switch) {
506 /* use driver's channel switch callback */
507 struct ieee80211_channel_switch ch_switch;
508 memset(&ch_switch, 0, sizeof(ch_switch));
509 ch_switch.timestamp = timestamp;
511 ch_switch.block_tx = true;
512 ieee80211_stop_queues_by_reason(&sdata->local->hw,
513 IEEE80211_QUEUE_STOP_REASON_CSA);
515 ch_switch.channel = new_ch;
516 ch_switch.count = sw_elem->count;
517 ifmgd->flags |= IEEE80211_STA_CSA_RECEIVED;
518 drv_channel_switch(sdata->local, &ch_switch);
522 /* channel switch handled in software */
523 if (sw_elem->count <= 1) {
524 ieee80211_queue_work(&sdata->local->hw, &ifmgd->chswitch_work);
527 ieee80211_stop_queues_by_reason(&sdata->local->hw,
528 IEEE80211_QUEUE_STOP_REASON_CSA);
529 ifmgd->flags |= IEEE80211_STA_CSA_RECEIVED;
530 mod_timer(&ifmgd->chswitch_timer,
532 msecs_to_jiffies(sw_elem->count *
533 cbss->beacon_interval));
537 static void ieee80211_handle_pwr_constr(struct ieee80211_sub_if_data *sdata,
538 u16 capab_info, u8 *pwr_constr_elem,
539 u8 pwr_constr_elem_len)
541 struct ieee80211_conf *conf = &sdata->local->hw.conf;
543 if (!(capab_info & WLAN_CAPABILITY_SPECTRUM_MGMT))
546 /* Power constraint IE length should be 1 octet */
547 if (pwr_constr_elem_len != 1)
550 if ((*pwr_constr_elem <= conf->channel->max_power) &&
551 (*pwr_constr_elem != sdata->local->power_constr_level)) {
552 sdata->local->power_constr_level = *pwr_constr_elem;
553 ieee80211_hw_config(sdata->local, 0);
557 void ieee80211_enable_dyn_ps(struct ieee80211_vif *vif)
559 struct ieee80211_sub_if_data *sdata = vif_to_sdata(vif);
560 struct ieee80211_local *local = sdata->local;
561 struct ieee80211_conf *conf = &local->hw.conf;
563 WARN_ON(sdata->vif.type != NL80211_IFTYPE_STATION ||
564 !(local->hw.flags & IEEE80211_HW_SUPPORTS_PS) ||
565 (local->hw.flags & IEEE80211_HW_SUPPORTS_DYNAMIC_PS));
567 local->disable_dynamic_ps = false;
568 conf->dynamic_ps_timeout = local->dynamic_ps_user_timeout;
570 EXPORT_SYMBOL(ieee80211_enable_dyn_ps);
572 void ieee80211_disable_dyn_ps(struct ieee80211_vif *vif)
574 struct ieee80211_sub_if_data *sdata = vif_to_sdata(vif);
575 struct ieee80211_local *local = sdata->local;
576 struct ieee80211_conf *conf = &local->hw.conf;
578 WARN_ON(sdata->vif.type != NL80211_IFTYPE_STATION ||
579 !(local->hw.flags & IEEE80211_HW_SUPPORTS_PS) ||
580 (local->hw.flags & IEEE80211_HW_SUPPORTS_DYNAMIC_PS));
582 local->disable_dynamic_ps = true;
583 conf->dynamic_ps_timeout = 0;
584 del_timer_sync(&local->dynamic_ps_timer);
585 ieee80211_queue_work(&local->hw,
586 &local->dynamic_ps_enable_work);
588 EXPORT_SYMBOL(ieee80211_disable_dyn_ps);
591 static void ieee80211_enable_ps(struct ieee80211_local *local,
592 struct ieee80211_sub_if_data *sdata)
594 struct ieee80211_conf *conf = &local->hw.conf;
597 * If we are scanning right now then the parameters will
598 * take effect when scan finishes.
603 if (conf->dynamic_ps_timeout > 0 &&
604 !(local->hw.flags & IEEE80211_HW_SUPPORTS_DYNAMIC_PS)) {
605 mod_timer(&local->dynamic_ps_timer, jiffies +
606 msecs_to_jiffies(conf->dynamic_ps_timeout));
608 if (local->hw.flags & IEEE80211_HW_PS_NULLFUNC_STACK)
609 ieee80211_send_nullfunc(local, sdata, 1);
611 if ((local->hw.flags & IEEE80211_HW_PS_NULLFUNC_STACK) &&
612 (local->hw.flags & IEEE80211_HW_REPORTS_TX_ACK_STATUS))
615 conf->flags |= IEEE80211_CONF_PS;
616 ieee80211_hw_config(local, IEEE80211_CONF_CHANGE_PS);
620 static void ieee80211_change_ps(struct ieee80211_local *local)
622 struct ieee80211_conf *conf = &local->hw.conf;
624 if (local->ps_sdata) {
625 ieee80211_enable_ps(local, local->ps_sdata);
626 } else if (conf->flags & IEEE80211_CONF_PS) {
627 conf->flags &= ~IEEE80211_CONF_PS;
628 ieee80211_hw_config(local, IEEE80211_CONF_CHANGE_PS);
629 del_timer_sync(&local->dynamic_ps_timer);
630 cancel_work_sync(&local->dynamic_ps_enable_work);
634 static bool ieee80211_powersave_allowed(struct ieee80211_sub_if_data *sdata)
636 struct ieee80211_if_managed *mgd = &sdata->u.mgd;
637 struct sta_info *sta = NULL;
638 bool authorized = false;
646 if (!mgd->associated)
649 if (!mgd->associated->beacon_ies)
652 if (mgd->flags & (IEEE80211_STA_BEACON_POLL |
653 IEEE80211_STA_CONNECTION_POLL))
657 sta = sta_info_get(sdata, mgd->bssid);
659 authorized = test_sta_flag(sta, WLAN_STA_AUTHORIZED);
665 /* need to hold RTNL or interface lock */
666 void ieee80211_recalc_ps(struct ieee80211_local *local, s32 latency)
668 struct ieee80211_sub_if_data *sdata, *found = NULL;
672 if (!(local->hw.flags & IEEE80211_HW_SUPPORTS_PS)) {
673 local->ps_sdata = NULL;
677 if (!list_empty(&local->work_list)) {
678 local->ps_sdata = NULL;
682 list_for_each_entry(sdata, &local->interfaces, list) {
683 if (!ieee80211_sdata_running(sdata))
685 if (sdata->vif.type == NL80211_IFTYPE_AP) {
686 /* If an AP vif is found, then disable PS
687 * by setting the count to zero thereby setting
693 if (sdata->vif.type != NL80211_IFTYPE_STATION)
699 if (count == 1 && ieee80211_powersave_allowed(found)) {
700 struct ieee80211_conf *conf = &local->hw.conf;
704 latency = pm_qos_request(PM_QOS_NETWORK_LATENCY);
706 beaconint_us = ieee80211_tu_to_usec(
707 found->vif.bss_conf.beacon_int);
709 timeout = local->dynamic_ps_forced_timeout;
712 * Go to full PSM if the user configures a very low
713 * latency requirement.
714 * The 2000 second value is there for compatibility
715 * until the PM_QOS_NETWORK_LATENCY is configured
718 if (latency > (1900 * USEC_PER_MSEC) &&
719 latency != (2000 * USEC_PER_SEC))
724 local->dynamic_ps_user_timeout = timeout;
725 if (!local->disable_dynamic_ps)
726 conf->dynamic_ps_timeout =
727 local->dynamic_ps_user_timeout;
729 if (beaconint_us > latency) {
730 local->ps_sdata = NULL;
732 struct ieee80211_bss *bss;
736 bss = (void *)found->u.mgd.associated->priv;
737 dtimper = bss->dtim_period;
739 /* If the TIM IE is invalid, pretend the value is 1 */
742 else if (dtimper > 1)
743 maxslp = min_t(int, dtimper,
744 latency / beaconint_us);
746 local->hw.conf.max_sleep_period = maxslp;
747 local->hw.conf.ps_dtim_period = dtimper;
748 local->ps_sdata = found;
751 local->ps_sdata = NULL;
755 ieee80211_change_ps(local);
758 void ieee80211_dynamic_ps_disable_work(struct work_struct *work)
760 struct ieee80211_local *local =
761 container_of(work, struct ieee80211_local,
762 dynamic_ps_disable_work);
764 if (local->hw.conf.flags & IEEE80211_CONF_PS) {
765 local->hw.conf.flags &= ~IEEE80211_CONF_PS;
766 ieee80211_hw_config(local, IEEE80211_CONF_CHANGE_PS);
769 ieee80211_wake_queues_by_reason(&local->hw,
770 IEEE80211_QUEUE_STOP_REASON_PS);
773 void ieee80211_dynamic_ps_enable_work(struct work_struct *work)
775 struct ieee80211_local *local =
776 container_of(work, struct ieee80211_local,
777 dynamic_ps_enable_work);
778 struct ieee80211_sub_if_data *sdata = local->ps_sdata;
779 struct ieee80211_if_managed *ifmgd;
783 /* can only happen when PS was just disabled anyway */
787 ifmgd = &sdata->u.mgd;
789 if (local->hw.conf.flags & IEEE80211_CONF_PS)
792 if (!local->disable_dynamic_ps &&
793 local->hw.conf.dynamic_ps_timeout > 0) {
794 /* don't enter PS if TX frames are pending */
795 if (drv_tx_frames_pending(local)) {
796 mod_timer(&local->dynamic_ps_timer, jiffies +
798 local->hw.conf.dynamic_ps_timeout));
803 * transmission can be stopped by others which leads to
804 * dynamic_ps_timer expiry. Postpone the ps timer if it
805 * is not the actual idle state.
807 spin_lock_irqsave(&local->queue_stop_reason_lock, flags);
808 for (q = 0; q < local->hw.queues; q++) {
809 if (local->queue_stop_reasons[q]) {
810 spin_unlock_irqrestore(&local->queue_stop_reason_lock,
812 mod_timer(&local->dynamic_ps_timer, jiffies +
814 local->hw.conf.dynamic_ps_timeout));
818 spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags);
821 if ((local->hw.flags & IEEE80211_HW_PS_NULLFUNC_STACK) &&
822 !(ifmgd->flags & IEEE80211_STA_NULLFUNC_ACKED)) {
823 netif_tx_stop_all_queues(sdata->dev);
825 if (drv_tx_frames_pending(local))
826 mod_timer(&local->dynamic_ps_timer, jiffies +
828 local->hw.conf.dynamic_ps_timeout));
830 ieee80211_send_nullfunc(local, sdata, 1);
831 /* Flush to get the tx status of nullfunc frame */
832 drv_flush(local, false);
836 if (!((local->hw.flags & IEEE80211_HW_REPORTS_TX_ACK_STATUS) &&
837 (local->hw.flags & IEEE80211_HW_PS_NULLFUNC_STACK)) ||
838 (ifmgd->flags & IEEE80211_STA_NULLFUNC_ACKED)) {
839 ifmgd->flags &= ~IEEE80211_STA_NULLFUNC_ACKED;
840 local->hw.conf.flags |= IEEE80211_CONF_PS;
841 ieee80211_hw_config(local, IEEE80211_CONF_CHANGE_PS);
844 if (local->hw.flags & IEEE80211_HW_PS_NULLFUNC_STACK)
845 netif_tx_wake_all_queues(sdata->dev);
848 void ieee80211_dynamic_ps_timer(unsigned long data)
850 struct ieee80211_local *local = (void *) data;
852 if (local->quiescing || local->suspended)
855 ieee80211_queue_work(&local->hw, &local->dynamic_ps_enable_work);
859 static void ieee80211_sta_wmm_params(struct ieee80211_local *local,
860 struct ieee80211_sub_if_data *sdata,
861 u8 *wmm_param, size_t wmm_param_len)
863 struct ieee80211_tx_queue_params params;
864 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
867 u8 *pos, uapsd_queues = 0;
869 if (!local->ops->conf_tx)
872 if (local->hw.queues < 4)
878 if (wmm_param_len < 8 || wmm_param[5] /* version */ != 1)
881 if (ifmgd->flags & IEEE80211_STA_UAPSD_ENABLED)
882 uapsd_queues = local->uapsd_queues;
884 count = wmm_param[6] & 0x0f;
885 if (count == ifmgd->wmm_last_param_set)
887 ifmgd->wmm_last_param_set = count;
890 left = wmm_param_len - 8;
892 memset(¶ms, 0, sizeof(params));
895 for (; left >= 4; left -= 4, pos += 4) {
896 int aci = (pos[0] >> 5) & 0x03;
897 int acm = (pos[0] >> 4) & 0x01;
905 local->wmm_acm |= BIT(1) | BIT(2); /* BK/- */
906 if (uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_BK)
912 local->wmm_acm |= BIT(4) | BIT(5); /* CL/VI */
913 if (uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_VI)
919 local->wmm_acm |= BIT(6) | BIT(7); /* VO/NC */
920 if (uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_VO)
927 local->wmm_acm |= BIT(0) | BIT(3); /* BE/EE */
928 if (uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_BE)
933 params.aifs = pos[0] & 0x0f;
934 params.cw_max = ecw2cw((pos[1] & 0xf0) >> 4);
935 params.cw_min = ecw2cw(pos[1] & 0x0f);
936 params.txop = get_unaligned_le16(pos + 2);
937 params.uapsd = uapsd;
939 #ifdef CONFIG_MAC80211_VERBOSE_DEBUG
940 wiphy_debug(local->hw.wiphy,
941 "WMM queue=%d aci=%d acm=%d aifs=%d "
942 "cWmin=%d cWmax=%d txop=%d uapsd=%d\n",
944 params.aifs, params.cw_min, params.cw_max,
945 params.txop, params.uapsd);
947 sdata->tx_conf[queue] = params;
948 if (drv_conf_tx(local, sdata, queue, ¶ms))
949 wiphy_debug(local->hw.wiphy,
950 "failed to set TX queue parameters for queue %d\n",
954 /* enable WMM or activate new settings */
955 sdata->vif.bss_conf.qos = true;
956 ieee80211_bss_info_change_notify(sdata, BSS_CHANGED_QOS);
959 static u32 ieee80211_handle_bss_capability(struct ieee80211_sub_if_data *sdata,
960 u16 capab, bool erp_valid, u8 erp)
962 struct ieee80211_bss_conf *bss_conf = &sdata->vif.bss_conf;
965 bool use_short_preamble;
969 use_protection = (erp & WLAN_ERP_USE_PROTECTION) != 0;
970 use_short_preamble = (erp & WLAN_ERP_BARKER_PREAMBLE) == 0;
972 use_protection = false;
973 use_short_preamble = !!(capab & WLAN_CAPABILITY_SHORT_PREAMBLE);
976 use_short_slot = !!(capab & WLAN_CAPABILITY_SHORT_SLOT_TIME);
977 if (sdata->local->hw.conf.channel->band == IEEE80211_BAND_5GHZ)
978 use_short_slot = true;
980 if (use_protection != bss_conf->use_cts_prot) {
981 bss_conf->use_cts_prot = use_protection;
982 changed |= BSS_CHANGED_ERP_CTS_PROT;
985 if (use_short_preamble != bss_conf->use_short_preamble) {
986 bss_conf->use_short_preamble = use_short_preamble;
987 changed |= BSS_CHANGED_ERP_PREAMBLE;
990 if (use_short_slot != bss_conf->use_short_slot) {
991 bss_conf->use_short_slot = use_short_slot;
992 changed |= BSS_CHANGED_ERP_SLOT;
998 static void ieee80211_set_associated(struct ieee80211_sub_if_data *sdata,
999 struct cfg80211_bss *cbss,
1000 u32 bss_info_changed)
1002 struct ieee80211_bss *bss = (void *)cbss->priv;
1003 struct ieee80211_local *local = sdata->local;
1004 struct ieee80211_bss_conf *bss_conf = &sdata->vif.bss_conf;
1006 bss_info_changed |= BSS_CHANGED_ASSOC;
1007 /* set timing information */
1008 bss_conf->beacon_int = cbss->beacon_interval;
1009 bss_conf->timestamp = cbss->tsf;
1011 bss_info_changed |= BSS_CHANGED_BEACON_INT;
1012 bss_info_changed |= ieee80211_handle_bss_capability(sdata,
1013 cbss->capability, bss->has_erp_value, bss->erp_value);
1015 sdata->u.mgd.beacon_timeout = usecs_to_jiffies(ieee80211_tu_to_usec(
1016 IEEE80211_BEACON_LOSS_COUNT * bss_conf->beacon_int));
1018 sdata->u.mgd.associated = cbss;
1019 memcpy(sdata->u.mgd.bssid, cbss->bssid, ETH_ALEN);
1021 sdata->u.mgd.flags |= IEEE80211_STA_RESET_SIGNAL_AVE;
1023 /* just to be sure */
1024 sdata->u.mgd.flags &= ~(IEEE80211_STA_CONNECTION_POLL |
1025 IEEE80211_STA_BEACON_POLL);
1027 ieee80211_led_assoc(local, 1);
1029 if (local->hw.flags & IEEE80211_HW_NEED_DTIM_PERIOD)
1030 bss_conf->dtim_period = bss->dtim_period;
1032 bss_conf->dtim_period = 0;
1034 bss_conf->assoc = 1;
1036 * For now just always ask the driver to update the basic rateset
1037 * when we have associated, we aren't checking whether it actually
1040 bss_info_changed |= BSS_CHANGED_BASIC_RATES;
1042 /* And the BSSID changed - we're associated now */
1043 bss_info_changed |= BSS_CHANGED_BSSID;
1045 /* Tell the driver to monitor connection quality (if supported) */
1046 if ((local->hw.flags & IEEE80211_HW_SUPPORTS_CQM_RSSI) &&
1047 bss_conf->cqm_rssi_thold)
1048 bss_info_changed |= BSS_CHANGED_CQM;
1050 /* Enable ARP filtering */
1051 if (bss_conf->arp_filter_enabled != sdata->arp_filter_state) {
1052 bss_conf->arp_filter_enabled = sdata->arp_filter_state;
1053 bss_info_changed |= BSS_CHANGED_ARP_FILTER;
1056 ieee80211_bss_info_change_notify(sdata, bss_info_changed);
1058 mutex_lock(&local->iflist_mtx);
1059 ieee80211_recalc_ps(local, -1);
1060 ieee80211_recalc_smps(local);
1061 mutex_unlock(&local->iflist_mtx);
1063 netif_tx_start_all_queues(sdata->dev);
1064 netif_carrier_on(sdata->dev);
1067 static void ieee80211_set_disassoc(struct ieee80211_sub_if_data *sdata,
1068 bool remove_sta, bool tx)
1070 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
1071 struct ieee80211_local *local = sdata->local;
1072 struct sta_info *sta;
1073 u32 changed = 0, config_changed = 0;
1076 ASSERT_MGD_MTX(ifmgd);
1078 if (WARN_ON(!ifmgd->associated))
1081 memcpy(bssid, ifmgd->associated->bssid, ETH_ALEN);
1083 ifmgd->associated = NULL;
1084 memset(ifmgd->bssid, 0, ETH_ALEN);
1087 * we need to commit the associated = NULL change because the
1088 * scan code uses that to determine whether this iface should
1089 * go to/wake up from powersave or not -- and could otherwise
1090 * wake the queues erroneously.
1095 * Thus, we can only afterwards stop the queues -- to account
1096 * for the case where another CPU is finishing a scan at this
1097 * time -- we don't want the scan code to enable queues.
1100 netif_tx_stop_all_queues(sdata->dev);
1101 netif_carrier_off(sdata->dev);
1103 mutex_lock(&local->sta_mtx);
1104 sta = sta_info_get(sdata, bssid);
1106 set_sta_flag(sta, WLAN_STA_BLOCK_BA);
1107 ieee80211_sta_tear_down_BA_sessions(sta, tx);
1109 mutex_unlock(&local->sta_mtx);
1111 changed |= ieee80211_reset_erp_info(sdata);
1113 ieee80211_led_assoc(local, 0);
1114 changed |= BSS_CHANGED_ASSOC;
1115 sdata->vif.bss_conf.assoc = false;
1117 ieee80211_set_wmm_default(sdata);
1119 /* channel(_type) changes are handled by ieee80211_hw_config */
1120 WARN_ON(!ieee80211_set_channel_type(local, sdata, NL80211_CHAN_NO_HT));
1122 /* on the next assoc, re-program HT parameters */
1123 sdata->ht_opmode_valid = false;
1124 memset(&ifmgd->ht_capa, 0, sizeof(ifmgd->ht_capa));
1125 memset(&ifmgd->ht_capa_mask, 0, sizeof(ifmgd->ht_capa_mask));
1127 local->power_constr_level = 0;
1129 del_timer_sync(&local->dynamic_ps_timer);
1130 cancel_work_sync(&local->dynamic_ps_enable_work);
1132 if (local->hw.conf.flags & IEEE80211_CONF_PS) {
1133 local->hw.conf.flags &= ~IEEE80211_CONF_PS;
1134 config_changed |= IEEE80211_CONF_CHANGE_PS;
1136 local->ps_sdata = NULL;
1138 ieee80211_hw_config(local, config_changed);
1140 /* Disable ARP filtering */
1141 if (sdata->vif.bss_conf.arp_filter_enabled) {
1142 sdata->vif.bss_conf.arp_filter_enabled = false;
1143 changed |= BSS_CHANGED_ARP_FILTER;
1146 /* The BSSID (not really interesting) and HT changed */
1147 changed |= BSS_CHANGED_BSSID | BSS_CHANGED_HT;
1148 ieee80211_bss_info_change_notify(sdata, changed);
1150 /* remove AP and TDLS peers */
1152 sta_info_flush(local, sdata);
1154 del_timer_sync(&sdata->u.mgd.conn_mon_timer);
1155 del_timer_sync(&sdata->u.mgd.bcn_mon_timer);
1156 del_timer_sync(&sdata->u.mgd.timer);
1157 del_timer_sync(&sdata->u.mgd.chswitch_timer);
1160 void ieee80211_sta_rx_notify(struct ieee80211_sub_if_data *sdata,
1161 struct ieee80211_hdr *hdr)
1164 * We can postpone the mgd.timer whenever receiving unicast frames
1165 * from AP because we know that the connection is working both ways
1166 * at that time. But multicast frames (and hence also beacons) must
1167 * be ignored here, because we need to trigger the timer during
1168 * data idle periods for sending the periodic probe request to the
1169 * AP we're connected to.
1171 if (is_multicast_ether_addr(hdr->addr1))
1174 ieee80211_sta_reset_conn_monitor(sdata);
1177 static void ieee80211_reset_ap_probe(struct ieee80211_sub_if_data *sdata)
1179 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
1181 if (!(ifmgd->flags & (IEEE80211_STA_BEACON_POLL |
1182 IEEE80211_STA_CONNECTION_POLL)))
1185 ifmgd->flags &= ~(IEEE80211_STA_CONNECTION_POLL |
1186 IEEE80211_STA_BEACON_POLL);
1187 mutex_lock(&sdata->local->iflist_mtx);
1188 ieee80211_recalc_ps(sdata->local, -1);
1189 mutex_unlock(&sdata->local->iflist_mtx);
1191 if (sdata->local->hw.flags & IEEE80211_HW_CONNECTION_MONITOR)
1195 * We've received a probe response, but are not sure whether
1196 * we have or will be receiving any beacons or data, so let's
1197 * schedule the timers again, just in case.
1199 ieee80211_sta_reset_beacon_monitor(sdata);
1201 mod_timer(&ifmgd->conn_mon_timer,
1202 round_jiffies_up(jiffies +
1203 IEEE80211_CONNECTION_IDLE_TIME));
1206 void ieee80211_sta_tx_notify(struct ieee80211_sub_if_data *sdata,
1207 struct ieee80211_hdr *hdr, bool ack)
1209 if (!ieee80211_is_data(hdr->frame_control))
1213 ieee80211_sta_reset_conn_monitor(sdata);
1215 if (ieee80211_is_nullfunc(hdr->frame_control) &&
1216 sdata->u.mgd.probe_send_count > 0) {
1218 sdata->u.mgd.probe_send_count = 0;
1220 sdata->u.mgd.nullfunc_failed = true;
1221 ieee80211_queue_work(&sdata->local->hw, &sdata->work);
1225 static void ieee80211_mgd_probe_ap_send(struct ieee80211_sub_if_data *sdata)
1227 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
1229 u8 *dst = ifmgd->associated->bssid;
1230 u8 unicast_limit = max(1, max_probe_tries - 3);
1233 * Try sending broadcast probe requests for the last three
1234 * probe requests after the first ones failed since some
1235 * buggy APs only support broadcast probe requests.
1237 if (ifmgd->probe_send_count >= unicast_limit)
1241 * When the hardware reports an accurate Tx ACK status, it's
1242 * better to send a nullfunc frame instead of a probe request,
1243 * as it will kick us off the AP quickly if we aren't associated
1244 * anymore. The timeout will be reset if the frame is ACKed by
1247 if (sdata->local->hw.flags & IEEE80211_HW_REPORTS_TX_ACK_STATUS) {
1248 ifmgd->nullfunc_failed = false;
1249 ieee80211_send_nullfunc(sdata->local, sdata, 0);
1251 ssid = ieee80211_bss_get_ie(ifmgd->associated, WLAN_EID_SSID);
1252 ieee80211_send_probe_req(sdata, dst, ssid + 2, ssid[1], NULL, 0,
1253 (u32) -1, true, false);
1256 ifmgd->probe_send_count++;
1257 ifmgd->probe_timeout = jiffies + msecs_to_jiffies(probe_wait_ms);
1258 run_again(ifmgd, ifmgd->probe_timeout);
1261 static void ieee80211_mgd_probe_ap(struct ieee80211_sub_if_data *sdata,
1264 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
1265 bool already = false;
1267 if (!ieee80211_sdata_running(sdata))
1270 if (sdata->local->scanning)
1273 if (sdata->local->tmp_channel)
1276 mutex_lock(&ifmgd->mtx);
1278 if (!ifmgd->associated)
1281 #ifdef CONFIG_MAC80211_VERBOSE_DEBUG
1282 if (beacon && net_ratelimit())
1283 printk(KERN_DEBUG "%s: detected beacon loss from AP "
1284 "- sending probe request\n", sdata->name);
1288 * The driver/our work has already reported this event or the
1289 * connection monitoring has kicked in and we have already sent
1290 * a probe request. Or maybe the AP died and the driver keeps
1291 * reporting until we disassociate...
1293 * In either case we have to ignore the current call to this
1294 * function (except for setting the correct probe reason bit)
1295 * because otherwise we would reset the timer every time and
1296 * never check whether we received a probe response!
1298 if (ifmgd->flags & (IEEE80211_STA_BEACON_POLL |
1299 IEEE80211_STA_CONNECTION_POLL))
1303 ifmgd->flags |= IEEE80211_STA_BEACON_POLL;
1305 ifmgd->flags |= IEEE80211_STA_CONNECTION_POLL;
1310 mutex_lock(&sdata->local->iflist_mtx);
1311 ieee80211_recalc_ps(sdata->local, -1);
1312 mutex_unlock(&sdata->local->iflist_mtx);
1314 ifmgd->probe_send_count = 0;
1315 ieee80211_mgd_probe_ap_send(sdata);
1317 mutex_unlock(&ifmgd->mtx);
1320 struct sk_buff *ieee80211_ap_probereq_get(struct ieee80211_hw *hw,
1321 struct ieee80211_vif *vif)
1323 struct ieee80211_sub_if_data *sdata = vif_to_sdata(vif);
1324 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
1325 struct sk_buff *skb;
1328 if (WARN_ON(sdata->vif.type != NL80211_IFTYPE_STATION))
1331 ASSERT_MGD_MTX(ifmgd);
1333 if (!ifmgd->associated)
1336 ssid = ieee80211_bss_get_ie(ifmgd->associated, WLAN_EID_SSID);
1337 skb = ieee80211_build_probe_req(sdata, ifmgd->associated->bssid,
1338 (u32) -1, ssid + 2, ssid[1],
1343 EXPORT_SYMBOL(ieee80211_ap_probereq_get);
1345 static void __ieee80211_connection_loss(struct ieee80211_sub_if_data *sdata)
1347 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
1348 struct ieee80211_local *local = sdata->local;
1351 mutex_lock(&ifmgd->mtx);
1352 if (!ifmgd->associated) {
1353 mutex_unlock(&ifmgd->mtx);
1357 memcpy(bssid, ifmgd->associated->bssid, ETH_ALEN);
1359 printk(KERN_DEBUG "%s: Connection to AP %pM lost.\n",
1360 sdata->name, bssid);
1362 ieee80211_set_disassoc(sdata, true, true);
1363 mutex_unlock(&ifmgd->mtx);
1366 * must be outside lock due to cfg80211,
1367 * but that's not a problem.
1369 ieee80211_send_deauth_disassoc(sdata, bssid,
1370 IEEE80211_STYPE_DEAUTH,
1371 WLAN_REASON_DISASSOC_DUE_TO_INACTIVITY,
1374 mutex_lock(&local->mtx);
1375 ieee80211_recalc_idle(local);
1376 mutex_unlock(&local->mtx);
1379 void ieee80211_beacon_connection_loss_work(struct work_struct *work)
1381 struct ieee80211_sub_if_data *sdata =
1382 container_of(work, struct ieee80211_sub_if_data,
1383 u.mgd.beacon_connection_loss_work);
1384 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
1385 struct sta_info *sta;
1387 if (ifmgd->associated) {
1388 sta = sta_info_get(sdata, ifmgd->bssid);
1390 sta->beacon_loss_count++;
1393 if (sdata->local->hw.flags & IEEE80211_HW_CONNECTION_MONITOR)
1394 __ieee80211_connection_loss(sdata);
1396 ieee80211_mgd_probe_ap(sdata, true);
1399 void ieee80211_beacon_loss(struct ieee80211_vif *vif)
1401 struct ieee80211_sub_if_data *sdata = vif_to_sdata(vif);
1402 struct ieee80211_hw *hw = &sdata->local->hw;
1404 trace_api_beacon_loss(sdata);
1406 WARN_ON(hw->flags & IEEE80211_HW_CONNECTION_MONITOR);
1407 ieee80211_queue_work(hw, &sdata->u.mgd.beacon_connection_loss_work);
1409 EXPORT_SYMBOL(ieee80211_beacon_loss);
1411 void ieee80211_connection_loss(struct ieee80211_vif *vif)
1413 struct ieee80211_sub_if_data *sdata = vif_to_sdata(vif);
1414 struct ieee80211_hw *hw = &sdata->local->hw;
1416 trace_api_connection_loss(sdata);
1418 WARN_ON(!(hw->flags & IEEE80211_HW_CONNECTION_MONITOR));
1419 ieee80211_queue_work(hw, &sdata->u.mgd.beacon_connection_loss_work);
1421 EXPORT_SYMBOL(ieee80211_connection_loss);
1424 static enum rx_mgmt_action __must_check
1425 ieee80211_rx_mgmt_deauth(struct ieee80211_sub_if_data *sdata,
1426 struct ieee80211_mgmt *mgmt, size_t len)
1428 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
1429 const u8 *bssid = NULL;
1433 return RX_MGMT_NONE;
1435 ASSERT_MGD_MTX(ifmgd);
1437 bssid = ifmgd->associated->bssid;
1439 reason_code = le16_to_cpu(mgmt->u.deauth.reason_code);
1441 printk(KERN_DEBUG "%s: deauthenticated from %pM (Reason: %u)\n",
1442 sdata->name, bssid, reason_code);
1444 ieee80211_set_disassoc(sdata, true, false);
1445 mutex_lock(&sdata->local->mtx);
1446 ieee80211_recalc_idle(sdata->local);
1447 mutex_unlock(&sdata->local->mtx);
1449 return RX_MGMT_CFG80211_DEAUTH;
1453 static enum rx_mgmt_action __must_check
1454 ieee80211_rx_mgmt_disassoc(struct ieee80211_sub_if_data *sdata,
1455 struct ieee80211_mgmt *mgmt, size_t len)
1457 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
1461 return RX_MGMT_NONE;
1463 ASSERT_MGD_MTX(ifmgd);
1465 if (WARN_ON(!ifmgd->associated))
1466 return RX_MGMT_NONE;
1468 if (WARN_ON(memcmp(ifmgd->associated->bssid, mgmt->sa, ETH_ALEN)))
1469 return RX_MGMT_NONE;
1471 reason_code = le16_to_cpu(mgmt->u.disassoc.reason_code);
1473 printk(KERN_DEBUG "%s: disassociated from %pM (Reason: %u)\n",
1474 sdata->name, mgmt->sa, reason_code);
1476 ieee80211_set_disassoc(sdata, true, false);
1477 mutex_lock(&sdata->local->mtx);
1478 ieee80211_recalc_idle(sdata->local);
1479 mutex_unlock(&sdata->local->mtx);
1480 return RX_MGMT_CFG80211_DISASSOC;
1483 static void ieee80211_get_rates(struct ieee80211_supported_band *sband,
1484 u8 *supp_rates, unsigned int supp_rates_len,
1485 u32 *rates, u32 *basic_rates,
1486 bool *have_higher_than_11mbit,
1487 int *min_rate, int *min_rate_index)
1491 for (i = 0; i < supp_rates_len; i++) {
1492 int rate = (supp_rates[i] & 0x7f) * 5;
1493 bool is_basic = !!(supp_rates[i] & 0x80);
1496 *have_higher_than_11mbit = true;
1499 * BSS_MEMBERSHIP_SELECTOR_HT_PHY is defined in 802.11n-2009
1500 * 7.3.2.2 as a magic value instead of a rate. Hence, skip it.
1502 * Note: Even through the membership selector and the basic
1503 * rate flag share the same bit, they are not exactly
1506 if (!!(supp_rates[i] & 0x80) &&
1507 (supp_rates[i] & 0x7f) == BSS_MEMBERSHIP_SELECTOR_HT_PHY)
1510 for (j = 0; j < sband->n_bitrates; j++) {
1511 if (sband->bitrates[j].bitrate == rate) {
1514 *basic_rates |= BIT(j);
1515 if (rate < *min_rate) {
1517 *min_rate_index = j;
1525 static bool ieee80211_assoc_success(struct ieee80211_work *wk,
1526 struct ieee80211_mgmt *mgmt, size_t len)
1528 struct ieee80211_sub_if_data *sdata = wk->sdata;
1529 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
1530 struct ieee80211_local *local = sdata->local;
1531 struct ieee80211_supported_band *sband;
1532 struct sta_info *sta;
1533 struct cfg80211_bss *cbss = wk->assoc.bss;
1535 u32 rates, basic_rates;
1536 u16 capab_info, aid;
1537 struct ieee802_11_elems elems;
1538 struct ieee80211_bss_conf *bss_conf = &sdata->vif.bss_conf;
1541 bool have_higher_than_11mbit = false;
1542 u16 ap_ht_cap_flags;
1543 int min_rate = INT_MAX, min_rate_index = -1;
1545 /* AssocResp and ReassocResp have identical structure */
1547 aid = le16_to_cpu(mgmt->u.assoc_resp.aid);
1548 capab_info = le16_to_cpu(mgmt->u.assoc_resp.capab_info);
1550 if ((aid & (BIT(15) | BIT(14))) != (BIT(15) | BIT(14)))
1552 "%s: invalid AID value 0x%x; bits 15:14 not set\n",
1554 aid &= ~(BIT(15) | BIT(14));
1556 ifmgd->broken_ap = false;
1558 if (aid == 0 || aid > IEEE80211_MAX_AID) {
1560 "%s: invalid AID value %d (out of range), turn off PS\n",
1563 ifmgd->broken_ap = true;
1566 pos = mgmt->u.assoc_resp.variable;
1567 ieee802_11_parse_elems(pos, len - (pos - (u8 *) mgmt), &elems);
1569 if (!elems.supp_rates) {
1570 printk(KERN_DEBUG "%s: no SuppRates element in AssocResp\n",
1577 mutex_lock(&sdata->local->sta_mtx);
1579 * station info was already allocated and inserted before
1580 * the association and should be available to us
1582 sta = sta_info_get_rx(sdata, cbss->bssid);
1583 if (WARN_ON(!sta)) {
1584 mutex_unlock(&sdata->local->sta_mtx);
1588 sta_info_move_state(sta, IEEE80211_STA_AUTH);
1589 sta_info_move_state(sta, IEEE80211_STA_ASSOC);
1590 if (!(ifmgd->flags & IEEE80211_STA_CONTROL_PORT))
1591 sta_info_move_state(sta, IEEE80211_STA_AUTHORIZED);
1595 sband = local->hw.wiphy->bands[wk->chan->band];
1597 ieee80211_get_rates(sband, elems.supp_rates, elems.supp_rates_len,
1598 &rates, &basic_rates, &have_higher_than_11mbit,
1599 &min_rate, &min_rate_index);
1601 ieee80211_get_rates(sband, elems.ext_supp_rates,
1602 elems.ext_supp_rates_len, &rates, &basic_rates,
1603 &have_higher_than_11mbit,
1604 &min_rate, &min_rate_index);
1607 * some buggy APs don't advertise basic_rates. use the lowest
1608 * supported rate instead.
1610 if (unlikely(!basic_rates) && min_rate_index >= 0) {
1611 printk(KERN_DEBUG "%s: No basic rates in AssocResp. "
1612 "Using min supported rate instead.\n", sdata->name);
1613 basic_rates = BIT(min_rate_index);
1616 sta->sta.supp_rates[wk->chan->band] = rates;
1617 sdata->vif.bss_conf.basic_rates = basic_rates;
1619 /* cf. IEEE 802.11 9.2.12 */
1620 if (wk->chan->band == IEEE80211_BAND_2GHZ &&
1621 have_higher_than_11mbit)
1622 sdata->flags |= IEEE80211_SDATA_OPERATING_GMODE;
1624 sdata->flags &= ~IEEE80211_SDATA_OPERATING_GMODE;
1626 if (elems.ht_cap_elem && !(ifmgd->flags & IEEE80211_STA_DISABLE_11N))
1627 ieee80211_ht_cap_ie_to_sta_ht_cap(sdata, sband,
1628 elems.ht_cap_elem, &sta->sta.ht_cap);
1630 ap_ht_cap_flags = sta->sta.ht_cap.cap;
1632 rate_control_rate_init(sta);
1634 if (ifmgd->flags & IEEE80211_STA_MFP_ENABLED)
1635 set_sta_flag(sta, WLAN_STA_MFP);
1637 if (elems.wmm_param)
1638 set_sta_flag(sta, WLAN_STA_WME);
1640 /* sta_info_reinsert will also unlock the mutex lock */
1641 err = sta_info_reinsert(sta);
1644 printk(KERN_DEBUG "%s: failed to insert STA entry for"
1645 " the AP (error %d)\n", sdata->name, err);
1650 * Always handle WMM once after association regardless
1651 * of the first value the AP uses. Setting -1 here has
1652 * that effect because the AP values is an unsigned
1655 ifmgd->wmm_last_param_set = -1;
1657 if (elems.wmm_param)
1658 ieee80211_sta_wmm_params(local, sdata, elems.wmm_param,
1659 elems.wmm_param_len);
1661 ieee80211_set_wmm_default(sdata);
1663 local->oper_channel = wk->chan;
1665 if (elems.ht_info_elem && elems.wmm_param &&
1666 (sdata->local->hw.queues >= 4) &&
1667 !(ifmgd->flags & IEEE80211_STA_DISABLE_11N))
1668 changed |= ieee80211_enable_ht(sdata, elems.ht_info_elem,
1669 cbss->bssid, ap_ht_cap_flags,
1672 /* set AID and assoc capability,
1673 * ieee80211_set_associated() will tell the driver */
1674 bss_conf->aid = aid;
1675 bss_conf->assoc_capability = capab_info;
1676 ieee80211_set_associated(sdata, cbss, changed);
1679 * If we're using 4-addr mode, let the AP know that we're
1680 * doing so, so that it can create the STA VLAN on its side
1682 if (ifmgd->use_4addr)
1683 ieee80211_send_4addr_nullfunc(local, sdata);
1686 * Start timer to probe the connection to the AP now.
1687 * Also start the timer that will detect beacon loss.
1689 ieee80211_sta_rx_notify(sdata, (struct ieee80211_hdr *)mgmt);
1690 ieee80211_sta_reset_beacon_monitor(sdata);
1696 static void ieee80211_rx_bss_info(struct ieee80211_sub_if_data *sdata,
1697 struct ieee80211_mgmt *mgmt,
1699 struct ieee80211_rx_status *rx_status,
1700 struct ieee802_11_elems *elems,
1703 struct ieee80211_local *local = sdata->local;
1705 struct ieee80211_bss *bss;
1706 struct ieee80211_channel *channel;
1707 bool need_ps = false;
1709 if (sdata->u.mgd.associated) {
1710 bss = (void *)sdata->u.mgd.associated->priv;
1711 /* not previously set so we may need to recalc */
1712 need_ps = !bss->dtim_period;
1715 if (elems->ds_params && elems->ds_params_len == 1)
1716 freq = ieee80211_channel_to_frequency(elems->ds_params[0],
1719 freq = rx_status->freq;
1721 channel = ieee80211_get_channel(local->hw.wiphy, freq);
1723 if (!channel || channel->flags & IEEE80211_CHAN_DISABLED)
1726 bss = ieee80211_bss_info_update(local, rx_status, mgmt, len, elems,
1729 ieee80211_rx_bss_put(local, bss);
1731 if (!sdata->u.mgd.associated)
1735 mutex_lock(&local->iflist_mtx);
1736 ieee80211_recalc_ps(local, -1);
1737 mutex_unlock(&local->iflist_mtx);
1740 if (elems->ch_switch_elem && (elems->ch_switch_elem_len == 3) &&
1741 (memcmp(mgmt->bssid, sdata->u.mgd.associated->bssid,
1743 struct ieee80211_channel_sw_ie *sw_elem =
1744 (struct ieee80211_channel_sw_ie *)elems->ch_switch_elem;
1745 ieee80211_sta_process_chanswitch(sdata, sw_elem,
1746 bss, rx_status->mactime);
1751 static void ieee80211_rx_mgmt_probe_resp(struct ieee80211_sub_if_data *sdata,
1752 struct sk_buff *skb)
1754 struct ieee80211_mgmt *mgmt = (void *)skb->data;
1755 struct ieee80211_if_managed *ifmgd;
1756 struct ieee80211_rx_status *rx_status = (void *) skb->cb;
1757 size_t baselen, len = skb->len;
1758 struct ieee802_11_elems elems;
1760 ifmgd = &sdata->u.mgd;
1762 ASSERT_MGD_MTX(ifmgd);
1764 if (memcmp(mgmt->da, sdata->vif.addr, ETH_ALEN))
1765 return; /* ignore ProbeResp to foreign address */
1767 baselen = (u8 *) mgmt->u.probe_resp.variable - (u8 *) mgmt;
1771 ieee802_11_parse_elems(mgmt->u.probe_resp.variable, len - baselen,
1774 ieee80211_rx_bss_info(sdata, mgmt, len, rx_status, &elems, false);
1776 if (ifmgd->associated &&
1777 memcmp(mgmt->bssid, ifmgd->associated->bssid, ETH_ALEN) == 0)
1778 ieee80211_reset_ap_probe(sdata);
1782 * This is the canonical list of information elements we care about,
1783 * the filter code also gives us all changes to the Microsoft OUI
1784 * (00:50:F2) vendor IE which is used for WMM which we need to track.
1786 * We implement beacon filtering in software since that means we can
1787 * avoid processing the frame here and in cfg80211, and userspace
1788 * will not be able to tell whether the hardware supports it or not.
1790 * XXX: This list needs to be dynamic -- userspace needs to be able to
1791 * add items it requires. It also needs to be able to tell us to
1792 * look out for other vendor IEs.
1794 static const u64 care_about_ies =
1795 (1ULL << WLAN_EID_COUNTRY) |
1796 (1ULL << WLAN_EID_ERP_INFO) |
1797 (1ULL << WLAN_EID_CHANNEL_SWITCH) |
1798 (1ULL << WLAN_EID_PWR_CONSTRAINT) |
1799 (1ULL << WLAN_EID_HT_CAPABILITY) |
1800 (1ULL << WLAN_EID_HT_INFORMATION);
1802 static void ieee80211_rx_mgmt_beacon(struct ieee80211_sub_if_data *sdata,
1803 struct ieee80211_mgmt *mgmt,
1805 struct ieee80211_rx_status *rx_status)
1807 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
1808 struct ieee80211_bss_conf *bss_conf = &sdata->vif.bss_conf;
1810 struct ieee802_11_elems elems;
1811 struct ieee80211_local *local = sdata->local;
1813 bool erp_valid, directed_tim = false;
1818 ASSERT_MGD_MTX(ifmgd);
1820 /* Process beacon from the current BSS */
1821 baselen = (u8 *) mgmt->u.beacon.variable - (u8 *) mgmt;
1825 if (rx_status->freq != local->hw.conf.channel->center_freq)
1829 * We might have received a number of frames, among them a
1830 * disassoc frame and a beacon...
1832 if (!ifmgd->associated)
1835 bssid = ifmgd->associated->bssid;
1838 * And in theory even frames from a different AP we were just
1839 * associated to a split-second ago!
1841 if (memcmp(bssid, mgmt->bssid, ETH_ALEN) != 0)
1844 /* Track average RSSI from the Beacon frames of the current AP */
1845 ifmgd->last_beacon_signal = rx_status->signal;
1846 if (ifmgd->flags & IEEE80211_STA_RESET_SIGNAL_AVE) {
1847 ifmgd->flags &= ~IEEE80211_STA_RESET_SIGNAL_AVE;
1848 ifmgd->ave_beacon_signal = rx_status->signal * 16;
1849 ifmgd->last_cqm_event_signal = 0;
1850 ifmgd->count_beacon_signal = 1;
1851 ifmgd->last_ave_beacon_signal = 0;
1853 ifmgd->ave_beacon_signal =
1854 (IEEE80211_SIGNAL_AVE_WEIGHT * rx_status->signal * 16 +
1855 (16 - IEEE80211_SIGNAL_AVE_WEIGHT) *
1856 ifmgd->ave_beacon_signal) / 16;
1857 ifmgd->count_beacon_signal++;
1860 if (ifmgd->rssi_min_thold != ifmgd->rssi_max_thold &&
1861 ifmgd->count_beacon_signal >= IEEE80211_SIGNAL_AVE_MIN_COUNT) {
1862 int sig = ifmgd->ave_beacon_signal;
1863 int last_sig = ifmgd->last_ave_beacon_signal;
1866 * if signal crosses either of the boundaries, invoke callback
1867 * with appropriate parameters
1869 if (sig > ifmgd->rssi_max_thold &&
1870 (last_sig <= ifmgd->rssi_min_thold || last_sig == 0)) {
1871 ifmgd->last_ave_beacon_signal = sig;
1872 drv_rssi_callback(local, RSSI_EVENT_HIGH);
1873 } else if (sig < ifmgd->rssi_min_thold &&
1874 (last_sig >= ifmgd->rssi_max_thold ||
1876 ifmgd->last_ave_beacon_signal = sig;
1877 drv_rssi_callback(local, RSSI_EVENT_LOW);
1881 if (bss_conf->cqm_rssi_thold &&
1882 ifmgd->count_beacon_signal >= IEEE80211_SIGNAL_AVE_MIN_COUNT &&
1883 !(local->hw.flags & IEEE80211_HW_SUPPORTS_CQM_RSSI)) {
1884 int sig = ifmgd->ave_beacon_signal / 16;
1885 int last_event = ifmgd->last_cqm_event_signal;
1886 int thold = bss_conf->cqm_rssi_thold;
1887 int hyst = bss_conf->cqm_rssi_hyst;
1889 (last_event == 0 || sig < last_event - hyst)) {
1890 ifmgd->last_cqm_event_signal = sig;
1891 ieee80211_cqm_rssi_notify(
1893 NL80211_CQM_RSSI_THRESHOLD_EVENT_LOW,
1895 } else if (sig > thold &&
1896 (last_event == 0 || sig > last_event + hyst)) {
1897 ifmgd->last_cqm_event_signal = sig;
1898 ieee80211_cqm_rssi_notify(
1900 NL80211_CQM_RSSI_THRESHOLD_EVENT_HIGH,
1905 if (ifmgd->flags & IEEE80211_STA_BEACON_POLL) {
1906 #ifdef CONFIG_MAC80211_VERBOSE_DEBUG
1907 if (net_ratelimit()) {
1908 printk(KERN_DEBUG "%s: cancelling probereq poll due "
1909 "to a received beacon\n", sdata->name);
1912 ifmgd->flags &= ~IEEE80211_STA_BEACON_POLL;
1913 mutex_lock(&local->iflist_mtx);
1914 ieee80211_recalc_ps(local, -1);
1915 mutex_unlock(&local->iflist_mtx);
1919 * Push the beacon loss detection into the future since
1920 * we are processing a beacon from the AP just now.
1922 ieee80211_sta_reset_beacon_monitor(sdata);
1924 ncrc = crc32_be(0, (void *)&mgmt->u.beacon.beacon_int, 4);
1925 ncrc = ieee802_11_parse_elems_crc(mgmt->u.beacon.variable,
1926 len - baselen, &elems,
1927 care_about_ies, ncrc);
1929 if (local->hw.flags & IEEE80211_HW_PS_NULLFUNC_STACK)
1930 directed_tim = ieee80211_check_tim(elems.tim, elems.tim_len,
1933 if (ncrc != ifmgd->beacon_crc || !ifmgd->beacon_crc_valid) {
1934 ieee80211_rx_bss_info(sdata, mgmt, len, rx_status, &elems,
1937 ieee80211_sta_wmm_params(local, sdata, elems.wmm_param,
1938 elems.wmm_param_len);
1941 if (local->hw.flags & IEEE80211_HW_PS_NULLFUNC_STACK) {
1943 if (local->hw.conf.dynamic_ps_timeout > 0) {
1944 local->hw.conf.flags &= ~IEEE80211_CONF_PS;
1945 ieee80211_hw_config(local,
1946 IEEE80211_CONF_CHANGE_PS);
1947 ieee80211_send_nullfunc(local, sdata, 0);
1949 local->pspolling = true;
1952 * Here is assumed that the driver will be
1953 * able to send ps-poll frame and receive a
1954 * response even though power save mode is
1955 * enabled, but some drivers might require
1956 * to disable power save here. This needs
1957 * to be investigated.
1959 ieee80211_send_pspoll(local, sdata);
1964 if (ncrc == ifmgd->beacon_crc && ifmgd->beacon_crc_valid)
1966 ifmgd->beacon_crc = ncrc;
1967 ifmgd->beacon_crc_valid = true;
1969 if (elems.erp_info && elems.erp_info_len >= 1) {
1971 erp_value = elems.erp_info[0];
1975 changed |= ieee80211_handle_bss_capability(sdata,
1976 le16_to_cpu(mgmt->u.beacon.capab_info),
1977 erp_valid, erp_value);
1980 if (elems.ht_cap_elem && elems.ht_info_elem && elems.wmm_param &&
1981 !(ifmgd->flags & IEEE80211_STA_DISABLE_11N)) {
1982 struct sta_info *sta;
1983 struct ieee80211_supported_band *sband;
1984 u16 ap_ht_cap_flags;
1988 sta = sta_info_get(sdata, bssid);
1989 if (WARN_ON(!sta)) {
1994 sband = local->hw.wiphy->bands[local->hw.conf.channel->band];
1996 ieee80211_ht_cap_ie_to_sta_ht_cap(sdata, sband,
1997 elems.ht_cap_elem, &sta->sta.ht_cap);
1999 ap_ht_cap_flags = sta->sta.ht_cap.cap;
2003 changed |= ieee80211_enable_ht(sdata, elems.ht_info_elem,
2004 bssid, ap_ht_cap_flags, true);
2007 /* Note: country IE parsing is done for us by cfg80211 */
2008 if (elems.country_elem) {
2009 /* TODO: IBSS also needs this */
2010 if (elems.pwr_constr_elem)
2011 ieee80211_handle_pwr_constr(sdata,
2012 le16_to_cpu(mgmt->u.probe_resp.capab_info),
2013 elems.pwr_constr_elem,
2014 elems.pwr_constr_elem_len);
2017 ieee80211_bss_info_change_notify(sdata, changed);
2020 void ieee80211_sta_rx_queued_mgmt(struct ieee80211_sub_if_data *sdata,
2021 struct sk_buff *skb)
2023 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
2024 struct ieee80211_rx_status *rx_status;
2025 struct ieee80211_mgmt *mgmt;
2026 enum rx_mgmt_action rma = RX_MGMT_NONE;
2029 rx_status = (struct ieee80211_rx_status *) skb->cb;
2030 mgmt = (struct ieee80211_mgmt *) skb->data;
2031 fc = le16_to_cpu(mgmt->frame_control);
2033 mutex_lock(&ifmgd->mtx);
2035 if (ifmgd->associated &&
2036 memcmp(ifmgd->associated->bssid, mgmt->bssid, ETH_ALEN) == 0) {
2037 switch (fc & IEEE80211_FCTL_STYPE) {
2038 case IEEE80211_STYPE_BEACON:
2039 ieee80211_rx_mgmt_beacon(sdata, mgmt, skb->len,
2042 case IEEE80211_STYPE_PROBE_RESP:
2043 ieee80211_rx_mgmt_probe_resp(sdata, skb);
2045 case IEEE80211_STYPE_DEAUTH:
2046 rma = ieee80211_rx_mgmt_deauth(sdata, mgmt, skb->len);
2048 case IEEE80211_STYPE_DISASSOC:
2049 rma = ieee80211_rx_mgmt_disassoc(sdata, mgmt, skb->len);
2051 case IEEE80211_STYPE_ACTION:
2052 switch (mgmt->u.action.category) {
2053 case WLAN_CATEGORY_SPECTRUM_MGMT:
2054 ieee80211_sta_process_chanswitch(sdata,
2055 &mgmt->u.action.u.chan_switch.sw_elem,
2056 (void *)ifmgd->associated->priv,
2057 rx_status->mactime);
2061 mutex_unlock(&ifmgd->mtx);
2067 case RX_MGMT_CFG80211_DEAUTH:
2068 cfg80211_send_deauth(sdata->dev, (u8 *)mgmt, skb->len);
2070 case RX_MGMT_CFG80211_DISASSOC:
2071 cfg80211_send_disassoc(sdata->dev, (u8 *)mgmt, skb->len);
2074 WARN(1, "unexpected: %d", rma);
2079 mutex_unlock(&ifmgd->mtx);
2081 if (skb->len >= 24 + 2 /* mgmt + deauth reason */ &&
2082 (fc & IEEE80211_FCTL_STYPE) == IEEE80211_STYPE_DEAUTH) {
2083 struct ieee80211_local *local = sdata->local;
2084 struct ieee80211_work *wk;
2086 mutex_lock(&local->mtx);
2087 list_for_each_entry(wk, &local->work_list, list) {
2088 if (wk->sdata != sdata)
2091 if (wk->type != IEEE80211_WORK_ASSOC &&
2092 wk->type != IEEE80211_WORK_ASSOC_BEACON_WAIT)
2095 if (memcmp(mgmt->bssid, wk->filter_ta, ETH_ALEN))
2097 if (memcmp(mgmt->sa, wk->filter_ta, ETH_ALEN))
2101 * Printing the message only here means we can't
2102 * spuriously print it, but it also means that it
2103 * won't be printed when the frame comes in before
2104 * we even tried to associate or in similar cases.
2106 * Ultimately, I suspect cfg80211 should print the
2110 "%s: deauthenticated from %pM (Reason: %u)\n",
2111 sdata->name, mgmt->bssid,
2112 le16_to_cpu(mgmt->u.deauth.reason_code));
2114 list_del_rcu(&wk->list);
2118 mutex_unlock(&local->mtx);
2120 cfg80211_send_deauth(sdata->dev, (u8 *)mgmt, skb->len);
2124 static void ieee80211_sta_timer(unsigned long data)
2126 struct ieee80211_sub_if_data *sdata =
2127 (struct ieee80211_sub_if_data *) data;
2128 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
2129 struct ieee80211_local *local = sdata->local;
2131 if (local->quiescing) {
2132 set_bit(TMR_RUNNING_TIMER, &ifmgd->timers_running);
2136 ieee80211_queue_work(&local->hw, &sdata->work);
2139 static void ieee80211_sta_connection_lost(struct ieee80211_sub_if_data *sdata,
2140 u8 *bssid, u8 reason)
2142 struct ieee80211_local *local = sdata->local;
2143 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
2145 ifmgd->flags &= ~(IEEE80211_STA_CONNECTION_POLL |
2146 IEEE80211_STA_BEACON_POLL);
2148 ieee80211_set_disassoc(sdata, true, true);
2149 mutex_unlock(&ifmgd->mtx);
2151 * must be outside lock due to cfg80211,
2152 * but that's not a problem.
2154 ieee80211_send_deauth_disassoc(sdata, bssid,
2155 IEEE80211_STYPE_DEAUTH, reason,
2158 mutex_lock(&local->mtx);
2159 ieee80211_recalc_idle(local);
2160 mutex_unlock(&local->mtx);
2162 mutex_lock(&ifmgd->mtx);
2165 void ieee80211_sta_work(struct ieee80211_sub_if_data *sdata)
2167 struct ieee80211_local *local = sdata->local;
2168 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
2170 /* then process the rest of the work */
2171 mutex_lock(&ifmgd->mtx);
2173 if (ifmgd->flags & (IEEE80211_STA_BEACON_POLL |
2174 IEEE80211_STA_CONNECTION_POLL) &&
2175 ifmgd->associated) {
2179 memcpy(bssid, ifmgd->associated->bssid, ETH_ALEN);
2181 if (local->hw.flags & IEEE80211_HW_REPORTS_TX_ACK_STATUS)
2182 max_tries = max_nullfunc_tries;
2184 max_tries = max_probe_tries;
2186 /* ACK received for nullfunc probing frame */
2187 if (!ifmgd->probe_send_count)
2188 ieee80211_reset_ap_probe(sdata);
2189 else if (ifmgd->nullfunc_failed) {
2190 if (ifmgd->probe_send_count < max_tries) {
2191 #ifdef CONFIG_MAC80211_VERBOSE_DEBUG
2192 wiphy_debug(local->hw.wiphy,
2193 "%s: No ack for nullfunc frame to"
2194 " AP %pM, try %d/%i\n",
2196 ifmgd->probe_send_count, max_tries);
2198 ieee80211_mgd_probe_ap_send(sdata);
2200 #ifdef CONFIG_MAC80211_VERBOSE_DEBUG
2201 wiphy_debug(local->hw.wiphy,
2202 "%s: No ack for nullfunc frame to"
2203 " AP %pM, disconnecting.\n",
2204 sdata->name, bssid);
2206 ieee80211_sta_connection_lost(sdata, bssid,
2207 WLAN_REASON_DISASSOC_DUE_TO_INACTIVITY);
2209 } else if (time_is_after_jiffies(ifmgd->probe_timeout))
2210 run_again(ifmgd, ifmgd->probe_timeout);
2211 else if (local->hw.flags & IEEE80211_HW_REPORTS_TX_ACK_STATUS) {
2212 #ifdef CONFIG_MAC80211_VERBOSE_DEBUG
2213 wiphy_debug(local->hw.wiphy,
2214 "%s: Failed to send nullfunc to AP %pM"
2215 " after %dms, disconnecting.\n",
2217 bssid, probe_wait_ms);
2219 ieee80211_sta_connection_lost(sdata, bssid,
2220 WLAN_REASON_DISASSOC_DUE_TO_INACTIVITY);
2221 } else if (ifmgd->probe_send_count < max_tries) {
2222 #ifdef CONFIG_MAC80211_VERBOSE_DEBUG
2223 wiphy_debug(local->hw.wiphy,
2224 "%s: No probe response from AP %pM"
2225 " after %dms, try %d/%i\n",
2227 bssid, probe_wait_ms,
2228 ifmgd->probe_send_count, max_tries);
2230 ieee80211_mgd_probe_ap_send(sdata);
2233 * We actually lost the connection ... or did we?
2236 wiphy_debug(local->hw.wiphy,
2237 "%s: No probe response from AP %pM"
2238 " after %dms, disconnecting.\n",
2240 bssid, probe_wait_ms);
2242 ieee80211_sta_connection_lost(sdata, bssid,
2243 WLAN_REASON_DISASSOC_DUE_TO_INACTIVITY);
2247 mutex_unlock(&ifmgd->mtx);
2250 static void ieee80211_sta_bcn_mon_timer(unsigned long data)
2252 struct ieee80211_sub_if_data *sdata =
2253 (struct ieee80211_sub_if_data *) data;
2254 struct ieee80211_local *local = sdata->local;
2256 if (local->quiescing)
2259 ieee80211_queue_work(&sdata->local->hw,
2260 &sdata->u.mgd.beacon_connection_loss_work);
2263 static void ieee80211_sta_conn_mon_timer(unsigned long data)
2265 struct ieee80211_sub_if_data *sdata =
2266 (struct ieee80211_sub_if_data *) data;
2267 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
2268 struct ieee80211_local *local = sdata->local;
2270 if (local->quiescing)
2273 ieee80211_queue_work(&local->hw, &ifmgd->monitor_work);
2276 static void ieee80211_sta_monitor_work(struct work_struct *work)
2278 struct ieee80211_sub_if_data *sdata =
2279 container_of(work, struct ieee80211_sub_if_data,
2280 u.mgd.monitor_work);
2282 ieee80211_mgd_probe_ap(sdata, false);
2285 static void ieee80211_restart_sta_timer(struct ieee80211_sub_if_data *sdata)
2287 if (sdata->vif.type == NL80211_IFTYPE_STATION) {
2288 sdata->u.mgd.flags &= ~(IEEE80211_STA_BEACON_POLL |
2289 IEEE80211_STA_CONNECTION_POLL);
2291 /* let's probe the connection once */
2292 ieee80211_queue_work(&sdata->local->hw,
2293 &sdata->u.mgd.monitor_work);
2294 /* and do all the other regular work too */
2295 ieee80211_queue_work(&sdata->local->hw, &sdata->work);
2300 void ieee80211_sta_quiesce(struct ieee80211_sub_if_data *sdata)
2302 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
2305 * we need to use atomic bitops for the running bits
2306 * only because both timers might fire at the same
2307 * time -- the code here is properly synchronised.
2310 cancel_work_sync(&ifmgd->request_smps_work);
2312 cancel_work_sync(&ifmgd->monitor_work);
2313 cancel_work_sync(&ifmgd->beacon_connection_loss_work);
2314 if (del_timer_sync(&ifmgd->timer))
2315 set_bit(TMR_RUNNING_TIMER, &ifmgd->timers_running);
2317 cancel_work_sync(&ifmgd->chswitch_work);
2318 if (del_timer_sync(&ifmgd->chswitch_timer))
2319 set_bit(TMR_RUNNING_CHANSW, &ifmgd->timers_running);
2321 /* these will just be re-established on connection */
2322 del_timer_sync(&ifmgd->conn_mon_timer);
2323 del_timer_sync(&ifmgd->bcn_mon_timer);
2326 void ieee80211_sta_restart(struct ieee80211_sub_if_data *sdata)
2328 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
2330 if (!ifmgd->associated)
2333 if (sdata->flags & IEEE80211_SDATA_DISCONNECT_RESUME) {
2334 sdata->flags &= ~IEEE80211_SDATA_DISCONNECT_RESUME;
2335 mutex_lock(&ifmgd->mtx);
2336 if (ifmgd->associated) {
2337 #ifdef CONFIG_MAC80211_VERBOSE_DEBUG
2338 wiphy_debug(sdata->local->hw.wiphy,
2339 "%s: driver requested disconnect after resume.\n",
2342 ieee80211_sta_connection_lost(sdata,
2343 ifmgd->associated->bssid,
2344 WLAN_REASON_UNSPECIFIED);
2345 mutex_unlock(&ifmgd->mtx);
2348 mutex_unlock(&ifmgd->mtx);
2351 if (test_and_clear_bit(TMR_RUNNING_TIMER, &ifmgd->timers_running))
2352 add_timer(&ifmgd->timer);
2353 if (test_and_clear_bit(TMR_RUNNING_CHANSW, &ifmgd->timers_running))
2354 add_timer(&ifmgd->chswitch_timer);
2355 ieee80211_sta_reset_beacon_monitor(sdata);
2356 ieee80211_restart_sta_timer(sdata);
2357 ieee80211_queue_work(&sdata->local->hw, &sdata->u.mgd.monitor_work);
2361 /* interface setup */
2362 void ieee80211_sta_setup_sdata(struct ieee80211_sub_if_data *sdata)
2364 struct ieee80211_if_managed *ifmgd;
2366 ifmgd = &sdata->u.mgd;
2367 INIT_WORK(&ifmgd->monitor_work, ieee80211_sta_monitor_work);
2368 INIT_WORK(&ifmgd->chswitch_work, ieee80211_chswitch_work);
2369 INIT_WORK(&ifmgd->beacon_connection_loss_work,
2370 ieee80211_beacon_connection_loss_work);
2371 INIT_WORK(&ifmgd->request_smps_work, ieee80211_request_smps_work);
2372 setup_timer(&ifmgd->timer, ieee80211_sta_timer,
2373 (unsigned long) sdata);
2374 setup_timer(&ifmgd->bcn_mon_timer, ieee80211_sta_bcn_mon_timer,
2375 (unsigned long) sdata);
2376 setup_timer(&ifmgd->conn_mon_timer, ieee80211_sta_conn_mon_timer,
2377 (unsigned long) sdata);
2378 setup_timer(&ifmgd->chswitch_timer, ieee80211_chswitch_timer,
2379 (unsigned long) sdata);
2382 ifmgd->powersave = sdata->wdev.ps;
2384 mutex_init(&ifmgd->mtx);
2386 if (sdata->local->hw.flags & IEEE80211_HW_SUPPORTS_DYNAMIC_SMPS)
2387 ifmgd->req_smps = IEEE80211_SMPS_AUTOMATIC;
2389 ifmgd->req_smps = IEEE80211_SMPS_OFF;
2392 /* scan finished notification */
2393 void ieee80211_mlme_notify_scan_completed(struct ieee80211_local *local)
2395 struct ieee80211_sub_if_data *sdata = local->scan_sdata;
2397 /* Restart STA timers */
2399 list_for_each_entry_rcu(sdata, &local->interfaces, list)
2400 ieee80211_restart_sta_timer(sdata);
2404 int ieee80211_max_network_latency(struct notifier_block *nb,
2405 unsigned long data, void *dummy)
2407 s32 latency_usec = (s32) data;
2408 struct ieee80211_local *local =
2409 container_of(nb, struct ieee80211_local,
2410 network_latency_notifier);
2412 mutex_lock(&local->iflist_mtx);
2413 ieee80211_recalc_ps(local, latency_usec);
2414 mutex_unlock(&local->iflist_mtx);
2420 static enum work_done_result
2421 ieee80211_probe_auth_done(struct ieee80211_work *wk,
2422 struct sk_buff *skb)
2424 struct ieee80211_local *local = wk->sdata->local;
2427 cfg80211_send_auth_timeout(wk->sdata->dev, wk->filter_ta);
2431 if (wk->type == IEEE80211_WORK_AUTH) {
2432 cfg80211_send_rx_auth(wk->sdata->dev, skb->data, skb->len);
2436 mutex_lock(&wk->sdata->u.mgd.mtx);
2437 ieee80211_rx_mgmt_probe_resp(wk->sdata, skb);
2438 mutex_unlock(&wk->sdata->u.mgd.mtx);
2440 wk->type = IEEE80211_WORK_AUTH;
2441 wk->probe_auth.tries = 0;
2442 return WORK_DONE_REQUEUE;
2444 if (wk->probe_auth.synced)
2445 drv_finish_tx_sync(local, wk->sdata, wk->filter_ta,
2446 IEEE80211_TX_SYNC_AUTH);
2448 return WORK_DONE_DESTROY;
2451 int ieee80211_mgd_auth(struct ieee80211_sub_if_data *sdata,
2452 struct cfg80211_auth_request *req)
2455 struct ieee80211_work *wk;
2458 if (req->local_state_change)
2459 return 0; /* no need to update mac80211 state */
2461 switch (req->auth_type) {
2462 case NL80211_AUTHTYPE_OPEN_SYSTEM:
2463 auth_alg = WLAN_AUTH_OPEN;
2465 case NL80211_AUTHTYPE_SHARED_KEY:
2466 if (IS_ERR(sdata->local->wep_tx_tfm))
2468 auth_alg = WLAN_AUTH_SHARED_KEY;
2470 case NL80211_AUTHTYPE_FT:
2471 auth_alg = WLAN_AUTH_FT;
2473 case NL80211_AUTHTYPE_NETWORK_EAP:
2474 auth_alg = WLAN_AUTH_LEAP;
2480 wk = kzalloc(sizeof(*wk) + req->ie_len, GFP_KERNEL);
2484 memcpy(wk->filter_ta, req->bss->bssid, ETH_ALEN);
2486 if (req->ie && req->ie_len) {
2487 memcpy(wk->ie, req->ie, req->ie_len);
2488 wk->ie_len = req->ie_len;
2491 if (req->key && req->key_len) {
2492 wk->probe_auth.key_len = req->key_len;
2493 wk->probe_auth.key_idx = req->key_idx;
2494 memcpy(wk->probe_auth.key, req->key, req->key_len);
2497 ssid = ieee80211_bss_get_ie(req->bss, WLAN_EID_SSID);
2498 memcpy(wk->probe_auth.ssid, ssid + 2, ssid[1]);
2499 wk->probe_auth.ssid_len = ssid[1];
2501 wk->probe_auth.algorithm = auth_alg;
2502 wk->probe_auth.privacy = req->bss->capability & WLAN_CAPABILITY_PRIVACY;
2504 /* if we already have a probe, don't probe again */
2505 if (req->bss->proberesp_ies)
2506 wk->type = IEEE80211_WORK_AUTH;
2508 wk->type = IEEE80211_WORK_DIRECT_PROBE;
2509 wk->chan = req->bss->channel;
2510 wk->chan_type = NL80211_CHAN_NO_HT;
2512 wk->done = ieee80211_probe_auth_done;
2514 ieee80211_add_work(wk);
2518 /* create and insert a dummy station entry */
2519 static int ieee80211_pre_assoc(struct ieee80211_sub_if_data *sdata,
2521 struct sta_info *sta;
2524 sta = sta_info_alloc(sdata, bssid, GFP_KERNEL);
2530 err = sta_info_insert(sta);
2533 printk(KERN_DEBUG "%s: failed to insert Dummy STA entry for"
2534 " the AP (error %d)\n", sdata->name, err);
2541 static enum work_done_result ieee80211_assoc_done(struct ieee80211_work *wk,
2542 struct sk_buff *skb)
2544 struct ieee80211_local *local = wk->sdata->local;
2545 struct ieee80211_mgmt *mgmt;
2546 struct ieee80211_rx_status *rx_status;
2547 struct ieee802_11_elems elems;
2548 struct cfg80211_bss *cbss = wk->assoc.bss;
2552 sta_info_destroy_addr(wk->sdata, cbss->bssid);
2553 cfg80211_send_assoc_timeout(wk->sdata->dev, wk->filter_ta);
2557 if (wk->type == IEEE80211_WORK_ASSOC_BEACON_WAIT) {
2558 mutex_lock(&wk->sdata->u.mgd.mtx);
2559 rx_status = (void *) skb->cb;
2560 ieee802_11_parse_elems(skb->data + 24 + 12, skb->len - 24 - 12, &elems);
2561 ieee80211_rx_bss_info(wk->sdata, (void *)skb->data, skb->len, rx_status,
2563 mutex_unlock(&wk->sdata->u.mgd.mtx);
2565 wk->type = IEEE80211_WORK_ASSOC;
2566 /* not really done yet */
2567 return WORK_DONE_REQUEUE;
2570 mgmt = (void *)skb->data;
2571 status = le16_to_cpu(mgmt->u.assoc_resp.status_code);
2573 if (status == WLAN_STATUS_SUCCESS) {
2574 if (wk->assoc.synced)
2575 drv_finish_tx_sync(local, wk->sdata, wk->filter_ta,
2576 IEEE80211_TX_SYNC_ASSOC);
2578 mutex_lock(&wk->sdata->u.mgd.mtx);
2579 if (!ieee80211_assoc_success(wk, mgmt, skb->len)) {
2580 mutex_unlock(&wk->sdata->u.mgd.mtx);
2581 /* oops -- internal error -- send timeout for now */
2582 sta_info_destroy_addr(wk->sdata, cbss->bssid);
2583 cfg80211_send_assoc_timeout(wk->sdata->dev,
2585 return WORK_DONE_DESTROY;
2588 mutex_unlock(&wk->sdata->u.mgd.mtx);
2590 /* assoc failed - destroy the dummy station entry */
2591 sta_info_destroy_addr(wk->sdata, cbss->bssid);
2594 cfg80211_send_rx_assoc(wk->sdata->dev, skb->data, skb->len);
2596 if (wk->assoc.synced)
2597 drv_finish_tx_sync(local, wk->sdata, wk->filter_ta,
2598 IEEE80211_TX_SYNC_ASSOC);
2600 return WORK_DONE_DESTROY;
2603 int ieee80211_mgd_assoc(struct ieee80211_sub_if_data *sdata,
2604 struct cfg80211_assoc_request *req)
2606 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
2607 struct ieee80211_bss *bss = (void *)req->bss->priv;
2608 struct ieee80211_work *wk;
2612 mutex_lock(&ifmgd->mtx);
2613 if (ifmgd->associated) {
2614 if (!req->prev_bssid ||
2615 memcmp(req->prev_bssid, ifmgd->associated->bssid,
2618 * We are already associated and the request was not a
2619 * reassociation request from the current BSS, so
2622 mutex_unlock(&ifmgd->mtx);
2626 /* Trying to reassociate - clear previous association state */
2627 ieee80211_set_disassoc(sdata, true, false);
2629 mutex_unlock(&ifmgd->mtx);
2631 wk = kzalloc(sizeof(*wk) + req->ie_len, GFP_KERNEL);
2636 * create a dummy station info entry in order
2637 * to start accepting incoming EAPOL packets from the station
2639 err = ieee80211_pre_assoc(sdata, req->bss->bssid);
2645 ifmgd->flags &= ~IEEE80211_STA_DISABLE_11N;
2646 ifmgd->flags &= ~IEEE80211_STA_NULLFUNC_ACKED;
2648 ifmgd->beacon_crc_valid = false;
2650 for (i = 0; i < req->crypto.n_ciphers_pairwise; i++)
2651 if (req->crypto.ciphers_pairwise[i] == WLAN_CIPHER_SUITE_WEP40 ||
2652 req->crypto.ciphers_pairwise[i] == WLAN_CIPHER_SUITE_TKIP ||
2653 req->crypto.ciphers_pairwise[i] == WLAN_CIPHER_SUITE_WEP104)
2654 ifmgd->flags |= IEEE80211_STA_DISABLE_11N;
2657 if (req->flags & ASSOC_REQ_DISABLE_HT)
2658 ifmgd->flags |= IEEE80211_STA_DISABLE_11N;
2660 memcpy(&ifmgd->ht_capa, &req->ht_capa, sizeof(ifmgd->ht_capa));
2661 memcpy(&ifmgd->ht_capa_mask, &req->ht_capa_mask,
2662 sizeof(ifmgd->ht_capa_mask));
2664 if (req->ie && req->ie_len) {
2665 memcpy(wk->ie, req->ie, req->ie_len);
2666 wk->ie_len = req->ie_len;
2670 wk->assoc.bss = req->bss;
2672 memcpy(wk->filter_ta, req->bss->bssid, ETH_ALEN);
2674 /* new association always uses requested smps mode */
2675 if (ifmgd->req_smps == IEEE80211_SMPS_AUTOMATIC) {
2676 if (ifmgd->powersave)
2677 ifmgd->ap_smps = IEEE80211_SMPS_DYNAMIC;
2679 ifmgd->ap_smps = IEEE80211_SMPS_OFF;
2681 ifmgd->ap_smps = ifmgd->req_smps;
2683 wk->assoc.smps = ifmgd->ap_smps;
2685 * IEEE802.11n does not allow TKIP/WEP as pairwise ciphers in HT mode.
2686 * We still associate in non-HT mode (11a/b/g) if any one of these
2687 * ciphers is configured as pairwise.
2688 * We can set this to true for non-11n hardware, that'll be checked
2689 * separately along with the peer capabilities.
2691 wk->assoc.use_11n = !(ifmgd->flags & IEEE80211_STA_DISABLE_11N);
2692 wk->assoc.capability = req->bss->capability;
2693 wk->assoc.wmm_used = bss->wmm_used;
2694 wk->assoc.supp_rates = bss->supp_rates;
2695 wk->assoc.supp_rates_len = bss->supp_rates_len;
2696 wk->assoc.ht_information_ie =
2697 ieee80211_bss_get_ie(req->bss, WLAN_EID_HT_INFORMATION);
2699 if (bss->wmm_used && bss->uapsd_supported &&
2700 (sdata->local->hw.flags & IEEE80211_HW_SUPPORTS_UAPSD)) {
2701 wk->assoc.uapsd_used = true;
2702 ifmgd->flags |= IEEE80211_STA_UAPSD_ENABLED;
2704 wk->assoc.uapsd_used = false;
2705 ifmgd->flags &= ~IEEE80211_STA_UAPSD_ENABLED;
2708 ssid = ieee80211_bss_get_ie(req->bss, WLAN_EID_SSID);
2709 memcpy(wk->assoc.ssid, ssid + 2, ssid[1]);
2710 wk->assoc.ssid_len = ssid[1];
2712 if (req->prev_bssid)
2713 memcpy(wk->assoc.prev_bssid, req->prev_bssid, ETH_ALEN);
2715 wk->chan = req->bss->channel;
2716 wk->chan_type = NL80211_CHAN_NO_HT;
2718 wk->done = ieee80211_assoc_done;
2719 if (!bss->dtim_period &&
2720 sdata->local->hw.flags & IEEE80211_HW_NEED_DTIM_PERIOD)
2721 wk->type = IEEE80211_WORK_ASSOC_BEACON_WAIT;
2723 wk->type = IEEE80211_WORK_ASSOC;
2726 ifmgd->mfp = IEEE80211_MFP_REQUIRED;
2727 ifmgd->flags |= IEEE80211_STA_MFP_ENABLED;
2729 ifmgd->mfp = IEEE80211_MFP_DISABLED;
2730 ifmgd->flags &= ~IEEE80211_STA_MFP_ENABLED;
2733 if (req->crypto.control_port)
2734 ifmgd->flags |= IEEE80211_STA_CONTROL_PORT;
2736 ifmgd->flags &= ~IEEE80211_STA_CONTROL_PORT;
2738 sdata->control_port_protocol = req->crypto.control_port_ethertype;
2739 sdata->control_port_no_encrypt = req->crypto.control_port_no_encrypt;
2741 ieee80211_add_work(wk);
2745 int ieee80211_mgd_deauth(struct ieee80211_sub_if_data *sdata,
2746 struct cfg80211_deauth_request *req,
2749 struct ieee80211_local *local = sdata->local;
2750 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
2751 struct ieee80211_work *wk;
2753 bool assoc_bss = false;
2755 mutex_lock(&ifmgd->mtx);
2757 memcpy(bssid, req->bss->bssid, ETH_ALEN);
2758 if (ifmgd->associated == req->bss) {
2759 ieee80211_set_disassoc(sdata, false, true);
2760 mutex_unlock(&ifmgd->mtx);
2763 bool not_auth_yet = false;
2765 mutex_unlock(&ifmgd->mtx);
2767 mutex_lock(&local->mtx);
2768 list_for_each_entry(wk, &local->work_list, list) {
2769 if (wk->sdata != sdata)
2772 if (wk->type != IEEE80211_WORK_DIRECT_PROBE &&
2773 wk->type != IEEE80211_WORK_AUTH &&
2774 wk->type != IEEE80211_WORK_ASSOC &&
2775 wk->type != IEEE80211_WORK_ASSOC_BEACON_WAIT)
2778 if (memcmp(req->bss->bssid, wk->filter_ta, ETH_ALEN))
2781 not_auth_yet = wk->type == IEEE80211_WORK_DIRECT_PROBE;
2782 list_del_rcu(&wk->list);
2786 mutex_unlock(&local->mtx);
2789 * If somebody requests authentication and we haven't
2790 * sent out an auth frame yet there's no need to send
2791 * out a deauth frame either. If the state was PROBE,
2792 * then this is the case. If it's AUTH we have sent a
2793 * frame, and if it's IDLE we have completed the auth
2797 __cfg80211_auth_canceled(sdata->dev, bssid);
2802 printk(KERN_DEBUG "%s: deauthenticating from %pM by local choice (reason=%d)\n",
2803 sdata->name, bssid, req->reason_code);
2805 ieee80211_send_deauth_disassoc(sdata, bssid, IEEE80211_STYPE_DEAUTH,
2806 req->reason_code, cookie,
2807 !req->local_state_change);
2809 sta_info_flush(sdata->local, sdata);
2811 mutex_lock(&sdata->local->mtx);
2812 ieee80211_recalc_idle(sdata->local);
2813 mutex_unlock(&sdata->local->mtx);
2818 int ieee80211_mgd_disassoc(struct ieee80211_sub_if_data *sdata,
2819 struct cfg80211_disassoc_request *req,
2822 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
2825 mutex_lock(&ifmgd->mtx);
2828 * cfg80211 should catch this ... but it's racy since
2829 * we can receive a disassoc frame, process it, hand it
2830 * to cfg80211 while that's in a locked section already
2831 * trying to tell us that the user wants to disconnect.
2833 if (ifmgd->associated != req->bss) {
2834 mutex_unlock(&ifmgd->mtx);
2838 printk(KERN_DEBUG "%s: disassociating from %pM by local choice (reason=%d)\n",
2839 sdata->name, req->bss->bssid, req->reason_code);
2841 memcpy(bssid, req->bss->bssid, ETH_ALEN);
2842 ieee80211_set_disassoc(sdata, false, true);
2844 mutex_unlock(&ifmgd->mtx);
2846 ieee80211_send_deauth_disassoc(sdata, req->bss->bssid,
2847 IEEE80211_STYPE_DISASSOC, req->reason_code,
2848 cookie, !req->local_state_change);
2849 sta_info_flush(sdata->local, sdata);
2851 mutex_lock(&sdata->local->mtx);
2852 ieee80211_recalc_idle(sdata->local);
2853 mutex_unlock(&sdata->local->mtx);
2858 void ieee80211_cqm_rssi_notify(struct ieee80211_vif *vif,
2859 enum nl80211_cqm_rssi_threshold_event rssi_event,
2862 struct ieee80211_sub_if_data *sdata = vif_to_sdata(vif);
2864 trace_api_cqm_rssi_notify(sdata, rssi_event);
2866 cfg80211_cqm_rssi_notify(sdata->dev, rssi_event, gfp);
2868 EXPORT_SYMBOL(ieee80211_cqm_rssi_notify);
2870 unsigned char ieee80211_get_operstate(struct ieee80211_vif *vif)
2872 struct ieee80211_sub_if_data *sdata = vif_to_sdata(vif);
2873 return sdata->dev->operstate;
2875 EXPORT_SYMBOL(ieee80211_get_operstate);