blob: 576fb25456dd7479a0ed51c50efad9c6a238c3d1 [file] [log] [blame]
Jiri Bencf0706e82007-05-05 11:45:53 -07001/*
2 * BSS client mode implementation
Jouni Malinen5394af42009-01-08 13:31:59 +02003 * Copyright 2003-2008, Jouni Malinen <j@w1.fi>
Jiri Bencf0706e82007-05-05 11:45:53 -07004 * 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
Geert Uytterhoeven5b323ed2007-05-08 18:40:27 -070014#include <linux/delay.h>
Jiri Bencf0706e82007-05-05 11:45:53 -070015#include <linux/if_ether.h>
16#include <linux/skbuff.h>
Jiri Bencf0706e82007-05-05 11:45:53 -070017#include <linux/if_arp.h>
Jiri Bencf0706e82007-05-05 11:45:53 -070018#include <linux/etherdevice.h>
Paul Gortmakerd9b93842011-09-18 13:21:27 -040019#include <linux/moduleparam.h>
Johannes Bergd0709a62008-02-25 16:27:46 +010020#include <linux/rtnetlink.h>
Jean Pihete8db0be2011-08-25 15:35:03 +020021#include <linux/pm_qos.h>
Johannes Bergd91f36d2009-04-16 13:17:26 +020022#include <linux/crc32.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090023#include <linux/slab.h>
Paul Gortmakerbc3b2d72011-07-15 11:47:34 -040024#include <linux/export.h>
Jiri Bencf0706e82007-05-05 11:45:53 -070025#include <net/mac80211.h>
Johannes Berg472dbc42008-09-11 00:01:49 +020026#include <asm/unaligned.h>
Johannes Berg60f8b392008-09-08 17:44:22 +020027
Jiri Bencf0706e82007-05-05 11:45:53 -070028#include "ieee80211_i.h"
Johannes Berg24487982009-04-23 18:52:52 +020029#include "driver-ops.h"
Johannes Berg2c8dccc2008-04-08 15:14:40 -040030#include "rate.h"
31#include "led.h"
Jiri Bencf0706e82007-05-05 11:45:53 -070032
Johannes Berg66e67e42012-01-20 13:55:27 +010033#define IEEE80211_AUTH_TIMEOUT (HZ / 5)
34#define IEEE80211_AUTH_MAX_TRIES 3
35#define IEEE80211_AUTH_WAIT_ASSOC (HZ * 5)
36#define IEEE80211_ASSOC_TIMEOUT (HZ / 5)
37#define IEEE80211_ASSOC_MAX_TRIES 3
38
Ben Greear180205b2011-02-04 15:30:24 -080039static int max_nullfunc_tries = 2;
40module_param(max_nullfunc_tries, int, 0644);
41MODULE_PARM_DESC(max_nullfunc_tries,
42 "Maximum nullfunc tx tries before disconnecting (reason 4).");
43
44static int max_probe_tries = 5;
45module_param(max_probe_tries, int, 0644);
46MODULE_PARM_DESC(max_probe_tries,
47 "Maximum probe tries before disconnecting (reason 4).");
Johannes Bergb291ba12009-07-10 15:29:03 +020048
49/*
Felix Fietkau7ccc8bd2010-11-19 22:55:38 +010050 * Beacon loss timeout is calculated as N frames times the
51 * advertised beacon interval. This may need to be somewhat
52 * higher than what hardware might detect to account for
53 * delays in the host processing frames. But since we also
54 * probe on beacon miss before declaring the connection lost
55 * default to what we want.
Johannes Bergb291ba12009-07-10 15:29:03 +020056 */
Felix Fietkau7ccc8bd2010-11-19 22:55:38 +010057#define IEEE80211_BEACON_LOSS_COUNT 7
58
Johannes Bergb291ba12009-07-10 15:29:03 +020059/*
60 * Time the connection can be idle before we probe
61 * it to see if we can still talk to the AP.
62 */
Maxim Levitskyd1c50912009-07-31 18:54:23 +030063#define IEEE80211_CONNECTION_IDLE_TIME (30 * HZ)
Johannes Bergb291ba12009-07-10 15:29:03 +020064/*
65 * Time we wait for a probe response after sending
66 * a probe request because of beacon loss or for
67 * checking the connection still works.
68 */
Ben Greear180205b2011-02-04 15:30:24 -080069static int probe_wait_ms = 500;
70module_param(probe_wait_ms, int, 0644);
71MODULE_PARM_DESC(probe_wait_ms,
72 "Maximum time(ms) to wait for probe response"
73 " before disconnecting (reason 4).");
Jiri Bencf0706e82007-05-05 11:45:53 -070074
Jouni Malinen17e4ec12010-03-29 23:28:30 -070075/*
76 * Weight given to the latest Beacon frame when calculating average signal
77 * strength for Beacon frames received in the current BSS. This must be
78 * between 1 and 15.
79 */
80#define IEEE80211_SIGNAL_AVE_WEIGHT 3
81
Jouni Malinen391a2002010-08-27 22:22:00 +030082/*
83 * How many Beacon frames need to have been used in average signal strength
84 * before starting to indicate signal change events.
85 */
86#define IEEE80211_SIGNAL_AVE_MIN_COUNT 4
87
Johannes Berg5bb644a2009-05-17 11:40:42 +020088#define TMR_RUNNING_TIMER 0
89#define TMR_RUNNING_CHANSW 1
90
Johannes Berg5fef7db2012-02-24 13:50:52 +010091#define DEAUTH_DISASSOC_LEN (24 /* hdr */ + 2 /* reason */)
92
Johannes Berg77fdaa12009-07-07 03:45:17 +020093/*
94 * All cfg80211 functions have to be called outside a locked
95 * section so that they can acquire a lock themselves... This
96 * is much simpler than queuing up things in cfg80211, but we
97 * do need some indirection for that here.
98 */
99enum rx_mgmt_action {
100 /* no action required */
101 RX_MGMT_NONE,
102
Johannes Berg77fdaa12009-07-07 03:45:17 +0200103 /* caller must call cfg80211_send_deauth() */
104 RX_MGMT_CFG80211_DEAUTH,
105
106 /* caller must call cfg80211_send_disassoc() */
107 RX_MGMT_CFG80211_DISASSOC,
Johannes Berg66e67e42012-01-20 13:55:27 +0100108
109 /* caller must call cfg80211_send_rx_auth() */
110 RX_MGMT_CFG80211_RX_AUTH,
111
112 /* caller must call cfg80211_send_rx_assoc() */
113 RX_MGMT_CFG80211_RX_ASSOC,
114
115 /* caller must call cfg80211_send_assoc_timeout() */
116 RX_MGMT_CFG80211_ASSOC_TIMEOUT,
Johannes Berg77fdaa12009-07-07 03:45:17 +0200117};
118
Johannes Berg5484e232008-09-08 17:44:27 +0200119/* utils */
Johannes Berg77fdaa12009-07-07 03:45:17 +0200120static inline void ASSERT_MGD_MTX(struct ieee80211_if_managed *ifmgd)
121{
Johannes Berg46a5eba2010-09-15 13:28:15 +0200122 lockdep_assert_held(&ifmgd->mtx);
Johannes Berg77fdaa12009-07-07 03:45:17 +0200123}
124
Johannes Bergca386f32009-07-10 02:39:48 +0200125/*
126 * We can have multiple work items (and connection probing)
127 * scheduling this timer, but we need to take care to only
128 * reschedule it when it should fire _earlier_ than it was
129 * asked for before, or if it's not pending right now. This
130 * function ensures that. Note that it then is required to
131 * run this function for all timeouts after the first one
132 * has happened -- the work that runs from this timer will
133 * do that.
134 */
Johannes Berg66e67e42012-01-20 13:55:27 +0100135static void run_again(struct ieee80211_if_managed *ifmgd, unsigned long timeout)
Johannes Bergca386f32009-07-10 02:39:48 +0200136{
137 ASSERT_MGD_MTX(ifmgd);
138
139 if (!timer_pending(&ifmgd->timer) ||
140 time_before(timeout, ifmgd->timer.expires))
141 mod_timer(&ifmgd->timer, timeout);
142}
143
Luis R. Rodriguezd3a910a2010-09-16 15:12:32 -0400144void ieee80211_sta_reset_beacon_monitor(struct ieee80211_sub_if_data *sdata)
Johannes Bergb291ba12009-07-10 15:29:03 +0200145{
Johannes Bergc1288b12012-01-19 09:29:57 +0100146 if (sdata->vif.driver_flags & IEEE80211_VIF_BEACON_FILTER)
Johannes Bergb291ba12009-07-10 15:29:03 +0200147 return;
148
149 mod_timer(&sdata->u.mgd.bcn_mon_timer,
Felix Fietkau7ccc8bd2010-11-19 22:55:38 +0100150 round_jiffies_up(jiffies + sdata->u.mgd.beacon_timeout));
Johannes Bergb291ba12009-07-10 15:29:03 +0200151}
152
Luis R. Rodriguezbe099e82010-09-16 15:12:29 -0400153void ieee80211_sta_reset_conn_monitor(struct ieee80211_sub_if_data *sdata)
154{
Luis R. Rodriguez0c699c32010-09-16 15:12:30 -0400155 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
156
Stanislaw Gruszka86281722011-02-25 14:46:02 +0100157 if (unlikely(!sdata->u.mgd.associated))
158 return;
159
Luis R. Rodriguezbe099e82010-09-16 15:12:29 -0400160 if (sdata->local->hw.flags & IEEE80211_HW_CONNECTION_MONITOR)
161 return;
162
163 mod_timer(&sdata->u.mgd.conn_mon_timer,
164 round_jiffies_up(jiffies + IEEE80211_CONNECTION_IDLE_TIME));
Luis R. Rodriguez0c699c32010-09-16 15:12:30 -0400165
166 ifmgd->probe_send_count = 0;
Luis R. Rodriguezbe099e82010-09-16 15:12:29 -0400167}
168
Johannes Berg5484e232008-09-08 17:44:27 +0200169static int ecw2cw(int ecw)
Johannes Berg60f8b392008-09-08 17:44:22 +0200170{
Johannes Berg5484e232008-09-08 17:44:27 +0200171 return (1 << ecw) - 1;
Johannes Berg60f8b392008-09-08 17:44:22 +0200172}
173
Johannes Bergd5522e02009-03-30 13:23:35 +0200174/*
175 * ieee80211_enable_ht should be called only after the operating band
176 * has been determined as ht configuration depends on the hw's
177 * HT abilities for a specific band.
178 */
179static u32 ieee80211_enable_ht(struct ieee80211_sub_if_data *sdata,
180 struct ieee80211_ht_info *hti,
Rajkumar Manoharan7cc44ed2011-09-16 15:32:34 +0530181 const u8 *bssid, u16 ap_ht_cap_flags,
182 bool beacon_htcap_ie)
Johannes Bergd5522e02009-03-30 13:23:35 +0200183{
184 struct ieee80211_local *local = sdata->local;
185 struct ieee80211_supported_band *sband;
Johannes Bergd5522e02009-03-30 13:23:35 +0200186 struct sta_info *sta;
187 u32 changed = 0;
Ben Greear172710b2011-01-28 17:05:43 -0800188 int hti_cfreq;
Johannes Berg9ed6bcc2009-05-08 20:47:39 +0200189 u16 ht_opmode;
Johannes Berg0aaffa92010-05-05 15:28:27 +0200190 bool enable_ht = true;
191 enum nl80211_channel_type prev_chantype;
Paul Stewart3117bbdb2012-03-13 07:46:18 -0700192 enum nl80211_channel_type rx_channel_type = NL80211_CHAN_NO_HT;
193 enum nl80211_channel_type tx_channel_type;
Johannes Bergd5522e02009-03-30 13:23:35 +0200194
195 sband = local->hw.wiphy->bands[local->hw.conf.channel->band];
Johannes Berg0aaffa92010-05-05 15:28:27 +0200196 prev_chantype = sdata->vif.bss_conf.channel_type;
197
Johannes Bergd5522e02009-03-30 13:23:35 +0200198
Johannes Berg4e74bfd2012-03-08 15:02:04 +0100199 hti_cfreq = ieee80211_channel_to_frequency(hti->control_chan,
200 sband->band);
201 /* check that channel matches the right operating channel */
202 if (local->hw.conf.channel->center_freq != hti_cfreq) {
203 /* Some APs mess this up, evidently.
204 * Netgear WNDR3700 sometimes reports 4 higher than
205 * the actual channel, for instance.
206 */
207 printk(KERN_DEBUG
208 "%s: Wrong control channel in association"
209 " response: configured center-freq: %d"
210 " hti-cfreq: %d hti->control_chan: %d"
211 " band: %d. Disabling HT.\n",
212 sdata->name,
213 local->hw.conf.channel->center_freq,
214 hti_cfreq, hti->control_chan,
215 sband->band);
216 enable_ht = false;
Ben Greear172710b2011-01-28 17:05:43 -0800217 }
Johannes Bergd5522e02009-03-30 13:23:35 +0200218
219 if (enable_ht) {
Paul Stewart3117bbdb2012-03-13 07:46:18 -0700220 rx_channel_type = NL80211_CHAN_HT20;
Johannes Bergd5522e02009-03-30 13:23:35 +0200221
222 if (!(ap_ht_cap_flags & IEEE80211_HT_CAP_40MHZ_INTOLERANT) &&
Ben Greearef96a8422011-11-18 11:32:00 -0800223 !ieee80111_cfg_override_disables_ht40(sdata) &&
Johannes Bergd5522e02009-03-30 13:23:35 +0200224 (sband->ht_cap.cap & IEEE80211_HT_CAP_SUP_WIDTH_20_40) &&
225 (hti->ht_param & IEEE80211_HT_PARAM_CHAN_WIDTH_ANY)) {
226 switch(hti->ht_param & IEEE80211_HT_PARAM_CHA_SEC_OFFSET) {
227 case IEEE80211_HT_PARAM_CHA_SEC_ABOVE:
Paul Stewart3117bbdb2012-03-13 07:46:18 -0700228 rx_channel_type = NL80211_CHAN_HT40PLUS;
Johannes Bergd5522e02009-03-30 13:23:35 +0200229 break;
230 case IEEE80211_HT_PARAM_CHA_SEC_BELOW:
Paul Stewart3117bbdb2012-03-13 07:46:18 -0700231 rx_channel_type = NL80211_CHAN_HT40MINUS;
Johannes Bergd5522e02009-03-30 13:23:35 +0200232 break;
233 }
234 }
235 }
236
Paul Stewart3117bbdb2012-03-13 07:46:18 -0700237 tx_channel_type = ieee80211_get_tx_channel_type(local, rx_channel_type);
Johannes Bergd5522e02009-03-30 13:23:35 +0200238
Paul Stewart3117bbdb2012-03-13 07:46:18 -0700239 if (local->tmp_channel)
240 local->tmp_channel_type = rx_channel_type;
241
242 if (!ieee80211_set_channel_type(local, sdata, rx_channel_type)) {
Johannes Berg0aaffa92010-05-05 15:28:27 +0200243 /* can only fail due to HT40+/- mismatch */
Paul Stewart3117bbdb2012-03-13 07:46:18 -0700244 rx_channel_type = NL80211_CHAN_HT20;
245 WARN_ON(!ieee80211_set_channel_type(local, sdata,
246 rx_channel_type));
Johannes Berg0aaffa92010-05-05 15:28:27 +0200247 }
Johannes Bergd5522e02009-03-30 13:23:35 +0200248
Paul Stewart3117bbdb2012-03-13 07:46:18 -0700249 if (beacon_htcap_ie && (prev_chantype != rx_channel_type)) {
Rajkumar Manoharan7cc44ed2011-09-16 15:32:34 +0530250 /*
251 * Whenever the AP announces the HT mode change that can be
252 * 40MHz intolerant or etc., it would be safer to stop tx
253 * queues before doing hw config to avoid buffer overflow.
254 */
255 ieee80211_stop_queues_by_reason(&sdata->local->hw,
256 IEEE80211_QUEUE_STOP_REASON_CHTYPE_CHANGE);
257
258 /* flush out all packets */
259 synchronize_net();
260
261 drv_flush(local, false);
262 }
263
Johannes Berg0aaffa92010-05-05 15:28:27 +0200264 /* channel_type change automatically detected */
265 ieee80211_hw_config(local, 0);
266
Paul Stewart3117bbdb2012-03-13 07:46:18 -0700267 if (prev_chantype != tx_channel_type) {
Johannes Bergd5522e02009-03-30 13:23:35 +0200268 rcu_read_lock();
Johannes Bergabe60632009-11-25 17:46:18 +0100269 sta = sta_info_get(sdata, bssid);
Johannes Bergd5522e02009-03-30 13:23:35 +0200270 if (sta)
271 rate_control_rate_update(local, sband, sta,
Sujith4fa00432010-03-01 14:42:57 +0530272 IEEE80211_RC_HT_CHANGED,
Paul Stewart3117bbdb2012-03-13 07:46:18 -0700273 tx_channel_type);
Johannes Bergd5522e02009-03-30 13:23:35 +0200274 rcu_read_unlock();
Rajkumar Manoharan7cc44ed2011-09-16 15:32:34 +0530275
276 if (beacon_htcap_ie)
277 ieee80211_wake_queues_by_reason(&sdata->local->hw,
278 IEEE80211_QUEUE_STOP_REASON_CHTYPE_CHANGE);
Johannes Berg0aaffa92010-05-05 15:28:27 +0200279 }
Johannes Bergd5522e02009-03-30 13:23:35 +0200280
Johannes Berg9ed6bcc2009-05-08 20:47:39 +0200281 ht_opmode = le16_to_cpu(hti->operation_mode);
Johannes Bergd5522e02009-03-30 13:23:35 +0200282
283 /* if bss configuration changed store the new one */
Johannes Berg0aaffa92010-05-05 15:28:27 +0200284 if (sdata->ht_opmode_valid != enable_ht ||
285 sdata->vif.bss_conf.ht_operation_mode != ht_opmode ||
Paul Stewart3117bbdb2012-03-13 07:46:18 -0700286 prev_chantype != rx_channel_type) {
Johannes Bergd5522e02009-03-30 13:23:35 +0200287 changed |= BSS_CHANGED_HT;
Johannes Berg9ed6bcc2009-05-08 20:47:39 +0200288 sdata->vif.bss_conf.ht_operation_mode = ht_opmode;
Johannes Berg0aaffa92010-05-05 15:28:27 +0200289 sdata->ht_opmode_valid = enable_ht;
Johannes Bergd5522e02009-03-30 13:23:35 +0200290 }
291
292 return changed;
293}
294
Johannes Berg9c6bd792008-09-11 00:01:52 +0200295/* frame sending functions */
296
Johannes Berg66e67e42012-01-20 13:55:27 +0100297static int ieee80211_compatible_rates(const u8 *supp_rates, int supp_rates_len,
298 struct ieee80211_supported_band *sband,
299 u32 *rates)
300{
301 int i, j, count;
302 *rates = 0;
303 count = 0;
304 for (i = 0; i < supp_rates_len; i++) {
305 int rate = (supp_rates[i] & 0x7F) * 5;
306
307 for (j = 0; j < sband->n_bitrates; j++)
308 if (sband->bitrates[j].bitrate == rate) {
309 *rates |= BIT(j);
310 count++;
311 break;
312 }
313 }
314
315 return count;
316}
317
318static void ieee80211_add_ht_ie(struct ieee80211_sub_if_data *sdata,
319 struct sk_buff *skb, const u8 *ht_info_ie,
320 struct ieee80211_supported_band *sband,
321 struct ieee80211_channel *channel,
322 enum ieee80211_smps_mode smps)
323{
324 struct ieee80211_ht_info *ht_info;
325 u8 *pos;
326 u32 flags = channel->flags;
327 u16 cap;
328 struct ieee80211_sta_ht_cap ht_cap;
329
330 BUILD_BUG_ON(sizeof(ht_cap) != sizeof(sband->ht_cap));
331
Johannes Berg66e67e42012-01-20 13:55:27 +0100332 if (!ht_info_ie)
333 return;
334
335 if (ht_info_ie[1] < sizeof(struct ieee80211_ht_info))
336 return;
337
338 memcpy(&ht_cap, &sband->ht_cap, sizeof(ht_cap));
339 ieee80211_apply_htcap_overrides(sdata, &ht_cap);
340
341 ht_info = (struct ieee80211_ht_info *)(ht_info_ie + 2);
342
343 /* determine capability flags */
344 cap = ht_cap.cap;
345
346 switch (ht_info->ht_param & IEEE80211_HT_PARAM_CHA_SEC_OFFSET) {
347 case IEEE80211_HT_PARAM_CHA_SEC_ABOVE:
348 if (flags & IEEE80211_CHAN_NO_HT40PLUS) {
349 cap &= ~IEEE80211_HT_CAP_SUP_WIDTH_20_40;
350 cap &= ~IEEE80211_HT_CAP_SGI_40;
351 }
352 break;
353 case IEEE80211_HT_PARAM_CHA_SEC_BELOW:
354 if (flags & IEEE80211_CHAN_NO_HT40MINUS) {
355 cap &= ~IEEE80211_HT_CAP_SUP_WIDTH_20_40;
356 cap &= ~IEEE80211_HT_CAP_SGI_40;
357 }
358 break;
359 }
360
361 /* set SM PS mode properly */
362 cap &= ~IEEE80211_HT_CAP_SM_PS;
363 switch (smps) {
364 case IEEE80211_SMPS_AUTOMATIC:
365 case IEEE80211_SMPS_NUM_MODES:
366 WARN_ON(1);
367 case IEEE80211_SMPS_OFF:
368 cap |= WLAN_HT_CAP_SM_PS_DISABLED <<
369 IEEE80211_HT_CAP_SM_PS_SHIFT;
370 break;
371 case IEEE80211_SMPS_STATIC:
372 cap |= WLAN_HT_CAP_SM_PS_STATIC <<
373 IEEE80211_HT_CAP_SM_PS_SHIFT;
374 break;
375 case IEEE80211_SMPS_DYNAMIC:
376 cap |= WLAN_HT_CAP_SM_PS_DYNAMIC <<
377 IEEE80211_HT_CAP_SM_PS_SHIFT;
378 break;
379 }
380
381 /* reserve and fill IE */
382 pos = skb_put(skb, sizeof(struct ieee80211_ht_cap) + 2);
383 ieee80211_ie_build_ht_cap(pos, &ht_cap, cap);
384}
385
386static void ieee80211_send_assoc(struct ieee80211_sub_if_data *sdata)
387{
388 struct ieee80211_local *local = sdata->local;
389 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
390 struct ieee80211_mgd_assoc_data *assoc_data = ifmgd->assoc_data;
391 struct sk_buff *skb;
392 struct ieee80211_mgmt *mgmt;
393 u8 *pos, qos_info;
394 size_t offset = 0, noffset;
395 int i, count, rates_len, supp_rates_len;
396 u16 capab;
397 struct ieee80211_supported_band *sband;
398 u32 rates = 0;
Johannes Berg66e67e42012-01-20 13:55:27 +0100399
400 lockdep_assert_held(&ifmgd->mtx);
401
402 sband = local->hw.wiphy->bands[local->oper_channel->band];
403
404 if (assoc_data->supp_rates_len) {
405 /*
406 * Get all rates supported by the device and the AP as
407 * some APs don't like getting a superset of their rates
408 * in the association request (e.g. D-Link DAP 1353 in
409 * b-only mode)...
410 */
411 rates_len = ieee80211_compatible_rates(assoc_data->supp_rates,
412 assoc_data->supp_rates_len,
413 sband, &rates);
414 } else {
415 /*
416 * In case AP not provide any supported rates information
417 * before association, we send information element(s) with
418 * all rates that we support.
419 */
420 rates = ~0;
421 rates_len = sband->n_bitrates;
422 }
423
424 skb = alloc_skb(local->hw.extra_tx_headroom +
425 sizeof(*mgmt) + /* bit too much but doesn't matter */
426 2 + assoc_data->ssid_len + /* SSID */
427 4 + rates_len + /* (extended) rates */
428 4 + /* power capability */
429 2 + 2 * sband->n_channels + /* supported channels */
430 2 + sizeof(struct ieee80211_ht_cap) + /* HT */
431 assoc_data->ie_len + /* extra IEs */
432 9, /* WMM */
433 GFP_KERNEL);
434 if (!skb)
435 return;
436
437 skb_reserve(skb, local->hw.extra_tx_headroom);
438
439 capab = WLAN_CAPABILITY_ESS;
440
441 if (sband->band == IEEE80211_BAND_2GHZ) {
442 if (!(local->hw.flags & IEEE80211_HW_2GHZ_SHORT_SLOT_INCAPABLE))
443 capab |= WLAN_CAPABILITY_SHORT_SLOT_TIME;
444 if (!(local->hw.flags & IEEE80211_HW_2GHZ_SHORT_PREAMBLE_INCAPABLE))
445 capab |= WLAN_CAPABILITY_SHORT_PREAMBLE;
446 }
447
448 if (assoc_data->capability & WLAN_CAPABILITY_PRIVACY)
449 capab |= WLAN_CAPABILITY_PRIVACY;
450
451 if ((assoc_data->capability & WLAN_CAPABILITY_SPECTRUM_MGMT) &&
452 (local->hw.flags & IEEE80211_HW_SPECTRUM_MGMT))
453 capab |= WLAN_CAPABILITY_SPECTRUM_MGMT;
454
455 mgmt = (struct ieee80211_mgmt *) skb_put(skb, 24);
456 memset(mgmt, 0, 24);
457 memcpy(mgmt->da, assoc_data->bss->bssid, ETH_ALEN);
458 memcpy(mgmt->sa, sdata->vif.addr, ETH_ALEN);
459 memcpy(mgmt->bssid, assoc_data->bss->bssid, ETH_ALEN);
460
461 if (!is_zero_ether_addr(assoc_data->prev_bssid)) {
462 skb_put(skb, 10);
463 mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
464 IEEE80211_STYPE_REASSOC_REQ);
465 mgmt->u.reassoc_req.capab_info = cpu_to_le16(capab);
466 mgmt->u.reassoc_req.listen_interval =
467 cpu_to_le16(local->hw.conf.listen_interval);
468 memcpy(mgmt->u.reassoc_req.current_ap, assoc_data->prev_bssid,
469 ETH_ALEN);
470 } else {
471 skb_put(skb, 4);
472 mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
473 IEEE80211_STYPE_ASSOC_REQ);
474 mgmt->u.assoc_req.capab_info = cpu_to_le16(capab);
475 mgmt->u.assoc_req.listen_interval =
476 cpu_to_le16(local->hw.conf.listen_interval);
477 }
478
479 /* SSID */
480 pos = skb_put(skb, 2 + assoc_data->ssid_len);
481 *pos++ = WLAN_EID_SSID;
482 *pos++ = assoc_data->ssid_len;
483 memcpy(pos, assoc_data->ssid, assoc_data->ssid_len);
484
485 /* add all rates which were marked to be used above */
486 supp_rates_len = rates_len;
487 if (supp_rates_len > 8)
488 supp_rates_len = 8;
489
490 pos = skb_put(skb, supp_rates_len + 2);
491 *pos++ = WLAN_EID_SUPP_RATES;
492 *pos++ = supp_rates_len;
493
494 count = 0;
495 for (i = 0; i < sband->n_bitrates; i++) {
496 if (BIT(i) & rates) {
497 int rate = sband->bitrates[i].bitrate;
498 *pos++ = (u8) (rate / 5);
499 if (++count == 8)
500 break;
501 }
502 }
503
504 if (rates_len > count) {
505 pos = skb_put(skb, rates_len - count + 2);
506 *pos++ = WLAN_EID_EXT_SUPP_RATES;
507 *pos++ = rates_len - count;
508
509 for (i++; i < sband->n_bitrates; i++) {
510 if (BIT(i) & rates) {
511 int rate = sband->bitrates[i].bitrate;
512 *pos++ = (u8) (rate / 5);
513 }
514 }
515 }
516
517 if (capab & WLAN_CAPABILITY_SPECTRUM_MGMT) {
518 /* 1. power capabilities */
519 pos = skb_put(skb, 4);
520 *pos++ = WLAN_EID_PWR_CAPABILITY;
521 *pos++ = 2;
522 *pos++ = 0; /* min tx power */
523 *pos++ = local->oper_channel->max_power; /* max tx power */
524
525 /* 2. supported channels */
526 /* TODO: get this in reg domain format */
527 pos = skb_put(skb, 2 * sband->n_channels + 2);
528 *pos++ = WLAN_EID_SUPPORTED_CHANNELS;
529 *pos++ = 2 * sband->n_channels;
530 for (i = 0; i < sband->n_channels; i++) {
531 *pos++ = ieee80211_frequency_to_channel(
532 sband->channels[i].center_freq);
533 *pos++ = 1; /* one channel in the subband*/
534 }
535 }
536
537 /* if present, add any custom IEs that go before HT */
538 if (assoc_data->ie_len && assoc_data->ie) {
539 static const u8 before_ht[] = {
540 WLAN_EID_SSID,
541 WLAN_EID_SUPP_RATES,
542 WLAN_EID_EXT_SUPP_RATES,
543 WLAN_EID_PWR_CAPABILITY,
544 WLAN_EID_SUPPORTED_CHANNELS,
545 WLAN_EID_RSN,
546 WLAN_EID_QOS_CAPA,
547 WLAN_EID_RRM_ENABLED_CAPABILITIES,
548 WLAN_EID_MOBILITY_DOMAIN,
549 WLAN_EID_SUPPORTED_REGULATORY_CLASSES,
550 };
551 noffset = ieee80211_ie_split(assoc_data->ie, assoc_data->ie_len,
552 before_ht, ARRAY_SIZE(before_ht),
553 offset);
554 pos = skb_put(skb, noffset - offset);
555 memcpy(pos, assoc_data->ie + offset, noffset - offset);
556 offset = noffset;
557 }
558
Johannes Berg4e74bfd2012-03-08 15:02:04 +0100559 if (!(ifmgd->flags & IEEE80211_STA_DISABLE_11N))
Johannes Berg66e67e42012-01-20 13:55:27 +0100560 ieee80211_add_ht_ie(sdata, skb, assoc_data->ht_information_ie,
561 sband, local->oper_channel, ifmgd->ap_smps);
562
563 /* if present, add any custom non-vendor IEs that go after HT */
564 if (assoc_data->ie_len && assoc_data->ie) {
565 noffset = ieee80211_ie_split_vendor(assoc_data->ie,
566 assoc_data->ie_len,
567 offset);
568 pos = skb_put(skb, noffset - offset);
569 memcpy(pos, assoc_data->ie + offset, noffset - offset);
570 offset = noffset;
571 }
572
Johannes Berg76f03032012-03-08 15:02:05 +0100573 if (assoc_data->wmm) {
574 if (assoc_data->uapsd) {
Eliad Pellerdc41e4d2012-03-14 16:15:03 +0200575 qos_info = ifmgd->uapsd_queues;
576 qos_info |= (ifmgd->uapsd_max_sp_len <<
Johannes Berg66e67e42012-01-20 13:55:27 +0100577 IEEE80211_WMM_IE_STA_QOSINFO_SP_SHIFT);
578 } else {
579 qos_info = 0;
580 }
581
582 pos = skb_put(skb, 9);
583 *pos++ = WLAN_EID_VENDOR_SPECIFIC;
584 *pos++ = 7; /* len */
585 *pos++ = 0x00; /* Microsoft OUI 00:50:F2 */
586 *pos++ = 0x50;
587 *pos++ = 0xf2;
588 *pos++ = 2; /* WME */
589 *pos++ = 0; /* WME info */
590 *pos++ = 1; /* WME ver */
591 *pos++ = qos_info;
592 }
593
594 /* add any remaining custom (i.e. vendor specific here) IEs */
595 if (assoc_data->ie_len && assoc_data->ie) {
596 noffset = assoc_data->ie_len;
597 pos = skb_put(skb, noffset - offset);
598 memcpy(pos, assoc_data->ie + offset, noffset - offset);
599 }
600
601 IEEE80211_SKB_CB(skb)->flags |= IEEE80211_TX_INTFL_DONT_ENCRYPT;
602 ieee80211_tx_skb(sdata, skb);
603}
604
Johannes Bergef422bc2008-09-09 10:58:25 +0200605static void ieee80211_send_deauth_disassoc(struct ieee80211_sub_if_data *sdata,
Johannes Berg63c9c5e2012-02-24 13:50:51 +0100606 const u8 *bssid, u16 stype,
Johannes Berg5fef7db2012-02-24 13:50:52 +0100607 u16 reason, bool send_frame,
608 u8 *frame_buf)
Johannes Berg9ac19a92008-09-09 10:57:09 +0200609{
610 struct ieee80211_local *local = sdata->local;
Johannes Berg46900292009-02-15 12:44:28 +0100611 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
Johannes Berg9ac19a92008-09-09 10:57:09 +0200612 struct sk_buff *skb;
Johannes Berg5fef7db2012-02-24 13:50:52 +0100613 struct ieee80211_mgmt *mgmt = (void *)frame_buf;
Johannes Berg9ac19a92008-09-09 10:57:09 +0200614
Johannes Berg5fef7db2012-02-24 13:50:52 +0100615 /* build frame */
616 mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT | stype);
617 mgmt->duration = 0; /* initialize only */
618 mgmt->seq_ctrl = 0; /* initialize only */
Johannes Berg77fdaa12009-07-07 03:45:17 +0200619 memcpy(mgmt->da, bssid, ETH_ALEN);
Johannes Berg47846c92009-11-25 17:46:19 +0100620 memcpy(mgmt->sa, sdata->vif.addr, ETH_ALEN);
Johannes Berg77fdaa12009-07-07 03:45:17 +0200621 memcpy(mgmt->bssid, bssid, ETH_ALEN);
Johannes Bergef422bc2008-09-09 10:58:25 +0200622 /* u.deauth.reason_code == u.disassoc.reason_code */
Johannes Berg9ac19a92008-09-09 10:57:09 +0200623 mgmt->u.deauth.reason_code = cpu_to_le16(reason);
624
Johannes Berg5fef7db2012-02-24 13:50:52 +0100625 if (send_frame) {
626 skb = dev_alloc_skb(local->hw.extra_tx_headroom +
627 DEAUTH_DISASSOC_LEN);
628 if (!skb)
629 return;
Jouni Malinend5cdfac2010-04-04 09:37:19 +0300630
Johannes Berg5fef7db2012-02-24 13:50:52 +0100631 skb_reserve(skb, local->hw.extra_tx_headroom);
632
633 /* copy in frame */
634 memcpy(skb_put(skb, DEAUTH_DISASSOC_LEN),
635 mgmt, DEAUTH_DISASSOC_LEN);
636
637 if (!(ifmgd->flags & IEEE80211_STA_MFP_ENABLED))
638 IEEE80211_SKB_CB(skb)->flags |=
639 IEEE80211_TX_INTFL_DONT_ENCRYPT;
Jouni Malinend5cdfac2010-04-04 09:37:19 +0300640 ieee80211_tx_skb(sdata, skb);
Johannes Berg5fef7db2012-02-24 13:50:52 +0100641 }
Johannes Berg9ac19a92008-09-09 10:57:09 +0200642}
643
Kalle Valo572e0012009-02-10 17:09:31 +0200644void ieee80211_send_pspoll(struct ieee80211_local *local,
645 struct ieee80211_sub_if_data *sdata)
646{
Kalle Valo572e0012009-02-10 17:09:31 +0200647 struct ieee80211_pspoll *pspoll;
648 struct sk_buff *skb;
Kalle Valo572e0012009-02-10 17:09:31 +0200649
Kalle Valod8cd1892010-01-05 20:16:26 +0200650 skb = ieee80211_pspoll_get(&local->hw, &sdata->vif);
651 if (!skb)
Kalle Valo572e0012009-02-10 17:09:31 +0200652 return;
Kalle Valo572e0012009-02-10 17:09:31 +0200653
Kalle Valod8cd1892010-01-05 20:16:26 +0200654 pspoll = (struct ieee80211_pspoll *) skb->data;
655 pspoll->frame_control |= cpu_to_le16(IEEE80211_FCTL_PM);
Kalle Valo572e0012009-02-10 17:09:31 +0200656
Johannes Berg62ae67b2009-11-18 18:42:05 +0100657 IEEE80211_SKB_CB(skb)->flags |= IEEE80211_TX_INTFL_DONT_ENCRYPT;
658 ieee80211_tx_skb(sdata, skb);
Kalle Valo572e0012009-02-10 17:09:31 +0200659}
660
Johannes Berg965beda2009-04-16 13:17:24 +0200661void ieee80211_send_nullfunc(struct ieee80211_local *local,
662 struct ieee80211_sub_if_data *sdata,
663 int powersave)
664{
665 struct sk_buff *skb;
Kalle Valod8cd1892010-01-05 20:16:26 +0200666 struct ieee80211_hdr_3addr *nullfunc;
Rajkumar Manoharanb6f35302011-09-29 20:34:04 +0530667 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
Johannes Berg965beda2009-04-16 13:17:24 +0200668
Kalle Valod8cd1892010-01-05 20:16:26 +0200669 skb = ieee80211_nullfunc_get(&local->hw, &sdata->vif);
670 if (!skb)
Johannes Berg965beda2009-04-16 13:17:24 +0200671 return;
672
Kalle Valod8cd1892010-01-05 20:16:26 +0200673 nullfunc = (struct ieee80211_hdr_3addr *) skb->data;
Johannes Berg965beda2009-04-16 13:17:24 +0200674 if (powersave)
Kalle Valod8cd1892010-01-05 20:16:26 +0200675 nullfunc->frame_control |= cpu_to_le16(IEEE80211_FCTL_PM);
Johannes Berg965beda2009-04-16 13:17:24 +0200676
Johannes Berg62ae67b2009-11-18 18:42:05 +0100677 IEEE80211_SKB_CB(skb)->flags |= IEEE80211_TX_INTFL_DONT_ENCRYPT;
Rajkumar Manoharanb6f35302011-09-29 20:34:04 +0530678 if (ifmgd->flags & (IEEE80211_STA_BEACON_POLL |
679 IEEE80211_STA_CONNECTION_POLL))
680 IEEE80211_SKB_CB(skb)->flags |= IEEE80211_TX_CTL_USE_MINRATE;
681
Johannes Berg62ae67b2009-11-18 18:42:05 +0100682 ieee80211_tx_skb(sdata, skb);
Johannes Berg965beda2009-04-16 13:17:24 +0200683}
684
Felix Fietkaud5242152010-01-08 18:06:26 +0100685static void ieee80211_send_4addr_nullfunc(struct ieee80211_local *local,
686 struct ieee80211_sub_if_data *sdata)
687{
688 struct sk_buff *skb;
689 struct ieee80211_hdr *nullfunc;
690 __le16 fc;
691
692 if (WARN_ON(sdata->vif.type != NL80211_IFTYPE_STATION))
693 return;
694
695 skb = dev_alloc_skb(local->hw.extra_tx_headroom + 30);
Joe Perchesd15b8452011-08-29 14:17:31 -0700696 if (!skb)
Felix Fietkaud5242152010-01-08 18:06:26 +0100697 return;
Joe Perchesd15b8452011-08-29 14:17:31 -0700698
Felix Fietkaud5242152010-01-08 18:06:26 +0100699 skb_reserve(skb, local->hw.extra_tx_headroom);
700
701 nullfunc = (struct ieee80211_hdr *) skb_put(skb, 30);
702 memset(nullfunc, 0, 30);
703 fc = cpu_to_le16(IEEE80211_FTYPE_DATA | IEEE80211_STYPE_NULLFUNC |
704 IEEE80211_FCTL_FROMDS | IEEE80211_FCTL_TODS);
705 nullfunc->frame_control = fc;
706 memcpy(nullfunc->addr1, sdata->u.mgd.bssid, ETH_ALEN);
707 memcpy(nullfunc->addr2, sdata->vif.addr, ETH_ALEN);
708 memcpy(nullfunc->addr3, sdata->u.mgd.bssid, ETH_ALEN);
709 memcpy(nullfunc->addr4, sdata->vif.addr, ETH_ALEN);
710
711 IEEE80211_SKB_CB(skb)->flags |= IEEE80211_TX_INTFL_DONT_ENCRYPT;
712 ieee80211_tx_skb(sdata, skb);
713}
714
Johannes Bergcc32abd2009-05-15 11:52:31 +0200715/* spectrum management related things */
716static void ieee80211_chswitch_work(struct work_struct *work)
717{
718 struct ieee80211_sub_if_data *sdata =
719 container_of(work, struct ieee80211_sub_if_data, u.mgd.chswitch_work);
Johannes Bergcc32abd2009-05-15 11:52:31 +0200720 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
721
Johannes Berg9607e6b2009-12-23 13:15:31 +0100722 if (!ieee80211_sdata_running(sdata))
Johannes Bergcc32abd2009-05-15 11:52:31 +0200723 return;
724
Johannes Berg77fdaa12009-07-07 03:45:17 +0200725 mutex_lock(&ifmgd->mtx);
726 if (!ifmgd->associated)
727 goto out;
Johannes Bergcc32abd2009-05-15 11:52:31 +0200728
729 sdata->local->oper_channel = sdata->local->csa_channel;
Johannes Berg5ce6e432010-05-11 16:20:57 +0200730 if (!sdata->local->ops->channel_switch) {
731 /* call "hw_config" only if doing sw channel switch */
732 ieee80211_hw_config(sdata->local,
733 IEEE80211_CONF_CHANGE_CHANNEL);
Shahar Levi1ea57b12011-09-08 08:44:05 +0300734 } else {
735 /* update the device channel directly */
736 sdata->local->hw.conf.channel = sdata->local->oper_channel;
Johannes Berg5ce6e432010-05-11 16:20:57 +0200737 }
Johannes Bergcc32abd2009-05-15 11:52:31 +0200738
Johannes Berg77fdaa12009-07-07 03:45:17 +0200739 /* XXX: shouldn't really modify cfg80211-owned data! */
Johannes Berg0c1ad2c2009-12-23 13:15:39 +0100740 ifmgd->associated->channel = sdata->local->oper_channel;
Johannes Berg77fdaa12009-07-07 03:45:17 +0200741
Johannes Bergcc32abd2009-05-15 11:52:31 +0200742 ieee80211_wake_queues_by_reason(&sdata->local->hw,
743 IEEE80211_QUEUE_STOP_REASON_CSA);
Johannes Berg77fdaa12009-07-07 03:45:17 +0200744 out:
745 ifmgd->flags &= ~IEEE80211_STA_CSA_RECEIVED;
746 mutex_unlock(&ifmgd->mtx);
Johannes Bergcc32abd2009-05-15 11:52:31 +0200747}
748
Johannes Berg5ce6e432010-05-11 16:20:57 +0200749void ieee80211_chswitch_done(struct ieee80211_vif *vif, bool success)
750{
751 struct ieee80211_sub_if_data *sdata;
752 struct ieee80211_if_managed *ifmgd;
753
754 sdata = vif_to_sdata(vif);
755 ifmgd = &sdata->u.mgd;
756
757 trace_api_chswitch_done(sdata, success);
758 if (!success) {
759 /*
760 * If the channel switch was not successful, stay
761 * around on the old channel. We currently lack
762 * good handling of this situation, possibly we
763 * should just drop the association.
764 */
765 sdata->local->csa_channel = sdata->local->oper_channel;
766 }
767
768 ieee80211_queue_work(&sdata->local->hw, &ifmgd->chswitch_work);
769}
770EXPORT_SYMBOL(ieee80211_chswitch_done);
771
Johannes Bergcc32abd2009-05-15 11:52:31 +0200772static void ieee80211_chswitch_timer(unsigned long data)
773{
774 struct ieee80211_sub_if_data *sdata =
775 (struct ieee80211_sub_if_data *) data;
776 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
777
Johannes Berg5bb644a2009-05-17 11:40:42 +0200778 if (sdata->local->quiescing) {
779 set_bit(TMR_RUNNING_CHANSW, &ifmgd->timers_running);
780 return;
781 }
782
Luis R. Rodriguez42935ec2009-07-29 20:08:07 -0400783 ieee80211_queue_work(&sdata->local->hw, &ifmgd->chswitch_work);
Johannes Bergcc32abd2009-05-15 11:52:31 +0200784}
785
786void ieee80211_sta_process_chanswitch(struct ieee80211_sub_if_data *sdata,
787 struct ieee80211_channel_sw_ie *sw_elem,
Johannes Berg5ce6e432010-05-11 16:20:57 +0200788 struct ieee80211_bss *bss,
789 u64 timestamp)
Johannes Bergcc32abd2009-05-15 11:52:31 +0200790{
Johannes Berg0c1ad2c2009-12-23 13:15:39 +0100791 struct cfg80211_bss *cbss =
792 container_of((void *)bss, struct cfg80211_bss, priv);
Johannes Bergcc32abd2009-05-15 11:52:31 +0200793 struct ieee80211_channel *new_ch;
794 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
Bruno Randolf59eb21a2011-01-17 13:37:28 +0900795 int new_freq = ieee80211_channel_to_frequency(sw_elem->new_ch_num,
796 cbss->channel->band);
Johannes Bergcc32abd2009-05-15 11:52:31 +0200797
Johannes Berg77fdaa12009-07-07 03:45:17 +0200798 ASSERT_MGD_MTX(ifmgd);
799
800 if (!ifmgd->associated)
Johannes Bergcc32abd2009-05-15 11:52:31 +0200801 return;
802
Helmut Schaafbe9c422009-07-23 12:14:04 +0200803 if (sdata->local->scanning)
Johannes Bergcc32abd2009-05-15 11:52:31 +0200804 return;
805
806 /* Disregard subsequent beacons if we are already running a timer
807 processing a CSA */
808
809 if (ifmgd->flags & IEEE80211_STA_CSA_RECEIVED)
810 return;
811
812 new_ch = ieee80211_get_channel(sdata->local->hw.wiphy, new_freq);
813 if (!new_ch || new_ch->flags & IEEE80211_CHAN_DISABLED)
814 return;
815
816 sdata->local->csa_channel = new_ch;
817
Johannes Berg5ce6e432010-05-11 16:20:57 +0200818 if (sdata->local->ops->channel_switch) {
819 /* use driver's channel switch callback */
820 struct ieee80211_channel_switch ch_switch;
821 memset(&ch_switch, 0, sizeof(ch_switch));
822 ch_switch.timestamp = timestamp;
823 if (sw_elem->mode) {
824 ch_switch.block_tx = true;
825 ieee80211_stop_queues_by_reason(&sdata->local->hw,
826 IEEE80211_QUEUE_STOP_REASON_CSA);
827 }
828 ch_switch.channel = new_ch;
829 ch_switch.count = sw_elem->count;
830 ifmgd->flags |= IEEE80211_STA_CSA_RECEIVED;
831 drv_channel_switch(sdata->local, &ch_switch);
832 return;
833 }
834
835 /* channel switch handled in software */
Johannes Bergcc32abd2009-05-15 11:52:31 +0200836 if (sw_elem->count <= 1) {
Luis R. Rodriguez42935ec2009-07-29 20:08:07 -0400837 ieee80211_queue_work(&sdata->local->hw, &ifmgd->chswitch_work);
Johannes Bergcc32abd2009-05-15 11:52:31 +0200838 } else {
Wey-Yi Guy9feaddc2010-05-05 20:34:02 -0700839 if (sw_elem->mode)
840 ieee80211_stop_queues_by_reason(&sdata->local->hw,
Johannes Bergcc32abd2009-05-15 11:52:31 +0200841 IEEE80211_QUEUE_STOP_REASON_CSA);
842 ifmgd->flags |= IEEE80211_STA_CSA_RECEIVED;
843 mod_timer(&ifmgd->chswitch_timer,
844 jiffies +
845 msecs_to_jiffies(sw_elem->count *
Johannes Berg0c1ad2c2009-12-23 13:15:39 +0100846 cbss->beacon_interval));
Johannes Bergcc32abd2009-05-15 11:52:31 +0200847 }
848}
849
850static void ieee80211_handle_pwr_constr(struct ieee80211_sub_if_data *sdata,
851 u16 capab_info, u8 *pwr_constr_elem,
852 u8 pwr_constr_elem_len)
853{
854 struct ieee80211_conf *conf = &sdata->local->hw.conf;
855
856 if (!(capab_info & WLAN_CAPABILITY_SPECTRUM_MGMT))
857 return;
858
859 /* Power constraint IE length should be 1 octet */
860 if (pwr_constr_elem_len != 1)
861 return;
862
Hong Wua48b13a2012-01-11 20:34:30 +0200863 if ((*pwr_constr_elem <= conf->channel->max_reg_power) &&
Johannes Bergcc32abd2009-05-15 11:52:31 +0200864 (*pwr_constr_elem != sdata->local->power_constr_level)) {
865 sdata->local->power_constr_level = *pwr_constr_elem;
866 ieee80211_hw_config(sdata->local, 0);
867 }
868}
869
Juuso Oikarinenf90754c2010-06-21 08:59:39 +0300870void ieee80211_enable_dyn_ps(struct ieee80211_vif *vif)
871{
872 struct ieee80211_sub_if_data *sdata = vif_to_sdata(vif);
873 struct ieee80211_local *local = sdata->local;
874 struct ieee80211_conf *conf = &local->hw.conf;
875
876 WARN_ON(sdata->vif.type != NL80211_IFTYPE_STATION ||
877 !(local->hw.flags & IEEE80211_HW_SUPPORTS_PS) ||
878 (local->hw.flags & IEEE80211_HW_SUPPORTS_DYNAMIC_PS));
879
880 local->disable_dynamic_ps = false;
881 conf->dynamic_ps_timeout = local->dynamic_ps_user_timeout;
882}
883EXPORT_SYMBOL(ieee80211_enable_dyn_ps);
884
885void ieee80211_disable_dyn_ps(struct ieee80211_vif *vif)
886{
887 struct ieee80211_sub_if_data *sdata = vif_to_sdata(vif);
888 struct ieee80211_local *local = sdata->local;
889 struct ieee80211_conf *conf = &local->hw.conf;
890
891 WARN_ON(sdata->vif.type != NL80211_IFTYPE_STATION ||
892 !(local->hw.flags & IEEE80211_HW_SUPPORTS_PS) ||
893 (local->hw.flags & IEEE80211_HW_SUPPORTS_DYNAMIC_PS));
894
895 local->disable_dynamic_ps = true;
896 conf->dynamic_ps_timeout = 0;
897 del_timer_sync(&local->dynamic_ps_timer);
898 ieee80211_queue_work(&local->hw,
899 &local->dynamic_ps_enable_work);
900}
901EXPORT_SYMBOL(ieee80211_disable_dyn_ps);
902
Johannes Berg965beda2009-04-16 13:17:24 +0200903/* powersave */
904static void ieee80211_enable_ps(struct ieee80211_local *local,
905 struct ieee80211_sub_if_data *sdata)
906{
907 struct ieee80211_conf *conf = &local->hw.conf;
908
Johannes Bergd5edaed2009-04-22 23:02:51 +0200909 /*
910 * If we are scanning right now then the parameters will
911 * take effect when scan finishes.
912 */
Helmut Schaafbe9c422009-07-23 12:14:04 +0200913 if (local->scanning)
Johannes Bergd5edaed2009-04-22 23:02:51 +0200914 return;
915
Johannes Berg965beda2009-04-16 13:17:24 +0200916 if (conf->dynamic_ps_timeout > 0 &&
917 !(local->hw.flags & IEEE80211_HW_SUPPORTS_DYNAMIC_PS)) {
918 mod_timer(&local->dynamic_ps_timer, jiffies +
919 msecs_to_jiffies(conf->dynamic_ps_timeout));
920 } else {
921 if (local->hw.flags & IEEE80211_HW_PS_NULLFUNC_STACK)
922 ieee80211_send_nullfunc(local, sdata, 1);
Vivek Natarajan375177b2010-02-09 14:50:28 +0530923
Juuso Oikarinen2a130522010-03-09 14:25:02 +0200924 if ((local->hw.flags & IEEE80211_HW_PS_NULLFUNC_STACK) &&
925 (local->hw.flags & IEEE80211_HW_REPORTS_TX_ACK_STATUS))
926 return;
927
928 conf->flags |= IEEE80211_CONF_PS;
929 ieee80211_hw_config(local, IEEE80211_CONF_CHANGE_PS);
Johannes Berg965beda2009-04-16 13:17:24 +0200930 }
931}
932
933static void ieee80211_change_ps(struct ieee80211_local *local)
934{
935 struct ieee80211_conf *conf = &local->hw.conf;
936
937 if (local->ps_sdata) {
Johannes Berg965beda2009-04-16 13:17:24 +0200938 ieee80211_enable_ps(local, local->ps_sdata);
939 } else if (conf->flags & IEEE80211_CONF_PS) {
940 conf->flags &= ~IEEE80211_CONF_PS;
941 ieee80211_hw_config(local, IEEE80211_CONF_CHANGE_PS);
942 del_timer_sync(&local->dynamic_ps_timer);
943 cancel_work_sync(&local->dynamic_ps_enable_work);
944 }
945}
946
Jason Young808118c2011-03-10 16:43:19 -0800947static bool ieee80211_powersave_allowed(struct ieee80211_sub_if_data *sdata)
948{
949 struct ieee80211_if_managed *mgd = &sdata->u.mgd;
950 struct sta_info *sta = NULL;
Johannes Bergc2c98fd2011-09-29 16:04:36 +0200951 bool authorized = false;
Jason Young808118c2011-03-10 16:43:19 -0800952
953 if (!mgd->powersave)
954 return false;
955
Johannes Berg05cb9102011-10-28 11:59:47 +0200956 if (mgd->broken_ap)
957 return false;
958
Jason Young808118c2011-03-10 16:43:19 -0800959 if (!mgd->associated)
960 return false;
961
962 if (!mgd->associated->beacon_ies)
963 return false;
964
965 if (mgd->flags & (IEEE80211_STA_BEACON_POLL |
966 IEEE80211_STA_CONNECTION_POLL))
967 return false;
968
969 rcu_read_lock();
970 sta = sta_info_get(sdata, mgd->bssid);
971 if (sta)
Johannes Bergc2c98fd2011-09-29 16:04:36 +0200972 authorized = test_sta_flag(sta, WLAN_STA_AUTHORIZED);
Jason Young808118c2011-03-10 16:43:19 -0800973 rcu_read_unlock();
974
Johannes Bergc2c98fd2011-09-29 16:04:36 +0200975 return authorized;
Jason Young808118c2011-03-10 16:43:19 -0800976}
977
Johannes Berg965beda2009-04-16 13:17:24 +0200978/* need to hold RTNL or interface lock */
Johannes Berg10f644a2009-04-16 13:17:25 +0200979void ieee80211_recalc_ps(struct ieee80211_local *local, s32 latency)
Johannes Berg965beda2009-04-16 13:17:24 +0200980{
981 struct ieee80211_sub_if_data *sdata, *found = NULL;
982 int count = 0;
Juuso Oikarinen195e2942010-04-27 12:47:40 +0300983 int timeout;
Johannes Berg965beda2009-04-16 13:17:24 +0200984
985 if (!(local->hw.flags & IEEE80211_HW_SUPPORTS_PS)) {
986 local->ps_sdata = NULL;
987 return;
988 }
989
Johannes Bergaf6b6372009-12-23 13:15:35 +0100990 if (!list_empty(&local->work_list)) {
991 local->ps_sdata = NULL;
992 goto change;
993 }
994
Johannes Berg965beda2009-04-16 13:17:24 +0200995 list_for_each_entry(sdata, &local->interfaces, list) {
Johannes Berg9607e6b2009-12-23 13:15:31 +0100996 if (!ieee80211_sdata_running(sdata))
Johannes Berg965beda2009-04-16 13:17:24 +0200997 continue;
Rajkumar Manoharan8c7914d2011-02-01 00:28:59 +0530998 if (sdata->vif.type == NL80211_IFTYPE_AP) {
999 /* If an AP vif is found, then disable PS
1000 * by setting the count to zero thereby setting
1001 * ps_sdata to NULL.
1002 */
1003 count = 0;
1004 break;
1005 }
Johannes Berg965beda2009-04-16 13:17:24 +02001006 if (sdata->vif.type != NL80211_IFTYPE_STATION)
1007 continue;
1008 found = sdata;
1009 count++;
1010 }
1011
Jason Young808118c2011-03-10 16:43:19 -08001012 if (count == 1 && ieee80211_powersave_allowed(found)) {
Juuso Oikarinenf90754c2010-06-21 08:59:39 +03001013 struct ieee80211_conf *conf = &local->hw.conf;
Johannes Berg10f644a2009-04-16 13:17:25 +02001014 s32 beaconint_us;
1015
1016 if (latency < 0)
Mark Grossed771342010-05-06 01:59:26 +02001017 latency = pm_qos_request(PM_QOS_NETWORK_LATENCY);
Johannes Berg10f644a2009-04-16 13:17:25 +02001018
1019 beaconint_us = ieee80211_tu_to_usec(
1020 found->vif.bss_conf.beacon_int);
1021
Juuso Oikarinenff616382010-06-09 09:51:52 +03001022 timeout = local->dynamic_ps_forced_timeout;
Juuso Oikarinen195e2942010-04-27 12:47:40 +03001023 if (timeout < 0) {
1024 /*
Juuso Oikarinenff616382010-06-09 09:51:52 +03001025 * Go to full PSM if the user configures a very low
1026 * latency requirement.
Eliad Peller0ab82b02010-12-03 02:16:23 +02001027 * The 2000 second value is there for compatibility
1028 * until the PM_QOS_NETWORK_LATENCY is configured
1029 * with real values.
Juuso Oikarinen195e2942010-04-27 12:47:40 +03001030 */
Eliad Peller0ab82b02010-12-03 02:16:23 +02001031 if (latency > (1900 * USEC_PER_MSEC) &&
1032 latency != (2000 * USEC_PER_SEC))
Juuso Oikarinen195e2942010-04-27 12:47:40 +03001033 timeout = 0;
Juuso Oikarinenff616382010-06-09 09:51:52 +03001034 else
1035 timeout = 100;
Juuso Oikarinen195e2942010-04-27 12:47:40 +03001036 }
Juuso Oikarinenf90754c2010-06-21 08:59:39 +03001037 local->dynamic_ps_user_timeout = timeout;
1038 if (!local->disable_dynamic_ps)
1039 conf->dynamic_ps_timeout =
1040 local->dynamic_ps_user_timeout;
Juuso Oikarinen195e2942010-04-27 12:47:40 +03001041
Johannes Berg04fe2032009-04-22 18:44:37 +02001042 if (beaconint_us > latency) {
Johannes Berg10f644a2009-04-16 13:17:25 +02001043 local->ps_sdata = NULL;
Johannes Berg04fe2032009-04-22 18:44:37 +02001044 } else {
Johannes Berg56007a02010-01-26 14:19:52 +01001045 struct ieee80211_bss *bss;
Johannes Berg04fe2032009-04-22 18:44:37 +02001046 int maxslp = 1;
Johannes Berg56007a02010-01-26 14:19:52 +01001047 u8 dtimper;
Johannes Berg04fe2032009-04-22 18:44:37 +02001048
Johannes Berg56007a02010-01-26 14:19:52 +01001049 bss = (void *)found->u.mgd.associated->priv;
1050 dtimper = bss->dtim_period;
1051
1052 /* If the TIM IE is invalid, pretend the value is 1 */
1053 if (!dtimper)
1054 dtimper = 1;
1055 else if (dtimper > 1)
Johannes Berg04fe2032009-04-22 18:44:37 +02001056 maxslp = min_t(int, dtimper,
1057 latency / beaconint_us);
1058
Johannes Berg9ccebe62009-04-23 10:32:36 +02001059 local->hw.conf.max_sleep_period = maxslp;
Johannes Berg56007a02010-01-26 14:19:52 +01001060 local->hw.conf.ps_dtim_period = dtimper;
Johannes Berg10f644a2009-04-16 13:17:25 +02001061 local->ps_sdata = found;
Johannes Berg04fe2032009-04-22 18:44:37 +02001062 }
Johannes Berg10f644a2009-04-16 13:17:25 +02001063 } else {
Johannes Berg965beda2009-04-16 13:17:24 +02001064 local->ps_sdata = NULL;
Johannes Berg10f644a2009-04-16 13:17:25 +02001065 }
Johannes Berg965beda2009-04-16 13:17:24 +02001066
Johannes Bergaf6b6372009-12-23 13:15:35 +01001067 change:
Johannes Berg965beda2009-04-16 13:17:24 +02001068 ieee80211_change_ps(local);
1069}
1070
1071void ieee80211_dynamic_ps_disable_work(struct work_struct *work)
1072{
1073 struct ieee80211_local *local =
1074 container_of(work, struct ieee80211_local,
1075 dynamic_ps_disable_work);
1076
1077 if (local->hw.conf.flags & IEEE80211_CONF_PS) {
1078 local->hw.conf.flags &= ~IEEE80211_CONF_PS;
1079 ieee80211_hw_config(local, IEEE80211_CONF_CHANGE_PS);
1080 }
1081
1082 ieee80211_wake_queues_by_reason(&local->hw,
1083 IEEE80211_QUEUE_STOP_REASON_PS);
1084}
1085
1086void ieee80211_dynamic_ps_enable_work(struct work_struct *work)
1087{
1088 struct ieee80211_local *local =
1089 container_of(work, struct ieee80211_local,
1090 dynamic_ps_enable_work);
1091 struct ieee80211_sub_if_data *sdata = local->ps_sdata;
Christian Lamparter5e340692011-06-30 21:08:43 +02001092 struct ieee80211_if_managed *ifmgd;
Rajkumar Manoharan1ddc2862011-05-03 17:03:59 +05301093 unsigned long flags;
1094 int q;
Johannes Berg965beda2009-04-16 13:17:24 +02001095
1096 /* can only happen when PS was just disabled anyway */
1097 if (!sdata)
1098 return;
1099
Christian Lamparter5e340692011-06-30 21:08:43 +02001100 ifmgd = &sdata->u.mgd;
1101
Johannes Berg965beda2009-04-16 13:17:24 +02001102 if (local->hw.conf.flags & IEEE80211_CONF_PS)
1103 return;
1104
Arik Nemtsov77b70232011-06-26 12:06:54 +03001105 if (!local->disable_dynamic_ps &&
1106 local->hw.conf.dynamic_ps_timeout > 0) {
1107 /* don't enter PS if TX frames are pending */
1108 if (drv_tx_frames_pending(local)) {
Rajkumar Manoharan1ddc2862011-05-03 17:03:59 +05301109 mod_timer(&local->dynamic_ps_timer, jiffies +
1110 msecs_to_jiffies(
1111 local->hw.conf.dynamic_ps_timeout));
1112 return;
1113 }
Arik Nemtsov77b70232011-06-26 12:06:54 +03001114
1115 /*
1116 * transmission can be stopped by others which leads to
1117 * dynamic_ps_timer expiry. Postpone the ps timer if it
1118 * is not the actual idle state.
1119 */
1120 spin_lock_irqsave(&local->queue_stop_reason_lock, flags);
1121 for (q = 0; q < local->hw.queues; q++) {
1122 if (local->queue_stop_reasons[q]) {
1123 spin_unlock_irqrestore(&local->queue_stop_reason_lock,
1124 flags);
1125 mod_timer(&local->dynamic_ps_timer, jiffies +
1126 msecs_to_jiffies(
1127 local->hw.conf.dynamic_ps_timeout));
1128 return;
1129 }
1130 }
1131 spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags);
Rajkumar Manoharan1ddc2862011-05-03 17:03:59 +05301132 }
Rajkumar Manoharan1ddc2862011-05-03 17:03:59 +05301133
Vivek Natarajan375177b2010-02-09 14:50:28 +05301134 if ((local->hw.flags & IEEE80211_HW_PS_NULLFUNC_STACK) &&
Mohammed Shafi Shajakhan9c38a8b2011-12-14 19:46:07 +05301135 !(ifmgd->flags & IEEE80211_STA_NULLFUNC_ACKED)) {
Vivek Natarajanf3e85b92011-02-23 13:04:32 +05301136 netif_tx_stop_all_queues(sdata->dev);
Johannes Berg965beda2009-04-16 13:17:24 +02001137
Vivek Natarajane8306f92011-04-06 11:41:10 +05301138 if (drv_tx_frames_pending(local))
1139 mod_timer(&local->dynamic_ps_timer, jiffies +
1140 msecs_to_jiffies(
1141 local->hw.conf.dynamic_ps_timeout));
1142 else {
1143 ieee80211_send_nullfunc(local, sdata, 1);
1144 /* Flush to get the tx status of nullfunc frame */
1145 drv_flush(local, false);
1146 }
Vivek Natarajanf3e85b92011-02-23 13:04:32 +05301147 }
1148
Juuso Oikarinen2a130522010-03-09 14:25:02 +02001149 if (!((local->hw.flags & IEEE80211_HW_REPORTS_TX_ACK_STATUS) &&
1150 (local->hw.flags & IEEE80211_HW_PS_NULLFUNC_STACK)) ||
Vivek Natarajan375177b2010-02-09 14:50:28 +05301151 (ifmgd->flags & IEEE80211_STA_NULLFUNC_ACKED)) {
1152 ifmgd->flags &= ~IEEE80211_STA_NULLFUNC_ACKED;
1153 local->hw.conf.flags |= IEEE80211_CONF_PS;
1154 ieee80211_hw_config(local, IEEE80211_CONF_CHANGE_PS);
1155 }
Vivek Natarajanf3e85b92011-02-23 13:04:32 +05301156
Arik Nemtsov77b70232011-06-26 12:06:54 +03001157 if (local->hw.flags & IEEE80211_HW_PS_NULLFUNC_STACK)
1158 netif_tx_wake_all_queues(sdata->dev);
Johannes Berg965beda2009-04-16 13:17:24 +02001159}
1160
1161void ieee80211_dynamic_ps_timer(unsigned long data)
1162{
1163 struct ieee80211_local *local = (void *) data;
1164
Luis R. Rodriguez78f1a8b2009-07-27 08:38:25 -07001165 if (local->quiescing || local->suspended)
Johannes Berg5bb644a2009-05-17 11:40:42 +02001166 return;
1167
Luis R. Rodriguez42935ec2009-07-29 20:08:07 -04001168 ieee80211_queue_work(&local->hw, &local->dynamic_ps_enable_work);
Johannes Berg965beda2009-04-16 13:17:24 +02001169}
1170
Johannes Berg60f8b392008-09-08 17:44:22 +02001171/* MLME */
Jasper Bryant-Greenef698d852008-08-03 12:04:37 +12001172static void ieee80211_sta_wmm_params(struct ieee80211_local *local,
Johannes Berg4ced3f72010-07-19 16:39:04 +02001173 struct ieee80211_sub_if_data *sdata,
Jiri Bencf0706e82007-05-05 11:45:53 -07001174 u8 *wmm_param, size_t wmm_param_len)
1175{
Jiri Bencf0706e82007-05-05 11:45:53 -07001176 struct ieee80211_tx_queue_params params;
Johannes Berg4ced3f72010-07-19 16:39:04 +02001177 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
Jiri Bencf0706e82007-05-05 11:45:53 -07001178 size_t left;
1179 int count;
Kalle Valoab133152010-01-12 10:42:31 +02001180 u8 *pos, uapsd_queues = 0;
Jiri Bencf0706e82007-05-05 11:45:53 -07001181
Stanislaw Gruszkae1b3ec12010-03-29 12:18:34 +02001182 if (!local->ops->conf_tx)
1183 return;
1184
Johannes Bergaf6b6372009-12-23 13:15:35 +01001185 if (local->hw.queues < 4)
Johannes Berg3434fbd2008-05-03 00:59:37 +02001186 return;
1187
1188 if (!wmm_param)
1189 return;
1190
Jiri Bencf0706e82007-05-05 11:45:53 -07001191 if (wmm_param_len < 8 || wmm_param[5] /* version */ != 1)
1192 return;
Kalle Valoab133152010-01-12 10:42:31 +02001193
1194 if (ifmgd->flags & IEEE80211_STA_UAPSD_ENABLED)
Eliad Pellerdc41e4d2012-03-14 16:15:03 +02001195 uapsd_queues = ifmgd->uapsd_queues;
Kalle Valoab133152010-01-12 10:42:31 +02001196
Jiri Bencf0706e82007-05-05 11:45:53 -07001197 count = wmm_param[6] & 0x0f;
Johannes Berg46900292009-02-15 12:44:28 +01001198 if (count == ifmgd->wmm_last_param_set)
Jiri Bencf0706e82007-05-05 11:45:53 -07001199 return;
Johannes Berg46900292009-02-15 12:44:28 +01001200 ifmgd->wmm_last_param_set = count;
Jiri Bencf0706e82007-05-05 11:45:53 -07001201
1202 pos = wmm_param + 8;
1203 left = wmm_param_len - 8;
1204
1205 memset(&params, 0, sizeof(params));
1206
Jiri Bencf0706e82007-05-05 11:45:53 -07001207 local->wmm_acm = 0;
1208 for (; left >= 4; left -= 4, pos += 4) {
1209 int aci = (pos[0] >> 5) & 0x03;
1210 int acm = (pos[0] >> 4) & 0x01;
Kalle Valoab133152010-01-12 10:42:31 +02001211 bool uapsd = false;
Jiri Bencf0706e82007-05-05 11:45:53 -07001212 int queue;
1213
1214 switch (aci) {
Jouni Malinen0eeb59f2009-03-05 17:23:46 +02001215 case 1: /* AC_BK */
Johannes Berge100bb62008-04-30 18:51:21 +02001216 queue = 3;
Johannes Berg988c0f72008-04-17 19:21:22 +02001217 if (acm)
Jouni Malinen0eeb59f2009-03-05 17:23:46 +02001218 local->wmm_acm |= BIT(1) | BIT(2); /* BK/- */
Kalle Valoab133152010-01-12 10:42:31 +02001219 if (uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_BK)
1220 uapsd = true;
Jiri Bencf0706e82007-05-05 11:45:53 -07001221 break;
Jouni Malinen0eeb59f2009-03-05 17:23:46 +02001222 case 2: /* AC_VI */
Johannes Berge100bb62008-04-30 18:51:21 +02001223 queue = 1;
Johannes Berg988c0f72008-04-17 19:21:22 +02001224 if (acm)
Jouni Malinen0eeb59f2009-03-05 17:23:46 +02001225 local->wmm_acm |= BIT(4) | BIT(5); /* CL/VI */
Kalle Valoab133152010-01-12 10:42:31 +02001226 if (uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_VI)
1227 uapsd = true;
Jiri Bencf0706e82007-05-05 11:45:53 -07001228 break;
Jouni Malinen0eeb59f2009-03-05 17:23:46 +02001229 case 3: /* AC_VO */
Johannes Berge100bb62008-04-30 18:51:21 +02001230 queue = 0;
Johannes Berg988c0f72008-04-17 19:21:22 +02001231 if (acm)
Jouni Malinen0eeb59f2009-03-05 17:23:46 +02001232 local->wmm_acm |= BIT(6) | BIT(7); /* VO/NC */
Kalle Valoab133152010-01-12 10:42:31 +02001233 if (uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_VO)
1234 uapsd = true;
Jiri Bencf0706e82007-05-05 11:45:53 -07001235 break;
Jouni Malinen0eeb59f2009-03-05 17:23:46 +02001236 case 0: /* AC_BE */
Jiri Bencf0706e82007-05-05 11:45:53 -07001237 default:
Johannes Berge100bb62008-04-30 18:51:21 +02001238 queue = 2;
Johannes Berg988c0f72008-04-17 19:21:22 +02001239 if (acm)
Jouni Malinen0eeb59f2009-03-05 17:23:46 +02001240 local->wmm_acm |= BIT(0) | BIT(3); /* BE/EE */
Kalle Valoab133152010-01-12 10:42:31 +02001241 if (uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_BE)
1242 uapsd = true;
Jiri Bencf0706e82007-05-05 11:45:53 -07001243 break;
1244 }
1245
1246 params.aifs = pos[0] & 0x0f;
1247 params.cw_max = ecw2cw((pos[1] & 0xf0) >> 4);
1248 params.cw_min = ecw2cw(pos[1] & 0x0f);
Johannes Bergf434b2d2008-07-10 11:22:31 +02001249 params.txop = get_unaligned_le16(pos + 2);
Kalle Valoab133152010-01-12 10:42:31 +02001250 params.uapsd = uapsd;
1251
Johannes Bergf4ea83d2008-06-30 15:10:46 +02001252#ifdef CONFIG_MAC80211_VERBOSE_DEBUG
Joe Perches0fb9a9e2010-08-20 16:25:38 -07001253 wiphy_debug(local->hw.wiphy,
1254 "WMM queue=%d aci=%d acm=%d aifs=%d "
1255 "cWmin=%d cWmax=%d txop=%d uapsd=%d\n",
1256 queue, aci, acm,
1257 params.aifs, params.cw_min, params.cw_max,
1258 params.txop, params.uapsd);
Johannes Berg3330d7b2008-02-10 16:49:38 +01001259#endif
Eliad Pellerf6f3def2011-09-25 20:06:54 +03001260 sdata->tx_conf[queue] = params;
1261 if (drv_conf_tx(local, sdata, queue, &params))
Joe Perches0fb9a9e2010-08-20 16:25:38 -07001262 wiphy_debug(local->hw.wiphy,
1263 "failed to set TX queue parameters for queue %d\n",
1264 queue);
Jiri Bencf0706e82007-05-05 11:45:53 -07001265 }
Stanislaw Gruszkae1b3ec12010-03-29 12:18:34 +02001266
1267 /* enable WMM or activate new settings */
Johannes Berg4ced3f72010-07-19 16:39:04 +02001268 sdata->vif.bss_conf.qos = true;
Jiri Bencf0706e82007-05-05 11:45:53 -07001269}
1270
Johannes Berg7a5158e2008-10-08 10:59:33 +02001271static u32 ieee80211_handle_bss_capability(struct ieee80211_sub_if_data *sdata,
1272 u16 capab, bool erp_valid, u8 erp)
Daniel Drake56282212007-07-10 19:32:10 +02001273{
Johannes Bergbda39332008-10-11 01:51:51 +02001274 struct ieee80211_bss_conf *bss_conf = &sdata->vif.bss_conf;
Johannes Berg471b3ef2007-12-28 14:32:58 +01001275 u32 changed = 0;
Johannes Berg7a5158e2008-10-08 10:59:33 +02001276 bool use_protection;
1277 bool use_short_preamble;
1278 bool use_short_slot;
1279
1280 if (erp_valid) {
1281 use_protection = (erp & WLAN_ERP_USE_PROTECTION) != 0;
1282 use_short_preamble = (erp & WLAN_ERP_BARKER_PREAMBLE) == 0;
1283 } else {
1284 use_protection = false;
1285 use_short_preamble = !!(capab & WLAN_CAPABILITY_SHORT_PREAMBLE);
1286 }
1287
1288 use_short_slot = !!(capab & WLAN_CAPABILITY_SHORT_SLOT_TIME);
Felix Fietkau43d35342010-01-15 03:00:48 +01001289 if (sdata->local->hw.conf.channel->band == IEEE80211_BAND_5GHZ)
1290 use_short_slot = true;
Daniel Drake56282212007-07-10 19:32:10 +02001291
Johannes Berg471b3ef2007-12-28 14:32:58 +01001292 if (use_protection != bss_conf->use_cts_prot) {
Johannes Berg471b3ef2007-12-28 14:32:58 +01001293 bss_conf->use_cts_prot = use_protection;
1294 changed |= BSS_CHANGED_ERP_CTS_PROT;
Daniel Drake56282212007-07-10 19:32:10 +02001295 }
Daniel Drake7e9ed182007-07-27 15:43:24 +02001296
Vladimir Koutnyd43c7b32008-03-31 17:05:03 +02001297 if (use_short_preamble != bss_conf->use_short_preamble) {
Vladimir Koutnyd43c7b32008-03-31 17:05:03 +02001298 bss_conf->use_short_preamble = use_short_preamble;
Johannes Berg471b3ef2007-12-28 14:32:58 +01001299 changed |= BSS_CHANGED_ERP_PREAMBLE;
Daniel Drake7e9ed182007-07-27 15:43:24 +02001300 }
Daniel Draked9430a32007-07-27 15:43:24 +02001301
Johannes Berg7a5158e2008-10-08 10:59:33 +02001302 if (use_short_slot != bss_conf->use_short_slot) {
Johannes Berg7a5158e2008-10-08 10:59:33 +02001303 bss_conf->use_short_slot = use_short_slot;
1304 changed |= BSS_CHANGED_ERP_SLOT;
John W. Linville50c4afb2008-04-15 14:09:27 -04001305 }
1306
1307 return changed;
1308}
1309
Jasper Bryant-Greenef698d852008-08-03 12:04:37 +12001310static void ieee80211_set_associated(struct ieee80211_sub_if_data *sdata,
Johannes Berg0c1ad2c2009-12-23 13:15:39 +01001311 struct cfg80211_bss *cbss,
Johannes Bergae5eb022008-10-14 16:58:37 +02001312 u32 bss_info_changed)
Jiri Bencf0706e82007-05-05 11:45:53 -07001313{
Johannes Berg0c1ad2c2009-12-23 13:15:39 +01001314 struct ieee80211_bss *bss = (void *)cbss->priv;
Johannes Berg471b3ef2007-12-28 14:32:58 +01001315 struct ieee80211_local *local = sdata->local;
Juuso Oikarinen68542962010-06-09 13:43:26 +03001316 struct ieee80211_bss_conf *bss_conf = &sdata->vif.bss_conf;
Jiri Slabyd6f2da52007-08-28 17:01:54 -04001317
Johannes Bergae5eb022008-10-14 16:58:37 +02001318 bss_info_changed |= BSS_CHANGED_ASSOC;
Johannes Berg77fdaa12009-07-07 03:45:17 +02001319 /* set timing information */
Juuso Oikarinen68542962010-06-09 13:43:26 +03001320 bss_conf->beacon_int = cbss->beacon_interval;
Johannes Berge9ac0742012-03-13 14:29:30 +01001321 bss_conf->last_tsf = cbss->tsf;
Jiri Slabyd6f2da52007-08-28 17:01:54 -04001322
Johannes Berg77fdaa12009-07-07 03:45:17 +02001323 bss_info_changed |= BSS_CHANGED_BEACON_INT;
1324 bss_info_changed |= ieee80211_handle_bss_capability(sdata,
Johannes Berg0c1ad2c2009-12-23 13:15:39 +01001325 cbss->capability, bss->has_erp_value, bss->erp_value);
Tomas Winkler21c0cbe2008-03-28 16:33:34 -07001326
Felix Fietkau7ccc8bd2010-11-19 22:55:38 +01001327 sdata->u.mgd.beacon_timeout = usecs_to_jiffies(ieee80211_tu_to_usec(
1328 IEEE80211_BEACON_LOSS_COUNT * bss_conf->beacon_int));
1329
Johannes Berg0c1ad2c2009-12-23 13:15:39 +01001330 sdata->u.mgd.associated = cbss;
1331 memcpy(sdata->u.mgd.bssid, cbss->bssid, ETH_ALEN);
Johannes Berg471b3ef2007-12-28 14:32:58 +01001332
Jouni Malinen17e4ec12010-03-29 23:28:30 -07001333 sdata->u.mgd.flags |= IEEE80211_STA_RESET_SIGNAL_AVE;
1334
Johannes Bergb291ba12009-07-10 15:29:03 +02001335 /* just to be sure */
1336 sdata->u.mgd.flags &= ~(IEEE80211_STA_CONNECTION_POLL |
1337 IEEE80211_STA_BEACON_POLL);
1338
Tomas Winklerf5e5bf22008-09-08 17:33:39 +02001339 ieee80211_led_assoc(local, 1);
1340
Johannes Berge5b900d2010-07-29 16:08:55 +02001341 if (local->hw.flags & IEEE80211_HW_NEED_DTIM_PERIOD)
1342 bss_conf->dtim_period = bss->dtim_period;
1343 else
1344 bss_conf->dtim_period = 0;
1345
Juuso Oikarinen68542962010-06-09 13:43:26 +03001346 bss_conf->assoc = 1;
Johannes Berg9cef8732009-05-14 13:10:14 +02001347
Juuso Oikarinena97c13c2010-03-23 09:02:34 +02001348 /* Tell the driver to monitor connection quality (if supported) */
Johannes Bergea086352012-01-19 09:29:58 +01001349 if (sdata->vif.driver_flags & IEEE80211_VIF_SUPPORTS_CQM_RSSI &&
Juuso Oikarinen68542962010-06-09 13:43:26 +03001350 bss_conf->cqm_rssi_thold)
Juuso Oikarinena97c13c2010-03-23 09:02:34 +02001351 bss_info_changed |= BSS_CHANGED_CQM;
1352
Juuso Oikarinen68542962010-06-09 13:43:26 +03001353 /* Enable ARP filtering */
1354 if (bss_conf->arp_filter_enabled != sdata->arp_filter_state) {
1355 bss_conf->arp_filter_enabled = sdata->arp_filter_state;
1356 bss_info_changed |= BSS_CHANGED_ARP_FILTER;
1357 }
1358
Johannes Bergae5eb022008-10-14 16:58:37 +02001359 ieee80211_bss_info_change_notify(sdata, bss_info_changed);
Guy Cohen8db93692008-07-03 19:56:13 +03001360
Johannes Berg056508d2009-07-30 21:43:55 +02001361 mutex_lock(&local->iflist_mtx);
1362 ieee80211_recalc_ps(local, -1);
Johannes Berg025e6be2010-10-05 10:41:47 +02001363 ieee80211_recalc_smps(local);
Johannes Berg056508d2009-07-30 21:43:55 +02001364 mutex_unlock(&local->iflist_mtx);
Kalle Valoe0cb6862008-12-18 23:35:13 +02001365
John W. Linville8a5b33f2010-01-06 15:39:39 -05001366 netif_tx_start_all_queues(sdata->dev);
Tomas Winklerf5e5bf22008-09-08 17:33:39 +02001367 netif_carrier_on(sdata->dev);
Jiri Bencf0706e82007-05-05 11:45:53 -07001368}
1369
Jouni Malinene69e95d2010-03-29 23:29:31 -07001370static void ieee80211_set_disassoc(struct ieee80211_sub_if_data *sdata,
Johannes Berg37ad3882012-02-24 13:50:54 +01001371 u16 stype, u16 reason, bool tx,
1372 u8 *frame_buf)
Tomas Winkleraa458d12008-09-09 00:32:12 +03001373{
Johannes Berg46900292009-02-15 12:44:28 +01001374 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
Tomas Winkleraa458d12008-09-09 00:32:12 +03001375 struct ieee80211_local *local = sdata->local;
1376 struct sta_info *sta;
Johannes Berg3cc52402012-03-09 13:12:35 +01001377 u32 changed = 0;
Johannes Bergb291ba12009-07-10 15:29:03 +02001378 u8 bssid[ETH_ALEN];
Tomas Winkleraa458d12008-09-09 00:32:12 +03001379
Johannes Berg77fdaa12009-07-07 03:45:17 +02001380 ASSERT_MGD_MTX(ifmgd);
1381
Johannes Berg37ad3882012-02-24 13:50:54 +01001382 if (WARN_ON_ONCE(tx && !frame_buf))
1383 return;
1384
Johannes Bergb291ba12009-07-10 15:29:03 +02001385 if (WARN_ON(!ifmgd->associated))
1386 return;
1387
Johannes Berg0c1ad2c2009-12-23 13:15:39 +01001388 memcpy(bssid, ifmgd->associated->bssid, ETH_ALEN);
Johannes Bergb291ba12009-07-10 15:29:03 +02001389
Johannes Berg77fdaa12009-07-07 03:45:17 +02001390 ifmgd->associated = NULL;
1391 memset(ifmgd->bssid, 0, ETH_ALEN);
1392
1393 /*
1394 * we need to commit the associated = NULL change because the
1395 * scan code uses that to determine whether this iface should
1396 * go to/wake up from powersave or not -- and could otherwise
1397 * wake the queues erroneously.
1398 */
1399 smp_mb();
1400
1401 /*
1402 * Thus, we can only afterwards stop the queues -- to account
1403 * for the case where another CPU is finishing a scan at this
1404 * time -- we don't want the scan code to enable queues.
1405 */
Tomas Winkleraa458d12008-09-09 00:32:12 +03001406
John W. Linville8a5b33f2010-01-06 15:39:39 -05001407 netif_tx_stop_all_queues(sdata->dev);
Tomas Winkleraa458d12008-09-09 00:32:12 +03001408 netif_carrier_off(sdata->dev);
1409
Johannes Berg2a419052010-06-10 10:21:29 +02001410 mutex_lock(&local->sta_mtx);
Johannes Bergabe60632009-11-25 17:46:18 +01001411 sta = sta_info_get(sdata, bssid);
Sujith4cad6c72010-02-10 14:52:21 +05301412 if (sta) {
Johannes Bergc2c98fd2011-09-29 16:04:36 +02001413 set_sta_flag(sta, WLAN_STA_BLOCK_BA);
Johannes Berg53f73c02010-10-05 19:37:40 +02001414 ieee80211_sta_tear_down_BA_sessions(sta, tx);
Sujith4cad6c72010-02-10 14:52:21 +05301415 }
Johannes Berg2a419052010-06-10 10:21:29 +02001416 mutex_unlock(&local->sta_mtx);
Tomas Winkleraa458d12008-09-09 00:32:12 +03001417
Johannes Berg37ad3882012-02-24 13:50:54 +01001418 /* deauthenticate/disassociate now */
1419 if (tx || frame_buf)
1420 ieee80211_send_deauth_disassoc(sdata, bssid, stype, reason,
1421 tx, frame_buf);
1422
1423 /* flush out frame */
1424 if (tx)
1425 drv_flush(local, false);
1426
1427 /* remove AP and TDLS peers */
1428 sta_info_flush(local, sdata);
1429
1430 /* finally reset all BSS / config parameters */
Tomas Winklerf5e5bf22008-09-08 17:33:39 +02001431 changed |= ieee80211_reset_erp_info(sdata);
1432
Tomas Winklerf5e5bf22008-09-08 17:33:39 +02001433 ieee80211_led_assoc(local, 0);
Johannes Bergae5eb022008-10-14 16:58:37 +02001434 changed |= BSS_CHANGED_ASSOC;
1435 sdata->vif.bss_conf.assoc = false;
Tomas Winklerf5e5bf22008-09-08 17:33:39 +02001436
Johannes Berg413ad502009-05-08 21:21:06 +02001437 /* on the next assoc, re-program HT parameters */
1438 sdata->ht_opmode_valid = false;
Ben Greearef96a8422011-11-18 11:32:00 -08001439 memset(&ifmgd->ht_capa, 0, sizeof(ifmgd->ht_capa));
1440 memset(&ifmgd->ht_capa_mask, 0, sizeof(ifmgd->ht_capa_mask));
Johannes Berg413ad502009-05-08 21:21:06 +02001441
Vasanthakumar Thiagarajana8302de2009-01-09 18:14:15 +05301442 local->power_constr_level = 0;
1443
Kalle Valo520eb822008-12-18 23:35:27 +02001444 del_timer_sync(&local->dynamic_ps_timer);
1445 cancel_work_sync(&local->dynamic_ps_enable_work);
1446
Kalle Valoe0cb6862008-12-18 23:35:13 +02001447 if (local->hw.conf.flags & IEEE80211_CONF_PS) {
1448 local->hw.conf.flags &= ~IEEE80211_CONF_PS;
Johannes Berg3cc52402012-03-09 13:12:35 +01001449 ieee80211_hw_config(local, IEEE80211_CONF_CHANGE_PS);
Kalle Valoe0cb6862008-12-18 23:35:13 +02001450 }
Eliad Pellera3314002011-05-26 11:46:37 +03001451 local->ps_sdata = NULL;
Kalle Valoe0cb6862008-12-18 23:35:13 +02001452
Juuso Oikarinen68542962010-06-09 13:43:26 +03001453 /* Disable ARP filtering */
1454 if (sdata->vif.bss_conf.arp_filter_enabled) {
1455 sdata->vif.bss_conf.arp_filter_enabled = false;
1456 changed |= BSS_CHANGED_ARP_FILTER;
1457 }
1458
Johannes Berg3abead52012-03-02 15:56:59 +01001459 sdata->vif.bss_conf.qos = false;
1460 changed |= BSS_CHANGED_QOS;
1461
Johannes Berg0aaffa92010-05-05 15:28:27 +02001462 /* The BSSID (not really interesting) and HT changed */
1463 changed |= BSS_CHANGED_BSSID | BSS_CHANGED_HT;
Johannes Bergae5eb022008-10-14 16:58:37 +02001464 ieee80211_bss_info_change_notify(sdata, changed);
Tomas Winkler8e268e42008-11-25 13:05:44 +02001465
Johannes Berg3cc52402012-03-09 13:12:35 +01001466 /* channel(_type) changes are handled by ieee80211_hw_config */
1467 WARN_ON(!ieee80211_set_channel_type(local, sdata, NL80211_CHAN_NO_HT));
1468 ieee80211_hw_config(local, 0);
1469
Johannes Berg3abead52012-03-02 15:56:59 +01001470 /* disassociated - set to defaults now */
1471 ieee80211_set_wmm_default(sdata, false);
1472
Johannes Bergb9dcf712010-08-27 12:35:54 +02001473 del_timer_sync(&sdata->u.mgd.conn_mon_timer);
1474 del_timer_sync(&sdata->u.mgd.bcn_mon_timer);
1475 del_timer_sync(&sdata->u.mgd.timer);
1476 del_timer_sync(&sdata->u.mgd.chswitch_timer);
Tomas Winkleraa458d12008-09-09 00:32:12 +03001477}
Jiri Bencf0706e82007-05-05 11:45:53 -07001478
Kalle Valo3cf335d2009-03-22 21:57:06 +02001479void ieee80211_sta_rx_notify(struct ieee80211_sub_if_data *sdata,
1480 struct ieee80211_hdr *hdr)
1481{
1482 /*
1483 * We can postpone the mgd.timer whenever receiving unicast frames
1484 * from AP because we know that the connection is working both ways
1485 * at that time. But multicast frames (and hence also beacons) must
1486 * be ignored here, because we need to trigger the timer during
Johannes Bergb291ba12009-07-10 15:29:03 +02001487 * data idle periods for sending the periodic probe request to the
1488 * AP we're connected to.
Kalle Valo3cf335d2009-03-22 21:57:06 +02001489 */
Johannes Bergb291ba12009-07-10 15:29:03 +02001490 if (is_multicast_ether_addr(hdr->addr1))
1491 return;
1492
Luis R. Rodriguezbe099e82010-09-16 15:12:29 -04001493 ieee80211_sta_reset_conn_monitor(sdata);
Kalle Valo3cf335d2009-03-22 21:57:06 +02001494}
Jiri Bencf0706e82007-05-05 11:45:53 -07001495
Felix Fietkau4e5ff372010-11-23 03:10:31 +01001496static void ieee80211_reset_ap_probe(struct ieee80211_sub_if_data *sdata)
1497{
1498 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
1499
1500 if (!(ifmgd->flags & (IEEE80211_STA_BEACON_POLL |
1501 IEEE80211_STA_CONNECTION_POLL)))
1502 return;
1503
1504 ifmgd->flags &= ~(IEEE80211_STA_CONNECTION_POLL |
1505 IEEE80211_STA_BEACON_POLL);
1506 mutex_lock(&sdata->local->iflist_mtx);
1507 ieee80211_recalc_ps(sdata->local, -1);
1508 mutex_unlock(&sdata->local->iflist_mtx);
1509
1510 if (sdata->local->hw.flags & IEEE80211_HW_CONNECTION_MONITOR)
1511 return;
1512
1513 /*
1514 * We've received a probe response, but are not sure whether
1515 * we have or will be receiving any beacons or data, so let's
1516 * schedule the timers again, just in case.
1517 */
1518 ieee80211_sta_reset_beacon_monitor(sdata);
1519
1520 mod_timer(&ifmgd->conn_mon_timer,
1521 round_jiffies_up(jiffies +
1522 IEEE80211_CONNECTION_IDLE_TIME));
1523}
1524
1525void ieee80211_sta_tx_notify(struct ieee80211_sub_if_data *sdata,
Felix Fietkau04ac3c02010-12-02 21:01:08 +01001526 struct ieee80211_hdr *hdr, bool ack)
Felix Fietkau4e5ff372010-11-23 03:10:31 +01001527{
Felix Fietkau75706d02010-12-02 21:01:07 +01001528 if (!ieee80211_is_data(hdr->frame_control))
Felix Fietkau4e5ff372010-11-23 03:10:31 +01001529 return;
1530
Felix Fietkau04ac3c02010-12-02 21:01:08 +01001531 if (ack)
1532 ieee80211_sta_reset_conn_monitor(sdata);
Felix Fietkau4e5ff372010-11-23 03:10:31 +01001533
1534 if (ieee80211_is_nullfunc(hdr->frame_control) &&
1535 sdata->u.mgd.probe_send_count > 0) {
Felix Fietkau04ac3c02010-12-02 21:01:08 +01001536 if (ack)
1537 sdata->u.mgd.probe_send_count = 0;
1538 else
1539 sdata->u.mgd.nullfunc_failed = true;
Felix Fietkau4e5ff372010-11-23 03:10:31 +01001540 ieee80211_queue_work(&sdata->local->hw, &sdata->work);
1541 }
1542}
1543
Maxim Levitskya43abf22009-07-31 18:54:12 +03001544static void ieee80211_mgd_probe_ap_send(struct ieee80211_sub_if_data *sdata)
1545{
1546 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
1547 const u8 *ssid;
Luis R. Rodriguezf01a0672010-09-16 15:12:34 -04001548 u8 *dst = ifmgd->associated->bssid;
Ben Greear180205b2011-02-04 15:30:24 -08001549 u8 unicast_limit = max(1, max_probe_tries - 3);
Luis R. Rodriguezf01a0672010-09-16 15:12:34 -04001550
1551 /*
1552 * Try sending broadcast probe requests for the last three
1553 * probe requests after the first ones failed since some
1554 * buggy APs only support broadcast probe requests.
1555 */
1556 if (ifmgd->probe_send_count >= unicast_limit)
1557 dst = NULL;
Maxim Levitskya43abf22009-07-31 18:54:12 +03001558
Felix Fietkau4e5ff372010-11-23 03:10:31 +01001559 /*
1560 * When the hardware reports an accurate Tx ACK status, it's
1561 * better to send a nullfunc frame instead of a probe request,
1562 * as it will kick us off the AP quickly if we aren't associated
1563 * anymore. The timeout will be reset if the frame is ACKed by
1564 * the AP.
1565 */
Felix Fietkau04ac3c02010-12-02 21:01:08 +01001566 if (sdata->local->hw.flags & IEEE80211_HW_REPORTS_TX_ACK_STATUS) {
1567 ifmgd->nullfunc_failed = false;
Felix Fietkau4e5ff372010-11-23 03:10:31 +01001568 ieee80211_send_nullfunc(sdata->local, sdata, 0);
Felix Fietkau04ac3c02010-12-02 21:01:08 +01001569 } else {
Felix Fietkau4e5ff372010-11-23 03:10:31 +01001570 ssid = ieee80211_bss_get_ie(ifmgd->associated, WLAN_EID_SSID);
Paul Stewarta806c552011-06-23 09:00:11 -08001571 ieee80211_send_probe_req(sdata, dst, ssid + 2, ssid[1], NULL, 0,
Rajkumar Manoharanaad14ce2011-09-25 14:53:31 +05301572 (u32) -1, true, false);
Felix Fietkau4e5ff372010-11-23 03:10:31 +01001573 }
Maxim Levitskya43abf22009-07-31 18:54:12 +03001574
1575 ifmgd->probe_send_count++;
Ben Greear180205b2011-02-04 15:30:24 -08001576 ifmgd->probe_timeout = jiffies + msecs_to_jiffies(probe_wait_ms);
Maxim Levitskya43abf22009-07-31 18:54:12 +03001577 run_again(ifmgd, ifmgd->probe_timeout);
1578}
1579
Johannes Bergb291ba12009-07-10 15:29:03 +02001580static void ieee80211_mgd_probe_ap(struct ieee80211_sub_if_data *sdata,
1581 bool beacon)
Kalle Valo04de8382009-03-22 21:57:35 +02001582{
Kalle Valo04de8382009-03-22 21:57:35 +02001583 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
Johannes Bergb291ba12009-07-10 15:29:03 +02001584 bool already = false;
Johannes Berg34bfc412009-05-12 19:58:12 +02001585
Johannes Berg9607e6b2009-12-23 13:15:31 +01001586 if (!ieee80211_sdata_running(sdata))
Johannes Berg0e2b6282009-07-13 13:23:39 +02001587 return;
1588
Luis R. Rodriguez91a3bd72009-07-23 16:37:47 -07001589 if (sdata->local->scanning)
1590 return;
1591
Johannes Bergb8bc4b02009-12-23 13:15:42 +01001592 if (sdata->local->tmp_channel)
1593 return;
1594
Johannes Berg77fdaa12009-07-07 03:45:17 +02001595 mutex_lock(&ifmgd->mtx);
1596
1597 if (!ifmgd->associated)
1598 goto out;
1599
Michael Buescha8604022009-04-15 14:41:22 -04001600#ifdef CONFIG_MAC80211_VERBOSE_DEBUG
Johannes Bergb291ba12009-07-10 15:29:03 +02001601 if (beacon && net_ratelimit())
1602 printk(KERN_DEBUG "%s: detected beacon loss from AP "
Johannes Berg47846c92009-11-25 17:46:19 +01001603 "- sending probe request\n", sdata->name);
Michael Buescha8604022009-04-15 14:41:22 -04001604#endif
Kalle Valo04de8382009-03-22 21:57:35 +02001605
Johannes Bergb291ba12009-07-10 15:29:03 +02001606 /*
1607 * The driver/our work has already reported this event or the
1608 * connection monitoring has kicked in and we have already sent
1609 * a probe request. Or maybe the AP died and the driver keeps
1610 * reporting until we disassociate...
1611 *
1612 * In either case we have to ignore the current call to this
1613 * function (except for setting the correct probe reason bit)
1614 * because otherwise we would reset the timer every time and
1615 * never check whether we received a probe response!
1616 */
1617 if (ifmgd->flags & (IEEE80211_STA_BEACON_POLL |
1618 IEEE80211_STA_CONNECTION_POLL))
1619 already = true;
1620
1621 if (beacon)
1622 ifmgd->flags |= IEEE80211_STA_BEACON_POLL;
1623 else
1624 ifmgd->flags |= IEEE80211_STA_CONNECTION_POLL;
1625
1626 if (already)
1627 goto out;
1628
Johannes Berg4e751842009-06-10 15:16:52 +02001629 mutex_lock(&sdata->local->iflist_mtx);
1630 ieee80211_recalc_ps(sdata->local, -1);
1631 mutex_unlock(&sdata->local->iflist_mtx);
1632
Maxim Levitskya43abf22009-07-31 18:54:12 +03001633 ifmgd->probe_send_count = 0;
1634 ieee80211_mgd_probe_ap_send(sdata);
Johannes Berg77fdaa12009-07-07 03:45:17 +02001635 out:
1636 mutex_unlock(&ifmgd->mtx);
Kalle Valo04de8382009-03-22 21:57:35 +02001637}
1638
Juuso Oikarinena619a4c2010-11-11 08:50:18 +02001639struct sk_buff *ieee80211_ap_probereq_get(struct ieee80211_hw *hw,
1640 struct ieee80211_vif *vif)
1641{
1642 struct ieee80211_sub_if_data *sdata = vif_to_sdata(vif);
1643 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
1644 struct sk_buff *skb;
1645 const u8 *ssid;
1646
1647 if (WARN_ON(sdata->vif.type != NL80211_IFTYPE_STATION))
1648 return NULL;
1649
1650 ASSERT_MGD_MTX(ifmgd);
1651
1652 if (!ifmgd->associated)
1653 return NULL;
1654
1655 ssid = ieee80211_bss_get_ie(ifmgd->associated, WLAN_EID_SSID);
1656 skb = ieee80211_build_probe_req(sdata, ifmgd->associated->bssid,
Johannes Berg85a237f2011-07-18 18:08:36 +02001657 (u32) -1, ssid + 2, ssid[1],
1658 NULL, 0, true);
Juuso Oikarinena619a4c2010-11-11 08:50:18 +02001659
1660 return skb;
1661}
1662EXPORT_SYMBOL(ieee80211_ap_probereq_get);
1663
Juuso Oikarinen1e4dcd02010-03-19 07:14:53 +02001664static void __ieee80211_connection_loss(struct ieee80211_sub_if_data *sdata)
1665{
1666 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
1667 struct ieee80211_local *local = sdata->local;
1668 u8 bssid[ETH_ALEN];
Johannes Berg5fef7db2012-02-24 13:50:52 +01001669 u8 frame_buf[DEAUTH_DISASSOC_LEN];
Juuso Oikarinen1e4dcd02010-03-19 07:14:53 +02001670
1671 mutex_lock(&ifmgd->mtx);
1672 if (!ifmgd->associated) {
1673 mutex_unlock(&ifmgd->mtx);
1674 return;
1675 }
1676
1677 memcpy(bssid, ifmgd->associated->bssid, ETH_ALEN);
1678
Ben Greear180205b2011-02-04 15:30:24 -08001679 printk(KERN_DEBUG "%s: Connection to AP %pM lost.\n",
1680 sdata->name, bssid);
Juuso Oikarinen1e4dcd02010-03-19 07:14:53 +02001681
Johannes Berg37ad3882012-02-24 13:50:54 +01001682 ieee80211_set_disassoc(sdata, IEEE80211_STYPE_DEAUTH,
1683 WLAN_REASON_DISASSOC_DUE_TO_INACTIVITY,
1684 false, frame_buf);
Juuso Oikarinen1e4dcd02010-03-19 07:14:53 +02001685 mutex_unlock(&ifmgd->mtx);
Johannes Berg7da7cc12010-08-05 17:02:38 +02001686
Juuso Oikarinen1e4dcd02010-03-19 07:14:53 +02001687 /*
1688 * must be outside lock due to cfg80211,
1689 * but that's not a problem.
1690 */
Johannes Berg5fef7db2012-02-24 13:50:52 +01001691 cfg80211_send_deauth(sdata->dev, frame_buf, DEAUTH_DISASSOC_LEN);
Felix Fietkaufcac4fb2011-11-16 13:34:55 +01001692
1693 mutex_lock(&local->mtx);
1694 ieee80211_recalc_idle(local);
1695 mutex_unlock(&local->mtx);
Juuso Oikarinen1e4dcd02010-03-19 07:14:53 +02001696}
1697
1698void ieee80211_beacon_connection_loss_work(struct work_struct *work)
Johannes Bergb291ba12009-07-10 15:29:03 +02001699{
1700 struct ieee80211_sub_if_data *sdata =
1701 container_of(work, struct ieee80211_sub_if_data,
Juuso Oikarinen1e4dcd02010-03-19 07:14:53 +02001702 u.mgd.beacon_connection_loss_work);
Paul Stewarta85e1d52011-12-09 11:01:49 -08001703 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
1704 struct sta_info *sta;
1705
1706 if (ifmgd->associated) {
Mohammed Shafi Shajakhan30fa9042011-12-27 18:54:07 +05301707 rcu_read_lock();
Paul Stewarta85e1d52011-12-09 11:01:49 -08001708 sta = sta_info_get(sdata, ifmgd->bssid);
1709 if (sta)
1710 sta->beacon_loss_count++;
Mohammed Shafi Shajakhan30fa9042011-12-27 18:54:07 +05301711 rcu_read_unlock();
Paul Stewarta85e1d52011-12-09 11:01:49 -08001712 }
Johannes Bergb291ba12009-07-10 15:29:03 +02001713
Juuso Oikarinen1e4dcd02010-03-19 07:14:53 +02001714 if (sdata->local->hw.flags & IEEE80211_HW_CONNECTION_MONITOR)
1715 __ieee80211_connection_loss(sdata);
1716 else
1717 ieee80211_mgd_probe_ap(sdata, true);
Johannes Bergb291ba12009-07-10 15:29:03 +02001718}
1719
Kalle Valo04de8382009-03-22 21:57:35 +02001720void ieee80211_beacon_loss(struct ieee80211_vif *vif)
1721{
1722 struct ieee80211_sub_if_data *sdata = vif_to_sdata(vif);
Juuso Oikarinen1e4dcd02010-03-19 07:14:53 +02001723 struct ieee80211_hw *hw = &sdata->local->hw;
Kalle Valo04de8382009-03-22 21:57:35 +02001724
Johannes Bergb5878a22010-04-07 16:48:40 +02001725 trace_api_beacon_loss(sdata);
1726
Juuso Oikarinen1e4dcd02010-03-19 07:14:53 +02001727 WARN_ON(hw->flags & IEEE80211_HW_CONNECTION_MONITOR);
1728 ieee80211_queue_work(hw, &sdata->u.mgd.beacon_connection_loss_work);
Kalle Valo04de8382009-03-22 21:57:35 +02001729}
1730EXPORT_SYMBOL(ieee80211_beacon_loss);
1731
Juuso Oikarinen1e4dcd02010-03-19 07:14:53 +02001732void ieee80211_connection_loss(struct ieee80211_vif *vif)
1733{
1734 struct ieee80211_sub_if_data *sdata = vif_to_sdata(vif);
1735 struct ieee80211_hw *hw = &sdata->local->hw;
1736
Johannes Bergb5878a22010-04-07 16:48:40 +02001737 trace_api_connection_loss(sdata);
1738
Juuso Oikarinen1e4dcd02010-03-19 07:14:53 +02001739 WARN_ON(!(hw->flags & IEEE80211_HW_CONNECTION_MONITOR));
1740 ieee80211_queue_work(hw, &sdata->u.mgd.beacon_connection_loss_work);
1741}
1742EXPORT_SYMBOL(ieee80211_connection_loss);
1743
1744
Johannes Berg66e67e42012-01-20 13:55:27 +01001745static void ieee80211_destroy_auth_data(struct ieee80211_sub_if_data *sdata,
1746 bool assoc)
1747{
1748 struct ieee80211_mgd_auth_data *auth_data = sdata->u.mgd.auth_data;
1749
1750 lockdep_assert_held(&sdata->u.mgd.mtx);
1751
Johannes Berg66e67e42012-01-20 13:55:27 +01001752 if (!assoc) {
1753 sta_info_destroy_addr(sdata, auth_data->bss->bssid);
1754
1755 memset(sdata->u.mgd.bssid, 0, ETH_ALEN);
1756 ieee80211_bss_info_change_notify(sdata, BSS_CHANGED_BSSID);
1757 }
1758
1759 cfg80211_put_bss(auth_data->bss);
1760 kfree(auth_data);
1761 sdata->u.mgd.auth_data = NULL;
1762}
1763
1764static void ieee80211_auth_challenge(struct ieee80211_sub_if_data *sdata,
1765 struct ieee80211_mgmt *mgmt, size_t len)
1766{
1767 struct ieee80211_mgd_auth_data *auth_data = sdata->u.mgd.auth_data;
1768 u8 *pos;
1769 struct ieee802_11_elems elems;
1770
1771 pos = mgmt->u.auth.variable;
1772 ieee802_11_parse_elems(pos, len - (pos - (u8 *) mgmt), &elems);
1773 if (!elems.challenge)
1774 return;
1775 auth_data->expected_transaction = 4;
1776 ieee80211_send_auth(sdata, 3, auth_data->algorithm,
1777 elems.challenge - 2, elems.challenge_len + 2,
1778 auth_data->bss->bssid, auth_data->bss->bssid,
1779 auth_data->key, auth_data->key_len,
1780 auth_data->key_idx);
1781}
1782
1783static enum rx_mgmt_action __must_check
1784ieee80211_rx_mgmt_auth(struct ieee80211_sub_if_data *sdata,
1785 struct ieee80211_mgmt *mgmt, size_t len)
1786{
1787 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
1788 u8 bssid[ETH_ALEN];
1789 u16 auth_alg, auth_transaction, status_code;
1790 struct sta_info *sta;
1791
1792 lockdep_assert_held(&ifmgd->mtx);
1793
1794 if (len < 24 + 6)
1795 return RX_MGMT_NONE;
1796
1797 if (!ifmgd->auth_data || ifmgd->auth_data->done)
1798 return RX_MGMT_NONE;
1799
1800 memcpy(bssid, ifmgd->auth_data->bss->bssid, ETH_ALEN);
1801
Felix Fietkau888d04d2012-03-01 15:22:09 +01001802 if (compare_ether_addr(bssid, mgmt->bssid))
Johannes Berg66e67e42012-01-20 13:55:27 +01001803 return RX_MGMT_NONE;
1804
1805 auth_alg = le16_to_cpu(mgmt->u.auth.auth_alg);
1806 auth_transaction = le16_to_cpu(mgmt->u.auth.auth_transaction);
1807 status_code = le16_to_cpu(mgmt->u.auth.status_code);
1808
1809 if (auth_alg != ifmgd->auth_data->algorithm ||
1810 auth_transaction != ifmgd->auth_data->expected_transaction)
1811 return RX_MGMT_NONE;
1812
1813 if (status_code != WLAN_STATUS_SUCCESS) {
1814 printk(KERN_DEBUG "%s: %pM denied authentication (status %d)\n",
1815 sdata->name, mgmt->sa, status_code);
1816 goto out;
1817 }
1818
1819 switch (ifmgd->auth_data->algorithm) {
1820 case WLAN_AUTH_OPEN:
1821 case WLAN_AUTH_LEAP:
1822 case WLAN_AUTH_FT:
1823 break;
1824 case WLAN_AUTH_SHARED_KEY:
1825 if (ifmgd->auth_data->expected_transaction != 4) {
1826 ieee80211_auth_challenge(sdata, mgmt, len);
1827 /* need another frame */
1828 return RX_MGMT_NONE;
1829 }
1830 break;
1831 default:
1832 WARN_ONCE(1, "invalid auth alg %d",
1833 ifmgd->auth_data->algorithm);
1834 return RX_MGMT_NONE;
1835 }
1836
1837 printk(KERN_DEBUG "%s: authenticated\n", sdata->name);
1838 out:
Johannes Berg66e67e42012-01-20 13:55:27 +01001839 ifmgd->auth_data->done = true;
1840 ifmgd->auth_data->timeout = jiffies + IEEE80211_AUTH_WAIT_ASSOC;
1841 run_again(ifmgd, ifmgd->auth_data->timeout);
1842
1843 /* move station state to auth */
1844 mutex_lock(&sdata->local->sta_mtx);
1845 sta = sta_info_get(sdata, bssid);
1846 if (!sta) {
1847 WARN_ONCE(1, "%s: STA %pM not found", sdata->name, bssid);
1848 goto out_err;
1849 }
1850 if (sta_info_move_state(sta, IEEE80211_STA_AUTH)) {
1851 printk(KERN_DEBUG "%s: failed moving %pM to auth\n",
1852 sdata->name, bssid);
1853 goto out_err;
1854 }
1855 mutex_unlock(&sdata->local->sta_mtx);
1856
1857 return RX_MGMT_CFG80211_RX_AUTH;
1858 out_err:
1859 mutex_unlock(&sdata->local->sta_mtx);
1860 /* ignore frame -- wait for timeout */
1861 return RX_MGMT_NONE;
1862}
1863
1864
Johannes Berg77fdaa12009-07-07 03:45:17 +02001865static enum rx_mgmt_action __must_check
1866ieee80211_rx_mgmt_deauth(struct ieee80211_sub_if_data *sdata,
Johannes Berg77fdaa12009-07-07 03:45:17 +02001867 struct ieee80211_mgmt *mgmt, size_t len)
Jiri Bencf0706e82007-05-05 11:45:53 -07001868{
Johannes Berg46900292009-02-15 12:44:28 +01001869 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
Johannes Berg77fdaa12009-07-07 03:45:17 +02001870 const u8 *bssid = NULL;
Jiri Bencf0706e82007-05-05 11:45:53 -07001871 u16 reason_code;
1872
Johannes Berg66e67e42012-01-20 13:55:27 +01001873 lockdep_assert_held(&ifmgd->mtx);
1874
Johannes Bergf4ea83d2008-06-30 15:10:46 +02001875 if (len < 24 + 2)
Johannes Berg77fdaa12009-07-07 03:45:17 +02001876 return RX_MGMT_NONE;
Jiri Bencf0706e82007-05-05 11:45:53 -07001877
Johannes Berg66e67e42012-01-20 13:55:27 +01001878 if (!ifmgd->associated ||
Felix Fietkau888d04d2012-03-01 15:22:09 +01001879 compare_ether_addr(mgmt->bssid, ifmgd->associated->bssid))
Johannes Berg66e67e42012-01-20 13:55:27 +01001880 return RX_MGMT_NONE;
Johannes Berg77fdaa12009-07-07 03:45:17 +02001881
Johannes Berg0c1ad2c2009-12-23 13:15:39 +01001882 bssid = ifmgd->associated->bssid;
Jiri Bencf0706e82007-05-05 11:45:53 -07001883
1884 reason_code = le16_to_cpu(mgmt->u.deauth.reason_code);
1885
Johannes Berg77fdaa12009-07-07 03:45:17 +02001886 printk(KERN_DEBUG "%s: deauthenticated from %pM (Reason: %u)\n",
Johannes Berg47846c92009-11-25 17:46:19 +01001887 sdata->name, bssid, reason_code);
Jiri Bencf0706e82007-05-05 11:45:53 -07001888
Johannes Berg37ad3882012-02-24 13:50:54 +01001889 ieee80211_set_disassoc(sdata, 0, 0, false, NULL);
1890
Johannes Berg7da7cc12010-08-05 17:02:38 +02001891 mutex_lock(&sdata->local->mtx);
Johannes Berg63f170e2009-12-23 13:15:33 +01001892 ieee80211_recalc_idle(sdata->local);
Johannes Berg7da7cc12010-08-05 17:02:38 +02001893 mutex_unlock(&sdata->local->mtx);
Johannes Berg77fdaa12009-07-07 03:45:17 +02001894
1895 return RX_MGMT_CFG80211_DEAUTH;
Jiri Bencf0706e82007-05-05 11:45:53 -07001896}
1897
1898
Johannes Berg77fdaa12009-07-07 03:45:17 +02001899static enum rx_mgmt_action __must_check
1900ieee80211_rx_mgmt_disassoc(struct ieee80211_sub_if_data *sdata,
1901 struct ieee80211_mgmt *mgmt, size_t len)
Jiri Bencf0706e82007-05-05 11:45:53 -07001902{
Johannes Berg46900292009-02-15 12:44:28 +01001903 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
Jiri Bencf0706e82007-05-05 11:45:53 -07001904 u16 reason_code;
1905
Johannes Berg66e67e42012-01-20 13:55:27 +01001906 lockdep_assert_held(&ifmgd->mtx);
1907
Johannes Bergf4ea83d2008-06-30 15:10:46 +02001908 if (len < 24 + 2)
Johannes Berg77fdaa12009-07-07 03:45:17 +02001909 return RX_MGMT_NONE;
Jiri Bencf0706e82007-05-05 11:45:53 -07001910
Johannes Berg66e67e42012-01-20 13:55:27 +01001911 if (!ifmgd->associated ||
Felix Fietkau888d04d2012-03-01 15:22:09 +01001912 compare_ether_addr(mgmt->bssid, ifmgd->associated->bssid))
Johannes Berg77fdaa12009-07-07 03:45:17 +02001913 return RX_MGMT_NONE;
Jiri Bencf0706e82007-05-05 11:45:53 -07001914
1915 reason_code = le16_to_cpu(mgmt->u.disassoc.reason_code);
1916
Johannes Berg0ff71612009-09-26 14:45:41 +02001917 printk(KERN_DEBUG "%s: disassociated from %pM (Reason: %u)\n",
Johannes Berg47846c92009-11-25 17:46:19 +01001918 sdata->name, mgmt->sa, reason_code);
Jiri Bencf0706e82007-05-05 11:45:53 -07001919
Johannes Berg37ad3882012-02-24 13:50:54 +01001920 ieee80211_set_disassoc(sdata, 0, 0, false, NULL);
1921
Johannes Berg7da7cc12010-08-05 17:02:38 +02001922 mutex_lock(&sdata->local->mtx);
Johannes Bergbc83b682009-11-29 12:19:06 +01001923 ieee80211_recalc_idle(sdata->local);
Johannes Berg7da7cc12010-08-05 17:02:38 +02001924 mutex_unlock(&sdata->local->mtx);
Johannes Berg37ad3882012-02-24 13:50:54 +01001925
Johannes Berg77fdaa12009-07-07 03:45:17 +02001926 return RX_MGMT_CFG80211_DISASSOC;
Jiri Bencf0706e82007-05-05 11:45:53 -07001927}
1928
Christian Lamparterc74d0842011-10-15 00:14:49 +02001929static void ieee80211_get_rates(struct ieee80211_supported_band *sband,
1930 u8 *supp_rates, unsigned int supp_rates_len,
1931 u32 *rates, u32 *basic_rates,
1932 bool *have_higher_than_11mbit,
1933 int *min_rate, int *min_rate_index)
1934{
1935 int i, j;
1936
1937 for (i = 0; i < supp_rates_len; i++) {
1938 int rate = (supp_rates[i] & 0x7f) * 5;
1939 bool is_basic = !!(supp_rates[i] & 0x80);
1940
1941 if (rate > 110)
1942 *have_higher_than_11mbit = true;
1943
1944 /*
1945 * BSS_MEMBERSHIP_SELECTOR_HT_PHY is defined in 802.11n-2009
1946 * 7.3.2.2 as a magic value instead of a rate. Hence, skip it.
1947 *
1948 * Note: Even through the membership selector and the basic
1949 * rate flag share the same bit, they are not exactly
1950 * the same.
1951 */
1952 if (!!(supp_rates[i] & 0x80) &&
1953 (supp_rates[i] & 0x7f) == BSS_MEMBERSHIP_SELECTOR_HT_PHY)
1954 continue;
1955
1956 for (j = 0; j < sband->n_bitrates; j++) {
1957 if (sband->bitrates[j].bitrate == rate) {
1958 *rates |= BIT(j);
1959 if (is_basic)
1960 *basic_rates |= BIT(j);
1961 if (rate < *min_rate) {
1962 *min_rate = rate;
1963 *min_rate_index = j;
1964 }
1965 break;
1966 }
1967 }
1968 }
1969}
Jiri Bencf0706e82007-05-05 11:45:53 -07001970
Johannes Berg66e67e42012-01-20 13:55:27 +01001971static void ieee80211_destroy_assoc_data(struct ieee80211_sub_if_data *sdata,
1972 bool assoc)
1973{
1974 struct ieee80211_mgd_assoc_data *assoc_data = sdata->u.mgd.assoc_data;
1975
1976 lockdep_assert_held(&sdata->u.mgd.mtx);
1977
Johannes Berg66e67e42012-01-20 13:55:27 +01001978 if (!assoc) {
1979 sta_info_destroy_addr(sdata, assoc_data->bss->bssid);
1980
1981 memset(sdata->u.mgd.bssid, 0, ETH_ALEN);
1982 ieee80211_bss_info_change_notify(sdata, BSS_CHANGED_BSSID);
1983 }
1984
1985 kfree(assoc_data);
1986 sdata->u.mgd.assoc_data = NULL;
1987}
1988
1989static bool ieee80211_assoc_success(struct ieee80211_sub_if_data *sdata,
1990 struct cfg80211_bss *cbss,
Johannes Bergaf6b6372009-12-23 13:15:35 +01001991 struct ieee80211_mgmt *mgmt, size_t len)
Jiri Bencf0706e82007-05-05 11:45:53 -07001992{
Johannes Berg46900292009-02-15 12:44:28 +01001993 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
Johannes Berg471b3ef2007-12-28 14:32:58 +01001994 struct ieee80211_local *local = sdata->local;
Johannes Berg8318d782008-01-24 19:38:38 +01001995 struct ieee80211_supported_band *sband;
Jiri Bencf0706e82007-05-05 11:45:53 -07001996 struct sta_info *sta;
Johannes Bergaf6b6372009-12-23 13:15:35 +01001997 u8 *pos;
Johannes Bergaf6b6372009-12-23 13:15:35 +01001998 u16 capab_info, aid;
Jiri Bencf0706e82007-05-05 11:45:53 -07001999 struct ieee802_11_elems elems;
Johannes Bergbda39332008-10-11 01:51:51 +02002000 struct ieee80211_bss_conf *bss_conf = &sdata->vif.bss_conf;
Johannes Bergae5eb022008-10-14 16:58:37 +02002001 u32 changed = 0;
Christian Lamparterc74d0842011-10-15 00:14:49 +02002002 int err;
Johannes Bergae5eb022008-10-14 16:58:37 +02002003 u16 ap_ht_cap_flags;
Jiri Bencf0706e82007-05-05 11:45:53 -07002004
Johannes Bergaf6b6372009-12-23 13:15:35 +01002005 /* AssocResp and ReassocResp have identical structure */
Jiri Bencf0706e82007-05-05 11:45:53 -07002006
Jiri Bencf0706e82007-05-05 11:45:53 -07002007 aid = le16_to_cpu(mgmt->u.assoc_resp.aid);
Johannes Bergaf6b6372009-12-23 13:15:35 +01002008 capab_info = le16_to_cpu(mgmt->u.assoc_resp.capab_info);
Jiri Bencf0706e82007-05-05 11:45:53 -07002009
Johannes Berg1dd84aa2007-10-10 12:03:41 +02002010 if ((aid & (BIT(15) | BIT(14))) != (BIT(15) | BIT(14)))
Johannes Berg05cb9102011-10-28 11:59:47 +02002011 printk(KERN_DEBUG
2012 "%s: invalid AID value 0x%x; bits 15:14 not set\n",
2013 sdata->name, aid);
Johannes Berg1dd84aa2007-10-10 12:03:41 +02002014 aid &= ~(BIT(15) | BIT(14));
2015
Johannes Berg05cb9102011-10-28 11:59:47 +02002016 ifmgd->broken_ap = false;
2017
2018 if (aid == 0 || aid > IEEE80211_MAX_AID) {
2019 printk(KERN_DEBUG
2020 "%s: invalid AID value %d (out of range), turn off PS\n",
2021 sdata->name, aid);
2022 aid = 0;
2023 ifmgd->broken_ap = true;
2024 }
2025
Johannes Bergaf6b6372009-12-23 13:15:35 +01002026 pos = mgmt->u.assoc_resp.variable;
2027 ieee802_11_parse_elems(pos, len - (pos - (u8 *) mgmt), &elems);
2028
Jiri Bencf0706e82007-05-05 11:45:53 -07002029 if (!elems.supp_rates) {
2030 printk(KERN_DEBUG "%s: no SuppRates element in AssocResp\n",
Johannes Berg47846c92009-11-25 17:46:19 +01002031 sdata->name);
Johannes Bergaf6b6372009-12-23 13:15:35 +01002032 return false;
Jiri Bencf0706e82007-05-05 11:45:53 -07002033 }
2034
Johannes Berg46900292009-02-15 12:44:28 +01002035 ifmgd->aid = aid;
Jiri Bencf0706e82007-05-05 11:45:53 -07002036
Guy Eilam2a33bee2011-08-17 15:18:15 +03002037 mutex_lock(&sdata->local->sta_mtx);
2038 /*
2039 * station info was already allocated and inserted before
2040 * the association and should be available to us
2041 */
Johannes Berg7852e362012-01-20 13:55:24 +01002042 sta = sta_info_get(sdata, cbss->bssid);
Guy Eilam2a33bee2011-08-17 15:18:15 +03002043 if (WARN_ON(!sta)) {
2044 mutex_unlock(&sdata->local->sta_mtx);
Johannes Bergaf6b6372009-12-23 13:15:35 +01002045 return false;
Jiri Bencf0706e82007-05-05 11:45:53 -07002046 }
2047
Johannes Berg66e67e42012-01-20 13:55:27 +01002048 sband = local->hw.wiphy->bands[local->oper_channel->band];
Johannes Berg8318d782008-01-24 19:38:38 +01002049
Johannes Bergab1faea2009-07-01 21:41:17 +02002050 if (elems.ht_cap_elem && !(ifmgd->flags & IEEE80211_STA_DISABLE_11N))
Ben Greearef96a8422011-11-18 11:32:00 -08002051 ieee80211_ht_cap_ie_to_sta_ht_cap(sdata, sband,
Johannes Bergd9fe60d2008-10-09 12:13:49 +02002052 elems.ht_cap_elem, &sta->sta.ht_cap);
Johannes Bergae5eb022008-10-14 16:58:37 +02002053
2054 ap_ht_cap_flags = sta->sta.ht_cap.cap;
Ron Rindjunskyd3c990f2007-11-26 16:14:34 +02002055
Johannes Berg4b7679a2008-09-18 18:14:18 +02002056 rate_control_rate_init(sta);
Jiri Bencf0706e82007-05-05 11:45:53 -07002057
Johannes Berg46900292009-02-15 12:44:28 +01002058 if (ifmgd->flags & IEEE80211_STA_MFP_ENABLED)
Johannes Bergc2c98fd2011-09-29 16:04:36 +02002059 set_sta_flag(sta, WLAN_STA_MFP);
Jouni Malinen5394af42009-01-08 13:31:59 +02002060
Johannes Bergddf4ac52008-10-22 11:41:38 +02002061 if (elems.wmm_param)
Johannes Bergc2c98fd2011-09-29 16:04:36 +02002062 set_sta_flag(sta, WLAN_STA_WME);
Johannes Bergddf4ac52008-10-22 11:41:38 +02002063
Johannes Bergc8987872012-01-20 13:55:17 +01002064 err = sta_info_move_state(sta, IEEE80211_STA_AUTH);
2065 if (!err)
2066 err = sta_info_move_state(sta, IEEE80211_STA_ASSOC);
2067 if (!err && !(ifmgd->flags & IEEE80211_STA_CONTROL_PORT))
2068 err = sta_info_move_state(sta, IEEE80211_STA_AUTHORIZED);
2069 if (err) {
2070 printk(KERN_DEBUG
2071 "%s: failed to move station %pM to desired state\n",
2072 sdata->name, sta->sta.addr);
2073 WARN_ON(__sta_info_destroy(sta));
2074 mutex_unlock(&sdata->local->sta_mtx);
2075 return false;
2076 }
2077
Johannes Berg7852e362012-01-20 13:55:24 +01002078 mutex_unlock(&sdata->local->sta_mtx);
Johannes Bergddf4ac52008-10-22 11:41:38 +02002079
Juuso Oikarinenf2176d72010-09-28 14:39:32 +03002080 /*
2081 * Always handle WMM once after association regardless
2082 * of the first value the AP uses. Setting -1 here has
2083 * that effect because the AP values is an unsigned
2084 * 4-bit value.
2085 */
2086 ifmgd->wmm_last_param_set = -1;
2087
Johannes Bergddf4ac52008-10-22 11:41:38 +02002088 if (elems.wmm_param)
Johannes Berg4ced3f72010-07-19 16:39:04 +02002089 ieee80211_sta_wmm_params(local, sdata, elems.wmm_param,
Jiri Bencf0706e82007-05-05 11:45:53 -07002090 elems.wmm_param_len);
Johannes Bergaa837e12009-05-07 16:16:24 +02002091 else
Johannes Berg3abead52012-03-02 15:56:59 +01002092 ieee80211_set_wmm_default(sdata, false);
2093 changed |= BSS_CHANGED_QOS;
Jiri Bencf0706e82007-05-05 11:45:53 -07002094
Johannes Bergae5eb022008-10-14 16:58:37 +02002095 if (elems.ht_info_elem && elems.wmm_param &&
Johannes Bergab1faea2009-07-01 21:41:17 +02002096 !(ifmgd->flags & IEEE80211_STA_DISABLE_11N))
Johannes Bergae5eb022008-10-14 16:58:37 +02002097 changed |= ieee80211_enable_ht(sdata, elems.ht_info_elem,
Rajkumar Manoharan7cc44ed2011-09-16 15:32:34 +05302098 cbss->bssid, ap_ht_cap_flags,
2099 false);
Johannes Bergae5eb022008-10-14 16:58:37 +02002100
Tomas Winkler21c0cbe2008-03-28 16:33:34 -07002101 /* set AID and assoc capability,
2102 * ieee80211_set_associated() will tell the driver */
Johannes Berg8318d782008-01-24 19:38:38 +01002103 bss_conf->aid = aid;
Tomas Winkler21c0cbe2008-03-28 16:33:34 -07002104 bss_conf->assoc_capability = capab_info;
Johannes Berg0c1ad2c2009-12-23 13:15:39 +01002105 ieee80211_set_associated(sdata, cbss, changed);
Jiri Bencf0706e82007-05-05 11:45:53 -07002106
Kalle Valo15b7b062009-03-22 21:57:14 +02002107 /*
Felix Fietkaud5242152010-01-08 18:06:26 +01002108 * If we're using 4-addr mode, let the AP know that we're
2109 * doing so, so that it can create the STA VLAN on its side
2110 */
2111 if (ifmgd->use_4addr)
2112 ieee80211_send_4addr_nullfunc(local, sdata);
2113
2114 /*
Johannes Bergb291ba12009-07-10 15:29:03 +02002115 * Start timer to probe the connection to the AP now.
2116 * Also start the timer that will detect beacon loss.
Kalle Valo15b7b062009-03-22 21:57:14 +02002117 */
Johannes Bergb291ba12009-07-10 15:29:03 +02002118 ieee80211_sta_rx_notify(sdata, (struct ieee80211_hdr *)mgmt);
Luis R. Rodriguezd3a910a2010-09-16 15:12:32 -04002119 ieee80211_sta_reset_beacon_monitor(sdata);
Kalle Valo15b7b062009-03-22 21:57:14 +02002120
Johannes Bergaf6b6372009-12-23 13:15:35 +01002121 return true;
Jiri Bencf0706e82007-05-05 11:45:53 -07002122}
2123
Johannes Berg66e67e42012-01-20 13:55:27 +01002124static enum rx_mgmt_action __must_check
2125ieee80211_rx_mgmt_assoc_resp(struct ieee80211_sub_if_data *sdata,
2126 struct ieee80211_mgmt *mgmt, size_t len,
2127 struct cfg80211_bss **bss)
2128{
2129 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
2130 struct ieee80211_mgd_assoc_data *assoc_data = ifmgd->assoc_data;
2131 u16 capab_info, status_code, aid;
2132 struct ieee802_11_elems elems;
2133 u8 *pos;
2134 bool reassoc;
Jiri Bencf0706e82007-05-05 11:45:53 -07002135
Johannes Berg66e67e42012-01-20 13:55:27 +01002136 lockdep_assert_held(&ifmgd->mtx);
2137
2138 if (!assoc_data)
2139 return RX_MGMT_NONE;
Felix Fietkau888d04d2012-03-01 15:22:09 +01002140 if (compare_ether_addr(assoc_data->bss->bssid, mgmt->bssid))
Johannes Berg66e67e42012-01-20 13:55:27 +01002141 return RX_MGMT_NONE;
2142
2143 /*
2144 * AssocResp and ReassocResp have identical structure, so process both
2145 * of them in this function.
2146 */
2147
2148 if (len < 24 + 6)
2149 return RX_MGMT_NONE;
2150
2151 reassoc = ieee80211_is_reassoc_req(mgmt->frame_control);
2152 capab_info = le16_to_cpu(mgmt->u.assoc_resp.capab_info);
2153 status_code = le16_to_cpu(mgmt->u.assoc_resp.status_code);
2154 aid = le16_to_cpu(mgmt->u.assoc_resp.aid);
2155
2156 printk(KERN_DEBUG "%s: RX %sssocResp from %pM (capab=0x%x "
2157 "status=%d aid=%d)\n",
2158 sdata->name, reassoc ? "Rea" : "A", mgmt->sa,
2159 capab_info, status_code, (u16)(aid & ~(BIT(15) | BIT(14))));
2160
2161 pos = mgmt->u.assoc_resp.variable;
2162 ieee802_11_parse_elems(pos, len - (pos - (u8 *) mgmt), &elems);
2163
2164 if (status_code == WLAN_STATUS_ASSOC_REJECTED_TEMPORARILY &&
2165 elems.timeout_int && elems.timeout_int_len == 5 &&
2166 elems.timeout_int[0] == WLAN_TIMEOUT_ASSOC_COMEBACK) {
2167 u32 tu, ms;
2168 tu = get_unaligned_le32(elems.timeout_int + 1);
2169 ms = tu * 1024 / 1000;
2170 printk(KERN_DEBUG "%s: %pM rejected association temporarily; "
2171 "comeback duration %u TU (%u ms)\n",
2172 sdata->name, mgmt->sa, tu, ms);
2173 assoc_data->timeout = jiffies + msecs_to_jiffies(ms);
2174 if (ms > IEEE80211_ASSOC_TIMEOUT)
2175 run_again(ifmgd, assoc_data->timeout);
2176 return RX_MGMT_NONE;
2177 }
2178
2179 *bss = assoc_data->bss;
2180
2181 if (status_code != WLAN_STATUS_SUCCESS) {
2182 printk(KERN_DEBUG "%s: %pM denied association (code=%d)\n",
2183 sdata->name, mgmt->sa, status_code);
2184 ieee80211_destroy_assoc_data(sdata, false);
2185 } else {
2186 printk(KERN_DEBUG "%s: associated\n", sdata->name);
2187
Johannes Berg66e67e42012-01-20 13:55:27 +01002188 if (!ieee80211_assoc_success(sdata, *bss, mgmt, len)) {
2189 /* oops -- internal error -- send timeout for now */
Johannes Berg79ebfb82012-02-20 14:19:58 +01002190 ieee80211_destroy_assoc_data(sdata, true);
Johannes Berg66e67e42012-01-20 13:55:27 +01002191 sta_info_destroy_addr(sdata, mgmt->bssid);
2192 cfg80211_put_bss(*bss);
2193 return RX_MGMT_CFG80211_ASSOC_TIMEOUT;
2194 }
Johannes Berg79ebfb82012-02-20 14:19:58 +01002195
2196 /*
2197 * destroy assoc_data afterwards, as otherwise an idle
2198 * recalc after assoc_data is NULL but before associated
2199 * is set can cause the interface to go idle
2200 */
2201 ieee80211_destroy_assoc_data(sdata, true);
Johannes Berg66e67e42012-01-20 13:55:27 +01002202 }
2203
2204 return RX_MGMT_CFG80211_RX_ASSOC;
2205}
Jasper Bryant-Greenef698d852008-08-03 12:04:37 +12002206static void ieee80211_rx_bss_info(struct ieee80211_sub_if_data *sdata,
Jiri Bencf0706e82007-05-05 11:45:53 -07002207 struct ieee80211_mgmt *mgmt,
2208 size_t len,
2209 struct ieee80211_rx_status *rx_status,
Johannes Berg98c8fcc2008-09-08 17:44:26 +02002210 struct ieee802_11_elems *elems,
2211 bool beacon)
Jiri Bencf0706e82007-05-05 11:45:53 -07002212{
Jasper Bryant-Greenef698d852008-08-03 12:04:37 +12002213 struct ieee80211_local *local = sdata->local;
Johannes Berg98c8fcc2008-09-08 17:44:26 +02002214 int freq;
Johannes Bergc2b13452008-09-11 00:01:55 +02002215 struct ieee80211_bss *bss;
Johannes Bergfab7d4a2008-03-16 18:42:44 +01002216 struct ieee80211_channel *channel;
Johannes Berg56007a02010-01-26 14:19:52 +01002217 bool need_ps = false;
2218
Johannes Berg66e67e42012-01-20 13:55:27 +01002219 if (sdata->u.mgd.associated &&
Felix Fietkau888d04d2012-03-01 15:22:09 +01002220 compare_ether_addr(mgmt->bssid, sdata->u.mgd.associated->bssid)
2221 == 0) {
Johannes Berg56007a02010-01-26 14:19:52 +01002222 bss = (void *)sdata->u.mgd.associated->priv;
2223 /* not previously set so we may need to recalc */
2224 need_ps = !bss->dtim_period;
2225 }
Jiri Bencf0706e82007-05-05 11:45:53 -07002226
Johannes Berg5bda6172008-09-08 11:05:10 +02002227 if (elems->ds_params && elems->ds_params_len == 1)
Bruno Randolf59eb21a2011-01-17 13:37:28 +09002228 freq = ieee80211_channel_to_frequency(elems->ds_params[0],
2229 rx_status->band);
Johannes Berg5bda6172008-09-08 11:05:10 +02002230 else
2231 freq = rx_status->freq;
2232
2233 channel = ieee80211_get_channel(local->hw.wiphy, freq);
2234
2235 if (!channel || channel->flags & IEEE80211_CHAN_DISABLED)
2236 return;
Jiri Bencf0706e82007-05-05 11:45:53 -07002237
Johannes Berg98c8fcc2008-09-08 17:44:26 +02002238 bss = ieee80211_bss_info_update(local, rx_status, mgmt, len, elems,
Johannes Berg2a519312009-02-10 21:25:55 +01002239 channel, beacon);
Johannes Berg77fdaa12009-07-07 03:45:17 +02002240 if (bss)
2241 ieee80211_rx_bss_put(local, bss);
2242
2243 if (!sdata->u.mgd.associated)
Johannes Berg98c8fcc2008-09-08 17:44:26 +02002244 return;
Jiri Bencf0706e82007-05-05 11:45:53 -07002245
Johannes Berg56007a02010-01-26 14:19:52 +01002246 if (need_ps) {
2247 mutex_lock(&local->iflist_mtx);
2248 ieee80211_recalc_ps(local, -1);
2249 mutex_unlock(&local->iflist_mtx);
2250 }
2251
Sujithc481ec92009-01-06 09:28:37 +05302252 if (elems->ch_switch_elem && (elems->ch_switch_elem_len == 3) &&
Johannes Berg0c1ad2c2009-12-23 13:15:39 +01002253 (memcmp(mgmt->bssid, sdata->u.mgd.associated->bssid,
Johannes Berg77fdaa12009-07-07 03:45:17 +02002254 ETH_ALEN) == 0)) {
Sujithc481ec92009-01-06 09:28:37 +05302255 struct ieee80211_channel_sw_ie *sw_elem =
2256 (struct ieee80211_channel_sw_ie *)elems->ch_switch_elem;
Johannes Berg5ce6e432010-05-11 16:20:57 +02002257 ieee80211_sta_process_chanswitch(sdata, sw_elem,
2258 bss, rx_status->mactime);
Sujithc481ec92009-01-06 09:28:37 +05302259 }
Jiri Bencf0706e82007-05-05 11:45:53 -07002260}
2261
2262
Jasper Bryant-Greenef698d852008-08-03 12:04:37 +12002263static void ieee80211_rx_mgmt_probe_resp(struct ieee80211_sub_if_data *sdata,
Johannes Bergaf6b6372009-12-23 13:15:35 +01002264 struct sk_buff *skb)
Jiri Bencf0706e82007-05-05 11:45:53 -07002265{
Johannes Bergaf6b6372009-12-23 13:15:35 +01002266 struct ieee80211_mgmt *mgmt = (void *)skb->data;
Kalle Valo15b7b062009-03-22 21:57:14 +02002267 struct ieee80211_if_managed *ifmgd;
Johannes Bergaf6b6372009-12-23 13:15:35 +01002268 struct ieee80211_rx_status *rx_status = (void *) skb->cb;
2269 size_t baselen, len = skb->len;
Ester Kummerae6a44e2008-06-27 18:54:48 +03002270 struct ieee802_11_elems elems;
2271
Kalle Valo15b7b062009-03-22 21:57:14 +02002272 ifmgd = &sdata->u.mgd;
2273
Johannes Berg77fdaa12009-07-07 03:45:17 +02002274 ASSERT_MGD_MTX(ifmgd);
2275
Felix Fietkau888d04d2012-03-01 15:22:09 +01002276 if (compare_ether_addr(mgmt->da, sdata->vif.addr))
Tomas Winkler8e7cdbb2008-08-03 14:32:01 +03002277 return; /* ignore ProbeResp to foreign address */
2278
Ester Kummerae6a44e2008-06-27 18:54:48 +03002279 baselen = (u8 *) mgmt->u.probe_resp.variable - (u8 *) mgmt;
2280 if (baselen > len)
2281 return;
2282
2283 ieee802_11_parse_elems(mgmt->u.probe_resp.variable, len - baselen,
2284 &elems);
2285
Johannes Berg98c8fcc2008-09-08 17:44:26 +02002286 ieee80211_rx_bss_info(sdata, mgmt, len, rx_status, &elems, false);
Ron Rindjunsky9859b812008-08-09 03:02:19 +03002287
Johannes Berg77fdaa12009-07-07 03:45:17 +02002288 if (ifmgd->associated &&
Felix Fietkau888d04d2012-03-01 15:22:09 +01002289 compare_ether_addr(mgmt->bssid, ifmgd->associated->bssid) == 0)
Felix Fietkau4e5ff372010-11-23 03:10:31 +01002290 ieee80211_reset_ap_probe(sdata);
Johannes Berg66e67e42012-01-20 13:55:27 +01002291
2292 if (ifmgd->auth_data && !ifmgd->auth_data->bss->proberesp_ies &&
Felix Fietkau888d04d2012-03-01 15:22:09 +01002293 compare_ether_addr(mgmt->bssid, ifmgd->auth_data->bss->bssid)
2294 == 0) {
Johannes Berg66e67e42012-01-20 13:55:27 +01002295 /* got probe response, continue with auth */
2296 printk(KERN_DEBUG "%s: direct probe responded\n", sdata->name);
2297 ifmgd->auth_data->tries = 0;
2298 ifmgd->auth_data->timeout = jiffies;
2299 run_again(ifmgd, ifmgd->auth_data->timeout);
2300 }
Jiri Bencf0706e82007-05-05 11:45:53 -07002301}
2302
Johannes Bergd91f36d2009-04-16 13:17:26 +02002303/*
2304 * This is the canonical list of information elements we care about,
2305 * the filter code also gives us all changes to the Microsoft OUI
2306 * (00:50:F2) vendor IE which is used for WMM which we need to track.
2307 *
2308 * We implement beacon filtering in software since that means we can
2309 * avoid processing the frame here and in cfg80211, and userspace
2310 * will not be able to tell whether the hardware supports it or not.
2311 *
2312 * XXX: This list needs to be dynamic -- userspace needs to be able to
2313 * add items it requires. It also needs to be able to tell us to
2314 * look out for other vendor IEs.
2315 */
2316static const u64 care_about_ies =
Johannes Berg1d4df3a2009-04-22 11:25:43 +02002317 (1ULL << WLAN_EID_COUNTRY) |
2318 (1ULL << WLAN_EID_ERP_INFO) |
2319 (1ULL << WLAN_EID_CHANNEL_SWITCH) |
2320 (1ULL << WLAN_EID_PWR_CONSTRAINT) |
2321 (1ULL << WLAN_EID_HT_CAPABILITY) |
2322 (1ULL << WLAN_EID_HT_INFORMATION);
Johannes Bergd91f36d2009-04-16 13:17:26 +02002323
Jasper Bryant-Greenef698d852008-08-03 12:04:37 +12002324static void ieee80211_rx_mgmt_beacon(struct ieee80211_sub_if_data *sdata,
Jiri Bencf0706e82007-05-05 11:45:53 -07002325 struct ieee80211_mgmt *mgmt,
2326 size_t len,
2327 struct ieee80211_rx_status *rx_status)
2328{
Johannes Bergd91f36d2009-04-16 13:17:26 +02002329 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
Jouni Malinen17e4ec12010-03-29 23:28:30 -07002330 struct ieee80211_bss_conf *bss_conf = &sdata->vif.bss_conf;
Jiri Bencf0706e82007-05-05 11:45:53 -07002331 size_t baselen;
2332 struct ieee802_11_elems elems;
Jasper Bryant-Greenef698d852008-08-03 12:04:37 +12002333 struct ieee80211_local *local = sdata->local;
Johannes Berg471b3ef2007-12-28 14:32:58 +01002334 u32 changed = 0;
Johannes Bergd91f36d2009-04-16 13:17:26 +02002335 bool erp_valid, directed_tim = false;
Johannes Berg7a5158e2008-10-08 10:59:33 +02002336 u8 erp_value = 0;
Johannes Bergd91f36d2009-04-16 13:17:26 +02002337 u32 ncrc;
Johannes Berg77fdaa12009-07-07 03:45:17 +02002338 u8 *bssid;
2339
Johannes Berg66e67e42012-01-20 13:55:27 +01002340 lockdep_assert_held(&ifmgd->mtx);
Jiri Bencf0706e82007-05-05 11:45:53 -07002341
Ester Kummerae6a44e2008-06-27 18:54:48 +03002342 /* Process beacon from the current BSS */
2343 baselen = (u8 *) mgmt->u.beacon.variable - (u8 *) mgmt;
2344 if (baselen > len)
2345 return;
2346
Johannes Bergd91f36d2009-04-16 13:17:26 +02002347 if (rx_status->freq != local->hw.conf.channel->center_freq)
Jiri Bencf0706e82007-05-05 11:45:53 -07002348 return;
Jiri Bencf0706e82007-05-05 11:45:53 -07002349
Johannes Berg66e67e42012-01-20 13:55:27 +01002350 if (ifmgd->assoc_data && !ifmgd->assoc_data->have_beacon &&
Felix Fietkau888d04d2012-03-01 15:22:09 +01002351 compare_ether_addr(mgmt->bssid, ifmgd->assoc_data->bss->bssid)
2352 == 0) {
Johannes Berg66e67e42012-01-20 13:55:27 +01002353 ieee802_11_parse_elems(mgmt->u.beacon.variable,
2354 len - baselen, &elems);
Johannes Berg77fdaa12009-07-07 03:45:17 +02002355
Johannes Berg66e67e42012-01-20 13:55:27 +01002356 ieee80211_rx_bss_info(sdata, mgmt, len, rx_status, &elems,
2357 false);
2358 ifmgd->assoc_data->have_beacon = true;
2359 ifmgd->assoc_data->sent_assoc = false;
2360 /* continue assoc process */
2361 ifmgd->assoc_data->timeout = jiffies;
2362 run_again(ifmgd, ifmgd->assoc_data->timeout);
2363 return;
2364 }
2365
2366 if (!ifmgd->associated ||
Felix Fietkau888d04d2012-03-01 15:22:09 +01002367 compare_ether_addr(mgmt->bssid, ifmgd->associated->bssid))
Johannes Berg66e67e42012-01-20 13:55:27 +01002368 return;
Johannes Berg0c1ad2c2009-12-23 13:15:39 +01002369 bssid = ifmgd->associated->bssid;
Johannes Berg77fdaa12009-07-07 03:45:17 +02002370
Jouni Malinen17e4ec12010-03-29 23:28:30 -07002371 /* Track average RSSI from the Beacon frames of the current AP */
2372 ifmgd->last_beacon_signal = rx_status->signal;
2373 if (ifmgd->flags & IEEE80211_STA_RESET_SIGNAL_AVE) {
2374 ifmgd->flags &= ~IEEE80211_STA_RESET_SIGNAL_AVE;
Jouni Malinen3ba06c62010-08-27 22:21:13 +03002375 ifmgd->ave_beacon_signal = rx_status->signal * 16;
Jouni Malinen17e4ec12010-03-29 23:28:30 -07002376 ifmgd->last_cqm_event_signal = 0;
Jouni Malinen391a2002010-08-27 22:22:00 +03002377 ifmgd->count_beacon_signal = 1;
Meenakshi Venkataraman615f7b92011-07-08 08:46:22 -07002378 ifmgd->last_ave_beacon_signal = 0;
Jouni Malinen17e4ec12010-03-29 23:28:30 -07002379 } else {
2380 ifmgd->ave_beacon_signal =
2381 (IEEE80211_SIGNAL_AVE_WEIGHT * rx_status->signal * 16 +
2382 (16 - IEEE80211_SIGNAL_AVE_WEIGHT) *
2383 ifmgd->ave_beacon_signal) / 16;
Jouni Malinen391a2002010-08-27 22:22:00 +03002384 ifmgd->count_beacon_signal++;
Jouni Malinen17e4ec12010-03-29 23:28:30 -07002385 }
Meenakshi Venkataraman615f7b92011-07-08 08:46:22 -07002386
2387 if (ifmgd->rssi_min_thold != ifmgd->rssi_max_thold &&
2388 ifmgd->count_beacon_signal >= IEEE80211_SIGNAL_AVE_MIN_COUNT) {
2389 int sig = ifmgd->ave_beacon_signal;
2390 int last_sig = ifmgd->last_ave_beacon_signal;
2391
2392 /*
2393 * if signal crosses either of the boundaries, invoke callback
2394 * with appropriate parameters
2395 */
2396 if (sig > ifmgd->rssi_max_thold &&
2397 (last_sig <= ifmgd->rssi_min_thold || last_sig == 0)) {
2398 ifmgd->last_ave_beacon_signal = sig;
2399 drv_rssi_callback(local, RSSI_EVENT_HIGH);
2400 } else if (sig < ifmgd->rssi_min_thold &&
2401 (last_sig >= ifmgd->rssi_max_thold ||
2402 last_sig == 0)) {
2403 ifmgd->last_ave_beacon_signal = sig;
2404 drv_rssi_callback(local, RSSI_EVENT_LOW);
2405 }
2406 }
2407
Jouni Malinen17e4ec12010-03-29 23:28:30 -07002408 if (bss_conf->cqm_rssi_thold &&
Jouni Malinen391a2002010-08-27 22:22:00 +03002409 ifmgd->count_beacon_signal >= IEEE80211_SIGNAL_AVE_MIN_COUNT &&
Johannes Bergea086352012-01-19 09:29:58 +01002410 !(sdata->vif.driver_flags & IEEE80211_VIF_SUPPORTS_CQM_RSSI)) {
Jouni Malinen17e4ec12010-03-29 23:28:30 -07002411 int sig = ifmgd->ave_beacon_signal / 16;
2412 int last_event = ifmgd->last_cqm_event_signal;
2413 int thold = bss_conf->cqm_rssi_thold;
2414 int hyst = bss_conf->cqm_rssi_hyst;
2415 if (sig < thold &&
2416 (last_event == 0 || sig < last_event - hyst)) {
2417 ifmgd->last_cqm_event_signal = sig;
2418 ieee80211_cqm_rssi_notify(
2419 &sdata->vif,
2420 NL80211_CQM_RSSI_THRESHOLD_EVENT_LOW,
2421 GFP_KERNEL);
2422 } else if (sig > thold &&
2423 (last_event == 0 || sig > last_event + hyst)) {
2424 ifmgd->last_cqm_event_signal = sig;
2425 ieee80211_cqm_rssi_notify(
2426 &sdata->vif,
2427 NL80211_CQM_RSSI_THRESHOLD_EVENT_HIGH,
2428 GFP_KERNEL);
2429 }
2430 }
2431
Johannes Bergb291ba12009-07-10 15:29:03 +02002432 if (ifmgd->flags & IEEE80211_STA_BEACON_POLL) {
Jouni Malinen92778182009-05-14 21:15:36 +03002433#ifdef CONFIG_MAC80211_VERBOSE_DEBUG
2434 if (net_ratelimit()) {
2435 printk(KERN_DEBUG "%s: cancelling probereq poll due "
Johannes Berg47846c92009-11-25 17:46:19 +01002436 "to a received beacon\n", sdata->name);
Jouni Malinen92778182009-05-14 21:15:36 +03002437 }
2438#endif
Johannes Bergb291ba12009-07-10 15:29:03 +02002439 ifmgd->flags &= ~IEEE80211_STA_BEACON_POLL;
Johannes Berg4e751842009-06-10 15:16:52 +02002440 mutex_lock(&local->iflist_mtx);
2441 ieee80211_recalc_ps(local, -1);
2442 mutex_unlock(&local->iflist_mtx);
Jouni Malinen92778182009-05-14 21:15:36 +03002443 }
2444
Johannes Bergb291ba12009-07-10 15:29:03 +02002445 /*
2446 * Push the beacon loss detection into the future since
2447 * we are processing a beacon from the AP just now.
2448 */
Luis R. Rodriguezd3a910a2010-09-16 15:12:32 -04002449 ieee80211_sta_reset_beacon_monitor(sdata);
Johannes Bergb291ba12009-07-10 15:29:03 +02002450
Johannes Bergd91f36d2009-04-16 13:17:26 +02002451 ncrc = crc32_be(0, (void *)&mgmt->u.beacon.beacon_int, 4);
2452 ncrc = ieee802_11_parse_elems_crc(mgmt->u.beacon.variable,
2453 len - baselen, &elems,
2454 care_about_ies, ncrc);
2455
2456 if (local->hw.flags & IEEE80211_HW_PS_NULLFUNC_STACK)
Johannes Berge7ec86f2009-04-18 17:33:24 +02002457 directed_tim = ieee80211_check_tim(elems.tim, elems.tim_len,
2458 ifmgd->aid);
Johannes Bergd91f36d2009-04-16 13:17:26 +02002459
Juuso Oikarinend8ec4432010-10-01 16:02:31 +03002460 if (ncrc != ifmgd->beacon_crc || !ifmgd->beacon_crc_valid) {
Jouni Malinen30196672009-05-19 17:01:43 +03002461 ieee80211_rx_bss_info(sdata, mgmt, len, rx_status, &elems,
2462 true);
Johannes Bergd91f36d2009-04-16 13:17:26 +02002463
Johannes Berg4ced3f72010-07-19 16:39:04 +02002464 ieee80211_sta_wmm_params(local, sdata, elems.wmm_param,
Jouni Malinen30196672009-05-19 17:01:43 +03002465 elems.wmm_param_len);
2466 }
Johannes Bergfe3fa822008-09-08 11:05:09 +02002467
Vivek Natarajan25c9c872009-03-02 20:20:30 +05302468 if (local->hw.flags & IEEE80211_HW_PS_NULLFUNC_STACK) {
Kalle Valo1fb36062009-02-10 17:09:24 +02002469 if (directed_tim) {
Kalle Valo572e0012009-02-10 17:09:31 +02002470 if (local->hw.conf.dynamic_ps_timeout > 0) {
2471 local->hw.conf.flags &= ~IEEE80211_CONF_PS;
2472 ieee80211_hw_config(local,
2473 IEEE80211_CONF_CHANGE_PS);
2474 ieee80211_send_nullfunc(local, sdata, 0);
2475 } else {
2476 local->pspolling = true;
2477
2478 /*
2479 * Here is assumed that the driver will be
2480 * able to send ps-poll frame and receive a
2481 * response even though power save mode is
2482 * enabled, but some drivers might require
2483 * to disable power save here. This needs
2484 * to be investigated.
2485 */
2486 ieee80211_send_pspoll(local, sdata);
2487 }
Vivek Natarajana97b77b2008-12-23 18:39:02 -08002488 }
2489 }
Johannes Berg7a5158e2008-10-08 10:59:33 +02002490
Juuso Oikarinend8ec4432010-10-01 16:02:31 +03002491 if (ncrc == ifmgd->beacon_crc && ifmgd->beacon_crc_valid)
Jouni Malinen30196672009-05-19 17:01:43 +03002492 return;
2493 ifmgd->beacon_crc = ncrc;
Juuso Oikarinend8ec4432010-10-01 16:02:31 +03002494 ifmgd->beacon_crc_valid = true;
Jouni Malinen30196672009-05-19 17:01:43 +03002495
Johannes Berg7a5158e2008-10-08 10:59:33 +02002496 if (elems.erp_info && elems.erp_info_len >= 1) {
2497 erp_valid = true;
2498 erp_value = elems.erp_info[0];
2499 } else {
2500 erp_valid = false;
John W. Linville50c4afb2008-04-15 14:09:27 -04002501 }
Johannes Berg7a5158e2008-10-08 10:59:33 +02002502 changed |= ieee80211_handle_bss_capability(sdata,
2503 le16_to_cpu(mgmt->u.beacon.capab_info),
2504 erp_valid, erp_value);
Jiri Bencf0706e82007-05-05 11:45:53 -07002505
Ron Rindjunskyd3c990f2007-11-26 16:14:34 +02002506
Vasanthakumar Thiagarajan53d6f81c2009-02-11 22:18:49 +05302507 if (elems.ht_cap_elem && elems.ht_info_elem && elems.wmm_param &&
Johannes Bergab1faea2009-07-01 21:41:17 +02002508 !(ifmgd->flags & IEEE80211_STA_DISABLE_11N)) {
Johannes Bergae5eb022008-10-14 16:58:37 +02002509 struct sta_info *sta;
2510 struct ieee80211_supported_band *sband;
2511 u16 ap_ht_cap_flags;
2512
2513 rcu_read_lock();
2514
Johannes Bergabe60632009-11-25 17:46:18 +01002515 sta = sta_info_get(sdata, bssid);
Johannes Berg77fdaa12009-07-07 03:45:17 +02002516 if (WARN_ON(!sta)) {
Johannes Bergae5eb022008-10-14 16:58:37 +02002517 rcu_read_unlock();
2518 return;
2519 }
2520
2521 sband = local->hw.wiphy->bands[local->hw.conf.channel->band];
2522
Ben Greearef96a8422011-11-18 11:32:00 -08002523 ieee80211_ht_cap_ie_to_sta_ht_cap(sdata, sband,
Johannes Bergae5eb022008-10-14 16:58:37 +02002524 elems.ht_cap_elem, &sta->sta.ht_cap);
2525
2526 ap_ht_cap_flags = sta->sta.ht_cap.cap;
2527
2528 rcu_read_unlock();
2529
2530 changed |= ieee80211_enable_ht(sdata, elems.ht_info_elem,
Rajkumar Manoharan7cc44ed2011-09-16 15:32:34 +05302531 bssid, ap_ht_cap_flags, true);
Ron Rindjunskyd3c990f2007-11-26 16:14:34 +02002532 }
2533
Luis R. Rodriguez8b19e6c2009-07-30 17:38:09 -07002534 /* Note: country IE parsing is done for us by cfg80211 */
Luis R. Rodriguez3f2355c2008-11-12 14:22:02 -08002535 if (elems.country_elem) {
Vasanthakumar Thiagarajana8302de2009-01-09 18:14:15 +05302536 /* TODO: IBSS also needs this */
2537 if (elems.pwr_constr_elem)
2538 ieee80211_handle_pwr_constr(sdata,
2539 le16_to_cpu(mgmt->u.probe_resp.capab_info),
2540 elems.pwr_constr_elem,
2541 elems.pwr_constr_elem_len);
Luis R. Rodriguez3f2355c2008-11-12 14:22:02 -08002542 }
2543
Johannes Berg471b3ef2007-12-28 14:32:58 +01002544 ieee80211_bss_info_change_notify(sdata, changed);
Jiri Bencf0706e82007-05-05 11:45:53 -07002545}
2546
Johannes Berg1fa57d02010-06-10 10:21:32 +02002547void ieee80211_sta_rx_queued_mgmt(struct ieee80211_sub_if_data *sdata,
2548 struct sk_buff *skb)
Jiri Bencf0706e82007-05-05 11:45:53 -07002549{
Johannes Berg77fdaa12009-07-07 03:45:17 +02002550 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
Jiri Bencf0706e82007-05-05 11:45:53 -07002551 struct ieee80211_rx_status *rx_status;
Jiri Bencf0706e82007-05-05 11:45:53 -07002552 struct ieee80211_mgmt *mgmt;
Johannes Berg66e67e42012-01-20 13:55:27 +01002553 struct cfg80211_bss *bss = NULL;
Johannes Berg77fdaa12009-07-07 03:45:17 +02002554 enum rx_mgmt_action rma = RX_MGMT_NONE;
Jiri Bencf0706e82007-05-05 11:45:53 -07002555 u16 fc;
2556
Jiri Bencf0706e82007-05-05 11:45:53 -07002557 rx_status = (struct ieee80211_rx_status *) skb->cb;
2558 mgmt = (struct ieee80211_mgmt *) skb->data;
2559 fc = le16_to_cpu(mgmt->frame_control);
2560
Johannes Berg77fdaa12009-07-07 03:45:17 +02002561 mutex_lock(&ifmgd->mtx);
2562
Johannes Berg66e67e42012-01-20 13:55:27 +01002563 switch (fc & IEEE80211_FCTL_STYPE) {
2564 case IEEE80211_STYPE_BEACON:
2565 ieee80211_rx_mgmt_beacon(sdata, mgmt, skb->len, rx_status);
2566 break;
2567 case IEEE80211_STYPE_PROBE_RESP:
2568 ieee80211_rx_mgmt_probe_resp(sdata, skb);
2569 break;
2570 case IEEE80211_STYPE_AUTH:
2571 rma = ieee80211_rx_mgmt_auth(sdata, mgmt, skb->len);
2572 break;
2573 case IEEE80211_STYPE_DEAUTH:
2574 rma = ieee80211_rx_mgmt_deauth(sdata, mgmt, skb->len);
2575 break;
2576 case IEEE80211_STYPE_DISASSOC:
2577 rma = ieee80211_rx_mgmt_disassoc(sdata, mgmt, skb->len);
2578 break;
2579 case IEEE80211_STYPE_ASSOC_RESP:
2580 case IEEE80211_STYPE_REASSOC_RESP:
2581 rma = ieee80211_rx_mgmt_assoc_resp(sdata, mgmt, skb->len, &bss);
2582 break;
2583 case IEEE80211_STYPE_ACTION:
2584 switch (mgmt->u.action.category) {
2585 case WLAN_CATEGORY_SPECTRUM_MGMT:
2586 ieee80211_sta_process_chanswitch(sdata,
2587 &mgmt->u.action.u.chan_switch.sw_elem,
2588 (void *)ifmgd->associated->priv,
2589 rx_status->mactime);
Johannes Berg77fdaa12009-07-07 03:45:17 +02002590 break;
Johannes Berg77fdaa12009-07-07 03:45:17 +02002591 }
Johannes Berg77fdaa12009-07-07 03:45:17 +02002592 }
Johannes Berg77fdaa12009-07-07 03:45:17 +02002593 mutex_unlock(&ifmgd->mtx);
2594
Johannes Berg66e67e42012-01-20 13:55:27 +01002595 switch (rma) {
2596 case RX_MGMT_NONE:
2597 /* no action */
2598 break;
2599 case RX_MGMT_CFG80211_DEAUTH:
Holger Schurigce470612009-10-13 13:28:13 +02002600 cfg80211_send_deauth(sdata->dev, (u8 *)mgmt, skb->len);
Johannes Berg66e67e42012-01-20 13:55:27 +01002601 break;
2602 case RX_MGMT_CFG80211_DISASSOC:
2603 cfg80211_send_disassoc(sdata->dev, (u8 *)mgmt, skb->len);
2604 break;
2605 case RX_MGMT_CFG80211_RX_AUTH:
2606 cfg80211_send_rx_auth(sdata->dev, (u8 *)mgmt, skb->len);
2607 break;
2608 case RX_MGMT_CFG80211_RX_ASSOC:
2609 cfg80211_send_rx_assoc(sdata->dev, bss, (u8 *)mgmt, skb->len);
2610 break;
2611 case RX_MGMT_CFG80211_ASSOC_TIMEOUT:
2612 cfg80211_send_assoc_timeout(sdata->dev, mgmt->bssid);
2613 break;
2614 default:
2615 WARN(1, "unexpected: %d", rma);
Johannes Bergb054b742010-06-07 21:50:07 +02002616 }
Jiri Bencf0706e82007-05-05 11:45:53 -07002617}
2618
Johannes Berg9c6bd792008-09-11 00:01:52 +02002619static void ieee80211_sta_timer(unsigned long data)
Jiri Bencf0706e82007-05-05 11:45:53 -07002620{
2621 struct ieee80211_sub_if_data *sdata =
2622 (struct ieee80211_sub_if_data *) data;
Johannes Berg46900292009-02-15 12:44:28 +01002623 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
Jasper Bryant-Greenef698d852008-08-03 12:04:37 +12002624 struct ieee80211_local *local = sdata->local;
Jiri Bencf0706e82007-05-05 11:45:53 -07002625
Johannes Berg5bb644a2009-05-17 11:40:42 +02002626 if (local->quiescing) {
2627 set_bit(TMR_RUNNING_TIMER, &ifmgd->timers_running);
2628 return;
2629 }
2630
Johannes Berg64592c82010-06-10 10:21:31 +02002631 ieee80211_queue_work(&local->hw, &sdata->work);
Jiri Bencf0706e82007-05-05 11:45:53 -07002632}
2633
Felix Fietkau04ac3c02010-12-02 21:01:08 +01002634static void ieee80211_sta_connection_lost(struct ieee80211_sub_if_data *sdata,
Johannes Berg95acac62011-07-12 12:30:59 +02002635 u8 *bssid, u8 reason)
Felix Fietkau04ac3c02010-12-02 21:01:08 +01002636{
2637 struct ieee80211_local *local = sdata->local;
2638 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
Johannes Berg5fef7db2012-02-24 13:50:52 +01002639 u8 frame_buf[DEAUTH_DISASSOC_LEN];
Felix Fietkau04ac3c02010-12-02 21:01:08 +01002640
2641 ifmgd->flags &= ~(IEEE80211_STA_CONNECTION_POLL |
2642 IEEE80211_STA_BEACON_POLL);
2643
Johannes Berg37ad3882012-02-24 13:50:54 +01002644 ieee80211_set_disassoc(sdata, IEEE80211_STYPE_DEAUTH, reason,
2645 false, frame_buf);
Felix Fietkau04ac3c02010-12-02 21:01:08 +01002646 mutex_unlock(&ifmgd->mtx);
Johannes Berg37ad3882012-02-24 13:50:54 +01002647
Felix Fietkau04ac3c02010-12-02 21:01:08 +01002648 /*
2649 * must be outside lock due to cfg80211,
2650 * but that's not a problem.
2651 */
Johannes Berg5fef7db2012-02-24 13:50:52 +01002652 cfg80211_send_deauth(sdata->dev, frame_buf, DEAUTH_DISASSOC_LEN);
Felix Fietkaufcac4fb2011-11-16 13:34:55 +01002653
2654 mutex_lock(&local->mtx);
2655 ieee80211_recalc_idle(local);
2656 mutex_unlock(&local->mtx);
2657
Felix Fietkau04ac3c02010-12-02 21:01:08 +01002658 mutex_lock(&ifmgd->mtx);
2659}
2660
Johannes Berg66e67e42012-01-20 13:55:27 +01002661static int ieee80211_probe_auth(struct ieee80211_sub_if_data *sdata)
2662{
2663 struct ieee80211_local *local = sdata->local;
2664 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
2665 struct ieee80211_mgd_auth_data *auth_data = ifmgd->auth_data;
2666
2667 lockdep_assert_held(&ifmgd->mtx);
2668
2669 if (WARN_ON_ONCE(!auth_data))
2670 return -EINVAL;
2671
Johannes Berg66e67e42012-01-20 13:55:27 +01002672 auth_data->tries++;
2673
2674 if (auth_data->tries > IEEE80211_AUTH_MAX_TRIES) {
2675 printk(KERN_DEBUG "%s: authentication with %pM timed out\n",
2676 sdata->name, auth_data->bss->bssid);
2677
2678 /*
2679 * Most likely AP is not in the range so remove the
2680 * bss struct for that AP.
2681 */
2682 cfg80211_unlink_bss(local->hw.wiphy, auth_data->bss);
2683
2684 return -ETIMEDOUT;
2685 }
2686
2687 if (auth_data->bss->proberesp_ies) {
2688 printk(KERN_DEBUG "%s: send auth to %pM (try %d/%d)\n",
2689 sdata->name, auth_data->bss->bssid, auth_data->tries,
2690 IEEE80211_AUTH_MAX_TRIES);
2691
2692 auth_data->expected_transaction = 2;
2693 ieee80211_send_auth(sdata, 1, auth_data->algorithm,
2694 auth_data->ie, auth_data->ie_len,
2695 auth_data->bss->bssid,
2696 auth_data->bss->bssid, NULL, 0, 0);
2697 } else {
2698 const u8 *ssidie;
2699
2700 printk(KERN_DEBUG "%s: direct probe to %pM (try %d/%i)\n",
2701 sdata->name, auth_data->bss->bssid, auth_data->tries,
2702 IEEE80211_AUTH_MAX_TRIES);
2703
2704 ssidie = ieee80211_bss_get_ie(auth_data->bss, WLAN_EID_SSID);
2705 if (!ssidie)
2706 return -EINVAL;
2707 /*
2708 * Direct probe is sent to broadcast address as some APs
2709 * will not answer to direct packet in unassociated state.
2710 */
2711 ieee80211_send_probe_req(sdata, NULL, ssidie + 2, ssidie[1],
2712 NULL, 0, (u32) -1, true, false);
2713 }
2714
2715 auth_data->timeout = jiffies + IEEE80211_AUTH_TIMEOUT;
2716 run_again(ifmgd, auth_data->timeout);
2717
2718 return 0;
2719}
2720
2721static int ieee80211_do_assoc(struct ieee80211_sub_if_data *sdata)
2722{
2723 struct ieee80211_mgd_assoc_data *assoc_data = sdata->u.mgd.assoc_data;
2724 struct ieee80211_local *local = sdata->local;
2725
2726 lockdep_assert_held(&sdata->u.mgd.mtx);
2727
Johannes Berg66e67e42012-01-20 13:55:27 +01002728 assoc_data->tries++;
2729 if (assoc_data->tries > IEEE80211_ASSOC_MAX_TRIES) {
2730 printk(KERN_DEBUG "%s: association with %pM timed out\n",
2731 sdata->name, assoc_data->bss->bssid);
2732
2733 /*
2734 * Most likely AP is not in the range so remove the
2735 * bss struct for that AP.
2736 */
2737 cfg80211_unlink_bss(local->hw.wiphy, assoc_data->bss);
2738
2739 return -ETIMEDOUT;
2740 }
2741
2742 printk(KERN_DEBUG "%s: associate with %pM (try %d/%d)\n",
2743 sdata->name, assoc_data->bss->bssid, assoc_data->tries,
2744 IEEE80211_ASSOC_MAX_TRIES);
2745 ieee80211_send_assoc(sdata);
2746
2747 assoc_data->timeout = jiffies + IEEE80211_ASSOC_TIMEOUT;
2748 run_again(&sdata->u.mgd, assoc_data->timeout);
2749
2750 return 0;
2751}
2752
Johannes Berg1fa57d02010-06-10 10:21:32 +02002753void ieee80211_sta_work(struct ieee80211_sub_if_data *sdata)
Johannes Berg60f8b392008-09-08 17:44:22 +02002754{
Johannes Berg60f8b392008-09-08 17:44:22 +02002755 struct ieee80211_local *local = sdata->local;
Johannes Berg1fa57d02010-06-10 10:21:32 +02002756 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
Johannes Berg60f8b392008-09-08 17:44:22 +02002757
Johannes Berg77fdaa12009-07-07 03:45:17 +02002758 mutex_lock(&ifmgd->mtx);
Johannes Berg60f8b392008-09-08 17:44:22 +02002759
Johannes Berg66e67e42012-01-20 13:55:27 +01002760 if (ifmgd->auth_data &&
2761 time_after(jiffies, ifmgd->auth_data->timeout)) {
2762 if (ifmgd->auth_data->done) {
2763 /*
2764 * ok ... we waited for assoc but userspace didn't,
2765 * so let's just kill the auth data
2766 */
2767 ieee80211_destroy_auth_data(sdata, false);
2768 } else if (ieee80211_probe_auth(sdata)) {
2769 u8 bssid[ETH_ALEN];
2770
2771 memcpy(bssid, ifmgd->auth_data->bss->bssid, ETH_ALEN);
2772
2773 ieee80211_destroy_auth_data(sdata, false);
2774
2775 mutex_unlock(&ifmgd->mtx);
2776 cfg80211_send_auth_timeout(sdata->dev, bssid);
2777 mutex_lock(&ifmgd->mtx);
2778 }
2779 } else if (ifmgd->auth_data)
2780 run_again(ifmgd, ifmgd->auth_data->timeout);
2781
2782 if (ifmgd->assoc_data &&
2783 time_after(jiffies, ifmgd->assoc_data->timeout)) {
2784 if (!ifmgd->assoc_data->have_beacon ||
2785 ieee80211_do_assoc(sdata)) {
2786 u8 bssid[ETH_ALEN];
2787
2788 memcpy(bssid, ifmgd->assoc_data->bss->bssid, ETH_ALEN);
2789
2790 ieee80211_destroy_assoc_data(sdata, false);
2791
2792 mutex_unlock(&ifmgd->mtx);
2793 cfg80211_send_assoc_timeout(sdata->dev, bssid);
2794 mutex_lock(&ifmgd->mtx);
2795 }
2796 } else if (ifmgd->assoc_data)
2797 run_again(ifmgd, ifmgd->assoc_data->timeout);
2798
Johannes Bergb291ba12009-07-10 15:29:03 +02002799 if (ifmgd->flags & (IEEE80211_STA_BEACON_POLL |
2800 IEEE80211_STA_CONNECTION_POLL) &&
2801 ifmgd->associated) {
Maxim Levitskya43abf22009-07-31 18:54:12 +03002802 u8 bssid[ETH_ALEN];
Felix Fietkau72a8a3e2010-11-23 03:10:32 +01002803 int max_tries;
Maxim Levitskya43abf22009-07-31 18:54:12 +03002804
Johannes Berg0c1ad2c2009-12-23 13:15:39 +01002805 memcpy(bssid, ifmgd->associated->bssid, ETH_ALEN);
Felix Fietkau4e5ff372010-11-23 03:10:31 +01002806
Felix Fietkau72a8a3e2010-11-23 03:10:32 +01002807 if (local->hw.flags & IEEE80211_HW_REPORTS_TX_ACK_STATUS)
Ben Greear180205b2011-02-04 15:30:24 -08002808 max_tries = max_nullfunc_tries;
Felix Fietkau72a8a3e2010-11-23 03:10:32 +01002809 else
Ben Greear180205b2011-02-04 15:30:24 -08002810 max_tries = max_probe_tries;
Felix Fietkau72a8a3e2010-11-23 03:10:32 +01002811
Felix Fietkau4e5ff372010-11-23 03:10:31 +01002812 /* ACK received for nullfunc probing frame */
2813 if (!ifmgd->probe_send_count)
2814 ieee80211_reset_ap_probe(sdata);
Felix Fietkau04ac3c02010-12-02 21:01:08 +01002815 else if (ifmgd->nullfunc_failed) {
2816 if (ifmgd->probe_send_count < max_tries) {
2817#ifdef CONFIG_MAC80211_VERBOSE_DEBUG
2818 wiphy_debug(local->hw.wiphy,
2819 "%s: No ack for nullfunc frame to"
Ben Greearbfc31df2011-01-14 09:32:18 -08002820 " AP %pM, try %d/%i\n",
Felix Fietkau04ac3c02010-12-02 21:01:08 +01002821 sdata->name, bssid,
Ben Greearbfc31df2011-01-14 09:32:18 -08002822 ifmgd->probe_send_count, max_tries);
Felix Fietkau04ac3c02010-12-02 21:01:08 +01002823#endif
2824 ieee80211_mgd_probe_ap_send(sdata);
2825 } else {
2826#ifdef CONFIG_MAC80211_VERBOSE_DEBUG
2827 wiphy_debug(local->hw.wiphy,
2828 "%s: No ack for nullfunc frame to"
2829 " AP %pM, disconnecting.\n",
Felix Fietkauc658e5d2010-12-07 04:40:18 +01002830 sdata->name, bssid);
Felix Fietkau04ac3c02010-12-02 21:01:08 +01002831#endif
Johannes Berg95acac62011-07-12 12:30:59 +02002832 ieee80211_sta_connection_lost(sdata, bssid,
2833 WLAN_REASON_DISASSOC_DUE_TO_INACTIVITY);
Felix Fietkau04ac3c02010-12-02 21:01:08 +01002834 }
2835 } else if (time_is_after_jiffies(ifmgd->probe_timeout))
Johannes Bergb291ba12009-07-10 15:29:03 +02002836 run_again(ifmgd, ifmgd->probe_timeout);
Felix Fietkau04ac3c02010-12-02 21:01:08 +01002837 else if (local->hw.flags & IEEE80211_HW_REPORTS_TX_ACK_STATUS) {
2838#ifdef CONFIG_MAC80211_VERBOSE_DEBUG
2839 wiphy_debug(local->hw.wiphy,
2840 "%s: Failed to send nullfunc to AP %pM"
2841 " after %dms, disconnecting.\n",
2842 sdata->name,
Ben Greear180205b2011-02-04 15:30:24 -08002843 bssid, probe_wait_ms);
Felix Fietkau04ac3c02010-12-02 21:01:08 +01002844#endif
Johannes Berg95acac62011-07-12 12:30:59 +02002845 ieee80211_sta_connection_lost(sdata, bssid,
2846 WLAN_REASON_DISASSOC_DUE_TO_INACTIVITY);
Felix Fietkau04ac3c02010-12-02 21:01:08 +01002847 } else if (ifmgd->probe_send_count < max_tries) {
Maxim Levitskya43abf22009-07-31 18:54:12 +03002848#ifdef CONFIG_MAC80211_VERBOSE_DEBUG
Ben Greearb38afa82010-10-07 16:12:06 -07002849 wiphy_debug(local->hw.wiphy,
2850 "%s: No probe response from AP %pM"
Ben Greearbfc31df2011-01-14 09:32:18 -08002851 " after %dms, try %d/%i\n",
Ben Greearb38afa82010-10-07 16:12:06 -07002852 sdata->name,
Ben Greear180205b2011-02-04 15:30:24 -08002853 bssid, probe_wait_ms,
Ben Greearbfc31df2011-01-14 09:32:18 -08002854 ifmgd->probe_send_count, max_tries);
Maxim Levitskya43abf22009-07-31 18:54:12 +03002855#endif
2856 ieee80211_mgd_probe_ap_send(sdata);
2857 } else {
Johannes Bergb291ba12009-07-10 15:29:03 +02002858 /*
2859 * We actually lost the connection ... or did we?
2860 * Let's make sure!
2861 */
Ben Greearb38afa82010-10-07 16:12:06 -07002862 wiphy_debug(local->hw.wiphy,
2863 "%s: No probe response from AP %pM"
2864 " after %dms, disconnecting.\n",
2865 sdata->name,
Ben Greear180205b2011-02-04 15:30:24 -08002866 bssid, probe_wait_ms);
Felix Fietkau04ac3c02010-12-02 21:01:08 +01002867
Johannes Berg95acac62011-07-12 12:30:59 +02002868 ieee80211_sta_connection_lost(sdata, bssid,
2869 WLAN_REASON_DISASSOC_DUE_TO_INACTIVITY);
Johannes Bergb291ba12009-07-10 15:29:03 +02002870 }
2871 }
2872
Johannes Berg77fdaa12009-07-07 03:45:17 +02002873 mutex_unlock(&ifmgd->mtx);
Johannes Berg66e67e42012-01-20 13:55:27 +01002874
2875 mutex_lock(&local->mtx);
2876 ieee80211_recalc_idle(local);
2877 mutex_unlock(&local->mtx);
Johannes Berg60f8b392008-09-08 17:44:22 +02002878}
Johannes Berg0a51b272008-09-08 17:44:25 +02002879
Johannes Bergb291ba12009-07-10 15:29:03 +02002880static void ieee80211_sta_bcn_mon_timer(unsigned long data)
2881{
2882 struct ieee80211_sub_if_data *sdata =
2883 (struct ieee80211_sub_if_data *) data;
2884 struct ieee80211_local *local = sdata->local;
2885
2886 if (local->quiescing)
2887 return;
2888
Juuso Oikarinen1e4dcd02010-03-19 07:14:53 +02002889 ieee80211_queue_work(&sdata->local->hw,
2890 &sdata->u.mgd.beacon_connection_loss_work);
Johannes Bergb291ba12009-07-10 15:29:03 +02002891}
2892
2893static void ieee80211_sta_conn_mon_timer(unsigned long data)
2894{
2895 struct ieee80211_sub_if_data *sdata =
2896 (struct ieee80211_sub_if_data *) data;
2897 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
2898 struct ieee80211_local *local = sdata->local;
2899
2900 if (local->quiescing)
2901 return;
2902
Luis R. Rodriguez42935ec2009-07-29 20:08:07 -04002903 ieee80211_queue_work(&local->hw, &ifmgd->monitor_work);
Johannes Bergb291ba12009-07-10 15:29:03 +02002904}
2905
2906static void ieee80211_sta_monitor_work(struct work_struct *work)
2907{
2908 struct ieee80211_sub_if_data *sdata =
2909 container_of(work, struct ieee80211_sub_if_data,
2910 u.mgd.monitor_work);
2911
2912 ieee80211_mgd_probe_ap(sdata, false);
2913}
2914
Johannes Berga1678f82008-09-11 00:01:47 +02002915static void ieee80211_restart_sta_timer(struct ieee80211_sub_if_data *sdata)
2916{
Eliad Peller494f1fe2012-02-19 15:26:09 +02002917 u32 flags;
2918
Kalle Vaload935682009-04-19 08:47:19 +03002919 if (sdata->vif.type == NL80211_IFTYPE_STATION) {
Johannes Bergb291ba12009-07-10 15:29:03 +02002920 sdata->u.mgd.flags &= ~(IEEE80211_STA_BEACON_POLL |
2921 IEEE80211_STA_CONNECTION_POLL);
Kalle Vaload935682009-04-19 08:47:19 +03002922
Johannes Bergb291ba12009-07-10 15:29:03 +02002923 /* let's probe the connection once */
Eliad Peller494f1fe2012-02-19 15:26:09 +02002924 flags = sdata->local->hw.flags;
2925 if (!(flags & IEEE80211_HW_CONNECTION_MONITOR))
2926 ieee80211_queue_work(&sdata->local->hw,
2927 &sdata->u.mgd.monitor_work);
Johannes Bergb291ba12009-07-10 15:29:03 +02002928 /* and do all the other regular work too */
Johannes Berg64592c82010-06-10 10:21:31 +02002929 ieee80211_queue_work(&sdata->local->hw, &sdata->work);
Kalle Vaload935682009-04-19 08:47:19 +03002930 }
Johannes Berga1678f82008-09-11 00:01:47 +02002931}
2932
Johannes Berg5bb644a2009-05-17 11:40:42 +02002933#ifdef CONFIG_PM
2934void ieee80211_sta_quiesce(struct ieee80211_sub_if_data *sdata)
2935{
2936 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
2937
2938 /*
2939 * we need to use atomic bitops for the running bits
2940 * only because both timers might fire at the same
2941 * time -- the code here is properly synchronised.
2942 */
2943
Johannes Bergd1f5b7a2010-08-05 17:05:55 +02002944 cancel_work_sync(&ifmgd->request_smps_work);
2945
Johannes Berg0ecfe8062011-11-09 12:14:16 +01002946 cancel_work_sync(&ifmgd->monitor_work);
Juuso Oikarinen1e4dcd02010-03-19 07:14:53 +02002947 cancel_work_sync(&ifmgd->beacon_connection_loss_work);
Johannes Berg5bb644a2009-05-17 11:40:42 +02002948 if (del_timer_sync(&ifmgd->timer))
2949 set_bit(TMR_RUNNING_TIMER, &ifmgd->timers_running);
2950
2951 cancel_work_sync(&ifmgd->chswitch_work);
2952 if (del_timer_sync(&ifmgd->chswitch_timer))
2953 set_bit(TMR_RUNNING_CHANSW, &ifmgd->timers_running);
Johannes Bergb291ba12009-07-10 15:29:03 +02002954
Johannes Bergb291ba12009-07-10 15:29:03 +02002955 /* these will just be re-established on connection */
2956 del_timer_sync(&ifmgd->conn_mon_timer);
2957 del_timer_sync(&ifmgd->bcn_mon_timer);
Johannes Berg5bb644a2009-05-17 11:40:42 +02002958}
2959
2960void ieee80211_sta_restart(struct ieee80211_sub_if_data *sdata)
2961{
2962 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
2963
Rajkumar Manoharan676b58c2011-07-07 23:33:39 +05302964 if (!ifmgd->associated)
2965 return;
2966
Johannes Berg95acac62011-07-12 12:30:59 +02002967 if (sdata->flags & IEEE80211_SDATA_DISCONNECT_RESUME) {
2968 sdata->flags &= ~IEEE80211_SDATA_DISCONNECT_RESUME;
2969 mutex_lock(&ifmgd->mtx);
2970 if (ifmgd->associated) {
2971#ifdef CONFIG_MAC80211_VERBOSE_DEBUG
2972 wiphy_debug(sdata->local->hw.wiphy,
2973 "%s: driver requested disconnect after resume.\n",
2974 sdata->name);
2975#endif
2976 ieee80211_sta_connection_lost(sdata,
2977 ifmgd->associated->bssid,
2978 WLAN_REASON_UNSPECIFIED);
2979 mutex_unlock(&ifmgd->mtx);
2980 return;
2981 }
2982 mutex_unlock(&ifmgd->mtx);
2983 }
2984
Johannes Berg5bb644a2009-05-17 11:40:42 +02002985 if (test_and_clear_bit(TMR_RUNNING_TIMER, &ifmgd->timers_running))
2986 add_timer(&ifmgd->timer);
2987 if (test_and_clear_bit(TMR_RUNNING_CHANSW, &ifmgd->timers_running))
2988 add_timer(&ifmgd->chswitch_timer);
Felix Fietkauc8a79722010-11-19 22:55:37 +01002989 ieee80211_sta_reset_beacon_monitor(sdata);
Felix Fietkau46090972010-11-23 20:28:03 +01002990 ieee80211_restart_sta_timer(sdata);
Johannes Berg5bb644a2009-05-17 11:40:42 +02002991}
2992#endif
2993
Johannes Berg9c6bd792008-09-11 00:01:52 +02002994/* interface setup */
2995void ieee80211_sta_setup_sdata(struct ieee80211_sub_if_data *sdata)
2996{
Johannes Berg46900292009-02-15 12:44:28 +01002997 struct ieee80211_if_managed *ifmgd;
Johannes Berg9c6bd792008-09-11 00:01:52 +02002998
Johannes Berg46900292009-02-15 12:44:28 +01002999 ifmgd = &sdata->u.mgd;
Johannes Bergb291ba12009-07-10 15:29:03 +02003000 INIT_WORK(&ifmgd->monitor_work, ieee80211_sta_monitor_work);
Johannes Berg46900292009-02-15 12:44:28 +01003001 INIT_WORK(&ifmgd->chswitch_work, ieee80211_chswitch_work);
Juuso Oikarinen1e4dcd02010-03-19 07:14:53 +02003002 INIT_WORK(&ifmgd->beacon_connection_loss_work,
3003 ieee80211_beacon_connection_loss_work);
Johannes Bergd1f5b7a2010-08-05 17:05:55 +02003004 INIT_WORK(&ifmgd->request_smps_work, ieee80211_request_smps_work);
Johannes Berg46900292009-02-15 12:44:28 +01003005 setup_timer(&ifmgd->timer, ieee80211_sta_timer,
Johannes Berg9c6bd792008-09-11 00:01:52 +02003006 (unsigned long) sdata);
Johannes Bergb291ba12009-07-10 15:29:03 +02003007 setup_timer(&ifmgd->bcn_mon_timer, ieee80211_sta_bcn_mon_timer,
3008 (unsigned long) sdata);
3009 setup_timer(&ifmgd->conn_mon_timer, ieee80211_sta_conn_mon_timer,
3010 (unsigned long) sdata);
Johannes Berg46900292009-02-15 12:44:28 +01003011 setup_timer(&ifmgd->chswitch_timer, ieee80211_chswitch_timer,
Sujithc481ec92009-01-06 09:28:37 +05303012 (unsigned long) sdata);
Johannes Berg9c6bd792008-09-11 00:01:52 +02003013
Johannes Bergab1faea2009-07-01 21:41:17 +02003014 ifmgd->flags = 0;
Mohammed Shafi Shajakhan1478acb2011-12-14 19:46:08 +05303015 ifmgd->powersave = sdata->wdev.ps;
Eliad Pellerdc41e4d2012-03-14 16:15:03 +02003016 ifmgd->uapsd_queues = IEEE80211_DEFAULT_UAPSD_QUEUES;
3017 ifmgd->uapsd_max_sp_len = IEEE80211_DEFAULT_MAX_SP_LEN;
Johannes Bergbbbdff92009-04-16 13:27:42 +02003018
Johannes Berg77fdaa12009-07-07 03:45:17 +02003019 mutex_init(&ifmgd->mtx);
Johannes Berg0f782312009-12-01 13:37:02 +01003020
3021 if (sdata->local->hw.flags & IEEE80211_HW_SUPPORTS_DYNAMIC_SMPS)
3022 ifmgd->req_smps = IEEE80211_SMPS_AUTOMATIC;
3023 else
3024 ifmgd->req_smps = IEEE80211_SMPS_OFF;
Johannes Berg9c6bd792008-09-11 00:01:52 +02003025}
3026
3027/* scan finished notification */
Johannes Berg0a51b272008-09-08 17:44:25 +02003028void ieee80211_mlme_notify_scan_completed(struct ieee80211_local *local)
3029{
3030 struct ieee80211_sub_if_data *sdata = local->scan_sdata;
Johannes Berga1678f82008-09-11 00:01:47 +02003031
3032 /* Restart STA timers */
3033 rcu_read_lock();
3034 list_for_each_entry_rcu(sdata, &local->interfaces, list)
3035 ieee80211_restart_sta_timer(sdata);
3036 rcu_read_unlock();
Johannes Berg0a51b272008-09-08 17:44:25 +02003037}
Johannes Berg10f644a2009-04-16 13:17:25 +02003038
3039int ieee80211_max_network_latency(struct notifier_block *nb,
3040 unsigned long data, void *dummy)
3041{
3042 s32 latency_usec = (s32) data;
3043 struct ieee80211_local *local =
3044 container_of(nb, struct ieee80211_local,
3045 network_latency_notifier);
3046
3047 mutex_lock(&local->iflist_mtx);
3048 ieee80211_recalc_ps(local, latency_usec);
3049 mutex_unlock(&local->iflist_mtx);
3050
3051 return 0;
3052}
Johannes Berg77fdaa12009-07-07 03:45:17 +02003053
Johannes Berga1cf7752012-03-08 15:02:07 +01003054static int ieee80211_prep_connection(struct ieee80211_sub_if_data *sdata,
Johannes Berg5d6a1b02012-03-08 15:02:08 +01003055 struct cfg80211_bss *cbss, bool assoc)
Johannes Berga1cf7752012-03-08 15:02:07 +01003056{
3057 struct ieee80211_local *local = sdata->local;
3058 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
Johannes Berg5d6a1b02012-03-08 15:02:08 +01003059 struct ieee80211_bss *bss = (void *)cbss->priv;
Johannes Berga1cf7752012-03-08 15:02:07 +01003060 struct sta_info *sta;
3061 bool have_sta = false;
3062 int err;
3063
3064 if (WARN_ON(!ifmgd->auth_data && !ifmgd->assoc_data))
3065 return -EINVAL;
3066
3067 if (assoc) {
3068 rcu_read_lock();
Johannes Berg5d6a1b02012-03-08 15:02:08 +01003069 have_sta = sta_info_get(sdata, cbss->bssid);
Johannes Berga1cf7752012-03-08 15:02:07 +01003070 rcu_read_unlock();
3071 }
3072
3073 if (!have_sta) {
Johannes Berg5d6a1b02012-03-08 15:02:08 +01003074 sta = sta_info_alloc(sdata, cbss->bssid, GFP_KERNEL);
Johannes Berga1cf7752012-03-08 15:02:07 +01003075 if (!sta)
3076 return -ENOMEM;
3077 }
3078
3079 mutex_lock(&local->mtx);
3080 ieee80211_recalc_idle(sdata->local);
3081 mutex_unlock(&local->mtx);
3082
3083 /* switch to the right channel */
Johannes Berg5d6a1b02012-03-08 15:02:08 +01003084 local->oper_channel = cbss->channel;
Johannes Berga1cf7752012-03-08 15:02:07 +01003085 ieee80211_hw_config(local, IEEE80211_CONF_CHANGE_CHANNEL);
3086
3087 if (!have_sta) {
Johannes Berg5d6a1b02012-03-08 15:02:08 +01003088 struct ieee80211_supported_band *sband;
3089 u32 rates = 0, basic_rates = 0;
3090 bool have_higher_than_11mbit;
3091 int min_rate = INT_MAX, min_rate_index = -1;
3092
3093 sband = sdata->local->hw.wiphy->bands[cbss->channel->band];
3094
3095 ieee80211_get_rates(sband, bss->supp_rates,
3096 bss->supp_rates_len,
3097 &rates, &basic_rates,
3098 &have_higher_than_11mbit,
3099 &min_rate, &min_rate_index);
3100
3101 /*
3102 * This used to be a workaround for basic rates missing
3103 * in the association response frame. Now that we no
3104 * longer use the basic rates from there, it probably
3105 * doesn't happen any more, but keep the workaround so
3106 * in case some *other* APs are buggy in different ways
3107 * we can connect -- with a warning.
3108 */
3109 if (!basic_rates && min_rate_index >= 0) {
3110 printk(KERN_DEBUG
3111 "%s: No basic rates, using min rate instead.\n",
3112 sdata->name);
3113 basic_rates = BIT(min_rate_index);
3114 }
3115
3116 sta->sta.supp_rates[cbss->channel->band] = rates;
3117 sdata->vif.bss_conf.basic_rates = basic_rates;
3118
3119 /* cf. IEEE 802.11 9.2.12 */
3120 if (local->oper_channel->band == IEEE80211_BAND_2GHZ &&
3121 have_higher_than_11mbit)
3122 sdata->flags |= IEEE80211_SDATA_OPERATING_GMODE;
3123 else
3124 sdata->flags &= ~IEEE80211_SDATA_OPERATING_GMODE;
3125
3126 memcpy(ifmgd->bssid, cbss->bssid, ETH_ALEN);
3127
3128 /* tell driver about BSSID and basic rates */
3129 ieee80211_bss_info_change_notify(sdata,
3130 BSS_CHANGED_BSSID | BSS_CHANGED_BASIC_RATES);
Johannes Berga1cf7752012-03-08 15:02:07 +01003131
3132 if (assoc)
3133 sta_info_pre_move_state(sta, IEEE80211_STA_AUTH);
3134
3135 err = sta_info_insert(sta);
3136 sta = NULL;
3137 if (err) {
3138 printk(KERN_DEBUG
3139 "%s: failed to insert STA entry for the AP (error %d)\n",
3140 sdata->name, err);
3141 return err;
3142 }
3143 } else
Johannes Berg5d6a1b02012-03-08 15:02:08 +01003144 WARN_ON_ONCE(compare_ether_addr(ifmgd->bssid, cbss->bssid));
Johannes Berga1cf7752012-03-08 15:02:07 +01003145
3146 return 0;
3147}
3148
Johannes Berg77fdaa12009-07-07 03:45:17 +02003149/* config hooks */
3150int ieee80211_mgd_auth(struct ieee80211_sub_if_data *sdata,
3151 struct cfg80211_auth_request *req)
3152{
Johannes Berg66e67e42012-01-20 13:55:27 +01003153 struct ieee80211_local *local = sdata->local;
3154 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
3155 struct ieee80211_mgd_auth_data *auth_data;
Johannes Berg77fdaa12009-07-07 03:45:17 +02003156 u16 auth_alg;
Johannes Berg66e67e42012-01-20 13:55:27 +01003157 int err;
3158
3159 /* prepare auth data structure */
Johannes Berg77fdaa12009-07-07 03:45:17 +02003160
3161 switch (req->auth_type) {
3162 case NL80211_AUTHTYPE_OPEN_SYSTEM:
3163 auth_alg = WLAN_AUTH_OPEN;
3164 break;
3165 case NL80211_AUTHTYPE_SHARED_KEY:
Johannes Berg66e67e42012-01-20 13:55:27 +01003166 if (IS_ERR(local->wep_tx_tfm))
Johannes Berg9dca9c42010-07-21 10:09:25 +02003167 return -EOPNOTSUPP;
Johannes Berg77fdaa12009-07-07 03:45:17 +02003168 auth_alg = WLAN_AUTH_SHARED_KEY;
3169 break;
3170 case NL80211_AUTHTYPE_FT:
3171 auth_alg = WLAN_AUTH_FT;
3172 break;
3173 case NL80211_AUTHTYPE_NETWORK_EAP:
3174 auth_alg = WLAN_AUTH_LEAP;
3175 break;
3176 default:
3177 return -EOPNOTSUPP;
3178 }
3179
Johannes Berg66e67e42012-01-20 13:55:27 +01003180 auth_data = kzalloc(sizeof(*auth_data) + req->ie_len, GFP_KERNEL);
3181 if (!auth_data)
Johannes Berg77fdaa12009-07-07 03:45:17 +02003182 return -ENOMEM;
3183
Johannes Berg66e67e42012-01-20 13:55:27 +01003184 auth_data->bss = req->bss;
Johannes Berg77fdaa12009-07-07 03:45:17 +02003185
3186 if (req->ie && req->ie_len) {
Johannes Berg66e67e42012-01-20 13:55:27 +01003187 memcpy(auth_data->ie, req->ie, req->ie_len);
3188 auth_data->ie_len = req->ie_len;
Johannes Berg77fdaa12009-07-07 03:45:17 +02003189 }
3190
Johannes Bergfffd0932009-07-08 14:22:54 +02003191 if (req->key && req->key_len) {
Johannes Berg66e67e42012-01-20 13:55:27 +01003192 auth_data->key_len = req->key_len;
3193 auth_data->key_idx = req->key_idx;
3194 memcpy(auth_data->key, req->key, req->key_len);
Johannes Bergfffd0932009-07-08 14:22:54 +02003195 }
3196
Johannes Berg66e67e42012-01-20 13:55:27 +01003197 auth_data->algorithm = auth_alg;
Johannes Berg77fdaa12009-07-07 03:45:17 +02003198
Johannes Berg66e67e42012-01-20 13:55:27 +01003199 /* try to authenticate/probe */
Johannes Bergf679f652009-12-23 13:15:34 +01003200
Johannes Berg66e67e42012-01-20 13:55:27 +01003201 mutex_lock(&ifmgd->mtx);
Johannes Berg77fdaa12009-07-07 03:45:17 +02003202
Johannes Berg66e67e42012-01-20 13:55:27 +01003203 if ((ifmgd->auth_data && !ifmgd->auth_data->done) ||
3204 ifmgd->assoc_data) {
3205 err = -EBUSY;
3206 goto err_free;
3207 }
Johannes Berg77fdaa12009-07-07 03:45:17 +02003208
Johannes Berg66e67e42012-01-20 13:55:27 +01003209 if (ifmgd->auth_data)
3210 ieee80211_destroy_auth_data(sdata, false);
Guy Eilam2a33bee2011-08-17 15:18:15 +03003211
Johannes Berg66e67e42012-01-20 13:55:27 +01003212 /* prep auth_data so we don't go into idle on disassoc */
3213 ifmgd->auth_data = auth_data;
3214
3215 if (ifmgd->associated)
Johannes Berg37ad3882012-02-24 13:50:54 +01003216 ieee80211_set_disassoc(sdata, 0, 0, false, NULL);
Johannes Berg66e67e42012-01-20 13:55:27 +01003217
3218 printk(KERN_DEBUG "%s: authenticate with %pM\n",
3219 sdata->name, req->bss->bssid);
3220
Johannes Berga1cf7752012-03-08 15:02:07 +01003221 err = ieee80211_prep_connection(sdata, req->bss, false);
3222 if (err)
Johannes Berg66e67e42012-01-20 13:55:27 +01003223 goto err_clear;
Guy Eilam2a33bee2011-08-17 15:18:15 +03003224
Johannes Berg66e67e42012-01-20 13:55:27 +01003225 err = ieee80211_probe_auth(sdata);
3226 if (err) {
Johannes Berg66e67e42012-01-20 13:55:27 +01003227 sta_info_destroy_addr(sdata, req->bss->bssid);
3228 goto err_clear;
Johannes Bergaf6b6372009-12-23 13:15:35 +01003229 }
3230
Johannes Berg66e67e42012-01-20 13:55:27 +01003231 /* hold our own reference */
3232 cfg80211_ref_bss(auth_data->bss);
3233 err = 0;
3234 goto out_unlock;
Johannes Berge5b900d2010-07-29 16:08:55 +02003235
Johannes Berg66e67e42012-01-20 13:55:27 +01003236 err_clear:
3237 ifmgd->auth_data = NULL;
3238 err_free:
3239 kfree(auth_data);
3240 out_unlock:
3241 mutex_unlock(&ifmgd->mtx);
Johannes Berge5b900d2010-07-29 16:08:55 +02003242
Johannes Berg66e67e42012-01-20 13:55:27 +01003243 return err;
Johannes Bergaf6b6372009-12-23 13:15:35 +01003244}
3245
Johannes Berg77fdaa12009-07-07 03:45:17 +02003246int ieee80211_mgd_assoc(struct ieee80211_sub_if_data *sdata,
3247 struct cfg80211_assoc_request *req)
3248{
Johannes Berg66e67e42012-01-20 13:55:27 +01003249 struct ieee80211_local *local = sdata->local;
Johannes Berg77fdaa12009-07-07 03:45:17 +02003250 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
Johannes Berg0c1ad2c2009-12-23 13:15:39 +01003251 struct ieee80211_bss *bss = (void *)req->bss->priv;
Johannes Berg66e67e42012-01-20 13:55:27 +01003252 struct ieee80211_mgd_assoc_data *assoc_data;
Johannes Berg4e74bfd2012-03-08 15:02:04 +01003253 struct ieee80211_supported_band *sband;
Johannes Berg66e67e42012-01-20 13:55:27 +01003254 const u8 *ssidie;
Guy Eilam2a33bee2011-08-17 15:18:15 +03003255 int i, err;
Johannes Berg77fdaa12009-07-07 03:45:17 +02003256
Johannes Berg66e67e42012-01-20 13:55:27 +01003257 ssidie = ieee80211_bss_get_ie(req->bss, WLAN_EID_SSID);
3258 if (!ssidie)
3259 return -EINVAL;
Jouni Malinen9c87ba62010-02-28 12:13:46 +02003260
Johannes Berg66e67e42012-01-20 13:55:27 +01003261 assoc_data = kzalloc(sizeof(*assoc_data) + req->ie_len, GFP_KERNEL);
3262 if (!assoc_data)
Johannes Bergaf6b6372009-12-23 13:15:35 +01003263 return -ENOMEM;
Johannes Berg77fdaa12009-07-07 03:45:17 +02003264
Johannes Berg66e67e42012-01-20 13:55:27 +01003265 mutex_lock(&ifmgd->mtx);
3266
3267 if (ifmgd->associated)
Johannes Berg37ad3882012-02-24 13:50:54 +01003268 ieee80211_set_disassoc(sdata, 0, 0, false, NULL);
Johannes Berg66e67e42012-01-20 13:55:27 +01003269
3270 if (ifmgd->auth_data && !ifmgd->auth_data->done) {
3271 err = -EBUSY;
3272 goto err_free;
Guy Eilam2a33bee2011-08-17 15:18:15 +03003273 }
3274
Johannes Berg66e67e42012-01-20 13:55:27 +01003275 if (ifmgd->assoc_data) {
3276 err = -EBUSY;
3277 goto err_free;
3278 }
3279
3280 if (ifmgd->auth_data) {
3281 bool match;
3282
3283 /* keep sta info, bssid if matching */
Felix Fietkau888d04d2012-03-01 15:22:09 +01003284 match = compare_ether_addr(ifmgd->bssid, req->bss->bssid) == 0;
Johannes Berg66e67e42012-01-20 13:55:27 +01003285 ieee80211_destroy_auth_data(sdata, match);
3286 }
3287
3288 /* prepare assoc data */
3289
Johannes Berg77fdaa12009-07-07 03:45:17 +02003290 ifmgd->flags &= ~IEEE80211_STA_DISABLE_11N;
Vivek Natarajan375177b2010-02-09 14:50:28 +05303291 ifmgd->flags &= ~IEEE80211_STA_NULLFUNC_ACKED;
Johannes Berg77fdaa12009-07-07 03:45:17 +02003292
Juuso Oikarinend8ec4432010-10-01 16:02:31 +03003293 ifmgd->beacon_crc_valid = false;
3294
Johannes Bergde5036a2012-03-08 15:02:03 +01003295 /*
3296 * IEEE802.11n does not allow TKIP/WEP as pairwise ciphers in HT mode.
3297 * We still associate in non-HT mode (11a/b/g) if any one of these
3298 * ciphers is configured as pairwise.
3299 * We can set this to true for non-11n hardware, that'll be checked
3300 * separately along with the peer capabilities.
3301 */
Johannes Berg77fdaa12009-07-07 03:45:17 +02003302 for (i = 0; i < req->crypto.n_ciphers_pairwise; i++)
3303 if (req->crypto.ciphers_pairwise[i] == WLAN_CIPHER_SUITE_WEP40 ||
3304 req->crypto.ciphers_pairwise[i] == WLAN_CIPHER_SUITE_TKIP ||
3305 req->crypto.ciphers_pairwise[i] == WLAN_CIPHER_SUITE_WEP104)
3306 ifmgd->flags |= IEEE80211_STA_DISABLE_11N;
3307
Ben Greearef96a8422011-11-18 11:32:00 -08003308 if (req->flags & ASSOC_REQ_DISABLE_HT)
3309 ifmgd->flags |= IEEE80211_STA_DISABLE_11N;
3310
Johannes Berg4e74bfd2012-03-08 15:02:04 +01003311 /* Also disable HT if we don't support it or the AP doesn't use WMM */
3312 sband = local->hw.wiphy->bands[req->bss->channel->band];
3313 if (!sband->ht_cap.ht_supported ||
3314 local->hw.queues < 4 || !bss->wmm_used)
3315 ifmgd->flags |= IEEE80211_STA_DISABLE_11N;
3316
Ben Greearef96a8422011-11-18 11:32:00 -08003317 memcpy(&ifmgd->ht_capa, &req->ht_capa, sizeof(ifmgd->ht_capa));
3318 memcpy(&ifmgd->ht_capa_mask, &req->ht_capa_mask,
3319 sizeof(ifmgd->ht_capa_mask));
3320
Johannes Berg77fdaa12009-07-07 03:45:17 +02003321 if (req->ie && req->ie_len) {
Johannes Berg66e67e42012-01-20 13:55:27 +01003322 memcpy(assoc_data->ie, req->ie, req->ie_len);
3323 assoc_data->ie_len = req->ie_len;
3324 }
Johannes Berg77fdaa12009-07-07 03:45:17 +02003325
Johannes Berg66e67e42012-01-20 13:55:27 +01003326 assoc_data->bss = req->bss;
Johannes Bergf679f652009-12-23 13:15:34 +01003327
Johannes Bergaf6b6372009-12-23 13:15:35 +01003328 if (ifmgd->req_smps == IEEE80211_SMPS_AUTOMATIC) {
3329 if (ifmgd->powersave)
3330 ifmgd->ap_smps = IEEE80211_SMPS_DYNAMIC;
3331 else
3332 ifmgd->ap_smps = IEEE80211_SMPS_OFF;
3333 } else
3334 ifmgd->ap_smps = ifmgd->req_smps;
3335
Johannes Berg66e67e42012-01-20 13:55:27 +01003336 assoc_data->capability = req->bss->capability;
Johannes Berg76f03032012-03-08 15:02:05 +01003337 assoc_data->wmm = bss->wmm_used && (local->hw.queues >= 4);
Johannes Berg66e67e42012-01-20 13:55:27 +01003338 assoc_data->supp_rates = bss->supp_rates;
3339 assoc_data->supp_rates_len = bss->supp_rates_len;
3340 assoc_data->ht_information_ie =
Johannes Bergf679f652009-12-23 13:15:34 +01003341 ieee80211_bss_get_ie(req->bss, WLAN_EID_HT_INFORMATION);
Johannes Berg63f170e2009-12-23 13:15:33 +01003342
Kalle Valoab133152010-01-12 10:42:31 +02003343 if (bss->wmm_used && bss->uapsd_supported &&
3344 (sdata->local->hw.flags & IEEE80211_HW_SUPPORTS_UAPSD)) {
Johannes Berg76f03032012-03-08 15:02:05 +01003345 assoc_data->uapsd = true;
Kalle Valoab133152010-01-12 10:42:31 +02003346 ifmgd->flags |= IEEE80211_STA_UAPSD_ENABLED;
3347 } else {
Johannes Berg76f03032012-03-08 15:02:05 +01003348 assoc_data->uapsd = false;
Kalle Valoab133152010-01-12 10:42:31 +02003349 ifmgd->flags &= ~IEEE80211_STA_UAPSD_ENABLED;
3350 }
3351
Johannes Berg66e67e42012-01-20 13:55:27 +01003352 memcpy(assoc_data->ssid, ssidie + 2, ssidie[1]);
3353 assoc_data->ssid_len = ssidie[1];
Johannes Berg63f170e2009-12-23 13:15:33 +01003354
Johannes Berg77fdaa12009-07-07 03:45:17 +02003355 if (req->prev_bssid)
Johannes Berg66e67e42012-01-20 13:55:27 +01003356 memcpy(assoc_data->prev_bssid, req->prev_bssid, ETH_ALEN);
Johannes Berg77fdaa12009-07-07 03:45:17 +02003357
3358 if (req->use_mfp) {
3359 ifmgd->mfp = IEEE80211_MFP_REQUIRED;
3360 ifmgd->flags |= IEEE80211_STA_MFP_ENABLED;
3361 } else {
3362 ifmgd->mfp = IEEE80211_MFP_DISABLED;
3363 ifmgd->flags &= ~IEEE80211_STA_MFP_ENABLED;
3364 }
3365
3366 if (req->crypto.control_port)
3367 ifmgd->flags |= IEEE80211_STA_CONTROL_PORT;
3368 else
3369 ifmgd->flags &= ~IEEE80211_STA_CONTROL_PORT;
3370
Johannes Berga621fa42010-08-27 14:26:54 +03003371 sdata->control_port_protocol = req->crypto.control_port_ethertype;
3372 sdata->control_port_no_encrypt = req->crypto.control_port_no_encrypt;
3373
Johannes Berg66e67e42012-01-20 13:55:27 +01003374 /* kick off associate process */
3375
3376 ifmgd->assoc_data = assoc_data;
3377
Johannes Berga1cf7752012-03-08 15:02:07 +01003378 err = ieee80211_prep_connection(sdata, req->bss, true);
3379 if (err)
3380 goto err_clear;
Johannes Berg66e67e42012-01-20 13:55:27 +01003381
3382 if (!bss->dtim_period &&
3383 sdata->local->hw.flags & IEEE80211_HW_NEED_DTIM_PERIOD) {
3384 /*
3385 * Wait up to one beacon interval ...
3386 * should this be more if we miss one?
3387 */
3388 printk(KERN_DEBUG "%s: waiting for beacon from %pM\n",
3389 sdata->name, ifmgd->bssid);
3390 assoc_data->timeout = jiffies +
3391 TU_TO_EXP_TIME(req->bss->beacon_interval);
3392 } else {
3393 assoc_data->have_beacon = true;
3394 assoc_data->sent_assoc = false;
3395 assoc_data->timeout = jiffies;
3396 }
3397 run_again(ifmgd, assoc_data->timeout);
3398
Paul Stewartfcff4f12012-02-23 17:59:53 -08003399 if (bss->corrupt_data) {
3400 char *corrupt_type = "data";
3401 if (bss->corrupt_data & IEEE80211_BSS_CORRUPT_BEACON) {
3402 if (bss->corrupt_data &
3403 IEEE80211_BSS_CORRUPT_PROBE_RESP)
3404 corrupt_type = "beacon and probe response";
3405 else
3406 corrupt_type = "beacon";
3407 } else if (bss->corrupt_data & IEEE80211_BSS_CORRUPT_PROBE_RESP)
3408 corrupt_type = "probe response";
3409 printk(KERN_DEBUG "%s: associating with AP with corrupt %s\n",
3410 sdata->name, corrupt_type);
3411 }
3412
Johannes Berg66e67e42012-01-20 13:55:27 +01003413 err = 0;
3414 goto out;
3415 err_clear:
3416 ifmgd->assoc_data = NULL;
3417 err_free:
3418 kfree(assoc_data);
3419 out:
3420 mutex_unlock(&ifmgd->mtx);
3421
3422 return err;
Johannes Berg77fdaa12009-07-07 03:45:17 +02003423}
3424
3425int ieee80211_mgd_deauth(struct ieee80211_sub_if_data *sdata,
Johannes Berg63c9c5e2012-02-24 13:50:51 +01003426 struct cfg80211_deauth_request *req)
Johannes Berg77fdaa12009-07-07 03:45:17 +02003427{
3428 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
Johannes Berg5fef7db2012-02-24 13:50:52 +01003429 u8 frame_buf[DEAUTH_DISASSOC_LEN];
Johannes Berg77fdaa12009-07-07 03:45:17 +02003430
Johannes Berg77fdaa12009-07-07 03:45:17 +02003431 mutex_lock(&ifmgd->mtx);
3432
Johannes Berg37ad3882012-02-24 13:50:54 +01003433 if (ifmgd->auth_data) {
Johannes Berg66e67e42012-01-20 13:55:27 +01003434 ieee80211_destroy_auth_data(sdata, false);
Johannes Bergaf6b6372009-12-23 13:15:35 +01003435 mutex_unlock(&ifmgd->mtx);
Johannes Berg66e67e42012-01-20 13:55:27 +01003436 return 0;
Johannes Bergaf6b6372009-12-23 13:15:35 +01003437 }
Johannes Berg77fdaa12009-07-07 03:45:17 +02003438
Johannes Berg37ad3882012-02-24 13:50:54 +01003439 printk(KERN_DEBUG
3440 "%s: deauthenticating from %pM by local choice (reason=%d)\n",
Johannes Berg95de8172012-01-20 13:55:25 +01003441 sdata->name, req->bssid, req->reason_code);
Johannes Berg0ff71612009-09-26 14:45:41 +02003442
Johannes Berg37ad3882012-02-24 13:50:54 +01003443 if (ifmgd->associated &&
Felix Fietkau888d04d2012-03-01 15:22:09 +01003444 compare_ether_addr(ifmgd->associated->bssid, req->bssid) == 0)
Johannes Berg37ad3882012-02-24 13:50:54 +01003445 ieee80211_set_disassoc(sdata, IEEE80211_STYPE_DEAUTH,
Johannes Berg5fef7db2012-02-24 13:50:52 +01003446 req->reason_code, true, frame_buf);
Johannes Berg37ad3882012-02-24 13:50:54 +01003447 else
3448 ieee80211_send_deauth_disassoc(sdata, req->bssid,
3449 IEEE80211_STYPE_DEAUTH,
3450 req->reason_code, true,
3451 frame_buf);
3452 mutex_unlock(&ifmgd->mtx);
3453
Johannes Berg5fef7db2012-02-24 13:50:52 +01003454 __cfg80211_send_deauth(sdata->dev, frame_buf, DEAUTH_DISASSOC_LEN);
Johannes Berg77fdaa12009-07-07 03:45:17 +02003455
Johannes Berg7da7cc12010-08-05 17:02:38 +02003456 mutex_lock(&sdata->local->mtx);
Johannes Bergbc83b682009-11-29 12:19:06 +01003457 ieee80211_recalc_idle(sdata->local);
Johannes Berg7da7cc12010-08-05 17:02:38 +02003458 mutex_unlock(&sdata->local->mtx);
Johannes Bergbc83b682009-11-29 12:19:06 +01003459
Johannes Berg77fdaa12009-07-07 03:45:17 +02003460 return 0;
3461}
3462
3463int ieee80211_mgd_disassoc(struct ieee80211_sub_if_data *sdata,
Johannes Berg63c9c5e2012-02-24 13:50:51 +01003464 struct cfg80211_disassoc_request *req)
Johannes Berg77fdaa12009-07-07 03:45:17 +02003465{
3466 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
Jouni Malinene69e95d2010-03-29 23:29:31 -07003467 u8 bssid[ETH_ALEN];
Johannes Berg5fef7db2012-02-24 13:50:52 +01003468 u8 frame_buf[DEAUTH_DISASSOC_LEN];
Johannes Berg77fdaa12009-07-07 03:45:17 +02003469
Johannes Berg77fdaa12009-07-07 03:45:17 +02003470 mutex_lock(&ifmgd->mtx);
3471
Johannes Berg8d8b2612009-07-25 11:58:36 +02003472 /*
3473 * cfg80211 should catch this ... but it's racy since
3474 * we can receive a disassoc frame, process it, hand it
3475 * to cfg80211 while that's in a locked section already
3476 * trying to tell us that the user wants to disconnect.
3477 */
Johannes Berg0c1ad2c2009-12-23 13:15:39 +01003478 if (ifmgd->associated != req->bss) {
Johannes Berg77fdaa12009-07-07 03:45:17 +02003479 mutex_unlock(&ifmgd->mtx);
3480 return -ENOLINK;
3481 }
3482
Johannes Berg0ff71612009-09-26 14:45:41 +02003483 printk(KERN_DEBUG "%s: disassociating from %pM by local choice (reason=%d)\n",
Johannes Berg47846c92009-11-25 17:46:19 +01003484 sdata->name, req->bss->bssid, req->reason_code);
Johannes Berg0ff71612009-09-26 14:45:41 +02003485
Jouni Malinene69e95d2010-03-29 23:29:31 -07003486 memcpy(bssid, req->bss->bssid, ETH_ALEN);
Johannes Berg37ad3882012-02-24 13:50:54 +01003487 ieee80211_set_disassoc(sdata, IEEE80211_STYPE_DISASSOC,
3488 req->reason_code, !req->local_state_change,
3489 frame_buf);
Johannes Berg77fdaa12009-07-07 03:45:17 +02003490 mutex_unlock(&ifmgd->mtx);
3491
Johannes Berg5fef7db2012-02-24 13:50:52 +01003492 __cfg80211_send_disassoc(sdata->dev, frame_buf, DEAUTH_DISASSOC_LEN);
Johannes Bergbc83b682009-11-29 12:19:06 +01003493
Johannes Berg7da7cc12010-08-05 17:02:38 +02003494 mutex_lock(&sdata->local->mtx);
Johannes Bergbc83b682009-11-29 12:19:06 +01003495 ieee80211_recalc_idle(sdata->local);
Johannes Berg7da7cc12010-08-05 17:02:38 +02003496 mutex_unlock(&sdata->local->mtx);
Johannes Bergbc83b682009-11-29 12:19:06 +01003497
Johannes Berg77fdaa12009-07-07 03:45:17 +02003498 return 0;
3499}
Jouni Malinen026331c2010-02-15 12:53:10 +02003500
Johannes Berg54e4ffb2012-02-25 21:48:08 +01003501void ieee80211_mgd_teardown(struct ieee80211_sub_if_data *sdata)
3502{
3503 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
3504
3505 mutex_lock(&ifmgd->mtx);
3506 if (ifmgd->assoc_data)
3507 ieee80211_destroy_assoc_data(sdata, false);
3508 if (ifmgd->auth_data)
3509 ieee80211_destroy_auth_data(sdata, false);
3510 del_timer_sync(&ifmgd->timer);
3511 mutex_unlock(&ifmgd->mtx);
3512}
3513
Juuso Oikarinena97c13c2010-03-23 09:02:34 +02003514void ieee80211_cqm_rssi_notify(struct ieee80211_vif *vif,
3515 enum nl80211_cqm_rssi_threshold_event rssi_event,
3516 gfp_t gfp)
3517{
3518 struct ieee80211_sub_if_data *sdata = vif_to_sdata(vif);
3519
Johannes Bergb5878a22010-04-07 16:48:40 +02003520 trace_api_cqm_rssi_notify(sdata, rssi_event);
3521
Juuso Oikarinena97c13c2010-03-23 09:02:34 +02003522 cfg80211_cqm_rssi_notify(sdata->dev, rssi_event, gfp);
3523}
3524EXPORT_SYMBOL(ieee80211_cqm_rssi_notify);
Eliad Peller1d34d102011-06-06 12:59:29 +03003525
3526unsigned char ieee80211_get_operstate(struct ieee80211_vif *vif)
3527{
3528 struct ieee80211_sub_if_data *sdata = vif_to_sdata(vif);
3529 return sdata->dev->operstate;
3530}
3531EXPORT_SYMBOL(ieee80211_get_operstate);