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