blob: a4bb856de08f528ae564ab68fd2e83e6f779075f [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 Berg24398e32012-03-28 10:58:36 +0200174static u32 ieee80211_config_ht_tx(struct ieee80211_sub_if_data *sdata,
175 struct ieee80211_ht_operation *ht_oper,
176 const u8 *bssid, bool reconfig)
Johannes Bergd5522e02009-03-30 13:23:35 +0200177{
178 struct ieee80211_local *local = sdata->local;
179 struct ieee80211_supported_band *sband;
Johannes Bergd5522e02009-03-30 13:23:35 +0200180 struct sta_info *sta;
181 u32 changed = 0;
Johannes Berg9ed6bcc2009-05-08 20:47:39 +0200182 u16 ht_opmode;
Johannes Berg64f68e52012-03-28 10:58:37 +0200183 bool disable_40 = false;
Johannes Bergd5522e02009-03-30 13:23:35 +0200184
185 sband = local->hw.wiphy->bands[local->hw.conf.channel->band];
Johannes Berg0aaffa92010-05-05 15:28:27 +0200186
Johannes Berg64f68e52012-03-28 10:58:37 +0200187 switch (sdata->vif.bss_conf.channel_type) {
188 case NL80211_CHAN_HT40PLUS:
189 if (local->hw.conf.channel->flags & IEEE80211_CHAN_NO_HT40PLUS)
190 disable_40 = true;
191 break;
192 case NL80211_CHAN_HT40MINUS:
193 if (local->hw.conf.channel->flags & IEEE80211_CHAN_NO_HT40MINUS)
194 disable_40 = true;
195 break;
196 default:
197 break;
198 }
Johannes Bergd5522e02009-03-30 13:23:35 +0200199
Johannes Berg24398e32012-03-28 10:58:36 +0200200 /* This can change during the lifetime of the BSS */
201 if (!(ht_oper->ht_param & IEEE80211_HT_PARAM_CHAN_WIDTH_ANY))
Johannes Berg64f68e52012-03-28 10:58:37 +0200202 disable_40 = true;
Johannes Bergd5522e02009-03-30 13:23:35 +0200203
Johannes Berg64f68e52012-03-28 10:58:37 +0200204 mutex_lock(&local->sta_mtx);
205 sta = sta_info_get(sdata, bssid);
206
207 WARN_ON_ONCE(!sta);
208
209 if (sta && !sta->supports_40mhz)
210 disable_40 = true;
211
212 if (sta && (!reconfig ||
Rajkumar Manoharan91a00992012-04-25 20:24:24 +0530213 (disable_40 != !(sta->sta.ht_cap.cap &
Johannes Berg64f68e52012-03-28 10:58:37 +0200214 IEEE80211_HT_CAP_SUP_WIDTH_20_40)))) {
Rajkumar Manoharan7cc44ed2011-09-16 15:32:34 +0530215
Johannes Berg64f68e52012-03-28 10:58:37 +0200216 if (disable_40)
217 sta->sta.ht_cap.cap &= ~IEEE80211_HT_CAP_SUP_WIDTH_20_40;
218 else
219 sta->sta.ht_cap.cap |= IEEE80211_HT_CAP_SUP_WIDTH_20_40;
Rajkumar Manoharan7cc44ed2011-09-16 15:32:34 +0530220
Johannes Berg64f68e52012-03-28 10:58:37 +0200221 rate_control_rate_update(local, sband, sta,
Johannes Berg8f727ef2012-03-30 08:43:32 +0200222 IEEE80211_RC_BW_CHANGED);
Johannes Berg0aaffa92010-05-05 15:28:27 +0200223 }
Johannes Berg64f68e52012-03-28 10:58:37 +0200224 mutex_unlock(&local->sta_mtx);
Johannes Bergd5522e02009-03-30 13:23:35 +0200225
Johannes Berg074d46d2012-03-15 19:45:16 +0100226 ht_opmode = le16_to_cpu(ht_oper->operation_mode);
Johannes Bergd5522e02009-03-30 13:23:35 +0200227
228 /* if bss configuration changed store the new one */
Johannes Berg24398e32012-03-28 10:58:36 +0200229 if (!reconfig || (sdata->vif.bss_conf.ht_operation_mode != ht_opmode)) {
Johannes Bergd5522e02009-03-30 13:23:35 +0200230 changed |= BSS_CHANGED_HT;
Johannes Berg9ed6bcc2009-05-08 20:47:39 +0200231 sdata->vif.bss_conf.ht_operation_mode = ht_opmode;
Johannes Bergd5522e02009-03-30 13:23:35 +0200232 }
233
234 return changed;
235}
236
Johannes Berg9c6bd792008-09-11 00:01:52 +0200237/* frame sending functions */
238
Johannes Berg66e67e42012-01-20 13:55:27 +0100239static int ieee80211_compatible_rates(const u8 *supp_rates, int supp_rates_len,
240 struct ieee80211_supported_band *sband,
241 u32 *rates)
242{
243 int i, j, count;
244 *rates = 0;
245 count = 0;
246 for (i = 0; i < supp_rates_len; i++) {
247 int rate = (supp_rates[i] & 0x7F) * 5;
248
249 for (j = 0; j < sband->n_bitrates; j++)
250 if (sband->bitrates[j].bitrate == rate) {
251 *rates |= BIT(j);
252 count++;
253 break;
254 }
255 }
256
257 return count;
258}
259
260static void ieee80211_add_ht_ie(struct ieee80211_sub_if_data *sdata,
Johannes Berg074d46d2012-03-15 19:45:16 +0100261 struct sk_buff *skb, const u8 *ht_oper_ie,
Johannes Berg66e67e42012-01-20 13:55:27 +0100262 struct ieee80211_supported_band *sband,
263 struct ieee80211_channel *channel,
264 enum ieee80211_smps_mode smps)
265{
Johannes Berg074d46d2012-03-15 19:45:16 +0100266 struct ieee80211_ht_operation *ht_oper;
Johannes Berg66e67e42012-01-20 13:55:27 +0100267 u8 *pos;
268 u32 flags = channel->flags;
269 u16 cap;
270 struct ieee80211_sta_ht_cap ht_cap;
271
272 BUILD_BUG_ON(sizeof(ht_cap) != sizeof(sband->ht_cap));
273
Johannes Berg074d46d2012-03-15 19:45:16 +0100274 if (!ht_oper_ie)
Johannes Berg66e67e42012-01-20 13:55:27 +0100275 return;
276
Johannes Berg074d46d2012-03-15 19:45:16 +0100277 if (ht_oper_ie[1] < sizeof(struct ieee80211_ht_operation))
Johannes Berg66e67e42012-01-20 13:55:27 +0100278 return;
279
280 memcpy(&ht_cap, &sband->ht_cap, sizeof(ht_cap));
281 ieee80211_apply_htcap_overrides(sdata, &ht_cap);
282
Johannes Berg074d46d2012-03-15 19:45:16 +0100283 ht_oper = (struct ieee80211_ht_operation *)(ht_oper_ie + 2);
Johannes Berg66e67e42012-01-20 13:55:27 +0100284
285 /* determine capability flags */
286 cap = ht_cap.cap;
287
Johannes Berg074d46d2012-03-15 19:45:16 +0100288 switch (ht_oper->ht_param & IEEE80211_HT_PARAM_CHA_SEC_OFFSET) {
Johannes Berg66e67e42012-01-20 13:55:27 +0100289 case IEEE80211_HT_PARAM_CHA_SEC_ABOVE:
290 if (flags & IEEE80211_CHAN_NO_HT40PLUS) {
291 cap &= ~IEEE80211_HT_CAP_SUP_WIDTH_20_40;
292 cap &= ~IEEE80211_HT_CAP_SGI_40;
293 }
294 break;
295 case IEEE80211_HT_PARAM_CHA_SEC_BELOW:
296 if (flags & IEEE80211_CHAN_NO_HT40MINUS) {
297 cap &= ~IEEE80211_HT_CAP_SUP_WIDTH_20_40;
298 cap &= ~IEEE80211_HT_CAP_SGI_40;
299 }
300 break;
301 }
302
Johannes Berg24398e32012-03-28 10:58:36 +0200303 /*
304 * If 40 MHz was disabled associate as though we weren't
305 * capable of 40 MHz -- some broken APs will never fall
306 * back to trying to transmit in 20 MHz.
307 */
308 if (sdata->u.mgd.flags & IEEE80211_STA_DISABLE_40MHZ) {
309 cap &= ~IEEE80211_HT_CAP_SUP_WIDTH_20_40;
310 cap &= ~IEEE80211_HT_CAP_SGI_40;
311 }
312
Johannes Berg66e67e42012-01-20 13:55:27 +0100313 /* set SM PS mode properly */
314 cap &= ~IEEE80211_HT_CAP_SM_PS;
315 switch (smps) {
316 case IEEE80211_SMPS_AUTOMATIC:
317 case IEEE80211_SMPS_NUM_MODES:
318 WARN_ON(1);
319 case IEEE80211_SMPS_OFF:
320 cap |= WLAN_HT_CAP_SM_PS_DISABLED <<
321 IEEE80211_HT_CAP_SM_PS_SHIFT;
322 break;
323 case IEEE80211_SMPS_STATIC:
324 cap |= WLAN_HT_CAP_SM_PS_STATIC <<
325 IEEE80211_HT_CAP_SM_PS_SHIFT;
326 break;
327 case IEEE80211_SMPS_DYNAMIC:
328 cap |= WLAN_HT_CAP_SM_PS_DYNAMIC <<
329 IEEE80211_HT_CAP_SM_PS_SHIFT;
330 break;
331 }
332
333 /* reserve and fill IE */
334 pos = skb_put(skb, sizeof(struct ieee80211_ht_cap) + 2);
335 ieee80211_ie_build_ht_cap(pos, &ht_cap, cap);
336}
337
338static void ieee80211_send_assoc(struct ieee80211_sub_if_data *sdata)
339{
340 struct ieee80211_local *local = sdata->local;
341 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
342 struct ieee80211_mgd_assoc_data *assoc_data = ifmgd->assoc_data;
343 struct sk_buff *skb;
344 struct ieee80211_mgmt *mgmt;
345 u8 *pos, qos_info;
346 size_t offset = 0, noffset;
347 int i, count, rates_len, supp_rates_len;
348 u16 capab;
349 struct ieee80211_supported_band *sband;
350 u32 rates = 0;
Johannes Berg66e67e42012-01-20 13:55:27 +0100351
352 lockdep_assert_held(&ifmgd->mtx);
353
354 sband = local->hw.wiphy->bands[local->oper_channel->band];
355
356 if (assoc_data->supp_rates_len) {
357 /*
358 * Get all rates supported by the device and the AP as
359 * some APs don't like getting a superset of their rates
360 * in the association request (e.g. D-Link DAP 1353 in
361 * b-only mode)...
362 */
363 rates_len = ieee80211_compatible_rates(assoc_data->supp_rates,
364 assoc_data->supp_rates_len,
365 sband, &rates);
366 } else {
367 /*
368 * In case AP not provide any supported rates information
369 * before association, we send information element(s) with
370 * all rates that we support.
371 */
372 rates = ~0;
373 rates_len = sband->n_bitrates;
374 }
375
376 skb = alloc_skb(local->hw.extra_tx_headroom +
377 sizeof(*mgmt) + /* bit too much but doesn't matter */
378 2 + assoc_data->ssid_len + /* SSID */
379 4 + rates_len + /* (extended) rates */
380 4 + /* power capability */
381 2 + 2 * sband->n_channels + /* supported channels */
382 2 + sizeof(struct ieee80211_ht_cap) + /* HT */
383 assoc_data->ie_len + /* extra IEs */
384 9, /* WMM */
385 GFP_KERNEL);
386 if (!skb)
387 return;
388
389 skb_reserve(skb, local->hw.extra_tx_headroom);
390
391 capab = WLAN_CAPABILITY_ESS;
392
393 if (sband->band == IEEE80211_BAND_2GHZ) {
394 if (!(local->hw.flags & IEEE80211_HW_2GHZ_SHORT_SLOT_INCAPABLE))
395 capab |= WLAN_CAPABILITY_SHORT_SLOT_TIME;
396 if (!(local->hw.flags & IEEE80211_HW_2GHZ_SHORT_PREAMBLE_INCAPABLE))
397 capab |= WLAN_CAPABILITY_SHORT_PREAMBLE;
398 }
399
400 if (assoc_data->capability & WLAN_CAPABILITY_PRIVACY)
401 capab |= WLAN_CAPABILITY_PRIVACY;
402
403 if ((assoc_data->capability & WLAN_CAPABILITY_SPECTRUM_MGMT) &&
404 (local->hw.flags & IEEE80211_HW_SPECTRUM_MGMT))
405 capab |= WLAN_CAPABILITY_SPECTRUM_MGMT;
406
407 mgmt = (struct ieee80211_mgmt *) skb_put(skb, 24);
408 memset(mgmt, 0, 24);
409 memcpy(mgmt->da, assoc_data->bss->bssid, ETH_ALEN);
410 memcpy(mgmt->sa, sdata->vif.addr, ETH_ALEN);
411 memcpy(mgmt->bssid, assoc_data->bss->bssid, ETH_ALEN);
412
413 if (!is_zero_ether_addr(assoc_data->prev_bssid)) {
414 skb_put(skb, 10);
415 mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
416 IEEE80211_STYPE_REASSOC_REQ);
417 mgmt->u.reassoc_req.capab_info = cpu_to_le16(capab);
418 mgmt->u.reassoc_req.listen_interval =
419 cpu_to_le16(local->hw.conf.listen_interval);
420 memcpy(mgmt->u.reassoc_req.current_ap, assoc_data->prev_bssid,
421 ETH_ALEN);
422 } else {
423 skb_put(skb, 4);
424 mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
425 IEEE80211_STYPE_ASSOC_REQ);
426 mgmt->u.assoc_req.capab_info = cpu_to_le16(capab);
427 mgmt->u.assoc_req.listen_interval =
428 cpu_to_le16(local->hw.conf.listen_interval);
429 }
430
431 /* SSID */
432 pos = skb_put(skb, 2 + assoc_data->ssid_len);
433 *pos++ = WLAN_EID_SSID;
434 *pos++ = assoc_data->ssid_len;
435 memcpy(pos, assoc_data->ssid, assoc_data->ssid_len);
436
437 /* add all rates which were marked to be used above */
438 supp_rates_len = rates_len;
439 if (supp_rates_len > 8)
440 supp_rates_len = 8;
441
442 pos = skb_put(skb, supp_rates_len + 2);
443 *pos++ = WLAN_EID_SUPP_RATES;
444 *pos++ = supp_rates_len;
445
446 count = 0;
447 for (i = 0; i < sband->n_bitrates; i++) {
448 if (BIT(i) & rates) {
449 int rate = sband->bitrates[i].bitrate;
450 *pos++ = (u8) (rate / 5);
451 if (++count == 8)
452 break;
453 }
454 }
455
456 if (rates_len > count) {
457 pos = skb_put(skb, rates_len - count + 2);
458 *pos++ = WLAN_EID_EXT_SUPP_RATES;
459 *pos++ = rates_len - count;
460
461 for (i++; i < sband->n_bitrates; i++) {
462 if (BIT(i) & rates) {
463 int rate = sband->bitrates[i].bitrate;
464 *pos++ = (u8) (rate / 5);
465 }
466 }
467 }
468
469 if (capab & WLAN_CAPABILITY_SPECTRUM_MGMT) {
470 /* 1. power capabilities */
471 pos = skb_put(skb, 4);
472 *pos++ = WLAN_EID_PWR_CAPABILITY;
473 *pos++ = 2;
474 *pos++ = 0; /* min tx power */
475 *pos++ = local->oper_channel->max_power; /* max tx power */
476
477 /* 2. supported channels */
478 /* TODO: get this in reg domain format */
479 pos = skb_put(skb, 2 * sband->n_channels + 2);
480 *pos++ = WLAN_EID_SUPPORTED_CHANNELS;
481 *pos++ = 2 * sband->n_channels;
482 for (i = 0; i < sband->n_channels; i++) {
483 *pos++ = ieee80211_frequency_to_channel(
484 sband->channels[i].center_freq);
485 *pos++ = 1; /* one channel in the subband*/
486 }
487 }
488
489 /* if present, add any custom IEs that go before HT */
490 if (assoc_data->ie_len && assoc_data->ie) {
491 static const u8 before_ht[] = {
492 WLAN_EID_SSID,
493 WLAN_EID_SUPP_RATES,
494 WLAN_EID_EXT_SUPP_RATES,
495 WLAN_EID_PWR_CAPABILITY,
496 WLAN_EID_SUPPORTED_CHANNELS,
497 WLAN_EID_RSN,
498 WLAN_EID_QOS_CAPA,
499 WLAN_EID_RRM_ENABLED_CAPABILITIES,
500 WLAN_EID_MOBILITY_DOMAIN,
501 WLAN_EID_SUPPORTED_REGULATORY_CLASSES,
502 };
503 noffset = ieee80211_ie_split(assoc_data->ie, assoc_data->ie_len,
504 before_ht, ARRAY_SIZE(before_ht),
505 offset);
506 pos = skb_put(skb, noffset - offset);
507 memcpy(pos, assoc_data->ie + offset, noffset - offset);
508 offset = noffset;
509 }
510
Johannes Berg4e74bfd2012-03-08 15:02:04 +0100511 if (!(ifmgd->flags & IEEE80211_STA_DISABLE_11N))
Johannes Berg074d46d2012-03-15 19:45:16 +0100512 ieee80211_add_ht_ie(sdata, skb, assoc_data->ht_operation_ie,
Johannes Berg66e67e42012-01-20 13:55:27 +0100513 sband, local->oper_channel, ifmgd->ap_smps);
514
515 /* if present, add any custom non-vendor IEs that go after HT */
516 if (assoc_data->ie_len && assoc_data->ie) {
517 noffset = ieee80211_ie_split_vendor(assoc_data->ie,
518 assoc_data->ie_len,
519 offset);
520 pos = skb_put(skb, noffset - offset);
521 memcpy(pos, assoc_data->ie + offset, noffset - offset);
522 offset = noffset;
523 }
524
Johannes Berg76f03032012-03-08 15:02:05 +0100525 if (assoc_data->wmm) {
526 if (assoc_data->uapsd) {
Eliad Pellerdc41e4d2012-03-14 16:15:03 +0200527 qos_info = ifmgd->uapsd_queues;
528 qos_info |= (ifmgd->uapsd_max_sp_len <<
Johannes Berg66e67e42012-01-20 13:55:27 +0100529 IEEE80211_WMM_IE_STA_QOSINFO_SP_SHIFT);
530 } else {
531 qos_info = 0;
532 }
533
534 pos = skb_put(skb, 9);
535 *pos++ = WLAN_EID_VENDOR_SPECIFIC;
536 *pos++ = 7; /* len */
537 *pos++ = 0x00; /* Microsoft OUI 00:50:F2 */
538 *pos++ = 0x50;
539 *pos++ = 0xf2;
540 *pos++ = 2; /* WME */
541 *pos++ = 0; /* WME info */
542 *pos++ = 1; /* WME ver */
543 *pos++ = qos_info;
544 }
545
546 /* add any remaining custom (i.e. vendor specific here) IEs */
547 if (assoc_data->ie_len && assoc_data->ie) {
548 noffset = assoc_data->ie_len;
549 pos = skb_put(skb, noffset - offset);
550 memcpy(pos, assoc_data->ie + offset, noffset - offset);
551 }
552
553 IEEE80211_SKB_CB(skb)->flags |= IEEE80211_TX_INTFL_DONT_ENCRYPT;
554 ieee80211_tx_skb(sdata, skb);
555}
556
Johannes Bergef422bc2008-09-09 10:58:25 +0200557static void ieee80211_send_deauth_disassoc(struct ieee80211_sub_if_data *sdata,
Johannes Berg63c9c5e2012-02-24 13:50:51 +0100558 const u8 *bssid, u16 stype,
Johannes Berg5fef7db2012-02-24 13:50:52 +0100559 u16 reason, bool send_frame,
560 u8 *frame_buf)
Johannes Berg9ac19a92008-09-09 10:57:09 +0200561{
562 struct ieee80211_local *local = sdata->local;
Johannes Berg46900292009-02-15 12:44:28 +0100563 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
Johannes Berg9ac19a92008-09-09 10:57:09 +0200564 struct sk_buff *skb;
Johannes Berg5fef7db2012-02-24 13:50:52 +0100565 struct ieee80211_mgmt *mgmt = (void *)frame_buf;
Johannes Berg9ac19a92008-09-09 10:57:09 +0200566
Johannes Berg5fef7db2012-02-24 13:50:52 +0100567 /* build frame */
568 mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT | stype);
569 mgmt->duration = 0; /* initialize only */
570 mgmt->seq_ctrl = 0; /* initialize only */
Johannes Berg77fdaa12009-07-07 03:45:17 +0200571 memcpy(mgmt->da, bssid, ETH_ALEN);
Johannes Berg47846c92009-11-25 17:46:19 +0100572 memcpy(mgmt->sa, sdata->vif.addr, ETH_ALEN);
Johannes Berg77fdaa12009-07-07 03:45:17 +0200573 memcpy(mgmt->bssid, bssid, ETH_ALEN);
Johannes Bergef422bc2008-09-09 10:58:25 +0200574 /* u.deauth.reason_code == u.disassoc.reason_code */
Johannes Berg9ac19a92008-09-09 10:57:09 +0200575 mgmt->u.deauth.reason_code = cpu_to_le16(reason);
576
Johannes Berg5fef7db2012-02-24 13:50:52 +0100577 if (send_frame) {
578 skb = dev_alloc_skb(local->hw.extra_tx_headroom +
579 DEAUTH_DISASSOC_LEN);
580 if (!skb)
581 return;
Jouni Malinend5cdfac2010-04-04 09:37:19 +0300582
Johannes Berg5fef7db2012-02-24 13:50:52 +0100583 skb_reserve(skb, local->hw.extra_tx_headroom);
584
585 /* copy in frame */
586 memcpy(skb_put(skb, DEAUTH_DISASSOC_LEN),
587 mgmt, DEAUTH_DISASSOC_LEN);
588
589 if (!(ifmgd->flags & IEEE80211_STA_MFP_ENABLED))
590 IEEE80211_SKB_CB(skb)->flags |=
591 IEEE80211_TX_INTFL_DONT_ENCRYPT;
Jouni Malinend5cdfac2010-04-04 09:37:19 +0300592 ieee80211_tx_skb(sdata, skb);
Johannes Berg5fef7db2012-02-24 13:50:52 +0100593 }
Johannes Berg9ac19a92008-09-09 10:57:09 +0200594}
595
Kalle Valo572e0012009-02-10 17:09:31 +0200596void ieee80211_send_pspoll(struct ieee80211_local *local,
597 struct ieee80211_sub_if_data *sdata)
598{
Kalle Valo572e0012009-02-10 17:09:31 +0200599 struct ieee80211_pspoll *pspoll;
600 struct sk_buff *skb;
Kalle Valo572e0012009-02-10 17:09:31 +0200601
Kalle Valod8cd1892010-01-05 20:16:26 +0200602 skb = ieee80211_pspoll_get(&local->hw, &sdata->vif);
603 if (!skb)
Kalle Valo572e0012009-02-10 17:09:31 +0200604 return;
Kalle Valo572e0012009-02-10 17:09:31 +0200605
Kalle Valod8cd1892010-01-05 20:16:26 +0200606 pspoll = (struct ieee80211_pspoll *) skb->data;
607 pspoll->frame_control |= cpu_to_le16(IEEE80211_FCTL_PM);
Kalle Valo572e0012009-02-10 17:09:31 +0200608
Johannes Berg62ae67b2009-11-18 18:42:05 +0100609 IEEE80211_SKB_CB(skb)->flags |= IEEE80211_TX_INTFL_DONT_ENCRYPT;
610 ieee80211_tx_skb(sdata, skb);
Kalle Valo572e0012009-02-10 17:09:31 +0200611}
612
Johannes Berg965beda2009-04-16 13:17:24 +0200613void ieee80211_send_nullfunc(struct ieee80211_local *local,
614 struct ieee80211_sub_if_data *sdata,
615 int powersave)
616{
617 struct sk_buff *skb;
Kalle Valod8cd1892010-01-05 20:16:26 +0200618 struct ieee80211_hdr_3addr *nullfunc;
Rajkumar Manoharanb6f35302011-09-29 20:34:04 +0530619 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
Johannes Berg965beda2009-04-16 13:17:24 +0200620
Kalle Valod8cd1892010-01-05 20:16:26 +0200621 skb = ieee80211_nullfunc_get(&local->hw, &sdata->vif);
622 if (!skb)
Johannes Berg965beda2009-04-16 13:17:24 +0200623 return;
624
Kalle Valod8cd1892010-01-05 20:16:26 +0200625 nullfunc = (struct ieee80211_hdr_3addr *) skb->data;
Johannes Berg965beda2009-04-16 13:17:24 +0200626 if (powersave)
Kalle Valod8cd1892010-01-05 20:16:26 +0200627 nullfunc->frame_control |= cpu_to_le16(IEEE80211_FCTL_PM);
Johannes Berg965beda2009-04-16 13:17:24 +0200628
Johannes Berg62ae67b2009-11-18 18:42:05 +0100629 IEEE80211_SKB_CB(skb)->flags |= IEEE80211_TX_INTFL_DONT_ENCRYPT;
Rajkumar Manoharanb6f35302011-09-29 20:34:04 +0530630 if (ifmgd->flags & (IEEE80211_STA_BEACON_POLL |
631 IEEE80211_STA_CONNECTION_POLL))
632 IEEE80211_SKB_CB(skb)->flags |= IEEE80211_TX_CTL_USE_MINRATE;
633
Johannes Berg62ae67b2009-11-18 18:42:05 +0100634 ieee80211_tx_skb(sdata, skb);
Johannes Berg965beda2009-04-16 13:17:24 +0200635}
636
Felix Fietkaud5242152010-01-08 18:06:26 +0100637static void ieee80211_send_4addr_nullfunc(struct ieee80211_local *local,
638 struct ieee80211_sub_if_data *sdata)
639{
640 struct sk_buff *skb;
641 struct ieee80211_hdr *nullfunc;
642 __le16 fc;
643
644 if (WARN_ON(sdata->vif.type != NL80211_IFTYPE_STATION))
645 return;
646
647 skb = dev_alloc_skb(local->hw.extra_tx_headroom + 30);
Joe Perchesd15b8452011-08-29 14:17:31 -0700648 if (!skb)
Felix Fietkaud5242152010-01-08 18:06:26 +0100649 return;
Joe Perchesd15b8452011-08-29 14:17:31 -0700650
Felix Fietkaud5242152010-01-08 18:06:26 +0100651 skb_reserve(skb, local->hw.extra_tx_headroom);
652
653 nullfunc = (struct ieee80211_hdr *) skb_put(skb, 30);
654 memset(nullfunc, 0, 30);
655 fc = cpu_to_le16(IEEE80211_FTYPE_DATA | IEEE80211_STYPE_NULLFUNC |
656 IEEE80211_FCTL_FROMDS | IEEE80211_FCTL_TODS);
657 nullfunc->frame_control = fc;
658 memcpy(nullfunc->addr1, sdata->u.mgd.bssid, ETH_ALEN);
659 memcpy(nullfunc->addr2, sdata->vif.addr, ETH_ALEN);
660 memcpy(nullfunc->addr3, sdata->u.mgd.bssid, ETH_ALEN);
661 memcpy(nullfunc->addr4, sdata->vif.addr, ETH_ALEN);
662
663 IEEE80211_SKB_CB(skb)->flags |= IEEE80211_TX_INTFL_DONT_ENCRYPT;
664 ieee80211_tx_skb(sdata, skb);
665}
666
Johannes Bergcc32abd2009-05-15 11:52:31 +0200667/* spectrum management related things */
668static void ieee80211_chswitch_work(struct work_struct *work)
669{
670 struct ieee80211_sub_if_data *sdata =
671 container_of(work, struct ieee80211_sub_if_data, u.mgd.chswitch_work);
Johannes Bergcc32abd2009-05-15 11:52:31 +0200672 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
673
Johannes Berg9607e6b2009-12-23 13:15:31 +0100674 if (!ieee80211_sdata_running(sdata))
Johannes Bergcc32abd2009-05-15 11:52:31 +0200675 return;
676
Johannes Berg77fdaa12009-07-07 03:45:17 +0200677 mutex_lock(&ifmgd->mtx);
678 if (!ifmgd->associated)
679 goto out;
Johannes Bergcc32abd2009-05-15 11:52:31 +0200680
681 sdata->local->oper_channel = sdata->local->csa_channel;
Johannes Berg5ce6e432010-05-11 16:20:57 +0200682 if (!sdata->local->ops->channel_switch) {
683 /* call "hw_config" only if doing sw channel switch */
684 ieee80211_hw_config(sdata->local,
685 IEEE80211_CONF_CHANGE_CHANNEL);
Shahar Levi1ea57b12011-09-08 08:44:05 +0300686 } else {
687 /* update the device channel directly */
688 sdata->local->hw.conf.channel = sdata->local->oper_channel;
Johannes Berg5ce6e432010-05-11 16:20:57 +0200689 }
Johannes Bergcc32abd2009-05-15 11:52:31 +0200690
Johannes Berg77fdaa12009-07-07 03:45:17 +0200691 /* XXX: shouldn't really modify cfg80211-owned data! */
Johannes Berg0c1ad2c2009-12-23 13:15:39 +0100692 ifmgd->associated->channel = sdata->local->oper_channel;
Johannes Berg77fdaa12009-07-07 03:45:17 +0200693
Johannes Bergcc32abd2009-05-15 11:52:31 +0200694 ieee80211_wake_queues_by_reason(&sdata->local->hw,
695 IEEE80211_QUEUE_STOP_REASON_CSA);
Johannes Berg77fdaa12009-07-07 03:45:17 +0200696 out:
697 ifmgd->flags &= ~IEEE80211_STA_CSA_RECEIVED;
698 mutex_unlock(&ifmgd->mtx);
Johannes Bergcc32abd2009-05-15 11:52:31 +0200699}
700
Johannes Berg5ce6e432010-05-11 16:20:57 +0200701void ieee80211_chswitch_done(struct ieee80211_vif *vif, bool success)
702{
703 struct ieee80211_sub_if_data *sdata;
704 struct ieee80211_if_managed *ifmgd;
705
706 sdata = vif_to_sdata(vif);
707 ifmgd = &sdata->u.mgd;
708
709 trace_api_chswitch_done(sdata, success);
710 if (!success) {
711 /*
712 * If the channel switch was not successful, stay
713 * around on the old channel. We currently lack
714 * good handling of this situation, possibly we
715 * should just drop the association.
716 */
717 sdata->local->csa_channel = sdata->local->oper_channel;
718 }
719
720 ieee80211_queue_work(&sdata->local->hw, &ifmgd->chswitch_work);
721}
722EXPORT_SYMBOL(ieee80211_chswitch_done);
723
Johannes Bergcc32abd2009-05-15 11:52:31 +0200724static void ieee80211_chswitch_timer(unsigned long data)
725{
726 struct ieee80211_sub_if_data *sdata =
727 (struct ieee80211_sub_if_data *) data;
728 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
729
Johannes Berg5bb644a2009-05-17 11:40:42 +0200730 if (sdata->local->quiescing) {
731 set_bit(TMR_RUNNING_CHANSW, &ifmgd->timers_running);
732 return;
733 }
734
Luis R. Rodriguez42935ec2009-07-29 20:08:07 -0400735 ieee80211_queue_work(&sdata->local->hw, &ifmgd->chswitch_work);
Johannes Bergcc32abd2009-05-15 11:52:31 +0200736}
737
738void ieee80211_sta_process_chanswitch(struct ieee80211_sub_if_data *sdata,
739 struct ieee80211_channel_sw_ie *sw_elem,
Johannes Berg5ce6e432010-05-11 16:20:57 +0200740 struct ieee80211_bss *bss,
741 u64 timestamp)
Johannes Bergcc32abd2009-05-15 11:52:31 +0200742{
Johannes Berg0c1ad2c2009-12-23 13:15:39 +0100743 struct cfg80211_bss *cbss =
744 container_of((void *)bss, struct cfg80211_bss, priv);
Johannes Bergcc32abd2009-05-15 11:52:31 +0200745 struct ieee80211_channel *new_ch;
746 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
Bruno Randolf59eb21a2011-01-17 13:37:28 +0900747 int new_freq = ieee80211_channel_to_frequency(sw_elem->new_ch_num,
748 cbss->channel->band);
Johannes Bergcc32abd2009-05-15 11:52:31 +0200749
Johannes Berg77fdaa12009-07-07 03:45:17 +0200750 ASSERT_MGD_MTX(ifmgd);
751
752 if (!ifmgd->associated)
Johannes Bergcc32abd2009-05-15 11:52:31 +0200753 return;
754
Helmut Schaafbe9c422009-07-23 12:14:04 +0200755 if (sdata->local->scanning)
Johannes Bergcc32abd2009-05-15 11:52:31 +0200756 return;
757
758 /* Disregard subsequent beacons if we are already running a timer
759 processing a CSA */
760
761 if (ifmgd->flags & IEEE80211_STA_CSA_RECEIVED)
762 return;
763
764 new_ch = ieee80211_get_channel(sdata->local->hw.wiphy, new_freq);
765 if (!new_ch || new_ch->flags & IEEE80211_CHAN_DISABLED)
766 return;
767
768 sdata->local->csa_channel = new_ch;
769
Johannes Berg5ce6e432010-05-11 16:20:57 +0200770 if (sdata->local->ops->channel_switch) {
771 /* use driver's channel switch callback */
772 struct ieee80211_channel_switch ch_switch;
773 memset(&ch_switch, 0, sizeof(ch_switch));
774 ch_switch.timestamp = timestamp;
775 if (sw_elem->mode) {
776 ch_switch.block_tx = true;
777 ieee80211_stop_queues_by_reason(&sdata->local->hw,
778 IEEE80211_QUEUE_STOP_REASON_CSA);
779 }
780 ch_switch.channel = new_ch;
781 ch_switch.count = sw_elem->count;
782 ifmgd->flags |= IEEE80211_STA_CSA_RECEIVED;
783 drv_channel_switch(sdata->local, &ch_switch);
784 return;
785 }
786
787 /* channel switch handled in software */
Johannes Bergcc32abd2009-05-15 11:52:31 +0200788 if (sw_elem->count <= 1) {
Luis R. Rodriguez42935ec2009-07-29 20:08:07 -0400789 ieee80211_queue_work(&sdata->local->hw, &ifmgd->chswitch_work);
Johannes Bergcc32abd2009-05-15 11:52:31 +0200790 } else {
Wey-Yi Guy9feaddc2010-05-05 20:34:02 -0700791 if (sw_elem->mode)
792 ieee80211_stop_queues_by_reason(&sdata->local->hw,
Johannes Bergcc32abd2009-05-15 11:52:31 +0200793 IEEE80211_QUEUE_STOP_REASON_CSA);
794 ifmgd->flags |= IEEE80211_STA_CSA_RECEIVED;
795 mod_timer(&ifmgd->chswitch_timer,
796 jiffies +
797 msecs_to_jiffies(sw_elem->count *
Johannes Berg0c1ad2c2009-12-23 13:15:39 +0100798 cbss->beacon_interval));
Johannes Bergcc32abd2009-05-15 11:52:31 +0200799 }
800}
801
802static void ieee80211_handle_pwr_constr(struct ieee80211_sub_if_data *sdata,
803 u16 capab_info, u8 *pwr_constr_elem,
804 u8 pwr_constr_elem_len)
805{
806 struct ieee80211_conf *conf = &sdata->local->hw.conf;
807
808 if (!(capab_info & WLAN_CAPABILITY_SPECTRUM_MGMT))
809 return;
810
811 /* Power constraint IE length should be 1 octet */
812 if (pwr_constr_elem_len != 1)
813 return;
814
Hong Wua48b13a2012-01-11 20:34:30 +0200815 if ((*pwr_constr_elem <= conf->channel->max_reg_power) &&
Johannes Bergcc32abd2009-05-15 11:52:31 +0200816 (*pwr_constr_elem != sdata->local->power_constr_level)) {
817 sdata->local->power_constr_level = *pwr_constr_elem;
818 ieee80211_hw_config(sdata->local, 0);
819 }
820}
821
Juuso Oikarinenf90754c2010-06-21 08:59:39 +0300822void ieee80211_enable_dyn_ps(struct ieee80211_vif *vif)
823{
824 struct ieee80211_sub_if_data *sdata = vif_to_sdata(vif);
825 struct ieee80211_local *local = sdata->local;
826 struct ieee80211_conf *conf = &local->hw.conf;
827
828 WARN_ON(sdata->vif.type != NL80211_IFTYPE_STATION ||
829 !(local->hw.flags & IEEE80211_HW_SUPPORTS_PS) ||
830 (local->hw.flags & IEEE80211_HW_SUPPORTS_DYNAMIC_PS));
831
832 local->disable_dynamic_ps = false;
833 conf->dynamic_ps_timeout = local->dynamic_ps_user_timeout;
834}
835EXPORT_SYMBOL(ieee80211_enable_dyn_ps);
836
837void ieee80211_disable_dyn_ps(struct ieee80211_vif *vif)
838{
839 struct ieee80211_sub_if_data *sdata = vif_to_sdata(vif);
840 struct ieee80211_local *local = sdata->local;
841 struct ieee80211_conf *conf = &local->hw.conf;
842
843 WARN_ON(sdata->vif.type != NL80211_IFTYPE_STATION ||
844 !(local->hw.flags & IEEE80211_HW_SUPPORTS_PS) ||
845 (local->hw.flags & IEEE80211_HW_SUPPORTS_DYNAMIC_PS));
846
847 local->disable_dynamic_ps = true;
848 conf->dynamic_ps_timeout = 0;
849 del_timer_sync(&local->dynamic_ps_timer);
850 ieee80211_queue_work(&local->hw,
851 &local->dynamic_ps_enable_work);
852}
853EXPORT_SYMBOL(ieee80211_disable_dyn_ps);
854
Johannes Berg965beda2009-04-16 13:17:24 +0200855/* powersave */
856static void ieee80211_enable_ps(struct ieee80211_local *local,
857 struct ieee80211_sub_if_data *sdata)
858{
859 struct ieee80211_conf *conf = &local->hw.conf;
860
Johannes Bergd5edaed2009-04-22 23:02:51 +0200861 /*
862 * If we are scanning right now then the parameters will
863 * take effect when scan finishes.
864 */
Helmut Schaafbe9c422009-07-23 12:14:04 +0200865 if (local->scanning)
Johannes Bergd5edaed2009-04-22 23:02:51 +0200866 return;
867
Johannes Berg965beda2009-04-16 13:17:24 +0200868 if (conf->dynamic_ps_timeout > 0 &&
869 !(local->hw.flags & IEEE80211_HW_SUPPORTS_DYNAMIC_PS)) {
870 mod_timer(&local->dynamic_ps_timer, jiffies +
871 msecs_to_jiffies(conf->dynamic_ps_timeout));
872 } else {
873 if (local->hw.flags & IEEE80211_HW_PS_NULLFUNC_STACK)
874 ieee80211_send_nullfunc(local, sdata, 1);
Vivek Natarajan375177b2010-02-09 14:50:28 +0530875
Juuso Oikarinen2a130522010-03-09 14:25:02 +0200876 if ((local->hw.flags & IEEE80211_HW_PS_NULLFUNC_STACK) &&
877 (local->hw.flags & IEEE80211_HW_REPORTS_TX_ACK_STATUS))
878 return;
879
880 conf->flags |= IEEE80211_CONF_PS;
881 ieee80211_hw_config(local, IEEE80211_CONF_CHANGE_PS);
Johannes Berg965beda2009-04-16 13:17:24 +0200882 }
883}
884
885static void ieee80211_change_ps(struct ieee80211_local *local)
886{
887 struct ieee80211_conf *conf = &local->hw.conf;
888
889 if (local->ps_sdata) {
Johannes Berg965beda2009-04-16 13:17:24 +0200890 ieee80211_enable_ps(local, local->ps_sdata);
891 } else if (conf->flags & IEEE80211_CONF_PS) {
892 conf->flags &= ~IEEE80211_CONF_PS;
893 ieee80211_hw_config(local, IEEE80211_CONF_CHANGE_PS);
894 del_timer_sync(&local->dynamic_ps_timer);
895 cancel_work_sync(&local->dynamic_ps_enable_work);
896 }
897}
898
Jason Young808118c2011-03-10 16:43:19 -0800899static bool ieee80211_powersave_allowed(struct ieee80211_sub_if_data *sdata)
900{
901 struct ieee80211_if_managed *mgd = &sdata->u.mgd;
902 struct sta_info *sta = NULL;
Johannes Bergc2c98fd2011-09-29 16:04:36 +0200903 bool authorized = false;
Jason Young808118c2011-03-10 16:43:19 -0800904
905 if (!mgd->powersave)
906 return false;
907
Johannes Berg05cb9102011-10-28 11:59:47 +0200908 if (mgd->broken_ap)
909 return false;
910
Jason Young808118c2011-03-10 16:43:19 -0800911 if (!mgd->associated)
912 return false;
913
914 if (!mgd->associated->beacon_ies)
915 return false;
916
917 if (mgd->flags & (IEEE80211_STA_BEACON_POLL |
918 IEEE80211_STA_CONNECTION_POLL))
919 return false;
920
921 rcu_read_lock();
922 sta = sta_info_get(sdata, mgd->bssid);
923 if (sta)
Johannes Bergc2c98fd2011-09-29 16:04:36 +0200924 authorized = test_sta_flag(sta, WLAN_STA_AUTHORIZED);
Jason Young808118c2011-03-10 16:43:19 -0800925 rcu_read_unlock();
926
Johannes Bergc2c98fd2011-09-29 16:04:36 +0200927 return authorized;
Jason Young808118c2011-03-10 16:43:19 -0800928}
929
Johannes Berg965beda2009-04-16 13:17:24 +0200930/* need to hold RTNL or interface lock */
Johannes Berg10f644a2009-04-16 13:17:25 +0200931void ieee80211_recalc_ps(struct ieee80211_local *local, s32 latency)
Johannes Berg965beda2009-04-16 13:17:24 +0200932{
933 struct ieee80211_sub_if_data *sdata, *found = NULL;
934 int count = 0;
Juuso Oikarinen195e2942010-04-27 12:47:40 +0300935 int timeout;
Johannes Berg965beda2009-04-16 13:17:24 +0200936
937 if (!(local->hw.flags & IEEE80211_HW_SUPPORTS_PS)) {
938 local->ps_sdata = NULL;
939 return;
940 }
941
Johannes Bergaf6b6372009-12-23 13:15:35 +0100942 if (!list_empty(&local->work_list)) {
943 local->ps_sdata = NULL;
944 goto change;
945 }
946
Johannes Berg965beda2009-04-16 13:17:24 +0200947 list_for_each_entry(sdata, &local->interfaces, list) {
Johannes Berg9607e6b2009-12-23 13:15:31 +0100948 if (!ieee80211_sdata_running(sdata))
Johannes Berg965beda2009-04-16 13:17:24 +0200949 continue;
Rajkumar Manoharan8c7914d2011-02-01 00:28:59 +0530950 if (sdata->vif.type == NL80211_IFTYPE_AP) {
951 /* If an AP vif is found, then disable PS
952 * by setting the count to zero thereby setting
953 * ps_sdata to NULL.
954 */
955 count = 0;
956 break;
957 }
Johannes Berg965beda2009-04-16 13:17:24 +0200958 if (sdata->vif.type != NL80211_IFTYPE_STATION)
959 continue;
960 found = sdata;
961 count++;
962 }
963
Jason Young808118c2011-03-10 16:43:19 -0800964 if (count == 1 && ieee80211_powersave_allowed(found)) {
Juuso Oikarinenf90754c2010-06-21 08:59:39 +0300965 struct ieee80211_conf *conf = &local->hw.conf;
Johannes Berg10f644a2009-04-16 13:17:25 +0200966 s32 beaconint_us;
967
968 if (latency < 0)
Mark Grossed771342010-05-06 01:59:26 +0200969 latency = pm_qos_request(PM_QOS_NETWORK_LATENCY);
Johannes Berg10f644a2009-04-16 13:17:25 +0200970
971 beaconint_us = ieee80211_tu_to_usec(
972 found->vif.bss_conf.beacon_int);
973
Juuso Oikarinenff616382010-06-09 09:51:52 +0300974 timeout = local->dynamic_ps_forced_timeout;
Juuso Oikarinen195e2942010-04-27 12:47:40 +0300975 if (timeout < 0) {
976 /*
Juuso Oikarinenff616382010-06-09 09:51:52 +0300977 * Go to full PSM if the user configures a very low
978 * latency requirement.
Eliad Peller0ab82b02010-12-03 02:16:23 +0200979 * The 2000 second value is there for compatibility
980 * until the PM_QOS_NETWORK_LATENCY is configured
981 * with real values.
Juuso Oikarinen195e2942010-04-27 12:47:40 +0300982 */
Eliad Peller0ab82b02010-12-03 02:16:23 +0200983 if (latency > (1900 * USEC_PER_MSEC) &&
984 latency != (2000 * USEC_PER_SEC))
Juuso Oikarinen195e2942010-04-27 12:47:40 +0300985 timeout = 0;
Juuso Oikarinenff616382010-06-09 09:51:52 +0300986 else
987 timeout = 100;
Juuso Oikarinen195e2942010-04-27 12:47:40 +0300988 }
Juuso Oikarinenf90754c2010-06-21 08:59:39 +0300989 local->dynamic_ps_user_timeout = timeout;
990 if (!local->disable_dynamic_ps)
991 conf->dynamic_ps_timeout =
992 local->dynamic_ps_user_timeout;
Juuso Oikarinen195e2942010-04-27 12:47:40 +0300993
Johannes Berg04fe2032009-04-22 18:44:37 +0200994 if (beaconint_us > latency) {
Johannes Berg10f644a2009-04-16 13:17:25 +0200995 local->ps_sdata = NULL;
Johannes Berg04fe2032009-04-22 18:44:37 +0200996 } else {
Johannes Berg56007a02010-01-26 14:19:52 +0100997 struct ieee80211_bss *bss;
Johannes Berg04fe2032009-04-22 18:44:37 +0200998 int maxslp = 1;
Johannes Berg56007a02010-01-26 14:19:52 +0100999 u8 dtimper;
Johannes Berg04fe2032009-04-22 18:44:37 +02001000
Johannes Berg56007a02010-01-26 14:19:52 +01001001 bss = (void *)found->u.mgd.associated->priv;
1002 dtimper = bss->dtim_period;
1003
1004 /* If the TIM IE is invalid, pretend the value is 1 */
1005 if (!dtimper)
1006 dtimper = 1;
1007 else if (dtimper > 1)
Johannes Berg04fe2032009-04-22 18:44:37 +02001008 maxslp = min_t(int, dtimper,
1009 latency / beaconint_us);
1010
Johannes Berg9ccebe62009-04-23 10:32:36 +02001011 local->hw.conf.max_sleep_period = maxslp;
Johannes Berg56007a02010-01-26 14:19:52 +01001012 local->hw.conf.ps_dtim_period = dtimper;
Johannes Berg10f644a2009-04-16 13:17:25 +02001013 local->ps_sdata = found;
Johannes Berg04fe2032009-04-22 18:44:37 +02001014 }
Johannes Berg10f644a2009-04-16 13:17:25 +02001015 } else {
Johannes Berg965beda2009-04-16 13:17:24 +02001016 local->ps_sdata = NULL;
Johannes Berg10f644a2009-04-16 13:17:25 +02001017 }
Johannes Berg965beda2009-04-16 13:17:24 +02001018
Johannes Bergaf6b6372009-12-23 13:15:35 +01001019 change:
Johannes Berg965beda2009-04-16 13:17:24 +02001020 ieee80211_change_ps(local);
1021}
1022
1023void ieee80211_dynamic_ps_disable_work(struct work_struct *work)
1024{
1025 struct ieee80211_local *local =
1026 container_of(work, struct ieee80211_local,
1027 dynamic_ps_disable_work);
1028
1029 if (local->hw.conf.flags & IEEE80211_CONF_PS) {
1030 local->hw.conf.flags &= ~IEEE80211_CONF_PS;
1031 ieee80211_hw_config(local, IEEE80211_CONF_CHANGE_PS);
1032 }
1033
1034 ieee80211_wake_queues_by_reason(&local->hw,
1035 IEEE80211_QUEUE_STOP_REASON_PS);
1036}
1037
1038void ieee80211_dynamic_ps_enable_work(struct work_struct *work)
1039{
1040 struct ieee80211_local *local =
1041 container_of(work, struct ieee80211_local,
1042 dynamic_ps_enable_work);
1043 struct ieee80211_sub_if_data *sdata = local->ps_sdata;
Christian Lamparter5e340692011-06-30 21:08:43 +02001044 struct ieee80211_if_managed *ifmgd;
Rajkumar Manoharan1ddc2862011-05-03 17:03:59 +05301045 unsigned long flags;
1046 int q;
Johannes Berg965beda2009-04-16 13:17:24 +02001047
1048 /* can only happen when PS was just disabled anyway */
1049 if (!sdata)
1050 return;
1051
Christian Lamparter5e340692011-06-30 21:08:43 +02001052 ifmgd = &sdata->u.mgd;
1053
Johannes Berg965beda2009-04-16 13:17:24 +02001054 if (local->hw.conf.flags & IEEE80211_CONF_PS)
1055 return;
1056
Arik Nemtsov77b70232011-06-26 12:06:54 +03001057 if (!local->disable_dynamic_ps &&
1058 local->hw.conf.dynamic_ps_timeout > 0) {
1059 /* don't enter PS if TX frames are pending */
1060 if (drv_tx_frames_pending(local)) {
Rajkumar Manoharan1ddc2862011-05-03 17:03:59 +05301061 mod_timer(&local->dynamic_ps_timer, jiffies +
1062 msecs_to_jiffies(
1063 local->hw.conf.dynamic_ps_timeout));
1064 return;
1065 }
Arik Nemtsov77b70232011-06-26 12:06:54 +03001066
1067 /*
1068 * transmission can be stopped by others which leads to
1069 * dynamic_ps_timer expiry. Postpone the ps timer if it
1070 * is not the actual idle state.
1071 */
1072 spin_lock_irqsave(&local->queue_stop_reason_lock, flags);
1073 for (q = 0; q < local->hw.queues; q++) {
1074 if (local->queue_stop_reasons[q]) {
1075 spin_unlock_irqrestore(&local->queue_stop_reason_lock,
1076 flags);
1077 mod_timer(&local->dynamic_ps_timer, jiffies +
1078 msecs_to_jiffies(
1079 local->hw.conf.dynamic_ps_timeout));
1080 return;
1081 }
1082 }
1083 spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags);
Rajkumar Manoharan1ddc2862011-05-03 17:03:59 +05301084 }
Rajkumar Manoharan1ddc2862011-05-03 17:03:59 +05301085
Vivek Natarajan375177b2010-02-09 14:50:28 +05301086 if ((local->hw.flags & IEEE80211_HW_PS_NULLFUNC_STACK) &&
Mohammed Shafi Shajakhan9c38a8b2011-12-14 19:46:07 +05301087 !(ifmgd->flags & IEEE80211_STA_NULLFUNC_ACKED)) {
Vivek Natarajanf3e85b92011-02-23 13:04:32 +05301088 netif_tx_stop_all_queues(sdata->dev);
Johannes Berg965beda2009-04-16 13:17:24 +02001089
Vivek Natarajane8306f92011-04-06 11:41:10 +05301090 if (drv_tx_frames_pending(local))
1091 mod_timer(&local->dynamic_ps_timer, jiffies +
1092 msecs_to_jiffies(
1093 local->hw.conf.dynamic_ps_timeout));
1094 else {
1095 ieee80211_send_nullfunc(local, sdata, 1);
1096 /* Flush to get the tx status of nullfunc frame */
1097 drv_flush(local, false);
1098 }
Vivek Natarajanf3e85b92011-02-23 13:04:32 +05301099 }
1100
Juuso Oikarinen2a130522010-03-09 14:25:02 +02001101 if (!((local->hw.flags & IEEE80211_HW_REPORTS_TX_ACK_STATUS) &&
1102 (local->hw.flags & IEEE80211_HW_PS_NULLFUNC_STACK)) ||
Vivek Natarajan375177b2010-02-09 14:50:28 +05301103 (ifmgd->flags & IEEE80211_STA_NULLFUNC_ACKED)) {
1104 ifmgd->flags &= ~IEEE80211_STA_NULLFUNC_ACKED;
1105 local->hw.conf.flags |= IEEE80211_CONF_PS;
1106 ieee80211_hw_config(local, IEEE80211_CONF_CHANGE_PS);
1107 }
Vivek Natarajanf3e85b92011-02-23 13:04:32 +05301108
Arik Nemtsov77b70232011-06-26 12:06:54 +03001109 if (local->hw.flags & IEEE80211_HW_PS_NULLFUNC_STACK)
1110 netif_tx_wake_all_queues(sdata->dev);
Johannes Berg965beda2009-04-16 13:17:24 +02001111}
1112
1113void ieee80211_dynamic_ps_timer(unsigned long data)
1114{
1115 struct ieee80211_local *local = (void *) data;
1116
Luis R. Rodriguez78f1a8b2009-07-27 08:38:25 -07001117 if (local->quiescing || local->suspended)
Johannes Berg5bb644a2009-05-17 11:40:42 +02001118 return;
1119
Luis R. Rodriguez42935ec2009-07-29 20:08:07 -04001120 ieee80211_queue_work(&local->hw, &local->dynamic_ps_enable_work);
Johannes Berg965beda2009-04-16 13:17:24 +02001121}
1122
Johannes Berg60f8b392008-09-08 17:44:22 +02001123/* MLME */
Jasper Bryant-Greenef698d852008-08-03 12:04:37 +12001124static void ieee80211_sta_wmm_params(struct ieee80211_local *local,
Johannes Berg4ced3f72010-07-19 16:39:04 +02001125 struct ieee80211_sub_if_data *sdata,
Jiri Bencf0706e82007-05-05 11:45:53 -07001126 u8 *wmm_param, size_t wmm_param_len)
1127{
Jiri Bencf0706e82007-05-05 11:45:53 -07001128 struct ieee80211_tx_queue_params params;
Johannes Berg4ced3f72010-07-19 16:39:04 +02001129 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
Jiri Bencf0706e82007-05-05 11:45:53 -07001130 size_t left;
1131 int count;
Kalle Valoab133152010-01-12 10:42:31 +02001132 u8 *pos, uapsd_queues = 0;
Jiri Bencf0706e82007-05-05 11:45:53 -07001133
Stanislaw Gruszkae1b3ec12010-03-29 12:18:34 +02001134 if (!local->ops->conf_tx)
1135 return;
1136
Johannes Berg32c50572012-03-28 11:04:29 +02001137 if (local->hw.queues < IEEE80211_NUM_ACS)
Johannes Berg3434fbd2008-05-03 00:59:37 +02001138 return;
1139
1140 if (!wmm_param)
1141 return;
1142
Jiri Bencf0706e82007-05-05 11:45:53 -07001143 if (wmm_param_len < 8 || wmm_param[5] /* version */ != 1)
1144 return;
Kalle Valoab133152010-01-12 10:42:31 +02001145
1146 if (ifmgd->flags & IEEE80211_STA_UAPSD_ENABLED)
Eliad Pellerdc41e4d2012-03-14 16:15:03 +02001147 uapsd_queues = ifmgd->uapsd_queues;
Kalle Valoab133152010-01-12 10:42:31 +02001148
Jiri Bencf0706e82007-05-05 11:45:53 -07001149 count = wmm_param[6] & 0x0f;
Johannes Berg46900292009-02-15 12:44:28 +01001150 if (count == ifmgd->wmm_last_param_set)
Jiri Bencf0706e82007-05-05 11:45:53 -07001151 return;
Johannes Berg46900292009-02-15 12:44:28 +01001152 ifmgd->wmm_last_param_set = count;
Jiri Bencf0706e82007-05-05 11:45:53 -07001153
1154 pos = wmm_param + 8;
1155 left = wmm_param_len - 8;
1156
1157 memset(&params, 0, sizeof(params));
1158
Jiri Bencf0706e82007-05-05 11:45:53 -07001159 local->wmm_acm = 0;
1160 for (; left >= 4; left -= 4, pos += 4) {
1161 int aci = (pos[0] >> 5) & 0x03;
1162 int acm = (pos[0] >> 4) & 0x01;
Kalle Valoab133152010-01-12 10:42:31 +02001163 bool uapsd = false;
Jiri Bencf0706e82007-05-05 11:45:53 -07001164 int queue;
1165
1166 switch (aci) {
Jouni Malinen0eeb59f2009-03-05 17:23:46 +02001167 case 1: /* AC_BK */
Johannes Berge100bb62008-04-30 18:51:21 +02001168 queue = 3;
Johannes Berg988c0f72008-04-17 19:21:22 +02001169 if (acm)
Jouni Malinen0eeb59f2009-03-05 17:23:46 +02001170 local->wmm_acm |= BIT(1) | BIT(2); /* BK/- */
Kalle Valoab133152010-01-12 10:42:31 +02001171 if (uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_BK)
1172 uapsd = true;
Jiri Bencf0706e82007-05-05 11:45:53 -07001173 break;
Jouni Malinen0eeb59f2009-03-05 17:23:46 +02001174 case 2: /* AC_VI */
Johannes Berge100bb62008-04-30 18:51:21 +02001175 queue = 1;
Johannes Berg988c0f72008-04-17 19:21:22 +02001176 if (acm)
Jouni Malinen0eeb59f2009-03-05 17:23:46 +02001177 local->wmm_acm |= BIT(4) | BIT(5); /* CL/VI */
Kalle Valoab133152010-01-12 10:42:31 +02001178 if (uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_VI)
1179 uapsd = true;
Jiri Bencf0706e82007-05-05 11:45:53 -07001180 break;
Jouni Malinen0eeb59f2009-03-05 17:23:46 +02001181 case 3: /* AC_VO */
Johannes Berge100bb62008-04-30 18:51:21 +02001182 queue = 0;
Johannes Berg988c0f72008-04-17 19:21:22 +02001183 if (acm)
Jouni Malinen0eeb59f2009-03-05 17:23:46 +02001184 local->wmm_acm |= BIT(6) | BIT(7); /* VO/NC */
Kalle Valoab133152010-01-12 10:42:31 +02001185 if (uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_VO)
1186 uapsd = true;
Jiri Bencf0706e82007-05-05 11:45:53 -07001187 break;
Jouni Malinen0eeb59f2009-03-05 17:23:46 +02001188 case 0: /* AC_BE */
Jiri Bencf0706e82007-05-05 11:45:53 -07001189 default:
Johannes Berge100bb62008-04-30 18:51:21 +02001190 queue = 2;
Johannes Berg988c0f72008-04-17 19:21:22 +02001191 if (acm)
Jouni Malinen0eeb59f2009-03-05 17:23:46 +02001192 local->wmm_acm |= BIT(0) | BIT(3); /* BE/EE */
Kalle Valoab133152010-01-12 10:42:31 +02001193 if (uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_BE)
1194 uapsd = true;
Jiri Bencf0706e82007-05-05 11:45:53 -07001195 break;
1196 }
1197
1198 params.aifs = pos[0] & 0x0f;
1199 params.cw_max = ecw2cw((pos[1] & 0xf0) >> 4);
1200 params.cw_min = ecw2cw(pos[1] & 0x0f);
Johannes Bergf434b2d2008-07-10 11:22:31 +02001201 params.txop = get_unaligned_le16(pos + 2);
Kalle Valoab133152010-01-12 10:42:31 +02001202 params.uapsd = uapsd;
1203
Johannes Bergf4ea83d2008-06-30 15:10:46 +02001204#ifdef CONFIG_MAC80211_VERBOSE_DEBUG
Joe Perches0fb9a9e2010-08-20 16:25:38 -07001205 wiphy_debug(local->hw.wiphy,
1206 "WMM queue=%d aci=%d acm=%d aifs=%d "
1207 "cWmin=%d cWmax=%d txop=%d uapsd=%d\n",
1208 queue, aci, acm,
1209 params.aifs, params.cw_min, params.cw_max,
1210 params.txop, params.uapsd);
Johannes Berg3330d7b2008-02-10 16:49:38 +01001211#endif
Eliad Pellerf6f3def2011-09-25 20:06:54 +03001212 sdata->tx_conf[queue] = params;
1213 if (drv_conf_tx(local, sdata, queue, &params))
Joe Perches0fb9a9e2010-08-20 16:25:38 -07001214 wiphy_debug(local->hw.wiphy,
1215 "failed to set TX queue parameters for queue %d\n",
1216 queue);
Jiri Bencf0706e82007-05-05 11:45:53 -07001217 }
Stanislaw Gruszkae1b3ec12010-03-29 12:18:34 +02001218
1219 /* enable WMM or activate new settings */
Johannes Berg4ced3f72010-07-19 16:39:04 +02001220 sdata->vif.bss_conf.qos = true;
Jiri Bencf0706e82007-05-05 11:45:53 -07001221}
1222
Stanislaw Gruszka925e64c2012-05-16 15:27:20 +02001223static void __ieee80211_stop_poll(struct ieee80211_sub_if_data *sdata)
1224{
1225 lockdep_assert_held(&sdata->local->mtx);
1226
1227 sdata->u.mgd.flags &= ~(IEEE80211_STA_CONNECTION_POLL |
1228 IEEE80211_STA_BEACON_POLL);
1229 ieee80211_run_deferred_scan(sdata->local);
1230}
1231
1232static void ieee80211_stop_poll(struct ieee80211_sub_if_data *sdata)
1233{
1234 mutex_lock(&sdata->local->mtx);
1235 __ieee80211_stop_poll(sdata);
1236 mutex_unlock(&sdata->local->mtx);
1237}
1238
Johannes Berg7a5158e2008-10-08 10:59:33 +02001239static u32 ieee80211_handle_bss_capability(struct ieee80211_sub_if_data *sdata,
1240 u16 capab, bool erp_valid, u8 erp)
Daniel Drake56282212007-07-10 19:32:10 +02001241{
Johannes Bergbda39332008-10-11 01:51:51 +02001242 struct ieee80211_bss_conf *bss_conf = &sdata->vif.bss_conf;
Johannes Berg471b3ef2007-12-28 14:32:58 +01001243 u32 changed = 0;
Johannes Berg7a5158e2008-10-08 10:59:33 +02001244 bool use_protection;
1245 bool use_short_preamble;
1246 bool use_short_slot;
1247
1248 if (erp_valid) {
1249 use_protection = (erp & WLAN_ERP_USE_PROTECTION) != 0;
1250 use_short_preamble = (erp & WLAN_ERP_BARKER_PREAMBLE) == 0;
1251 } else {
1252 use_protection = false;
1253 use_short_preamble = !!(capab & WLAN_CAPABILITY_SHORT_PREAMBLE);
1254 }
1255
1256 use_short_slot = !!(capab & WLAN_CAPABILITY_SHORT_SLOT_TIME);
Felix Fietkau43d35342010-01-15 03:00:48 +01001257 if (sdata->local->hw.conf.channel->band == IEEE80211_BAND_5GHZ)
1258 use_short_slot = true;
Daniel Drake56282212007-07-10 19:32:10 +02001259
Johannes Berg471b3ef2007-12-28 14:32:58 +01001260 if (use_protection != bss_conf->use_cts_prot) {
Johannes Berg471b3ef2007-12-28 14:32:58 +01001261 bss_conf->use_cts_prot = use_protection;
1262 changed |= BSS_CHANGED_ERP_CTS_PROT;
Daniel Drake56282212007-07-10 19:32:10 +02001263 }
Daniel Drake7e9ed182007-07-27 15:43:24 +02001264
Vladimir Koutnyd43c7b32008-03-31 17:05:03 +02001265 if (use_short_preamble != bss_conf->use_short_preamble) {
Vladimir Koutnyd43c7b32008-03-31 17:05:03 +02001266 bss_conf->use_short_preamble = use_short_preamble;
Johannes Berg471b3ef2007-12-28 14:32:58 +01001267 changed |= BSS_CHANGED_ERP_PREAMBLE;
Daniel Drake7e9ed182007-07-27 15:43:24 +02001268 }
Daniel Draked9430a32007-07-27 15:43:24 +02001269
Johannes Berg7a5158e2008-10-08 10:59:33 +02001270 if (use_short_slot != bss_conf->use_short_slot) {
Johannes Berg7a5158e2008-10-08 10:59:33 +02001271 bss_conf->use_short_slot = use_short_slot;
1272 changed |= BSS_CHANGED_ERP_SLOT;
John W. Linville50c4afb2008-04-15 14:09:27 -04001273 }
1274
1275 return changed;
1276}
1277
Jasper Bryant-Greenef698d852008-08-03 12:04:37 +12001278static void ieee80211_set_associated(struct ieee80211_sub_if_data *sdata,
Johannes Berg0c1ad2c2009-12-23 13:15:39 +01001279 struct cfg80211_bss *cbss,
Johannes Bergae5eb022008-10-14 16:58:37 +02001280 u32 bss_info_changed)
Jiri Bencf0706e82007-05-05 11:45:53 -07001281{
Johannes Berg0c1ad2c2009-12-23 13:15:39 +01001282 struct ieee80211_bss *bss = (void *)cbss->priv;
Johannes Berg471b3ef2007-12-28 14:32:58 +01001283 struct ieee80211_local *local = sdata->local;
Juuso Oikarinen68542962010-06-09 13:43:26 +03001284 struct ieee80211_bss_conf *bss_conf = &sdata->vif.bss_conf;
Jiri Slabyd6f2da52007-08-28 17:01:54 -04001285
Johannes Bergae5eb022008-10-14 16:58:37 +02001286 bss_info_changed |= BSS_CHANGED_ASSOC;
Johannes Berg77fdaa12009-07-07 03:45:17 +02001287 /* set timing information */
Juuso Oikarinen68542962010-06-09 13:43:26 +03001288 bss_conf->beacon_int = cbss->beacon_interval;
Johannes Berge9ac0742012-03-13 14:29:30 +01001289 bss_conf->last_tsf = cbss->tsf;
Jiri Slabyd6f2da52007-08-28 17:01:54 -04001290
Johannes Berg77fdaa12009-07-07 03:45:17 +02001291 bss_info_changed |= BSS_CHANGED_BEACON_INT;
1292 bss_info_changed |= ieee80211_handle_bss_capability(sdata,
Johannes Berg0c1ad2c2009-12-23 13:15:39 +01001293 cbss->capability, bss->has_erp_value, bss->erp_value);
Tomas Winkler21c0cbe2008-03-28 16:33:34 -07001294
Felix Fietkau7ccc8bd2010-11-19 22:55:38 +01001295 sdata->u.mgd.beacon_timeout = usecs_to_jiffies(ieee80211_tu_to_usec(
1296 IEEE80211_BEACON_LOSS_COUNT * bss_conf->beacon_int));
1297
Johannes Berg0c1ad2c2009-12-23 13:15:39 +01001298 sdata->u.mgd.associated = cbss;
1299 memcpy(sdata->u.mgd.bssid, cbss->bssid, ETH_ALEN);
Johannes Berg471b3ef2007-12-28 14:32:58 +01001300
Jouni Malinen17e4ec12010-03-29 23:28:30 -07001301 sdata->u.mgd.flags |= IEEE80211_STA_RESET_SIGNAL_AVE;
1302
Johannes Bergb291ba12009-07-10 15:29:03 +02001303 /* just to be sure */
Stanislaw Gruszka925e64c2012-05-16 15:27:20 +02001304 ieee80211_stop_poll(sdata);
Johannes Bergb291ba12009-07-10 15:29:03 +02001305
Tomas Winklerf5e5bf22008-09-08 17:33:39 +02001306 ieee80211_led_assoc(local, 1);
1307
Johannes Berge5b900d2010-07-29 16:08:55 +02001308 if (local->hw.flags & IEEE80211_HW_NEED_DTIM_PERIOD)
1309 bss_conf->dtim_period = bss->dtim_period;
1310 else
1311 bss_conf->dtim_period = 0;
1312
Juuso Oikarinen68542962010-06-09 13:43:26 +03001313 bss_conf->assoc = 1;
Johannes Berg9cef8732009-05-14 13:10:14 +02001314
Juuso Oikarinena97c13c2010-03-23 09:02:34 +02001315 /* Tell the driver to monitor connection quality (if supported) */
Johannes Bergea086352012-01-19 09:29:58 +01001316 if (sdata->vif.driver_flags & IEEE80211_VIF_SUPPORTS_CQM_RSSI &&
Juuso Oikarinen68542962010-06-09 13:43:26 +03001317 bss_conf->cqm_rssi_thold)
Juuso Oikarinena97c13c2010-03-23 09:02:34 +02001318 bss_info_changed |= BSS_CHANGED_CQM;
1319
Juuso Oikarinen68542962010-06-09 13:43:26 +03001320 /* Enable ARP filtering */
1321 if (bss_conf->arp_filter_enabled != sdata->arp_filter_state) {
1322 bss_conf->arp_filter_enabled = sdata->arp_filter_state;
1323 bss_info_changed |= BSS_CHANGED_ARP_FILTER;
1324 }
1325
Johannes Bergae5eb022008-10-14 16:58:37 +02001326 ieee80211_bss_info_change_notify(sdata, bss_info_changed);
Guy Cohen8db93692008-07-03 19:56:13 +03001327
Johannes Berg056508d2009-07-30 21:43:55 +02001328 mutex_lock(&local->iflist_mtx);
1329 ieee80211_recalc_ps(local, -1);
Johannes Berg025e6be2010-10-05 10:41:47 +02001330 ieee80211_recalc_smps(local);
Johannes Berg056508d2009-07-30 21:43:55 +02001331 mutex_unlock(&local->iflist_mtx);
Kalle Valoe0cb6862008-12-18 23:35:13 +02001332
John W. Linville8a5b33f2010-01-06 15:39:39 -05001333 netif_tx_start_all_queues(sdata->dev);
Tomas Winklerf5e5bf22008-09-08 17:33:39 +02001334 netif_carrier_on(sdata->dev);
Jiri Bencf0706e82007-05-05 11:45:53 -07001335}
1336
Jouni Malinene69e95d2010-03-29 23:29:31 -07001337static void ieee80211_set_disassoc(struct ieee80211_sub_if_data *sdata,
Johannes Berg37ad3882012-02-24 13:50:54 +01001338 u16 stype, u16 reason, bool tx,
1339 u8 *frame_buf)
Tomas Winkleraa458d12008-09-09 00:32:12 +03001340{
Johannes Berg46900292009-02-15 12:44:28 +01001341 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
Tomas Winkleraa458d12008-09-09 00:32:12 +03001342 struct ieee80211_local *local = sdata->local;
1343 struct sta_info *sta;
Johannes Berg3cc52402012-03-09 13:12:35 +01001344 u32 changed = 0;
Tomas Winkleraa458d12008-09-09 00:32:12 +03001345
Johannes Berg77fdaa12009-07-07 03:45:17 +02001346 ASSERT_MGD_MTX(ifmgd);
1347
Johannes Berg37ad3882012-02-24 13:50:54 +01001348 if (WARN_ON_ONCE(tx && !frame_buf))
1349 return;
1350
Johannes Bergb291ba12009-07-10 15:29:03 +02001351 if (WARN_ON(!ifmgd->associated))
1352 return;
1353
David Spinadel79543d82012-06-12 09:59:45 +03001354 ieee80211_stop_poll(sdata);
1355
Johannes Berg77fdaa12009-07-07 03:45:17 +02001356 ifmgd->associated = NULL;
Johannes Berg77fdaa12009-07-07 03:45:17 +02001357
1358 /*
1359 * we need to commit the associated = NULL change because the
1360 * scan code uses that to determine whether this iface should
1361 * go to/wake up from powersave or not -- and could otherwise
1362 * wake the queues erroneously.
1363 */
1364 smp_mb();
1365
1366 /*
1367 * Thus, we can only afterwards stop the queues -- to account
1368 * for the case where another CPU is finishing a scan at this
1369 * time -- we don't want the scan code to enable queues.
1370 */
Tomas Winkleraa458d12008-09-09 00:32:12 +03001371
John W. Linville8a5b33f2010-01-06 15:39:39 -05001372 netif_tx_stop_all_queues(sdata->dev);
Tomas Winkleraa458d12008-09-09 00:32:12 +03001373 netif_carrier_off(sdata->dev);
1374
Johannes Berg2a419052010-06-10 10:21:29 +02001375 mutex_lock(&local->sta_mtx);
Eliad Peller88a9e312012-06-01 11:14:03 +03001376 sta = sta_info_get(sdata, ifmgd->bssid);
Sujith4cad6c72010-02-10 14:52:21 +05301377 if (sta) {
Johannes Bergc2c98fd2011-09-29 16:04:36 +02001378 set_sta_flag(sta, WLAN_STA_BLOCK_BA);
Johannes Berg53f73c02010-10-05 19:37:40 +02001379 ieee80211_sta_tear_down_BA_sessions(sta, tx);
Sujith4cad6c72010-02-10 14:52:21 +05301380 }
Johannes Berg2a419052010-06-10 10:21:29 +02001381 mutex_unlock(&local->sta_mtx);
Tomas Winkleraa458d12008-09-09 00:32:12 +03001382
Johannes Berg37ad3882012-02-24 13:50:54 +01001383 /* deauthenticate/disassociate now */
1384 if (tx || frame_buf)
Eliad Peller88a9e312012-06-01 11:14:03 +03001385 ieee80211_send_deauth_disassoc(sdata, ifmgd->bssid, stype,
1386 reason, tx, frame_buf);
Johannes Berg37ad3882012-02-24 13:50:54 +01001387
1388 /* flush out frame */
1389 if (tx)
1390 drv_flush(local, false);
1391
Eliad Peller88a9e312012-06-01 11:14:03 +03001392 /* clear bssid only after building the needed mgmt frames */
1393 memset(ifmgd->bssid, 0, ETH_ALEN);
1394
Johannes Berg37ad3882012-02-24 13:50:54 +01001395 /* remove AP and TDLS peers */
1396 sta_info_flush(local, sdata);
1397
1398 /* finally reset all BSS / config parameters */
Tomas Winklerf5e5bf22008-09-08 17:33:39 +02001399 changed |= ieee80211_reset_erp_info(sdata);
1400
Tomas Winklerf5e5bf22008-09-08 17:33:39 +02001401 ieee80211_led_assoc(local, 0);
Johannes Bergae5eb022008-10-14 16:58:37 +02001402 changed |= BSS_CHANGED_ASSOC;
1403 sdata->vif.bss_conf.assoc = false;
Tomas Winklerf5e5bf22008-09-08 17:33:39 +02001404
Johannes Berg413ad502009-05-08 21:21:06 +02001405 /* on the next assoc, re-program HT parameters */
Ben Greearef96a8422011-11-18 11:32:00 -08001406 memset(&ifmgd->ht_capa, 0, sizeof(ifmgd->ht_capa));
1407 memset(&ifmgd->ht_capa_mask, 0, sizeof(ifmgd->ht_capa_mask));
Johannes Berg413ad502009-05-08 21:21:06 +02001408
Vasanthakumar Thiagarajana8302de2009-01-09 18:14:15 +05301409 local->power_constr_level = 0;
1410
Kalle Valo520eb822008-12-18 23:35:27 +02001411 del_timer_sync(&local->dynamic_ps_timer);
1412 cancel_work_sync(&local->dynamic_ps_enable_work);
1413
Kalle Valoe0cb6862008-12-18 23:35:13 +02001414 if (local->hw.conf.flags & IEEE80211_CONF_PS) {
1415 local->hw.conf.flags &= ~IEEE80211_CONF_PS;
Johannes Berg3cc52402012-03-09 13:12:35 +01001416 ieee80211_hw_config(local, IEEE80211_CONF_CHANGE_PS);
Kalle Valoe0cb6862008-12-18 23:35:13 +02001417 }
Eliad Pellera3314002011-05-26 11:46:37 +03001418 local->ps_sdata = NULL;
Kalle Valoe0cb6862008-12-18 23:35:13 +02001419
Juuso Oikarinen68542962010-06-09 13:43:26 +03001420 /* Disable ARP filtering */
1421 if (sdata->vif.bss_conf.arp_filter_enabled) {
1422 sdata->vif.bss_conf.arp_filter_enabled = false;
1423 changed |= BSS_CHANGED_ARP_FILTER;
1424 }
1425
Johannes Berg3abead52012-03-02 15:56:59 +01001426 sdata->vif.bss_conf.qos = false;
1427 changed |= BSS_CHANGED_QOS;
1428
Johannes Berg0aaffa92010-05-05 15:28:27 +02001429 /* The BSSID (not really interesting) and HT changed */
1430 changed |= BSS_CHANGED_BSSID | BSS_CHANGED_HT;
Johannes Bergae5eb022008-10-14 16:58:37 +02001431 ieee80211_bss_info_change_notify(sdata, changed);
Tomas Winkler8e268e42008-11-25 13:05:44 +02001432
Johannes Berg3cc52402012-03-09 13:12:35 +01001433 /* channel(_type) changes are handled by ieee80211_hw_config */
1434 WARN_ON(!ieee80211_set_channel_type(local, sdata, NL80211_CHAN_NO_HT));
1435 ieee80211_hw_config(local, 0);
1436
Johannes Berg3abead52012-03-02 15:56:59 +01001437 /* disassociated - set to defaults now */
1438 ieee80211_set_wmm_default(sdata, false);
1439
Johannes Bergb9dcf712010-08-27 12:35:54 +02001440 del_timer_sync(&sdata->u.mgd.conn_mon_timer);
1441 del_timer_sync(&sdata->u.mgd.bcn_mon_timer);
1442 del_timer_sync(&sdata->u.mgd.timer);
1443 del_timer_sync(&sdata->u.mgd.chswitch_timer);
Tomas Winkleraa458d12008-09-09 00:32:12 +03001444}
Jiri Bencf0706e82007-05-05 11:45:53 -07001445
Kalle Valo3cf335d2009-03-22 21:57:06 +02001446void ieee80211_sta_rx_notify(struct ieee80211_sub_if_data *sdata,
1447 struct ieee80211_hdr *hdr)
1448{
1449 /*
1450 * We can postpone the mgd.timer whenever receiving unicast frames
1451 * from AP because we know that the connection is working both ways
1452 * at that time. But multicast frames (and hence also beacons) must
1453 * be ignored here, because we need to trigger the timer during
Johannes Bergb291ba12009-07-10 15:29:03 +02001454 * data idle periods for sending the periodic probe request to the
1455 * AP we're connected to.
Kalle Valo3cf335d2009-03-22 21:57:06 +02001456 */
Johannes Bergb291ba12009-07-10 15:29:03 +02001457 if (is_multicast_ether_addr(hdr->addr1))
1458 return;
1459
Luis R. Rodriguezbe099e82010-09-16 15:12:29 -04001460 ieee80211_sta_reset_conn_monitor(sdata);
Kalle Valo3cf335d2009-03-22 21:57:06 +02001461}
Jiri Bencf0706e82007-05-05 11:45:53 -07001462
Felix Fietkau4e5ff372010-11-23 03:10:31 +01001463static void ieee80211_reset_ap_probe(struct ieee80211_sub_if_data *sdata)
1464{
1465 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
Stanislaw Gruszka133d40f2012-03-28 16:01:19 +02001466 struct ieee80211_local *local = sdata->local;
Felix Fietkau4e5ff372010-11-23 03:10:31 +01001467
Stanislaw Gruszka133d40f2012-03-28 16:01:19 +02001468 mutex_lock(&local->mtx);
Felix Fietkau4e5ff372010-11-23 03:10:31 +01001469 if (!(ifmgd->flags & (IEEE80211_STA_BEACON_POLL |
Stanislaw Gruszka133d40f2012-03-28 16:01:19 +02001470 IEEE80211_STA_CONNECTION_POLL))) {
1471 mutex_unlock(&local->mtx);
1472 return;
1473 }
Felix Fietkau4e5ff372010-11-23 03:10:31 +01001474
Stanislaw Gruszka925e64c2012-05-16 15:27:20 +02001475 __ieee80211_stop_poll(sdata);
Stanislaw Gruszka133d40f2012-03-28 16:01:19 +02001476
1477 mutex_lock(&local->iflist_mtx);
1478 ieee80211_recalc_ps(local, -1);
1479 mutex_unlock(&local->iflist_mtx);
Felix Fietkau4e5ff372010-11-23 03:10:31 +01001480
1481 if (sdata->local->hw.flags & IEEE80211_HW_CONNECTION_MONITOR)
Stanislaw Gruszka133d40f2012-03-28 16:01:19 +02001482 goto out;
Felix Fietkau4e5ff372010-11-23 03:10:31 +01001483
1484 /*
1485 * We've received a probe response, but are not sure whether
1486 * we have or will be receiving any beacons or data, so let's
1487 * schedule the timers again, just in case.
1488 */
1489 ieee80211_sta_reset_beacon_monitor(sdata);
1490
1491 mod_timer(&ifmgd->conn_mon_timer,
1492 round_jiffies_up(jiffies +
1493 IEEE80211_CONNECTION_IDLE_TIME));
Stanislaw Gruszka133d40f2012-03-28 16:01:19 +02001494out:
Stanislaw Gruszka133d40f2012-03-28 16:01:19 +02001495 mutex_unlock(&local->mtx);
Felix Fietkau4e5ff372010-11-23 03:10:31 +01001496}
1497
1498void ieee80211_sta_tx_notify(struct ieee80211_sub_if_data *sdata,
Felix Fietkau04ac3c02010-12-02 21:01:08 +01001499 struct ieee80211_hdr *hdr, bool ack)
Felix Fietkau4e5ff372010-11-23 03:10:31 +01001500{
Felix Fietkau75706d02010-12-02 21:01:07 +01001501 if (!ieee80211_is_data(hdr->frame_control))
Felix Fietkau4e5ff372010-11-23 03:10:31 +01001502 return;
1503
Felix Fietkau04ac3c02010-12-02 21:01:08 +01001504 if (ack)
1505 ieee80211_sta_reset_conn_monitor(sdata);
Felix Fietkau4e5ff372010-11-23 03:10:31 +01001506
1507 if (ieee80211_is_nullfunc(hdr->frame_control) &&
1508 sdata->u.mgd.probe_send_count > 0) {
Felix Fietkau04ac3c02010-12-02 21:01:08 +01001509 if (ack)
1510 sdata->u.mgd.probe_send_count = 0;
1511 else
1512 sdata->u.mgd.nullfunc_failed = true;
Felix Fietkau4e5ff372010-11-23 03:10:31 +01001513 ieee80211_queue_work(&sdata->local->hw, &sdata->work);
1514 }
1515}
1516
Maxim Levitskya43abf22009-07-31 18:54:12 +03001517static void ieee80211_mgd_probe_ap_send(struct ieee80211_sub_if_data *sdata)
1518{
1519 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
1520 const u8 *ssid;
Luis R. Rodriguezf01a0672010-09-16 15:12:34 -04001521 u8 *dst = ifmgd->associated->bssid;
Ben Greear180205b2011-02-04 15:30:24 -08001522 u8 unicast_limit = max(1, max_probe_tries - 3);
Luis R. Rodriguezf01a0672010-09-16 15:12:34 -04001523
1524 /*
1525 * Try sending broadcast probe requests for the last three
1526 * probe requests after the first ones failed since some
1527 * buggy APs only support broadcast probe requests.
1528 */
1529 if (ifmgd->probe_send_count >= unicast_limit)
1530 dst = NULL;
Maxim Levitskya43abf22009-07-31 18:54:12 +03001531
Felix Fietkau4e5ff372010-11-23 03:10:31 +01001532 /*
1533 * When the hardware reports an accurate Tx ACK status, it's
1534 * better to send a nullfunc frame instead of a probe request,
1535 * as it will kick us off the AP quickly if we aren't associated
1536 * anymore. The timeout will be reset if the frame is ACKed by
1537 * the AP.
1538 */
Soumik Das992e68b2012-05-20 15:31:13 +05301539 ifmgd->probe_send_count++;
1540
Felix Fietkau04ac3c02010-12-02 21:01:08 +01001541 if (sdata->local->hw.flags & IEEE80211_HW_REPORTS_TX_ACK_STATUS) {
1542 ifmgd->nullfunc_failed = false;
Felix Fietkau4e5ff372010-11-23 03:10:31 +01001543 ieee80211_send_nullfunc(sdata->local, sdata, 0);
Felix Fietkau04ac3c02010-12-02 21:01:08 +01001544 } else {
Stanislaw Gruszka88c868c2012-03-29 16:30:41 +02001545 int ssid_len;
1546
Felix Fietkau4e5ff372010-11-23 03:10:31 +01001547 ssid = ieee80211_bss_get_ie(ifmgd->associated, WLAN_EID_SSID);
Stanislaw Gruszka88c868c2012-03-29 16:30:41 +02001548 if (WARN_ON_ONCE(ssid == NULL))
1549 ssid_len = 0;
1550 else
1551 ssid_len = ssid[1];
1552
1553 ieee80211_send_probe_req(sdata, dst, ssid + 2, ssid_len, NULL,
1554 0, (u32) -1, true, false);
Felix Fietkau4e5ff372010-11-23 03:10:31 +01001555 }
Maxim Levitskya43abf22009-07-31 18:54:12 +03001556
Ben Greear180205b2011-02-04 15:30:24 -08001557 ifmgd->probe_timeout = jiffies + msecs_to_jiffies(probe_wait_ms);
Maxim Levitskya43abf22009-07-31 18:54:12 +03001558 run_again(ifmgd, ifmgd->probe_timeout);
Rajkumar Manoharanf69b9c72012-03-15 06:15:26 +05301559 if (sdata->local->hw.flags & IEEE80211_HW_REPORTS_TX_ACK_STATUS)
1560 drv_flush(sdata->local, false);
Maxim Levitskya43abf22009-07-31 18:54:12 +03001561}
1562
Johannes Bergb291ba12009-07-10 15:29:03 +02001563static void ieee80211_mgd_probe_ap(struct ieee80211_sub_if_data *sdata,
1564 bool beacon)
Kalle Valo04de8382009-03-22 21:57:35 +02001565{
Kalle Valo04de8382009-03-22 21:57:35 +02001566 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
Johannes Bergb291ba12009-07-10 15:29:03 +02001567 bool already = false;
Johannes Berg34bfc412009-05-12 19:58:12 +02001568
Johannes Berg9607e6b2009-12-23 13:15:31 +01001569 if (!ieee80211_sdata_running(sdata))
Johannes Berg0e2b6282009-07-13 13:23:39 +02001570 return;
1571
Johannes Berg77fdaa12009-07-07 03:45:17 +02001572 mutex_lock(&ifmgd->mtx);
1573
1574 if (!ifmgd->associated)
1575 goto out;
1576
Stanislaw Gruszka133d40f2012-03-28 16:01:19 +02001577 mutex_lock(&sdata->local->mtx);
1578
1579 if (sdata->local->tmp_channel || sdata->local->scanning) {
1580 mutex_unlock(&sdata->local->mtx);
1581 goto out;
1582 }
1583
Michael Buescha8604022009-04-15 14:41:22 -04001584#ifdef CONFIG_MAC80211_VERBOSE_DEBUG
Joe Perchese87cc472012-05-13 21:56:26 +00001585 if (beacon)
1586 net_dbg_ratelimited("%s: detected beacon loss from AP - sending probe request\n",
1587 sdata->name);
Michael Buescha8604022009-04-15 14:41:22 -04001588#endif
Kalle Valo04de8382009-03-22 21:57:35 +02001589
Johannes Bergb291ba12009-07-10 15:29:03 +02001590 /*
1591 * The driver/our work has already reported this event or the
1592 * connection monitoring has kicked in and we have already sent
1593 * a probe request. Or maybe the AP died and the driver keeps
1594 * reporting until we disassociate...
1595 *
1596 * In either case we have to ignore the current call to this
1597 * function (except for setting the correct probe reason bit)
1598 * because otherwise we would reset the timer every time and
1599 * never check whether we received a probe response!
1600 */
1601 if (ifmgd->flags & (IEEE80211_STA_BEACON_POLL |
1602 IEEE80211_STA_CONNECTION_POLL))
1603 already = true;
1604
1605 if (beacon)
1606 ifmgd->flags |= IEEE80211_STA_BEACON_POLL;
1607 else
1608 ifmgd->flags |= IEEE80211_STA_CONNECTION_POLL;
1609
Stanislaw Gruszka133d40f2012-03-28 16:01:19 +02001610 mutex_unlock(&sdata->local->mtx);
1611
Johannes Bergb291ba12009-07-10 15:29:03 +02001612 if (already)
1613 goto out;
1614
Johannes Berg4e751842009-06-10 15:16:52 +02001615 mutex_lock(&sdata->local->iflist_mtx);
1616 ieee80211_recalc_ps(sdata->local, -1);
1617 mutex_unlock(&sdata->local->iflist_mtx);
1618
Maxim Levitskya43abf22009-07-31 18:54:12 +03001619 ifmgd->probe_send_count = 0;
1620 ieee80211_mgd_probe_ap_send(sdata);
Johannes Berg77fdaa12009-07-07 03:45:17 +02001621 out:
1622 mutex_unlock(&ifmgd->mtx);
Kalle Valo04de8382009-03-22 21:57:35 +02001623}
1624
Juuso Oikarinena619a4c2010-11-11 08:50:18 +02001625struct sk_buff *ieee80211_ap_probereq_get(struct ieee80211_hw *hw,
1626 struct ieee80211_vif *vif)
1627{
1628 struct ieee80211_sub_if_data *sdata = vif_to_sdata(vif);
1629 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
1630 struct sk_buff *skb;
1631 const u8 *ssid;
Stanislaw Gruszka88c868c2012-03-29 16:30:41 +02001632 int ssid_len;
Juuso Oikarinena619a4c2010-11-11 08:50:18 +02001633
1634 if (WARN_ON(sdata->vif.type != NL80211_IFTYPE_STATION))
1635 return NULL;
1636
1637 ASSERT_MGD_MTX(ifmgd);
1638
1639 if (!ifmgd->associated)
1640 return NULL;
1641
1642 ssid = ieee80211_bss_get_ie(ifmgd->associated, WLAN_EID_SSID);
Stanislaw Gruszka88c868c2012-03-29 16:30:41 +02001643 if (WARN_ON_ONCE(ssid == NULL))
1644 ssid_len = 0;
1645 else
1646 ssid_len = ssid[1];
1647
Juuso Oikarinena619a4c2010-11-11 08:50:18 +02001648 skb = ieee80211_build_probe_req(sdata, ifmgd->associated->bssid,
Stanislaw Gruszka88c868c2012-03-29 16:30:41 +02001649 (u32) -1, ssid + 2, ssid_len,
Johannes Berg85a237f2011-07-18 18:08:36 +02001650 NULL, 0, true);
Juuso Oikarinena619a4c2010-11-11 08:50:18 +02001651
1652 return skb;
1653}
1654EXPORT_SYMBOL(ieee80211_ap_probereq_get);
1655
Juuso Oikarinen1e4dcd02010-03-19 07:14:53 +02001656static void __ieee80211_connection_loss(struct ieee80211_sub_if_data *sdata)
1657{
1658 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
1659 struct ieee80211_local *local = sdata->local;
1660 u8 bssid[ETH_ALEN];
Johannes Berg5fef7db2012-02-24 13:50:52 +01001661 u8 frame_buf[DEAUTH_DISASSOC_LEN];
Juuso Oikarinen1e4dcd02010-03-19 07:14:53 +02001662
1663 mutex_lock(&ifmgd->mtx);
1664 if (!ifmgd->associated) {
1665 mutex_unlock(&ifmgd->mtx);
1666 return;
1667 }
1668
1669 memcpy(bssid, ifmgd->associated->bssid, ETH_ALEN);
1670
Ben Greear180205b2011-02-04 15:30:24 -08001671 printk(KERN_DEBUG "%s: Connection to AP %pM lost.\n",
1672 sdata->name, bssid);
Juuso Oikarinen1e4dcd02010-03-19 07:14:53 +02001673
Johannes Berg37ad3882012-02-24 13:50:54 +01001674 ieee80211_set_disassoc(sdata, IEEE80211_STYPE_DEAUTH,
1675 WLAN_REASON_DISASSOC_DUE_TO_INACTIVITY,
1676 false, frame_buf);
Juuso Oikarinen1e4dcd02010-03-19 07:14:53 +02001677 mutex_unlock(&ifmgd->mtx);
Johannes Berg7da7cc12010-08-05 17:02:38 +02001678
Juuso Oikarinen1e4dcd02010-03-19 07:14:53 +02001679 /*
1680 * must be outside lock due to cfg80211,
1681 * but that's not a problem.
1682 */
Johannes Berg5fef7db2012-02-24 13:50:52 +01001683 cfg80211_send_deauth(sdata->dev, frame_buf, DEAUTH_DISASSOC_LEN);
Felix Fietkaufcac4fb2011-11-16 13:34:55 +01001684
1685 mutex_lock(&local->mtx);
1686 ieee80211_recalc_idle(local);
1687 mutex_unlock(&local->mtx);
Juuso Oikarinen1e4dcd02010-03-19 07:14:53 +02001688}
1689
1690void ieee80211_beacon_connection_loss_work(struct work_struct *work)
Johannes Bergb291ba12009-07-10 15:29:03 +02001691{
1692 struct ieee80211_sub_if_data *sdata =
1693 container_of(work, struct ieee80211_sub_if_data,
Juuso Oikarinen1e4dcd02010-03-19 07:14:53 +02001694 u.mgd.beacon_connection_loss_work);
Paul Stewarta85e1d52011-12-09 11:01:49 -08001695 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
1696 struct sta_info *sta;
1697
1698 if (ifmgd->associated) {
Mohammed Shafi Shajakhan30fa9042011-12-27 18:54:07 +05301699 rcu_read_lock();
Paul Stewarta85e1d52011-12-09 11:01:49 -08001700 sta = sta_info_get(sdata, ifmgd->bssid);
1701 if (sta)
1702 sta->beacon_loss_count++;
Mohammed Shafi Shajakhan30fa9042011-12-27 18:54:07 +05301703 rcu_read_unlock();
Paul Stewarta85e1d52011-12-09 11:01:49 -08001704 }
Johannes Bergb291ba12009-07-10 15:29:03 +02001705
Juuso Oikarinen1e4dcd02010-03-19 07:14:53 +02001706 if (sdata->local->hw.flags & IEEE80211_HW_CONNECTION_MONITOR)
1707 __ieee80211_connection_loss(sdata);
1708 else
1709 ieee80211_mgd_probe_ap(sdata, true);
Johannes Bergb291ba12009-07-10 15:29:03 +02001710}
1711
Kalle Valo04de8382009-03-22 21:57:35 +02001712void ieee80211_beacon_loss(struct ieee80211_vif *vif)
1713{
1714 struct ieee80211_sub_if_data *sdata = vif_to_sdata(vif);
Juuso Oikarinen1e4dcd02010-03-19 07:14:53 +02001715 struct ieee80211_hw *hw = &sdata->local->hw;
Kalle Valo04de8382009-03-22 21:57:35 +02001716
Johannes Bergb5878a22010-04-07 16:48:40 +02001717 trace_api_beacon_loss(sdata);
1718
Juuso Oikarinen1e4dcd02010-03-19 07:14:53 +02001719 WARN_ON(hw->flags & IEEE80211_HW_CONNECTION_MONITOR);
1720 ieee80211_queue_work(hw, &sdata->u.mgd.beacon_connection_loss_work);
Kalle Valo04de8382009-03-22 21:57:35 +02001721}
1722EXPORT_SYMBOL(ieee80211_beacon_loss);
1723
Juuso Oikarinen1e4dcd02010-03-19 07:14:53 +02001724void ieee80211_connection_loss(struct ieee80211_vif *vif)
1725{
1726 struct ieee80211_sub_if_data *sdata = vif_to_sdata(vif);
1727 struct ieee80211_hw *hw = &sdata->local->hw;
1728
Johannes Bergb5878a22010-04-07 16:48:40 +02001729 trace_api_connection_loss(sdata);
1730
Juuso Oikarinen1e4dcd02010-03-19 07:14:53 +02001731 WARN_ON(!(hw->flags & IEEE80211_HW_CONNECTION_MONITOR));
1732 ieee80211_queue_work(hw, &sdata->u.mgd.beacon_connection_loss_work);
1733}
1734EXPORT_SYMBOL(ieee80211_connection_loss);
1735
1736
Johannes Berg66e67e42012-01-20 13:55:27 +01001737static void ieee80211_destroy_auth_data(struct ieee80211_sub_if_data *sdata,
1738 bool assoc)
1739{
1740 struct ieee80211_mgd_auth_data *auth_data = sdata->u.mgd.auth_data;
1741
1742 lockdep_assert_held(&sdata->u.mgd.mtx);
1743
Johannes Berg66e67e42012-01-20 13:55:27 +01001744 if (!assoc) {
1745 sta_info_destroy_addr(sdata, auth_data->bss->bssid);
1746
1747 memset(sdata->u.mgd.bssid, 0, ETH_ALEN);
1748 ieee80211_bss_info_change_notify(sdata, BSS_CHANGED_BSSID);
1749 }
1750
1751 cfg80211_put_bss(auth_data->bss);
1752 kfree(auth_data);
1753 sdata->u.mgd.auth_data = NULL;
1754}
1755
1756static void ieee80211_auth_challenge(struct ieee80211_sub_if_data *sdata,
1757 struct ieee80211_mgmt *mgmt, size_t len)
1758{
1759 struct ieee80211_mgd_auth_data *auth_data = sdata->u.mgd.auth_data;
1760 u8 *pos;
1761 struct ieee802_11_elems elems;
1762
1763 pos = mgmt->u.auth.variable;
1764 ieee802_11_parse_elems(pos, len - (pos - (u8 *) mgmt), &elems);
1765 if (!elems.challenge)
1766 return;
1767 auth_data->expected_transaction = 4;
1768 ieee80211_send_auth(sdata, 3, auth_data->algorithm,
1769 elems.challenge - 2, elems.challenge_len + 2,
1770 auth_data->bss->bssid, auth_data->bss->bssid,
1771 auth_data->key, auth_data->key_len,
1772 auth_data->key_idx);
1773}
1774
1775static enum rx_mgmt_action __must_check
1776ieee80211_rx_mgmt_auth(struct ieee80211_sub_if_data *sdata,
1777 struct ieee80211_mgmt *mgmt, size_t len)
1778{
1779 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
1780 u8 bssid[ETH_ALEN];
1781 u16 auth_alg, auth_transaction, status_code;
1782 struct sta_info *sta;
1783
1784 lockdep_assert_held(&ifmgd->mtx);
1785
1786 if (len < 24 + 6)
1787 return RX_MGMT_NONE;
1788
1789 if (!ifmgd->auth_data || ifmgd->auth_data->done)
1790 return RX_MGMT_NONE;
1791
1792 memcpy(bssid, ifmgd->auth_data->bss->bssid, ETH_ALEN);
1793
Joe Perchesb203ca32012-05-08 18:56:52 +00001794 if (!ether_addr_equal(bssid, mgmt->bssid))
Johannes Berg66e67e42012-01-20 13:55:27 +01001795 return RX_MGMT_NONE;
1796
1797 auth_alg = le16_to_cpu(mgmt->u.auth.auth_alg);
1798 auth_transaction = le16_to_cpu(mgmt->u.auth.auth_transaction);
1799 status_code = le16_to_cpu(mgmt->u.auth.status_code);
1800
1801 if (auth_alg != ifmgd->auth_data->algorithm ||
1802 auth_transaction != ifmgd->auth_data->expected_transaction)
1803 return RX_MGMT_NONE;
1804
1805 if (status_code != WLAN_STATUS_SUCCESS) {
1806 printk(KERN_DEBUG "%s: %pM denied authentication (status %d)\n",
1807 sdata->name, mgmt->sa, status_code);
1808 goto out;
1809 }
1810
1811 switch (ifmgd->auth_data->algorithm) {
1812 case WLAN_AUTH_OPEN:
1813 case WLAN_AUTH_LEAP:
1814 case WLAN_AUTH_FT:
1815 break;
1816 case WLAN_AUTH_SHARED_KEY:
1817 if (ifmgd->auth_data->expected_transaction != 4) {
1818 ieee80211_auth_challenge(sdata, mgmt, len);
1819 /* need another frame */
1820 return RX_MGMT_NONE;
1821 }
1822 break;
1823 default:
1824 WARN_ONCE(1, "invalid auth alg %d",
1825 ifmgd->auth_data->algorithm);
1826 return RX_MGMT_NONE;
1827 }
1828
1829 printk(KERN_DEBUG "%s: authenticated\n", sdata->name);
1830 out:
Johannes Berg66e67e42012-01-20 13:55:27 +01001831 ifmgd->auth_data->done = true;
1832 ifmgd->auth_data->timeout = jiffies + IEEE80211_AUTH_WAIT_ASSOC;
1833 run_again(ifmgd, ifmgd->auth_data->timeout);
1834
1835 /* move station state to auth */
1836 mutex_lock(&sdata->local->sta_mtx);
1837 sta = sta_info_get(sdata, bssid);
1838 if (!sta) {
1839 WARN_ONCE(1, "%s: STA %pM not found", sdata->name, bssid);
1840 goto out_err;
1841 }
1842 if (sta_info_move_state(sta, IEEE80211_STA_AUTH)) {
1843 printk(KERN_DEBUG "%s: failed moving %pM to auth\n",
1844 sdata->name, bssid);
1845 goto out_err;
1846 }
1847 mutex_unlock(&sdata->local->sta_mtx);
1848
1849 return RX_MGMT_CFG80211_RX_AUTH;
1850 out_err:
1851 mutex_unlock(&sdata->local->sta_mtx);
1852 /* ignore frame -- wait for timeout */
1853 return RX_MGMT_NONE;
1854}
1855
1856
Johannes Berg77fdaa12009-07-07 03:45:17 +02001857static enum rx_mgmt_action __must_check
1858ieee80211_rx_mgmt_deauth(struct ieee80211_sub_if_data *sdata,
Johannes Berg77fdaa12009-07-07 03:45:17 +02001859 struct ieee80211_mgmt *mgmt, size_t len)
Jiri Bencf0706e82007-05-05 11:45:53 -07001860{
Johannes Berg46900292009-02-15 12:44:28 +01001861 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
Johannes Berg77fdaa12009-07-07 03:45:17 +02001862 const u8 *bssid = NULL;
Jiri Bencf0706e82007-05-05 11:45:53 -07001863 u16 reason_code;
1864
Johannes Berg66e67e42012-01-20 13:55:27 +01001865 lockdep_assert_held(&ifmgd->mtx);
1866
Johannes Bergf4ea83d2008-06-30 15:10:46 +02001867 if (len < 24 + 2)
Johannes Berg77fdaa12009-07-07 03:45:17 +02001868 return RX_MGMT_NONE;
Jiri Bencf0706e82007-05-05 11:45:53 -07001869
Johannes Berg66e67e42012-01-20 13:55:27 +01001870 if (!ifmgd->associated ||
Joe Perchesb203ca32012-05-08 18:56:52 +00001871 !ether_addr_equal(mgmt->bssid, ifmgd->associated->bssid))
Johannes Berg66e67e42012-01-20 13:55:27 +01001872 return RX_MGMT_NONE;
Johannes Berg77fdaa12009-07-07 03:45:17 +02001873
Johannes Berg0c1ad2c2009-12-23 13:15:39 +01001874 bssid = ifmgd->associated->bssid;
Jiri Bencf0706e82007-05-05 11:45:53 -07001875
1876 reason_code = le16_to_cpu(mgmt->u.deauth.reason_code);
1877
Johannes Berg77fdaa12009-07-07 03:45:17 +02001878 printk(KERN_DEBUG "%s: deauthenticated from %pM (Reason: %u)\n",
Johannes Berg47846c92009-11-25 17:46:19 +01001879 sdata->name, bssid, reason_code);
Jiri Bencf0706e82007-05-05 11:45:53 -07001880
Johannes Berg37ad3882012-02-24 13:50:54 +01001881 ieee80211_set_disassoc(sdata, 0, 0, false, NULL);
1882
Johannes Berg7da7cc12010-08-05 17:02:38 +02001883 mutex_lock(&sdata->local->mtx);
Johannes Berg63f170e2009-12-23 13:15:33 +01001884 ieee80211_recalc_idle(sdata->local);
Johannes Berg7da7cc12010-08-05 17:02:38 +02001885 mutex_unlock(&sdata->local->mtx);
Johannes Berg77fdaa12009-07-07 03:45:17 +02001886
1887 return RX_MGMT_CFG80211_DEAUTH;
Jiri Bencf0706e82007-05-05 11:45:53 -07001888}
1889
1890
Johannes Berg77fdaa12009-07-07 03:45:17 +02001891static enum rx_mgmt_action __must_check
1892ieee80211_rx_mgmt_disassoc(struct ieee80211_sub_if_data *sdata,
1893 struct ieee80211_mgmt *mgmt, size_t len)
Jiri Bencf0706e82007-05-05 11:45:53 -07001894{
Johannes Berg46900292009-02-15 12:44:28 +01001895 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
Jiri Bencf0706e82007-05-05 11:45:53 -07001896 u16 reason_code;
1897
Johannes Berg66e67e42012-01-20 13:55:27 +01001898 lockdep_assert_held(&ifmgd->mtx);
1899
Johannes Bergf4ea83d2008-06-30 15:10:46 +02001900 if (len < 24 + 2)
Johannes Berg77fdaa12009-07-07 03:45:17 +02001901 return RX_MGMT_NONE;
Jiri Bencf0706e82007-05-05 11:45:53 -07001902
Johannes Berg66e67e42012-01-20 13:55:27 +01001903 if (!ifmgd->associated ||
Joe Perchesb203ca32012-05-08 18:56:52 +00001904 !ether_addr_equal(mgmt->bssid, ifmgd->associated->bssid))
Johannes Berg77fdaa12009-07-07 03:45:17 +02001905 return RX_MGMT_NONE;
Jiri Bencf0706e82007-05-05 11:45:53 -07001906
1907 reason_code = le16_to_cpu(mgmt->u.disassoc.reason_code);
1908
Johannes Berg0ff71612009-09-26 14:45:41 +02001909 printk(KERN_DEBUG "%s: disassociated from %pM (Reason: %u)\n",
Johannes Berg47846c92009-11-25 17:46:19 +01001910 sdata->name, mgmt->sa, reason_code);
Jiri Bencf0706e82007-05-05 11:45:53 -07001911
Johannes Berg37ad3882012-02-24 13:50:54 +01001912 ieee80211_set_disassoc(sdata, 0, 0, false, NULL);
1913
Johannes Berg7da7cc12010-08-05 17:02:38 +02001914 mutex_lock(&sdata->local->mtx);
Johannes Bergbc83b682009-11-29 12:19:06 +01001915 ieee80211_recalc_idle(sdata->local);
Johannes Berg7da7cc12010-08-05 17:02:38 +02001916 mutex_unlock(&sdata->local->mtx);
Johannes Berg37ad3882012-02-24 13:50:54 +01001917
Johannes Berg77fdaa12009-07-07 03:45:17 +02001918 return RX_MGMT_CFG80211_DISASSOC;
Jiri Bencf0706e82007-05-05 11:45:53 -07001919}
1920
Christian Lamparterc74d0842011-10-15 00:14:49 +02001921static void ieee80211_get_rates(struct ieee80211_supported_band *sband,
1922 u8 *supp_rates, unsigned int supp_rates_len,
1923 u32 *rates, u32 *basic_rates,
1924 bool *have_higher_than_11mbit,
1925 int *min_rate, int *min_rate_index)
1926{
1927 int i, j;
1928
1929 for (i = 0; i < supp_rates_len; i++) {
1930 int rate = (supp_rates[i] & 0x7f) * 5;
1931 bool is_basic = !!(supp_rates[i] & 0x80);
1932
1933 if (rate > 110)
1934 *have_higher_than_11mbit = true;
1935
1936 /*
1937 * BSS_MEMBERSHIP_SELECTOR_HT_PHY is defined in 802.11n-2009
1938 * 7.3.2.2 as a magic value instead of a rate. Hence, skip it.
1939 *
1940 * Note: Even through the membership selector and the basic
1941 * rate flag share the same bit, they are not exactly
1942 * the same.
1943 */
1944 if (!!(supp_rates[i] & 0x80) &&
1945 (supp_rates[i] & 0x7f) == BSS_MEMBERSHIP_SELECTOR_HT_PHY)
1946 continue;
1947
1948 for (j = 0; j < sband->n_bitrates; j++) {
1949 if (sband->bitrates[j].bitrate == rate) {
1950 *rates |= BIT(j);
1951 if (is_basic)
1952 *basic_rates |= BIT(j);
1953 if (rate < *min_rate) {
1954 *min_rate = rate;
1955 *min_rate_index = j;
1956 }
1957 break;
1958 }
1959 }
1960 }
1961}
Jiri Bencf0706e82007-05-05 11:45:53 -07001962
Johannes Berg66e67e42012-01-20 13:55:27 +01001963static void ieee80211_destroy_assoc_data(struct ieee80211_sub_if_data *sdata,
1964 bool assoc)
1965{
1966 struct ieee80211_mgd_assoc_data *assoc_data = sdata->u.mgd.assoc_data;
1967
1968 lockdep_assert_held(&sdata->u.mgd.mtx);
1969
Johannes Berg66e67e42012-01-20 13:55:27 +01001970 if (!assoc) {
1971 sta_info_destroy_addr(sdata, assoc_data->bss->bssid);
1972
1973 memset(sdata->u.mgd.bssid, 0, ETH_ALEN);
1974 ieee80211_bss_info_change_notify(sdata, BSS_CHANGED_BSSID);
1975 }
1976
1977 kfree(assoc_data);
1978 sdata->u.mgd.assoc_data = NULL;
1979}
1980
1981static bool ieee80211_assoc_success(struct ieee80211_sub_if_data *sdata,
1982 struct cfg80211_bss *cbss,
Johannes Bergaf6b6372009-12-23 13:15:35 +01001983 struct ieee80211_mgmt *mgmt, size_t len)
Jiri Bencf0706e82007-05-05 11:45:53 -07001984{
Johannes Berg46900292009-02-15 12:44:28 +01001985 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
Johannes Berg471b3ef2007-12-28 14:32:58 +01001986 struct ieee80211_local *local = sdata->local;
Johannes Berg8318d782008-01-24 19:38:38 +01001987 struct ieee80211_supported_band *sband;
Jiri Bencf0706e82007-05-05 11:45:53 -07001988 struct sta_info *sta;
Johannes Bergaf6b6372009-12-23 13:15:35 +01001989 u8 *pos;
Johannes Bergaf6b6372009-12-23 13:15:35 +01001990 u16 capab_info, aid;
Jiri Bencf0706e82007-05-05 11:45:53 -07001991 struct ieee802_11_elems elems;
Johannes Bergbda39332008-10-11 01:51:51 +02001992 struct ieee80211_bss_conf *bss_conf = &sdata->vif.bss_conf;
Johannes Bergae5eb022008-10-14 16:58:37 +02001993 u32 changed = 0;
Christian Lamparterc74d0842011-10-15 00:14:49 +02001994 int err;
Jiri Bencf0706e82007-05-05 11:45:53 -07001995
Johannes Bergaf6b6372009-12-23 13:15:35 +01001996 /* AssocResp and ReassocResp have identical structure */
Jiri Bencf0706e82007-05-05 11:45:53 -07001997
Jiri Bencf0706e82007-05-05 11:45:53 -07001998 aid = le16_to_cpu(mgmt->u.assoc_resp.aid);
Johannes Bergaf6b6372009-12-23 13:15:35 +01001999 capab_info = le16_to_cpu(mgmt->u.assoc_resp.capab_info);
Jiri Bencf0706e82007-05-05 11:45:53 -07002000
Johannes Berg1dd84aa2007-10-10 12:03:41 +02002001 if ((aid & (BIT(15) | BIT(14))) != (BIT(15) | BIT(14)))
Johannes Berg05cb9102011-10-28 11:59:47 +02002002 printk(KERN_DEBUG
2003 "%s: invalid AID value 0x%x; bits 15:14 not set\n",
2004 sdata->name, aid);
Johannes Berg1dd84aa2007-10-10 12:03:41 +02002005 aid &= ~(BIT(15) | BIT(14));
2006
Johannes Berg05cb9102011-10-28 11:59:47 +02002007 ifmgd->broken_ap = false;
2008
2009 if (aid == 0 || aid > IEEE80211_MAX_AID) {
2010 printk(KERN_DEBUG
2011 "%s: invalid AID value %d (out of range), turn off PS\n",
2012 sdata->name, aid);
2013 aid = 0;
2014 ifmgd->broken_ap = true;
2015 }
2016
Johannes Bergaf6b6372009-12-23 13:15:35 +01002017 pos = mgmt->u.assoc_resp.variable;
2018 ieee802_11_parse_elems(pos, len - (pos - (u8 *) mgmt), &elems);
2019
Jiri Bencf0706e82007-05-05 11:45:53 -07002020 if (!elems.supp_rates) {
2021 printk(KERN_DEBUG "%s: no SuppRates element in AssocResp\n",
Johannes Berg47846c92009-11-25 17:46:19 +01002022 sdata->name);
Johannes Bergaf6b6372009-12-23 13:15:35 +01002023 return false;
Jiri Bencf0706e82007-05-05 11:45:53 -07002024 }
2025
Johannes Berg46900292009-02-15 12:44:28 +01002026 ifmgd->aid = aid;
Jiri Bencf0706e82007-05-05 11:45:53 -07002027
Guy Eilam2a33bee2011-08-17 15:18:15 +03002028 mutex_lock(&sdata->local->sta_mtx);
2029 /*
2030 * station info was already allocated and inserted before
2031 * the association and should be available to us
2032 */
Johannes Berg7852e362012-01-20 13:55:24 +01002033 sta = sta_info_get(sdata, cbss->bssid);
Guy Eilam2a33bee2011-08-17 15:18:15 +03002034 if (WARN_ON(!sta)) {
2035 mutex_unlock(&sdata->local->sta_mtx);
Johannes Bergaf6b6372009-12-23 13:15:35 +01002036 return false;
Jiri Bencf0706e82007-05-05 11:45:53 -07002037 }
2038
Johannes Berg66e67e42012-01-20 13:55:27 +01002039 sband = local->hw.wiphy->bands[local->oper_channel->band];
Johannes Berg8318d782008-01-24 19:38:38 +01002040
Johannes Bergab1faea2009-07-01 21:41:17 +02002041 if (elems.ht_cap_elem && !(ifmgd->flags & IEEE80211_STA_DISABLE_11N))
Ben Greearef96a8422011-11-18 11:32:00 -08002042 ieee80211_ht_cap_ie_to_sta_ht_cap(sdata, sband,
Johannes Bergd9fe60d2008-10-09 12:13:49 +02002043 elems.ht_cap_elem, &sta->sta.ht_cap);
Johannes Bergae5eb022008-10-14 16:58:37 +02002044
Johannes Berg64f68e52012-03-28 10:58:37 +02002045 sta->supports_40mhz =
2046 sta->sta.ht_cap.cap & IEEE80211_HT_CAP_SUP_WIDTH_20_40;
2047
Johannes Berg4b7679a2008-09-18 18:14:18 +02002048 rate_control_rate_init(sta);
Jiri Bencf0706e82007-05-05 11:45:53 -07002049
Johannes Berg46900292009-02-15 12:44:28 +01002050 if (ifmgd->flags & IEEE80211_STA_MFP_ENABLED)
Johannes Bergc2c98fd2011-09-29 16:04:36 +02002051 set_sta_flag(sta, WLAN_STA_MFP);
Jouni Malinen5394af42009-01-08 13:31:59 +02002052
Johannes Bergddf4ac52008-10-22 11:41:38 +02002053 if (elems.wmm_param)
Johannes Bergc2c98fd2011-09-29 16:04:36 +02002054 set_sta_flag(sta, WLAN_STA_WME);
Johannes Bergddf4ac52008-10-22 11:41:38 +02002055
Johannes Bergc8987872012-01-20 13:55:17 +01002056 err = sta_info_move_state(sta, IEEE80211_STA_AUTH);
2057 if (!err)
2058 err = sta_info_move_state(sta, IEEE80211_STA_ASSOC);
2059 if (!err && !(ifmgd->flags & IEEE80211_STA_CONTROL_PORT))
2060 err = sta_info_move_state(sta, IEEE80211_STA_AUTHORIZED);
2061 if (err) {
2062 printk(KERN_DEBUG
2063 "%s: failed to move station %pM to desired state\n",
2064 sdata->name, sta->sta.addr);
2065 WARN_ON(__sta_info_destroy(sta));
2066 mutex_unlock(&sdata->local->sta_mtx);
2067 return false;
2068 }
2069
Johannes Berg7852e362012-01-20 13:55:24 +01002070 mutex_unlock(&sdata->local->sta_mtx);
Johannes Bergddf4ac52008-10-22 11:41:38 +02002071
Juuso Oikarinenf2176d72010-09-28 14:39:32 +03002072 /*
2073 * Always handle WMM once after association regardless
2074 * of the first value the AP uses. Setting -1 here has
2075 * that effect because the AP values is an unsigned
2076 * 4-bit value.
2077 */
2078 ifmgd->wmm_last_param_set = -1;
2079
Johannes Bergddf4ac52008-10-22 11:41:38 +02002080 if (elems.wmm_param)
Johannes Berg4ced3f72010-07-19 16:39:04 +02002081 ieee80211_sta_wmm_params(local, sdata, elems.wmm_param,
Jiri Bencf0706e82007-05-05 11:45:53 -07002082 elems.wmm_param_len);
Johannes Bergaa837e12009-05-07 16:16:24 +02002083 else
Johannes Berg3abead52012-03-02 15:56:59 +01002084 ieee80211_set_wmm_default(sdata, false);
2085 changed |= BSS_CHANGED_QOS;
Jiri Bencf0706e82007-05-05 11:45:53 -07002086
Johannes Berg074d46d2012-03-15 19:45:16 +01002087 if (elems.ht_operation && elems.wmm_param &&
Johannes Bergab1faea2009-07-01 21:41:17 +02002088 !(ifmgd->flags & IEEE80211_STA_DISABLE_11N))
Johannes Berg24398e32012-03-28 10:58:36 +02002089 changed |= ieee80211_config_ht_tx(sdata, elems.ht_operation,
2090 cbss->bssid, false);
Johannes Bergae5eb022008-10-14 16:58:37 +02002091
Tomas Winkler21c0cbe2008-03-28 16:33:34 -07002092 /* set AID and assoc capability,
2093 * ieee80211_set_associated() will tell the driver */
Johannes Berg8318d782008-01-24 19:38:38 +01002094 bss_conf->aid = aid;
Tomas Winkler21c0cbe2008-03-28 16:33:34 -07002095 bss_conf->assoc_capability = capab_info;
Johannes Berg0c1ad2c2009-12-23 13:15:39 +01002096 ieee80211_set_associated(sdata, cbss, changed);
Jiri Bencf0706e82007-05-05 11:45:53 -07002097
Kalle Valo15b7b062009-03-22 21:57:14 +02002098 /*
Felix Fietkaud5242152010-01-08 18:06:26 +01002099 * If we're using 4-addr mode, let the AP know that we're
2100 * doing so, so that it can create the STA VLAN on its side
2101 */
2102 if (ifmgd->use_4addr)
2103 ieee80211_send_4addr_nullfunc(local, sdata);
2104
2105 /*
Johannes Bergb291ba12009-07-10 15:29:03 +02002106 * Start timer to probe the connection to the AP now.
2107 * Also start the timer that will detect beacon loss.
Kalle Valo15b7b062009-03-22 21:57:14 +02002108 */
Johannes Bergb291ba12009-07-10 15:29:03 +02002109 ieee80211_sta_rx_notify(sdata, (struct ieee80211_hdr *)mgmt);
Luis R. Rodriguezd3a910a2010-09-16 15:12:32 -04002110 ieee80211_sta_reset_beacon_monitor(sdata);
Kalle Valo15b7b062009-03-22 21:57:14 +02002111
Johannes Bergaf6b6372009-12-23 13:15:35 +01002112 return true;
Jiri Bencf0706e82007-05-05 11:45:53 -07002113}
2114
Johannes Berg66e67e42012-01-20 13:55:27 +01002115static enum rx_mgmt_action __must_check
2116ieee80211_rx_mgmt_assoc_resp(struct ieee80211_sub_if_data *sdata,
2117 struct ieee80211_mgmt *mgmt, size_t len,
2118 struct cfg80211_bss **bss)
2119{
2120 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
2121 struct ieee80211_mgd_assoc_data *assoc_data = ifmgd->assoc_data;
2122 u16 capab_info, status_code, aid;
2123 struct ieee802_11_elems elems;
2124 u8 *pos;
2125 bool reassoc;
Jiri Bencf0706e82007-05-05 11:45:53 -07002126
Johannes Berg66e67e42012-01-20 13:55:27 +01002127 lockdep_assert_held(&ifmgd->mtx);
2128
2129 if (!assoc_data)
2130 return RX_MGMT_NONE;
Joe Perchesb203ca32012-05-08 18:56:52 +00002131 if (!ether_addr_equal(assoc_data->bss->bssid, mgmt->bssid))
Johannes Berg66e67e42012-01-20 13:55:27 +01002132 return RX_MGMT_NONE;
2133
2134 /*
2135 * AssocResp and ReassocResp have identical structure, so process both
2136 * of them in this function.
2137 */
2138
2139 if (len < 24 + 6)
2140 return RX_MGMT_NONE;
2141
2142 reassoc = ieee80211_is_reassoc_req(mgmt->frame_control);
2143 capab_info = le16_to_cpu(mgmt->u.assoc_resp.capab_info);
2144 status_code = le16_to_cpu(mgmt->u.assoc_resp.status_code);
2145 aid = le16_to_cpu(mgmt->u.assoc_resp.aid);
2146
2147 printk(KERN_DEBUG "%s: RX %sssocResp from %pM (capab=0x%x "
2148 "status=%d aid=%d)\n",
2149 sdata->name, reassoc ? "Rea" : "A", mgmt->sa,
2150 capab_info, status_code, (u16)(aid & ~(BIT(15) | BIT(14))));
2151
2152 pos = mgmt->u.assoc_resp.variable;
2153 ieee802_11_parse_elems(pos, len - (pos - (u8 *) mgmt), &elems);
2154
2155 if (status_code == WLAN_STATUS_ASSOC_REJECTED_TEMPORARILY &&
2156 elems.timeout_int && elems.timeout_int_len == 5 &&
2157 elems.timeout_int[0] == WLAN_TIMEOUT_ASSOC_COMEBACK) {
2158 u32 tu, ms;
2159 tu = get_unaligned_le32(elems.timeout_int + 1);
2160 ms = tu * 1024 / 1000;
2161 printk(KERN_DEBUG "%s: %pM rejected association temporarily; "
2162 "comeback duration %u TU (%u ms)\n",
2163 sdata->name, mgmt->sa, tu, ms);
2164 assoc_data->timeout = jiffies + msecs_to_jiffies(ms);
2165 if (ms > IEEE80211_ASSOC_TIMEOUT)
2166 run_again(ifmgd, assoc_data->timeout);
2167 return RX_MGMT_NONE;
2168 }
2169
2170 *bss = assoc_data->bss;
2171
2172 if (status_code != WLAN_STATUS_SUCCESS) {
2173 printk(KERN_DEBUG "%s: %pM denied association (code=%d)\n",
2174 sdata->name, mgmt->sa, status_code);
2175 ieee80211_destroy_assoc_data(sdata, false);
2176 } else {
2177 printk(KERN_DEBUG "%s: associated\n", sdata->name);
2178
Johannes Berg66e67e42012-01-20 13:55:27 +01002179 if (!ieee80211_assoc_success(sdata, *bss, mgmt, len)) {
2180 /* oops -- internal error -- send timeout for now */
Johannes Berg79ebfb82012-02-20 14:19:58 +01002181 ieee80211_destroy_assoc_data(sdata, true);
Johannes Berg66e67e42012-01-20 13:55:27 +01002182 sta_info_destroy_addr(sdata, mgmt->bssid);
2183 cfg80211_put_bss(*bss);
2184 return RX_MGMT_CFG80211_ASSOC_TIMEOUT;
2185 }
Johannes Berg79ebfb82012-02-20 14:19:58 +01002186
2187 /*
2188 * destroy assoc_data afterwards, as otherwise an idle
2189 * recalc after assoc_data is NULL but before associated
2190 * is set can cause the interface to go idle
2191 */
2192 ieee80211_destroy_assoc_data(sdata, true);
Johannes Berg66e67e42012-01-20 13:55:27 +01002193 }
2194
2195 return RX_MGMT_CFG80211_RX_ASSOC;
2196}
Jasper Bryant-Greenef698d852008-08-03 12:04:37 +12002197static void ieee80211_rx_bss_info(struct ieee80211_sub_if_data *sdata,
Jiri Bencf0706e82007-05-05 11:45:53 -07002198 struct ieee80211_mgmt *mgmt,
2199 size_t len,
2200 struct ieee80211_rx_status *rx_status,
Johannes Berg98c8fcc2008-09-08 17:44:26 +02002201 struct ieee802_11_elems *elems,
2202 bool beacon)
Jiri Bencf0706e82007-05-05 11:45:53 -07002203{
Jasper Bryant-Greenef698d852008-08-03 12:04:37 +12002204 struct ieee80211_local *local = sdata->local;
Johannes Berg98c8fcc2008-09-08 17:44:26 +02002205 int freq;
Johannes Bergc2b13452008-09-11 00:01:55 +02002206 struct ieee80211_bss *bss;
Johannes Bergfab7d4a2008-03-16 18:42:44 +01002207 struct ieee80211_channel *channel;
Johannes Berg56007a02010-01-26 14:19:52 +01002208 bool need_ps = false;
2209
Johannes Berg66e67e42012-01-20 13:55:27 +01002210 if (sdata->u.mgd.associated &&
Joe Perchesb203ca32012-05-08 18:56:52 +00002211 ether_addr_equal(mgmt->bssid, sdata->u.mgd.associated->bssid)) {
Johannes Berg56007a02010-01-26 14:19:52 +01002212 bss = (void *)sdata->u.mgd.associated->priv;
2213 /* not previously set so we may need to recalc */
2214 need_ps = !bss->dtim_period;
2215 }
Jiri Bencf0706e82007-05-05 11:45:53 -07002216
Johannes Berg5bda6172008-09-08 11:05:10 +02002217 if (elems->ds_params && elems->ds_params_len == 1)
Bruno Randolf59eb21a2011-01-17 13:37:28 +09002218 freq = ieee80211_channel_to_frequency(elems->ds_params[0],
2219 rx_status->band);
Johannes Berg5bda6172008-09-08 11:05:10 +02002220 else
2221 freq = rx_status->freq;
2222
2223 channel = ieee80211_get_channel(local->hw.wiphy, freq);
2224
2225 if (!channel || channel->flags & IEEE80211_CHAN_DISABLED)
2226 return;
Jiri Bencf0706e82007-05-05 11:45:53 -07002227
Johannes Berg98c8fcc2008-09-08 17:44:26 +02002228 bss = ieee80211_bss_info_update(local, rx_status, mgmt, len, elems,
Johannes Berg2a519312009-02-10 21:25:55 +01002229 channel, beacon);
Johannes Berg77fdaa12009-07-07 03:45:17 +02002230 if (bss)
2231 ieee80211_rx_bss_put(local, bss);
2232
2233 if (!sdata->u.mgd.associated)
Johannes Berg98c8fcc2008-09-08 17:44:26 +02002234 return;
Jiri Bencf0706e82007-05-05 11:45:53 -07002235
Johannes Berg56007a02010-01-26 14:19:52 +01002236 if (need_ps) {
2237 mutex_lock(&local->iflist_mtx);
2238 ieee80211_recalc_ps(local, -1);
2239 mutex_unlock(&local->iflist_mtx);
2240 }
2241
Sujithc481ec92009-01-06 09:28:37 +05302242 if (elems->ch_switch_elem && (elems->ch_switch_elem_len == 3) &&
Johannes Berg0c1ad2c2009-12-23 13:15:39 +01002243 (memcmp(mgmt->bssid, sdata->u.mgd.associated->bssid,
Johannes Berg77fdaa12009-07-07 03:45:17 +02002244 ETH_ALEN) == 0)) {
Sujithc481ec92009-01-06 09:28:37 +05302245 struct ieee80211_channel_sw_ie *sw_elem =
2246 (struct ieee80211_channel_sw_ie *)elems->ch_switch_elem;
Johannes Berg5ce6e432010-05-11 16:20:57 +02002247 ieee80211_sta_process_chanswitch(sdata, sw_elem,
2248 bss, rx_status->mactime);
Sujithc481ec92009-01-06 09:28:37 +05302249 }
Jiri Bencf0706e82007-05-05 11:45:53 -07002250}
2251
2252
Jasper Bryant-Greenef698d852008-08-03 12:04:37 +12002253static void ieee80211_rx_mgmt_probe_resp(struct ieee80211_sub_if_data *sdata,
Johannes Bergaf6b6372009-12-23 13:15:35 +01002254 struct sk_buff *skb)
Jiri Bencf0706e82007-05-05 11:45:53 -07002255{
Johannes Bergaf6b6372009-12-23 13:15:35 +01002256 struct ieee80211_mgmt *mgmt = (void *)skb->data;
Kalle Valo15b7b062009-03-22 21:57:14 +02002257 struct ieee80211_if_managed *ifmgd;
Johannes Bergaf6b6372009-12-23 13:15:35 +01002258 struct ieee80211_rx_status *rx_status = (void *) skb->cb;
2259 size_t baselen, len = skb->len;
Ester Kummerae6a44e2008-06-27 18:54:48 +03002260 struct ieee802_11_elems elems;
2261
Kalle Valo15b7b062009-03-22 21:57:14 +02002262 ifmgd = &sdata->u.mgd;
2263
Johannes Berg77fdaa12009-07-07 03:45:17 +02002264 ASSERT_MGD_MTX(ifmgd);
2265
Joe Perchesb203ca32012-05-08 18:56:52 +00002266 if (!ether_addr_equal(mgmt->da, sdata->vif.addr))
Tomas Winkler8e7cdbb2008-08-03 14:32:01 +03002267 return; /* ignore ProbeResp to foreign address */
2268
Ester Kummerae6a44e2008-06-27 18:54:48 +03002269 baselen = (u8 *) mgmt->u.probe_resp.variable - (u8 *) mgmt;
2270 if (baselen > len)
2271 return;
2272
2273 ieee802_11_parse_elems(mgmt->u.probe_resp.variable, len - baselen,
2274 &elems);
2275
Johannes Berg98c8fcc2008-09-08 17:44:26 +02002276 ieee80211_rx_bss_info(sdata, mgmt, len, rx_status, &elems, false);
Ron Rindjunsky9859b812008-08-09 03:02:19 +03002277
Johannes Berg77fdaa12009-07-07 03:45:17 +02002278 if (ifmgd->associated &&
Joe Perchesb203ca32012-05-08 18:56:52 +00002279 ether_addr_equal(mgmt->bssid, ifmgd->associated->bssid))
Felix Fietkau4e5ff372010-11-23 03:10:31 +01002280 ieee80211_reset_ap_probe(sdata);
Johannes Berg66e67e42012-01-20 13:55:27 +01002281
2282 if (ifmgd->auth_data && !ifmgd->auth_data->bss->proberesp_ies &&
Joe Perchesb203ca32012-05-08 18:56:52 +00002283 ether_addr_equal(mgmt->bssid, ifmgd->auth_data->bss->bssid)) {
Johannes Berg66e67e42012-01-20 13:55:27 +01002284 /* got probe response, continue with auth */
2285 printk(KERN_DEBUG "%s: direct probe responded\n", sdata->name);
2286 ifmgd->auth_data->tries = 0;
2287 ifmgd->auth_data->timeout = jiffies;
2288 run_again(ifmgd, ifmgd->auth_data->timeout);
2289 }
Jiri Bencf0706e82007-05-05 11:45:53 -07002290}
2291
Johannes Bergd91f36d2009-04-16 13:17:26 +02002292/*
2293 * This is the canonical list of information elements we care about,
2294 * the filter code also gives us all changes to the Microsoft OUI
2295 * (00:50:F2) vendor IE which is used for WMM which we need to track.
2296 *
2297 * We implement beacon filtering in software since that means we can
2298 * avoid processing the frame here and in cfg80211, and userspace
2299 * will not be able to tell whether the hardware supports it or not.
2300 *
2301 * XXX: This list needs to be dynamic -- userspace needs to be able to
2302 * add items it requires. It also needs to be able to tell us to
2303 * look out for other vendor IEs.
2304 */
2305static const u64 care_about_ies =
Johannes Berg1d4df3a2009-04-22 11:25:43 +02002306 (1ULL << WLAN_EID_COUNTRY) |
2307 (1ULL << WLAN_EID_ERP_INFO) |
2308 (1ULL << WLAN_EID_CHANNEL_SWITCH) |
2309 (1ULL << WLAN_EID_PWR_CONSTRAINT) |
2310 (1ULL << WLAN_EID_HT_CAPABILITY) |
Johannes Berg074d46d2012-03-15 19:45:16 +01002311 (1ULL << WLAN_EID_HT_OPERATION);
Johannes Bergd91f36d2009-04-16 13:17:26 +02002312
Jasper Bryant-Greenef698d852008-08-03 12:04:37 +12002313static void ieee80211_rx_mgmt_beacon(struct ieee80211_sub_if_data *sdata,
Jiri Bencf0706e82007-05-05 11:45:53 -07002314 struct ieee80211_mgmt *mgmt,
2315 size_t len,
2316 struct ieee80211_rx_status *rx_status)
2317{
Johannes Bergd91f36d2009-04-16 13:17:26 +02002318 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
Jouni Malinen17e4ec12010-03-29 23:28:30 -07002319 struct ieee80211_bss_conf *bss_conf = &sdata->vif.bss_conf;
Jiri Bencf0706e82007-05-05 11:45:53 -07002320 size_t baselen;
2321 struct ieee802_11_elems elems;
Jasper Bryant-Greenef698d852008-08-03 12:04:37 +12002322 struct ieee80211_local *local = sdata->local;
Johannes Berg471b3ef2007-12-28 14:32:58 +01002323 u32 changed = 0;
Johannes Bergd91f36d2009-04-16 13:17:26 +02002324 bool erp_valid, directed_tim = false;
Johannes Berg7a5158e2008-10-08 10:59:33 +02002325 u8 erp_value = 0;
Johannes Bergd91f36d2009-04-16 13:17:26 +02002326 u32 ncrc;
Johannes Berg77fdaa12009-07-07 03:45:17 +02002327 u8 *bssid;
2328
Johannes Berg66e67e42012-01-20 13:55:27 +01002329 lockdep_assert_held(&ifmgd->mtx);
Jiri Bencf0706e82007-05-05 11:45:53 -07002330
Ester Kummerae6a44e2008-06-27 18:54:48 +03002331 /* Process beacon from the current BSS */
2332 baselen = (u8 *) mgmt->u.beacon.variable - (u8 *) mgmt;
2333 if (baselen > len)
2334 return;
2335
Johannes Bergd91f36d2009-04-16 13:17:26 +02002336 if (rx_status->freq != local->hw.conf.channel->center_freq)
Jiri Bencf0706e82007-05-05 11:45:53 -07002337 return;
Jiri Bencf0706e82007-05-05 11:45:53 -07002338
Johannes Berg66e67e42012-01-20 13:55:27 +01002339 if (ifmgd->assoc_data && !ifmgd->assoc_data->have_beacon &&
Joe Perchesb203ca32012-05-08 18:56:52 +00002340 ether_addr_equal(mgmt->bssid, ifmgd->assoc_data->bss->bssid)) {
Johannes Berg66e67e42012-01-20 13:55:27 +01002341 ieee802_11_parse_elems(mgmt->u.beacon.variable,
2342 len - baselen, &elems);
Johannes Berg77fdaa12009-07-07 03:45:17 +02002343
Johannes Berg66e67e42012-01-20 13:55:27 +01002344 ieee80211_rx_bss_info(sdata, mgmt, len, rx_status, &elems,
2345 false);
2346 ifmgd->assoc_data->have_beacon = true;
2347 ifmgd->assoc_data->sent_assoc = false;
2348 /* continue assoc process */
2349 ifmgd->assoc_data->timeout = jiffies;
2350 run_again(ifmgd, ifmgd->assoc_data->timeout);
2351 return;
2352 }
2353
2354 if (!ifmgd->associated ||
Joe Perchesb203ca32012-05-08 18:56:52 +00002355 !ether_addr_equal(mgmt->bssid, ifmgd->associated->bssid))
Johannes Berg66e67e42012-01-20 13:55:27 +01002356 return;
Johannes Berg0c1ad2c2009-12-23 13:15:39 +01002357 bssid = ifmgd->associated->bssid;
Johannes Berg77fdaa12009-07-07 03:45:17 +02002358
Jouni Malinen17e4ec12010-03-29 23:28:30 -07002359 /* Track average RSSI from the Beacon frames of the current AP */
2360 ifmgd->last_beacon_signal = rx_status->signal;
2361 if (ifmgd->flags & IEEE80211_STA_RESET_SIGNAL_AVE) {
2362 ifmgd->flags &= ~IEEE80211_STA_RESET_SIGNAL_AVE;
Jouni Malinen3ba06c62010-08-27 22:21:13 +03002363 ifmgd->ave_beacon_signal = rx_status->signal * 16;
Jouni Malinen17e4ec12010-03-29 23:28:30 -07002364 ifmgd->last_cqm_event_signal = 0;
Jouni Malinen391a2002010-08-27 22:22:00 +03002365 ifmgd->count_beacon_signal = 1;
Meenakshi Venkataraman615f7b92011-07-08 08:46:22 -07002366 ifmgd->last_ave_beacon_signal = 0;
Jouni Malinen17e4ec12010-03-29 23:28:30 -07002367 } else {
2368 ifmgd->ave_beacon_signal =
2369 (IEEE80211_SIGNAL_AVE_WEIGHT * rx_status->signal * 16 +
2370 (16 - IEEE80211_SIGNAL_AVE_WEIGHT) *
2371 ifmgd->ave_beacon_signal) / 16;
Jouni Malinen391a2002010-08-27 22:22:00 +03002372 ifmgd->count_beacon_signal++;
Jouni Malinen17e4ec12010-03-29 23:28:30 -07002373 }
Meenakshi Venkataraman615f7b92011-07-08 08:46:22 -07002374
2375 if (ifmgd->rssi_min_thold != ifmgd->rssi_max_thold &&
2376 ifmgd->count_beacon_signal >= IEEE80211_SIGNAL_AVE_MIN_COUNT) {
2377 int sig = ifmgd->ave_beacon_signal;
2378 int last_sig = ifmgd->last_ave_beacon_signal;
2379
2380 /*
2381 * if signal crosses either of the boundaries, invoke callback
2382 * with appropriate parameters
2383 */
2384 if (sig > ifmgd->rssi_max_thold &&
2385 (last_sig <= ifmgd->rssi_min_thold || last_sig == 0)) {
2386 ifmgd->last_ave_beacon_signal = sig;
2387 drv_rssi_callback(local, RSSI_EVENT_HIGH);
2388 } else if (sig < ifmgd->rssi_min_thold &&
2389 (last_sig >= ifmgd->rssi_max_thold ||
2390 last_sig == 0)) {
2391 ifmgd->last_ave_beacon_signal = sig;
2392 drv_rssi_callback(local, RSSI_EVENT_LOW);
2393 }
2394 }
2395
Jouni Malinen17e4ec12010-03-29 23:28:30 -07002396 if (bss_conf->cqm_rssi_thold &&
Jouni Malinen391a2002010-08-27 22:22:00 +03002397 ifmgd->count_beacon_signal >= IEEE80211_SIGNAL_AVE_MIN_COUNT &&
Johannes Bergea086352012-01-19 09:29:58 +01002398 !(sdata->vif.driver_flags & IEEE80211_VIF_SUPPORTS_CQM_RSSI)) {
Jouni Malinen17e4ec12010-03-29 23:28:30 -07002399 int sig = ifmgd->ave_beacon_signal / 16;
2400 int last_event = ifmgd->last_cqm_event_signal;
2401 int thold = bss_conf->cqm_rssi_thold;
2402 int hyst = bss_conf->cqm_rssi_hyst;
2403 if (sig < thold &&
2404 (last_event == 0 || sig < last_event - hyst)) {
2405 ifmgd->last_cqm_event_signal = sig;
2406 ieee80211_cqm_rssi_notify(
2407 &sdata->vif,
2408 NL80211_CQM_RSSI_THRESHOLD_EVENT_LOW,
2409 GFP_KERNEL);
2410 } else if (sig > thold &&
2411 (last_event == 0 || sig > last_event + hyst)) {
2412 ifmgd->last_cqm_event_signal = sig;
2413 ieee80211_cqm_rssi_notify(
2414 &sdata->vif,
2415 NL80211_CQM_RSSI_THRESHOLD_EVENT_HIGH,
2416 GFP_KERNEL);
2417 }
2418 }
2419
Johannes Bergb291ba12009-07-10 15:29:03 +02002420 if (ifmgd->flags & IEEE80211_STA_BEACON_POLL) {
Jouni Malinen92778182009-05-14 21:15:36 +03002421#ifdef CONFIG_MAC80211_VERBOSE_DEBUG
Joe Perchese87cc472012-05-13 21:56:26 +00002422 net_dbg_ratelimited("%s: cancelling probereq poll due to a received beacon\n",
2423 sdata->name);
Jouni Malinen92778182009-05-14 21:15:36 +03002424#endif
Stanislaw Gruszka925e64c2012-05-16 15:27:20 +02002425 mutex_lock(&local->mtx);
Johannes Bergb291ba12009-07-10 15:29:03 +02002426 ifmgd->flags &= ~IEEE80211_STA_BEACON_POLL;
Stanislaw Gruszka925e64c2012-05-16 15:27:20 +02002427 ieee80211_run_deferred_scan(local);
2428 mutex_unlock(&local->mtx);
2429
Johannes Berg4e751842009-06-10 15:16:52 +02002430 mutex_lock(&local->iflist_mtx);
2431 ieee80211_recalc_ps(local, -1);
2432 mutex_unlock(&local->iflist_mtx);
Jouni Malinen92778182009-05-14 21:15:36 +03002433 }
2434
Johannes Bergb291ba12009-07-10 15:29:03 +02002435 /*
2436 * Push the beacon loss detection into the future since
2437 * we are processing a beacon from the AP just now.
2438 */
Luis R. Rodriguezd3a910a2010-09-16 15:12:32 -04002439 ieee80211_sta_reset_beacon_monitor(sdata);
Johannes Bergb291ba12009-07-10 15:29:03 +02002440
Johannes Bergd91f36d2009-04-16 13:17:26 +02002441 ncrc = crc32_be(0, (void *)&mgmt->u.beacon.beacon_int, 4);
2442 ncrc = ieee802_11_parse_elems_crc(mgmt->u.beacon.variable,
2443 len - baselen, &elems,
2444 care_about_ies, ncrc);
2445
2446 if (local->hw.flags & IEEE80211_HW_PS_NULLFUNC_STACK)
Johannes Berge7ec86f2009-04-18 17:33:24 +02002447 directed_tim = ieee80211_check_tim(elems.tim, elems.tim_len,
2448 ifmgd->aid);
Johannes Bergd91f36d2009-04-16 13:17:26 +02002449
Juuso Oikarinend8ec4432010-10-01 16:02:31 +03002450 if (ncrc != ifmgd->beacon_crc || !ifmgd->beacon_crc_valid) {
Jouni Malinen30196672009-05-19 17:01:43 +03002451 ieee80211_rx_bss_info(sdata, mgmt, len, rx_status, &elems,
2452 true);
Johannes Bergd91f36d2009-04-16 13:17:26 +02002453
Johannes Berg4ced3f72010-07-19 16:39:04 +02002454 ieee80211_sta_wmm_params(local, sdata, elems.wmm_param,
Jouni Malinen30196672009-05-19 17:01:43 +03002455 elems.wmm_param_len);
2456 }
Johannes Bergfe3fa822008-09-08 11:05:09 +02002457
Vivek Natarajan25c9c872009-03-02 20:20:30 +05302458 if (local->hw.flags & IEEE80211_HW_PS_NULLFUNC_STACK) {
Kalle Valo1fb36062009-02-10 17:09:24 +02002459 if (directed_tim) {
Kalle Valo572e0012009-02-10 17:09:31 +02002460 if (local->hw.conf.dynamic_ps_timeout > 0) {
Ronald Wahl70b12f22012-03-19 14:37:20 +01002461 if (local->hw.conf.flags & IEEE80211_CONF_PS) {
2462 local->hw.conf.flags &= ~IEEE80211_CONF_PS;
2463 ieee80211_hw_config(local,
2464 IEEE80211_CONF_CHANGE_PS);
2465 }
Kalle Valo572e0012009-02-10 17:09:31 +02002466 ieee80211_send_nullfunc(local, sdata, 0);
Rajkumar Manoharan6f0756a2012-03-15 05:50:36 +05302467 } else if (!local->pspolling && sdata->u.mgd.powersave) {
Kalle Valo572e0012009-02-10 17:09:31 +02002468 local->pspolling = true;
2469
2470 /*
2471 * Here is assumed that the driver will be
2472 * able to send ps-poll frame and receive a
2473 * response even though power save mode is
2474 * enabled, but some drivers might require
2475 * to disable power save here. This needs
2476 * to be investigated.
2477 */
2478 ieee80211_send_pspoll(local, sdata);
2479 }
Vivek Natarajana97b77b2008-12-23 18:39:02 -08002480 }
2481 }
Johannes Berg7a5158e2008-10-08 10:59:33 +02002482
Juuso Oikarinend8ec4432010-10-01 16:02:31 +03002483 if (ncrc == ifmgd->beacon_crc && ifmgd->beacon_crc_valid)
Jouni Malinen30196672009-05-19 17:01:43 +03002484 return;
2485 ifmgd->beacon_crc = ncrc;
Juuso Oikarinend8ec4432010-10-01 16:02:31 +03002486 ifmgd->beacon_crc_valid = true;
Jouni Malinen30196672009-05-19 17:01:43 +03002487
Johannes Berg7a5158e2008-10-08 10:59:33 +02002488 if (elems.erp_info && elems.erp_info_len >= 1) {
2489 erp_valid = true;
2490 erp_value = elems.erp_info[0];
2491 } else {
2492 erp_valid = false;
John W. Linville50c4afb2008-04-15 14:09:27 -04002493 }
Johannes Berg7a5158e2008-10-08 10:59:33 +02002494 changed |= ieee80211_handle_bss_capability(sdata,
2495 le16_to_cpu(mgmt->u.beacon.capab_info),
2496 erp_valid, erp_value);
Jiri Bencf0706e82007-05-05 11:45:53 -07002497
Ron Rindjunskyd3c990f2007-11-26 16:14:34 +02002498
Johannes Berg074d46d2012-03-15 19:45:16 +01002499 if (elems.ht_cap_elem && elems.ht_operation && elems.wmm_param &&
Johannes Bergab1faea2009-07-01 21:41:17 +02002500 !(ifmgd->flags & IEEE80211_STA_DISABLE_11N)) {
Johannes Bergae5eb022008-10-14 16:58:37 +02002501 struct ieee80211_supported_band *sband;
Johannes Bergae5eb022008-10-14 16:58:37 +02002502
2503 sband = local->hw.wiphy->bands[local->hw.conf.channel->band];
2504
Johannes Berg24398e32012-03-28 10:58:36 +02002505 changed |= ieee80211_config_ht_tx(sdata, elems.ht_operation,
2506 bssid, true);
Ron Rindjunskyd3c990f2007-11-26 16:14:34 +02002507 }
2508
Luis R. Rodriguez8b19e6c2009-07-30 17:38:09 -07002509 /* Note: country IE parsing is done for us by cfg80211 */
Luis R. Rodriguez3f2355c2008-11-12 14:22:02 -08002510 if (elems.country_elem) {
Vasanthakumar Thiagarajana8302de2009-01-09 18:14:15 +05302511 /* TODO: IBSS also needs this */
2512 if (elems.pwr_constr_elem)
2513 ieee80211_handle_pwr_constr(sdata,
2514 le16_to_cpu(mgmt->u.probe_resp.capab_info),
2515 elems.pwr_constr_elem,
2516 elems.pwr_constr_elem_len);
Luis R. Rodriguez3f2355c2008-11-12 14:22:02 -08002517 }
2518
Johannes Berg471b3ef2007-12-28 14:32:58 +01002519 ieee80211_bss_info_change_notify(sdata, changed);
Jiri Bencf0706e82007-05-05 11:45:53 -07002520}
2521
Johannes Berg1fa57d02010-06-10 10:21:32 +02002522void ieee80211_sta_rx_queued_mgmt(struct ieee80211_sub_if_data *sdata,
2523 struct sk_buff *skb)
Jiri Bencf0706e82007-05-05 11:45:53 -07002524{
Johannes Berg77fdaa12009-07-07 03:45:17 +02002525 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
Jiri Bencf0706e82007-05-05 11:45:53 -07002526 struct ieee80211_rx_status *rx_status;
Jiri Bencf0706e82007-05-05 11:45:53 -07002527 struct ieee80211_mgmt *mgmt;
Johannes Berg66e67e42012-01-20 13:55:27 +01002528 struct cfg80211_bss *bss = NULL;
Johannes Berg77fdaa12009-07-07 03:45:17 +02002529 enum rx_mgmt_action rma = RX_MGMT_NONE;
Jiri Bencf0706e82007-05-05 11:45:53 -07002530 u16 fc;
2531
Jiri Bencf0706e82007-05-05 11:45:53 -07002532 rx_status = (struct ieee80211_rx_status *) skb->cb;
2533 mgmt = (struct ieee80211_mgmt *) skb->data;
2534 fc = le16_to_cpu(mgmt->frame_control);
2535
Johannes Berg77fdaa12009-07-07 03:45:17 +02002536 mutex_lock(&ifmgd->mtx);
2537
Johannes Berg66e67e42012-01-20 13:55:27 +01002538 switch (fc & IEEE80211_FCTL_STYPE) {
2539 case IEEE80211_STYPE_BEACON:
2540 ieee80211_rx_mgmt_beacon(sdata, mgmt, skb->len, rx_status);
2541 break;
2542 case IEEE80211_STYPE_PROBE_RESP:
2543 ieee80211_rx_mgmt_probe_resp(sdata, skb);
2544 break;
2545 case IEEE80211_STYPE_AUTH:
2546 rma = ieee80211_rx_mgmt_auth(sdata, mgmt, skb->len);
2547 break;
2548 case IEEE80211_STYPE_DEAUTH:
2549 rma = ieee80211_rx_mgmt_deauth(sdata, mgmt, skb->len);
2550 break;
2551 case IEEE80211_STYPE_DISASSOC:
2552 rma = ieee80211_rx_mgmt_disassoc(sdata, mgmt, skb->len);
2553 break;
2554 case IEEE80211_STYPE_ASSOC_RESP:
2555 case IEEE80211_STYPE_REASSOC_RESP:
2556 rma = ieee80211_rx_mgmt_assoc_resp(sdata, mgmt, skb->len, &bss);
2557 break;
2558 case IEEE80211_STYPE_ACTION:
2559 switch (mgmt->u.action.category) {
2560 case WLAN_CATEGORY_SPECTRUM_MGMT:
2561 ieee80211_sta_process_chanswitch(sdata,
2562 &mgmt->u.action.u.chan_switch.sw_elem,
2563 (void *)ifmgd->associated->priv,
2564 rx_status->mactime);
Johannes Berg77fdaa12009-07-07 03:45:17 +02002565 break;
Johannes Berg77fdaa12009-07-07 03:45:17 +02002566 }
Johannes Berg77fdaa12009-07-07 03:45:17 +02002567 }
Johannes Berg77fdaa12009-07-07 03:45:17 +02002568 mutex_unlock(&ifmgd->mtx);
2569
Johannes Berg66e67e42012-01-20 13:55:27 +01002570 switch (rma) {
2571 case RX_MGMT_NONE:
2572 /* no action */
2573 break;
2574 case RX_MGMT_CFG80211_DEAUTH:
Holger Schurigce470612009-10-13 13:28:13 +02002575 cfg80211_send_deauth(sdata->dev, (u8 *)mgmt, skb->len);
Johannes Berg66e67e42012-01-20 13:55:27 +01002576 break;
2577 case RX_MGMT_CFG80211_DISASSOC:
2578 cfg80211_send_disassoc(sdata->dev, (u8 *)mgmt, skb->len);
2579 break;
2580 case RX_MGMT_CFG80211_RX_AUTH:
2581 cfg80211_send_rx_auth(sdata->dev, (u8 *)mgmt, skb->len);
2582 break;
2583 case RX_MGMT_CFG80211_RX_ASSOC:
2584 cfg80211_send_rx_assoc(sdata->dev, bss, (u8 *)mgmt, skb->len);
2585 break;
2586 case RX_MGMT_CFG80211_ASSOC_TIMEOUT:
2587 cfg80211_send_assoc_timeout(sdata->dev, mgmt->bssid);
2588 break;
2589 default:
2590 WARN(1, "unexpected: %d", rma);
Johannes Bergb054b742010-06-07 21:50:07 +02002591 }
Jiri Bencf0706e82007-05-05 11:45:53 -07002592}
2593
Johannes Berg9c6bd792008-09-11 00:01:52 +02002594static void ieee80211_sta_timer(unsigned long data)
Jiri Bencf0706e82007-05-05 11:45:53 -07002595{
2596 struct ieee80211_sub_if_data *sdata =
2597 (struct ieee80211_sub_if_data *) data;
Johannes Berg46900292009-02-15 12:44:28 +01002598 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
Jasper Bryant-Greenef698d852008-08-03 12:04:37 +12002599 struct ieee80211_local *local = sdata->local;
Jiri Bencf0706e82007-05-05 11:45:53 -07002600
Johannes Berg5bb644a2009-05-17 11:40:42 +02002601 if (local->quiescing) {
2602 set_bit(TMR_RUNNING_TIMER, &ifmgd->timers_running);
2603 return;
2604 }
2605
Johannes Berg64592c82010-06-10 10:21:31 +02002606 ieee80211_queue_work(&local->hw, &sdata->work);
Jiri Bencf0706e82007-05-05 11:45:53 -07002607}
2608
Felix Fietkau04ac3c02010-12-02 21:01:08 +01002609static void ieee80211_sta_connection_lost(struct ieee80211_sub_if_data *sdata,
Johannes Berg95acac62011-07-12 12:30:59 +02002610 u8 *bssid, u8 reason)
Felix Fietkau04ac3c02010-12-02 21:01:08 +01002611{
2612 struct ieee80211_local *local = sdata->local;
2613 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
Johannes Berg5fef7db2012-02-24 13:50:52 +01002614 u8 frame_buf[DEAUTH_DISASSOC_LEN];
Felix Fietkau04ac3c02010-12-02 21:01:08 +01002615
Johannes Berg37ad3882012-02-24 13:50:54 +01002616 ieee80211_set_disassoc(sdata, IEEE80211_STYPE_DEAUTH, reason,
2617 false, frame_buf);
Felix Fietkau04ac3c02010-12-02 21:01:08 +01002618 mutex_unlock(&ifmgd->mtx);
Johannes Berg37ad3882012-02-24 13:50:54 +01002619
Felix Fietkau04ac3c02010-12-02 21:01:08 +01002620 /*
2621 * must be outside lock due to cfg80211,
2622 * but that's not a problem.
2623 */
Johannes Berg5fef7db2012-02-24 13:50:52 +01002624 cfg80211_send_deauth(sdata->dev, frame_buf, DEAUTH_DISASSOC_LEN);
Felix Fietkaufcac4fb2011-11-16 13:34:55 +01002625
2626 mutex_lock(&local->mtx);
2627 ieee80211_recalc_idle(local);
2628 mutex_unlock(&local->mtx);
2629
Felix Fietkau04ac3c02010-12-02 21:01:08 +01002630 mutex_lock(&ifmgd->mtx);
2631}
2632
Johannes Berg66e67e42012-01-20 13:55:27 +01002633static int ieee80211_probe_auth(struct ieee80211_sub_if_data *sdata)
2634{
2635 struct ieee80211_local *local = sdata->local;
2636 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
2637 struct ieee80211_mgd_auth_data *auth_data = ifmgd->auth_data;
2638
2639 lockdep_assert_held(&ifmgd->mtx);
2640
2641 if (WARN_ON_ONCE(!auth_data))
2642 return -EINVAL;
2643
Johannes Berg66e67e42012-01-20 13:55:27 +01002644 auth_data->tries++;
2645
2646 if (auth_data->tries > IEEE80211_AUTH_MAX_TRIES) {
2647 printk(KERN_DEBUG "%s: authentication with %pM timed out\n",
2648 sdata->name, auth_data->bss->bssid);
2649
2650 /*
2651 * Most likely AP is not in the range so remove the
2652 * bss struct for that AP.
2653 */
2654 cfg80211_unlink_bss(local->hw.wiphy, auth_data->bss);
2655
2656 return -ETIMEDOUT;
2657 }
2658
2659 if (auth_data->bss->proberesp_ies) {
2660 printk(KERN_DEBUG "%s: send auth to %pM (try %d/%d)\n",
2661 sdata->name, auth_data->bss->bssid, auth_data->tries,
2662 IEEE80211_AUTH_MAX_TRIES);
2663
2664 auth_data->expected_transaction = 2;
2665 ieee80211_send_auth(sdata, 1, auth_data->algorithm,
2666 auth_data->ie, auth_data->ie_len,
2667 auth_data->bss->bssid,
2668 auth_data->bss->bssid, NULL, 0, 0);
2669 } else {
2670 const u8 *ssidie;
2671
2672 printk(KERN_DEBUG "%s: direct probe to %pM (try %d/%i)\n",
2673 sdata->name, auth_data->bss->bssid, auth_data->tries,
2674 IEEE80211_AUTH_MAX_TRIES);
2675
2676 ssidie = ieee80211_bss_get_ie(auth_data->bss, WLAN_EID_SSID);
2677 if (!ssidie)
2678 return -EINVAL;
2679 /*
2680 * Direct probe is sent to broadcast address as some APs
2681 * will not answer to direct packet in unassociated state.
2682 */
2683 ieee80211_send_probe_req(sdata, NULL, ssidie + 2, ssidie[1],
2684 NULL, 0, (u32) -1, true, false);
2685 }
2686
2687 auth_data->timeout = jiffies + IEEE80211_AUTH_TIMEOUT;
2688 run_again(ifmgd, auth_data->timeout);
2689
2690 return 0;
2691}
2692
2693static int ieee80211_do_assoc(struct ieee80211_sub_if_data *sdata)
2694{
2695 struct ieee80211_mgd_assoc_data *assoc_data = sdata->u.mgd.assoc_data;
2696 struct ieee80211_local *local = sdata->local;
2697
2698 lockdep_assert_held(&sdata->u.mgd.mtx);
2699
Johannes Berg66e67e42012-01-20 13:55:27 +01002700 assoc_data->tries++;
2701 if (assoc_data->tries > IEEE80211_ASSOC_MAX_TRIES) {
2702 printk(KERN_DEBUG "%s: association with %pM timed out\n",
2703 sdata->name, assoc_data->bss->bssid);
2704
2705 /*
2706 * Most likely AP is not in the range so remove the
2707 * bss struct for that AP.
2708 */
2709 cfg80211_unlink_bss(local->hw.wiphy, assoc_data->bss);
2710
2711 return -ETIMEDOUT;
2712 }
2713
2714 printk(KERN_DEBUG "%s: associate with %pM (try %d/%d)\n",
2715 sdata->name, assoc_data->bss->bssid, assoc_data->tries,
2716 IEEE80211_ASSOC_MAX_TRIES);
2717 ieee80211_send_assoc(sdata);
2718
2719 assoc_data->timeout = jiffies + IEEE80211_ASSOC_TIMEOUT;
2720 run_again(&sdata->u.mgd, assoc_data->timeout);
2721
2722 return 0;
2723}
2724
Johannes Berg1fa57d02010-06-10 10:21:32 +02002725void ieee80211_sta_work(struct ieee80211_sub_if_data *sdata)
Johannes Berg60f8b392008-09-08 17:44:22 +02002726{
Johannes Berg60f8b392008-09-08 17:44:22 +02002727 struct ieee80211_local *local = sdata->local;
Johannes Berg1fa57d02010-06-10 10:21:32 +02002728 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
Johannes Berg60f8b392008-09-08 17:44:22 +02002729
Johannes Berg77fdaa12009-07-07 03:45:17 +02002730 mutex_lock(&ifmgd->mtx);
Johannes Berg60f8b392008-09-08 17:44:22 +02002731
Johannes Berg66e67e42012-01-20 13:55:27 +01002732 if (ifmgd->auth_data &&
2733 time_after(jiffies, ifmgd->auth_data->timeout)) {
2734 if (ifmgd->auth_data->done) {
2735 /*
2736 * ok ... we waited for assoc but userspace didn't,
2737 * so let's just kill the auth data
2738 */
2739 ieee80211_destroy_auth_data(sdata, false);
2740 } else if (ieee80211_probe_auth(sdata)) {
2741 u8 bssid[ETH_ALEN];
2742
2743 memcpy(bssid, ifmgd->auth_data->bss->bssid, ETH_ALEN);
2744
2745 ieee80211_destroy_auth_data(sdata, false);
2746
2747 mutex_unlock(&ifmgd->mtx);
2748 cfg80211_send_auth_timeout(sdata->dev, bssid);
2749 mutex_lock(&ifmgd->mtx);
2750 }
2751 } else if (ifmgd->auth_data)
2752 run_again(ifmgd, ifmgd->auth_data->timeout);
2753
2754 if (ifmgd->assoc_data &&
2755 time_after(jiffies, ifmgd->assoc_data->timeout)) {
2756 if (!ifmgd->assoc_data->have_beacon ||
2757 ieee80211_do_assoc(sdata)) {
2758 u8 bssid[ETH_ALEN];
2759
2760 memcpy(bssid, ifmgd->assoc_data->bss->bssid, ETH_ALEN);
2761
2762 ieee80211_destroy_assoc_data(sdata, false);
2763
2764 mutex_unlock(&ifmgd->mtx);
2765 cfg80211_send_assoc_timeout(sdata->dev, bssid);
2766 mutex_lock(&ifmgd->mtx);
2767 }
2768 } else if (ifmgd->assoc_data)
2769 run_again(ifmgd, ifmgd->assoc_data->timeout);
2770
Johannes Bergb291ba12009-07-10 15:29:03 +02002771 if (ifmgd->flags & (IEEE80211_STA_BEACON_POLL |
2772 IEEE80211_STA_CONNECTION_POLL) &&
2773 ifmgd->associated) {
Maxim Levitskya43abf22009-07-31 18:54:12 +03002774 u8 bssid[ETH_ALEN];
Felix Fietkau72a8a3e2010-11-23 03:10:32 +01002775 int max_tries;
Maxim Levitskya43abf22009-07-31 18:54:12 +03002776
Johannes Berg0c1ad2c2009-12-23 13:15:39 +01002777 memcpy(bssid, ifmgd->associated->bssid, ETH_ALEN);
Felix Fietkau4e5ff372010-11-23 03:10:31 +01002778
Felix Fietkau72a8a3e2010-11-23 03:10:32 +01002779 if (local->hw.flags & IEEE80211_HW_REPORTS_TX_ACK_STATUS)
Ben Greear180205b2011-02-04 15:30:24 -08002780 max_tries = max_nullfunc_tries;
Felix Fietkau72a8a3e2010-11-23 03:10:32 +01002781 else
Ben Greear180205b2011-02-04 15:30:24 -08002782 max_tries = max_probe_tries;
Felix Fietkau72a8a3e2010-11-23 03:10:32 +01002783
Felix Fietkau4e5ff372010-11-23 03:10:31 +01002784 /* ACK received for nullfunc probing frame */
2785 if (!ifmgd->probe_send_count)
2786 ieee80211_reset_ap_probe(sdata);
Felix Fietkau04ac3c02010-12-02 21:01:08 +01002787 else if (ifmgd->nullfunc_failed) {
2788 if (ifmgd->probe_send_count < max_tries) {
2789#ifdef CONFIG_MAC80211_VERBOSE_DEBUG
2790 wiphy_debug(local->hw.wiphy,
2791 "%s: No ack for nullfunc frame to"
Ben Greearbfc31df2011-01-14 09:32:18 -08002792 " AP %pM, try %d/%i\n",
Felix Fietkau04ac3c02010-12-02 21:01:08 +01002793 sdata->name, bssid,
Ben Greearbfc31df2011-01-14 09:32:18 -08002794 ifmgd->probe_send_count, max_tries);
Felix Fietkau04ac3c02010-12-02 21:01:08 +01002795#endif
2796 ieee80211_mgd_probe_ap_send(sdata);
2797 } else {
2798#ifdef CONFIG_MAC80211_VERBOSE_DEBUG
2799 wiphy_debug(local->hw.wiphy,
2800 "%s: No ack for nullfunc frame to"
2801 " AP %pM, disconnecting.\n",
Felix Fietkauc658e5d2010-12-07 04:40:18 +01002802 sdata->name, bssid);
Felix Fietkau04ac3c02010-12-02 21:01:08 +01002803#endif
Johannes Berg95acac62011-07-12 12:30:59 +02002804 ieee80211_sta_connection_lost(sdata, bssid,
2805 WLAN_REASON_DISASSOC_DUE_TO_INACTIVITY);
Felix Fietkau04ac3c02010-12-02 21:01:08 +01002806 }
2807 } else if (time_is_after_jiffies(ifmgd->probe_timeout))
Johannes Bergb291ba12009-07-10 15:29:03 +02002808 run_again(ifmgd, ifmgd->probe_timeout);
Felix Fietkau04ac3c02010-12-02 21:01:08 +01002809 else if (local->hw.flags & IEEE80211_HW_REPORTS_TX_ACK_STATUS) {
2810#ifdef CONFIG_MAC80211_VERBOSE_DEBUG
2811 wiphy_debug(local->hw.wiphy,
2812 "%s: Failed to send nullfunc to AP %pM"
2813 " after %dms, disconnecting.\n",
2814 sdata->name,
Ben Greear180205b2011-02-04 15:30:24 -08002815 bssid, probe_wait_ms);
Felix Fietkau04ac3c02010-12-02 21:01:08 +01002816#endif
Johannes Berg95acac62011-07-12 12:30:59 +02002817 ieee80211_sta_connection_lost(sdata, bssid,
2818 WLAN_REASON_DISASSOC_DUE_TO_INACTIVITY);
Felix Fietkau04ac3c02010-12-02 21:01:08 +01002819 } else if (ifmgd->probe_send_count < max_tries) {
Maxim Levitskya43abf22009-07-31 18:54:12 +03002820#ifdef CONFIG_MAC80211_VERBOSE_DEBUG
Ben Greearb38afa82010-10-07 16:12:06 -07002821 wiphy_debug(local->hw.wiphy,
2822 "%s: No probe response from AP %pM"
Ben Greearbfc31df2011-01-14 09:32:18 -08002823 " after %dms, try %d/%i\n",
Ben Greearb38afa82010-10-07 16:12:06 -07002824 sdata->name,
Ben Greear180205b2011-02-04 15:30:24 -08002825 bssid, probe_wait_ms,
Ben Greearbfc31df2011-01-14 09:32:18 -08002826 ifmgd->probe_send_count, max_tries);
Maxim Levitskya43abf22009-07-31 18:54:12 +03002827#endif
2828 ieee80211_mgd_probe_ap_send(sdata);
2829 } else {
Johannes Bergb291ba12009-07-10 15:29:03 +02002830 /*
2831 * We actually lost the connection ... or did we?
2832 * Let's make sure!
2833 */
Ben Greearb38afa82010-10-07 16:12:06 -07002834 wiphy_debug(local->hw.wiphy,
2835 "%s: No probe response from AP %pM"
2836 " after %dms, disconnecting.\n",
2837 sdata->name,
Ben Greear180205b2011-02-04 15:30:24 -08002838 bssid, probe_wait_ms);
Felix Fietkau04ac3c02010-12-02 21:01:08 +01002839
Johannes Berg95acac62011-07-12 12:30:59 +02002840 ieee80211_sta_connection_lost(sdata, bssid,
2841 WLAN_REASON_DISASSOC_DUE_TO_INACTIVITY);
Johannes Bergb291ba12009-07-10 15:29:03 +02002842 }
2843 }
2844
Johannes Berg77fdaa12009-07-07 03:45:17 +02002845 mutex_unlock(&ifmgd->mtx);
Johannes Berg66e67e42012-01-20 13:55:27 +01002846
2847 mutex_lock(&local->mtx);
2848 ieee80211_recalc_idle(local);
2849 mutex_unlock(&local->mtx);
Johannes Berg60f8b392008-09-08 17:44:22 +02002850}
Johannes Berg0a51b272008-09-08 17:44:25 +02002851
Johannes Bergb291ba12009-07-10 15:29:03 +02002852static void ieee80211_sta_bcn_mon_timer(unsigned long data)
2853{
2854 struct ieee80211_sub_if_data *sdata =
2855 (struct ieee80211_sub_if_data *) data;
2856 struct ieee80211_local *local = sdata->local;
2857
2858 if (local->quiescing)
2859 return;
2860
Juuso Oikarinen1e4dcd02010-03-19 07:14:53 +02002861 ieee80211_queue_work(&sdata->local->hw,
2862 &sdata->u.mgd.beacon_connection_loss_work);
Johannes Bergb291ba12009-07-10 15:29:03 +02002863}
2864
2865static void ieee80211_sta_conn_mon_timer(unsigned long data)
2866{
2867 struct ieee80211_sub_if_data *sdata =
2868 (struct ieee80211_sub_if_data *) data;
2869 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
2870 struct ieee80211_local *local = sdata->local;
2871
2872 if (local->quiescing)
2873 return;
2874
Luis R. Rodriguez42935ec2009-07-29 20:08:07 -04002875 ieee80211_queue_work(&local->hw, &ifmgd->monitor_work);
Johannes Bergb291ba12009-07-10 15:29:03 +02002876}
2877
2878static void ieee80211_sta_monitor_work(struct work_struct *work)
2879{
2880 struct ieee80211_sub_if_data *sdata =
2881 container_of(work, struct ieee80211_sub_if_data,
2882 u.mgd.monitor_work);
2883
2884 ieee80211_mgd_probe_ap(sdata, false);
2885}
2886
Johannes Berga1678f82008-09-11 00:01:47 +02002887static void ieee80211_restart_sta_timer(struct ieee80211_sub_if_data *sdata)
2888{
Eliad Peller494f1fe2012-02-19 15:26:09 +02002889 u32 flags;
2890
Kalle Vaload935682009-04-19 08:47:19 +03002891 if (sdata->vif.type == NL80211_IFTYPE_STATION) {
Stanislaw Gruszka925e64c2012-05-16 15:27:20 +02002892 __ieee80211_stop_poll(sdata);
Kalle Vaload935682009-04-19 08:47:19 +03002893
Johannes Bergb291ba12009-07-10 15:29:03 +02002894 /* let's probe the connection once */
Eliad Peller494f1fe2012-02-19 15:26:09 +02002895 flags = sdata->local->hw.flags;
2896 if (!(flags & IEEE80211_HW_CONNECTION_MONITOR))
2897 ieee80211_queue_work(&sdata->local->hw,
2898 &sdata->u.mgd.monitor_work);
Johannes Bergb291ba12009-07-10 15:29:03 +02002899 /* and do all the other regular work too */
Johannes Berg64592c82010-06-10 10:21:31 +02002900 ieee80211_queue_work(&sdata->local->hw, &sdata->work);
Kalle Vaload935682009-04-19 08:47:19 +03002901 }
Johannes Berga1678f82008-09-11 00:01:47 +02002902}
2903
Johannes Berg5bb644a2009-05-17 11:40:42 +02002904#ifdef CONFIG_PM
2905void ieee80211_sta_quiesce(struct ieee80211_sub_if_data *sdata)
2906{
2907 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
2908
2909 /*
2910 * we need to use atomic bitops for the running bits
2911 * only because both timers might fire at the same
2912 * time -- the code here is properly synchronised.
2913 */
2914
Johannes Bergd1f5b7a2010-08-05 17:05:55 +02002915 cancel_work_sync(&ifmgd->request_smps_work);
2916
Johannes Berg0ecfe8062011-11-09 12:14:16 +01002917 cancel_work_sync(&ifmgd->monitor_work);
Juuso Oikarinen1e4dcd02010-03-19 07:14:53 +02002918 cancel_work_sync(&ifmgd->beacon_connection_loss_work);
Johannes Berg5bb644a2009-05-17 11:40:42 +02002919 if (del_timer_sync(&ifmgd->timer))
2920 set_bit(TMR_RUNNING_TIMER, &ifmgd->timers_running);
2921
2922 cancel_work_sync(&ifmgd->chswitch_work);
2923 if (del_timer_sync(&ifmgd->chswitch_timer))
2924 set_bit(TMR_RUNNING_CHANSW, &ifmgd->timers_running);
Johannes Bergb291ba12009-07-10 15:29:03 +02002925
Johannes Bergb291ba12009-07-10 15:29:03 +02002926 /* these will just be re-established on connection */
2927 del_timer_sync(&ifmgd->conn_mon_timer);
2928 del_timer_sync(&ifmgd->bcn_mon_timer);
Johannes Berg5bb644a2009-05-17 11:40:42 +02002929}
2930
2931void ieee80211_sta_restart(struct ieee80211_sub_if_data *sdata)
2932{
2933 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
2934
Rajkumar Manoharan676b58c2011-07-07 23:33:39 +05302935 if (!ifmgd->associated)
2936 return;
2937
Johannes Berg95acac62011-07-12 12:30:59 +02002938 if (sdata->flags & IEEE80211_SDATA_DISCONNECT_RESUME) {
2939 sdata->flags &= ~IEEE80211_SDATA_DISCONNECT_RESUME;
2940 mutex_lock(&ifmgd->mtx);
2941 if (ifmgd->associated) {
2942#ifdef CONFIG_MAC80211_VERBOSE_DEBUG
2943 wiphy_debug(sdata->local->hw.wiphy,
2944 "%s: driver requested disconnect after resume.\n",
2945 sdata->name);
2946#endif
2947 ieee80211_sta_connection_lost(sdata,
2948 ifmgd->associated->bssid,
2949 WLAN_REASON_UNSPECIFIED);
2950 mutex_unlock(&ifmgd->mtx);
2951 return;
2952 }
2953 mutex_unlock(&ifmgd->mtx);
2954 }
2955
Johannes Berg5bb644a2009-05-17 11:40:42 +02002956 if (test_and_clear_bit(TMR_RUNNING_TIMER, &ifmgd->timers_running))
2957 add_timer(&ifmgd->timer);
2958 if (test_and_clear_bit(TMR_RUNNING_CHANSW, &ifmgd->timers_running))
2959 add_timer(&ifmgd->chswitch_timer);
Felix Fietkauc8a79722010-11-19 22:55:37 +01002960 ieee80211_sta_reset_beacon_monitor(sdata);
Stanislaw Gruszka925e64c2012-05-16 15:27:20 +02002961
2962 mutex_lock(&sdata->local->mtx);
Felix Fietkau46090972010-11-23 20:28:03 +01002963 ieee80211_restart_sta_timer(sdata);
Stanislaw Gruszka925e64c2012-05-16 15:27:20 +02002964 mutex_unlock(&sdata->local->mtx);
Johannes Berg5bb644a2009-05-17 11:40:42 +02002965}
2966#endif
2967
Johannes Berg9c6bd792008-09-11 00:01:52 +02002968/* interface setup */
2969void ieee80211_sta_setup_sdata(struct ieee80211_sub_if_data *sdata)
2970{
Johannes Berg46900292009-02-15 12:44:28 +01002971 struct ieee80211_if_managed *ifmgd;
Johannes Berg9c6bd792008-09-11 00:01:52 +02002972
Johannes Berg46900292009-02-15 12:44:28 +01002973 ifmgd = &sdata->u.mgd;
Johannes Bergb291ba12009-07-10 15:29:03 +02002974 INIT_WORK(&ifmgd->monitor_work, ieee80211_sta_monitor_work);
Johannes Berg46900292009-02-15 12:44:28 +01002975 INIT_WORK(&ifmgd->chswitch_work, ieee80211_chswitch_work);
Juuso Oikarinen1e4dcd02010-03-19 07:14:53 +02002976 INIT_WORK(&ifmgd->beacon_connection_loss_work,
2977 ieee80211_beacon_connection_loss_work);
Johannes Bergd1f5b7a2010-08-05 17:05:55 +02002978 INIT_WORK(&ifmgd->request_smps_work, ieee80211_request_smps_work);
Johannes Berg46900292009-02-15 12:44:28 +01002979 setup_timer(&ifmgd->timer, ieee80211_sta_timer,
Johannes Berg9c6bd792008-09-11 00:01:52 +02002980 (unsigned long) sdata);
Johannes Bergb291ba12009-07-10 15:29:03 +02002981 setup_timer(&ifmgd->bcn_mon_timer, ieee80211_sta_bcn_mon_timer,
2982 (unsigned long) sdata);
2983 setup_timer(&ifmgd->conn_mon_timer, ieee80211_sta_conn_mon_timer,
2984 (unsigned long) sdata);
Johannes Berg46900292009-02-15 12:44:28 +01002985 setup_timer(&ifmgd->chswitch_timer, ieee80211_chswitch_timer,
Sujithc481ec92009-01-06 09:28:37 +05302986 (unsigned long) sdata);
Johannes Berg9c6bd792008-09-11 00:01:52 +02002987
Johannes Bergab1faea2009-07-01 21:41:17 +02002988 ifmgd->flags = 0;
Mohammed Shafi Shajakhan1478acb2011-12-14 19:46:08 +05302989 ifmgd->powersave = sdata->wdev.ps;
Eliad Pellerdc41e4d2012-03-14 16:15:03 +02002990 ifmgd->uapsd_queues = IEEE80211_DEFAULT_UAPSD_QUEUES;
2991 ifmgd->uapsd_max_sp_len = IEEE80211_DEFAULT_MAX_SP_LEN;
Johannes Bergbbbdff92009-04-16 13:27:42 +02002992
Johannes Berg77fdaa12009-07-07 03:45:17 +02002993 mutex_init(&ifmgd->mtx);
Johannes Berg0f782312009-12-01 13:37:02 +01002994
2995 if (sdata->local->hw.flags & IEEE80211_HW_SUPPORTS_DYNAMIC_SMPS)
2996 ifmgd->req_smps = IEEE80211_SMPS_AUTOMATIC;
2997 else
2998 ifmgd->req_smps = IEEE80211_SMPS_OFF;
Johannes Berg9c6bd792008-09-11 00:01:52 +02002999}
3000
3001/* scan finished notification */
Johannes Berg0a51b272008-09-08 17:44:25 +02003002void ieee80211_mlme_notify_scan_completed(struct ieee80211_local *local)
3003{
3004 struct ieee80211_sub_if_data *sdata = local->scan_sdata;
Johannes Berga1678f82008-09-11 00:01:47 +02003005
3006 /* Restart STA timers */
3007 rcu_read_lock();
3008 list_for_each_entry_rcu(sdata, &local->interfaces, list)
3009 ieee80211_restart_sta_timer(sdata);
3010 rcu_read_unlock();
Johannes Berg0a51b272008-09-08 17:44:25 +02003011}
Johannes Berg10f644a2009-04-16 13:17:25 +02003012
3013int ieee80211_max_network_latency(struct notifier_block *nb,
3014 unsigned long data, void *dummy)
3015{
3016 s32 latency_usec = (s32) data;
3017 struct ieee80211_local *local =
3018 container_of(nb, struct ieee80211_local,
3019 network_latency_notifier);
3020
3021 mutex_lock(&local->iflist_mtx);
3022 ieee80211_recalc_ps(local, latency_usec);
3023 mutex_unlock(&local->iflist_mtx);
3024
3025 return 0;
3026}
Johannes Berg77fdaa12009-07-07 03:45:17 +02003027
Johannes Berga1cf7752012-03-08 15:02:07 +01003028static int ieee80211_prep_connection(struct ieee80211_sub_if_data *sdata,
Johannes Berg5d6a1b02012-03-08 15:02:08 +01003029 struct cfg80211_bss *cbss, bool assoc)
Johannes Berga1cf7752012-03-08 15:02:07 +01003030{
3031 struct ieee80211_local *local = sdata->local;
3032 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
Johannes Berg5d6a1b02012-03-08 15:02:08 +01003033 struct ieee80211_bss *bss = (void *)cbss->priv;
Johannes Berga1cf7752012-03-08 15:02:07 +01003034 struct sta_info *sta;
3035 bool have_sta = false;
3036 int err;
Johannes Berg24398e32012-03-28 10:58:36 +02003037 int ht_cfreq;
3038 enum nl80211_channel_type channel_type = NL80211_CHAN_NO_HT;
3039 const u8 *ht_oper_ie;
3040 const struct ieee80211_ht_operation *ht_oper = NULL;
3041 struct ieee80211_supported_band *sband;
Johannes Berga1cf7752012-03-08 15:02:07 +01003042
3043 if (WARN_ON(!ifmgd->auth_data && !ifmgd->assoc_data))
3044 return -EINVAL;
3045
3046 if (assoc) {
3047 rcu_read_lock();
Johannes Berg5d6a1b02012-03-08 15:02:08 +01003048 have_sta = sta_info_get(sdata, cbss->bssid);
Johannes Berga1cf7752012-03-08 15:02:07 +01003049 rcu_read_unlock();
3050 }
3051
3052 if (!have_sta) {
Johannes Berg5d6a1b02012-03-08 15:02:08 +01003053 sta = sta_info_alloc(sdata, cbss->bssid, GFP_KERNEL);
Johannes Berga1cf7752012-03-08 15:02:07 +01003054 if (!sta)
3055 return -ENOMEM;
3056 }
3057
3058 mutex_lock(&local->mtx);
3059 ieee80211_recalc_idle(sdata->local);
3060 mutex_unlock(&local->mtx);
3061
3062 /* switch to the right channel */
Johannes Berg24398e32012-03-28 10:58:36 +02003063 sband = local->hw.wiphy->bands[cbss->channel->band];
3064
3065 ifmgd->flags &= ~IEEE80211_STA_DISABLE_40MHZ;
3066
3067 if (sband->ht_cap.ht_supported) {
3068 ht_oper_ie = cfg80211_find_ie(WLAN_EID_HT_OPERATION,
3069 cbss->information_elements,
3070 cbss->len_information_elements);
3071 if (ht_oper_ie && ht_oper_ie[1] >= sizeof(*ht_oper))
3072 ht_oper = (void *)(ht_oper_ie + 2);
3073 }
3074
3075 if (ht_oper) {
3076 ht_cfreq = ieee80211_channel_to_frequency(ht_oper->primary_chan,
3077 cbss->channel->band);
3078 /* check that channel matches the right operating channel */
3079 if (cbss->channel->center_freq != ht_cfreq) {
3080 /*
3081 * It's possible that some APs are confused here;
3082 * Netgear WNDR3700 sometimes reports 4 higher than
3083 * the actual channel in association responses, but
3084 * since we look at probe response/beacon data here
3085 * it should be OK.
3086 */
3087 printk(KERN_DEBUG
3088 "%s: Wrong control channel: center-freq: %d"
3089 " ht-cfreq: %d ht->primary_chan: %d"
3090 " band: %d. Disabling HT.\n",
3091 sdata->name, cbss->channel->center_freq,
3092 ht_cfreq, ht_oper->primary_chan,
3093 cbss->channel->band);
3094 ht_oper = NULL;
3095 }
3096 }
3097
3098 if (ht_oper) {
3099 channel_type = NL80211_CHAN_HT20;
3100
3101 if (sband->ht_cap.cap & IEEE80211_HT_CAP_SUP_WIDTH_20_40) {
3102 switch (ht_oper->ht_param &
3103 IEEE80211_HT_PARAM_CHA_SEC_OFFSET) {
3104 case IEEE80211_HT_PARAM_CHA_SEC_ABOVE:
3105 channel_type = NL80211_CHAN_HT40PLUS;
3106 break;
3107 case IEEE80211_HT_PARAM_CHA_SEC_BELOW:
3108 channel_type = NL80211_CHAN_HT40MINUS;
3109 break;
3110 }
3111 }
3112 }
3113
3114 if (!ieee80211_set_channel_type(local, sdata, channel_type)) {
3115 /* can only fail due to HT40+/- mismatch */
3116 channel_type = NL80211_CHAN_HT20;
3117 printk(KERN_DEBUG
3118 "%s: disabling 40 MHz due to multi-vif mismatch\n",
3119 sdata->name);
3120 ifmgd->flags |= IEEE80211_STA_DISABLE_40MHZ;
3121 WARN_ON(!ieee80211_set_channel_type(local, sdata,
3122 channel_type));
3123 }
3124
Johannes Berg5d6a1b02012-03-08 15:02:08 +01003125 local->oper_channel = cbss->channel;
Stanislaw Gruszka6aee4ca2012-06-07 14:47:21 +02003126 ieee80211_hw_config(local, IEEE80211_CONF_CHANGE_CHANNEL);
Johannes Berga1cf7752012-03-08 15:02:07 +01003127
3128 if (!have_sta) {
Johannes Berg5d6a1b02012-03-08 15:02:08 +01003129 u32 rates = 0, basic_rates = 0;
3130 bool have_higher_than_11mbit;
3131 int min_rate = INT_MAX, min_rate_index = -1;
3132
Johannes Berg5d6a1b02012-03-08 15:02:08 +01003133 ieee80211_get_rates(sband, bss->supp_rates,
3134 bss->supp_rates_len,
3135 &rates, &basic_rates,
3136 &have_higher_than_11mbit,
3137 &min_rate, &min_rate_index);
3138
3139 /*
3140 * This used to be a workaround for basic rates missing
3141 * in the association response frame. Now that we no
3142 * longer use the basic rates from there, it probably
3143 * doesn't happen any more, but keep the workaround so
3144 * in case some *other* APs are buggy in different ways
3145 * we can connect -- with a warning.
3146 */
3147 if (!basic_rates && min_rate_index >= 0) {
3148 printk(KERN_DEBUG
3149 "%s: No basic rates, using min rate instead.\n",
3150 sdata->name);
3151 basic_rates = BIT(min_rate_index);
3152 }
3153
3154 sta->sta.supp_rates[cbss->channel->band] = rates;
3155 sdata->vif.bss_conf.basic_rates = basic_rates;
3156
3157 /* cf. IEEE 802.11 9.2.12 */
3158 if (local->oper_channel->band == IEEE80211_BAND_2GHZ &&
3159 have_higher_than_11mbit)
3160 sdata->flags |= IEEE80211_SDATA_OPERATING_GMODE;
3161 else
3162 sdata->flags &= ~IEEE80211_SDATA_OPERATING_GMODE;
3163
3164 memcpy(ifmgd->bssid, cbss->bssid, ETH_ALEN);
3165
3166 /* tell driver about BSSID and basic rates */
3167 ieee80211_bss_info_change_notify(sdata,
3168 BSS_CHANGED_BSSID | BSS_CHANGED_BASIC_RATES);
Johannes Berga1cf7752012-03-08 15:02:07 +01003169
3170 if (assoc)
3171 sta_info_pre_move_state(sta, IEEE80211_STA_AUTH);
3172
3173 err = sta_info_insert(sta);
3174 sta = NULL;
3175 if (err) {
3176 printk(KERN_DEBUG
3177 "%s: failed to insert STA entry for the AP (error %d)\n",
3178 sdata->name, err);
3179 return err;
3180 }
3181 } else
Joe Perchesb203ca32012-05-08 18:56:52 +00003182 WARN_ON_ONCE(!ether_addr_equal(ifmgd->bssid, cbss->bssid));
Johannes Berga1cf7752012-03-08 15:02:07 +01003183
3184 return 0;
3185}
3186
Johannes Berg77fdaa12009-07-07 03:45:17 +02003187/* config hooks */
3188int ieee80211_mgd_auth(struct ieee80211_sub_if_data *sdata,
3189 struct cfg80211_auth_request *req)
3190{
Johannes Berg66e67e42012-01-20 13:55:27 +01003191 struct ieee80211_local *local = sdata->local;
3192 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
3193 struct ieee80211_mgd_auth_data *auth_data;
Johannes Berg77fdaa12009-07-07 03:45:17 +02003194 u16 auth_alg;
Johannes Berg66e67e42012-01-20 13:55:27 +01003195 int err;
3196
3197 /* prepare auth data structure */
Johannes Berg77fdaa12009-07-07 03:45:17 +02003198
3199 switch (req->auth_type) {
3200 case NL80211_AUTHTYPE_OPEN_SYSTEM:
3201 auth_alg = WLAN_AUTH_OPEN;
3202 break;
3203 case NL80211_AUTHTYPE_SHARED_KEY:
Johannes Berg66e67e42012-01-20 13:55:27 +01003204 if (IS_ERR(local->wep_tx_tfm))
Johannes Berg9dca9c42010-07-21 10:09:25 +02003205 return -EOPNOTSUPP;
Johannes Berg77fdaa12009-07-07 03:45:17 +02003206 auth_alg = WLAN_AUTH_SHARED_KEY;
3207 break;
3208 case NL80211_AUTHTYPE_FT:
3209 auth_alg = WLAN_AUTH_FT;
3210 break;
3211 case NL80211_AUTHTYPE_NETWORK_EAP:
3212 auth_alg = WLAN_AUTH_LEAP;
3213 break;
3214 default:
3215 return -EOPNOTSUPP;
3216 }
3217
Johannes Berg66e67e42012-01-20 13:55:27 +01003218 auth_data = kzalloc(sizeof(*auth_data) + req->ie_len, GFP_KERNEL);
3219 if (!auth_data)
Johannes Berg77fdaa12009-07-07 03:45:17 +02003220 return -ENOMEM;
3221
Johannes Berg66e67e42012-01-20 13:55:27 +01003222 auth_data->bss = req->bss;
Johannes Berg77fdaa12009-07-07 03:45:17 +02003223
3224 if (req->ie && req->ie_len) {
Johannes Berg66e67e42012-01-20 13:55:27 +01003225 memcpy(auth_data->ie, req->ie, req->ie_len);
3226 auth_data->ie_len = req->ie_len;
Johannes Berg77fdaa12009-07-07 03:45:17 +02003227 }
3228
Johannes Bergfffd0932009-07-08 14:22:54 +02003229 if (req->key && req->key_len) {
Johannes Berg66e67e42012-01-20 13:55:27 +01003230 auth_data->key_len = req->key_len;
3231 auth_data->key_idx = req->key_idx;
3232 memcpy(auth_data->key, req->key, req->key_len);
Johannes Bergfffd0932009-07-08 14:22:54 +02003233 }
3234
Johannes Berg66e67e42012-01-20 13:55:27 +01003235 auth_data->algorithm = auth_alg;
Johannes Berg77fdaa12009-07-07 03:45:17 +02003236
Johannes Berg66e67e42012-01-20 13:55:27 +01003237 /* try to authenticate/probe */
Johannes Bergf679f652009-12-23 13:15:34 +01003238
Johannes Berg66e67e42012-01-20 13:55:27 +01003239 mutex_lock(&ifmgd->mtx);
Johannes Berg77fdaa12009-07-07 03:45:17 +02003240
Johannes Berg66e67e42012-01-20 13:55:27 +01003241 if ((ifmgd->auth_data && !ifmgd->auth_data->done) ||
3242 ifmgd->assoc_data) {
3243 err = -EBUSY;
3244 goto err_free;
3245 }
Johannes Berg77fdaa12009-07-07 03:45:17 +02003246
Johannes Berg66e67e42012-01-20 13:55:27 +01003247 if (ifmgd->auth_data)
3248 ieee80211_destroy_auth_data(sdata, false);
Guy Eilam2a33bee2011-08-17 15:18:15 +03003249
Johannes Berg66e67e42012-01-20 13:55:27 +01003250 /* prep auth_data so we don't go into idle on disassoc */
3251 ifmgd->auth_data = auth_data;
3252
3253 if (ifmgd->associated)
Johannes Berg37ad3882012-02-24 13:50:54 +01003254 ieee80211_set_disassoc(sdata, 0, 0, false, NULL);
Johannes Berg66e67e42012-01-20 13:55:27 +01003255
3256 printk(KERN_DEBUG "%s: authenticate with %pM\n",
3257 sdata->name, req->bss->bssid);
3258
Johannes Berga1cf7752012-03-08 15:02:07 +01003259 err = ieee80211_prep_connection(sdata, req->bss, false);
3260 if (err)
Johannes Berg66e67e42012-01-20 13:55:27 +01003261 goto err_clear;
Guy Eilam2a33bee2011-08-17 15:18:15 +03003262
Johannes Berg66e67e42012-01-20 13:55:27 +01003263 err = ieee80211_probe_auth(sdata);
3264 if (err) {
Johannes Berg66e67e42012-01-20 13:55:27 +01003265 sta_info_destroy_addr(sdata, req->bss->bssid);
3266 goto err_clear;
Johannes Bergaf6b6372009-12-23 13:15:35 +01003267 }
3268
Johannes Berg66e67e42012-01-20 13:55:27 +01003269 /* hold our own reference */
3270 cfg80211_ref_bss(auth_data->bss);
3271 err = 0;
3272 goto out_unlock;
Johannes Berge5b900d2010-07-29 16:08:55 +02003273
Johannes Berg66e67e42012-01-20 13:55:27 +01003274 err_clear:
3275 ifmgd->auth_data = NULL;
3276 err_free:
3277 kfree(auth_data);
3278 out_unlock:
3279 mutex_unlock(&ifmgd->mtx);
Johannes Berge5b900d2010-07-29 16:08:55 +02003280
Johannes Berg66e67e42012-01-20 13:55:27 +01003281 return err;
Johannes Bergaf6b6372009-12-23 13:15:35 +01003282}
3283
Johannes Berg77fdaa12009-07-07 03:45:17 +02003284int ieee80211_mgd_assoc(struct ieee80211_sub_if_data *sdata,
3285 struct cfg80211_assoc_request *req)
3286{
Johannes Berg66e67e42012-01-20 13:55:27 +01003287 struct ieee80211_local *local = sdata->local;
Johannes Berg77fdaa12009-07-07 03:45:17 +02003288 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
Johannes Berg0c1ad2c2009-12-23 13:15:39 +01003289 struct ieee80211_bss *bss = (void *)req->bss->priv;
Johannes Berg66e67e42012-01-20 13:55:27 +01003290 struct ieee80211_mgd_assoc_data *assoc_data;
Johannes Berg4e74bfd2012-03-08 15:02:04 +01003291 struct ieee80211_supported_band *sband;
Johannes Berg66e67e42012-01-20 13:55:27 +01003292 const u8 *ssidie;
Guy Eilam2a33bee2011-08-17 15:18:15 +03003293 int i, err;
Johannes Berg77fdaa12009-07-07 03:45:17 +02003294
Johannes Berg66e67e42012-01-20 13:55:27 +01003295 ssidie = ieee80211_bss_get_ie(req->bss, WLAN_EID_SSID);
3296 if (!ssidie)
3297 return -EINVAL;
Jouni Malinen9c87ba62010-02-28 12:13:46 +02003298
Johannes Berg66e67e42012-01-20 13:55:27 +01003299 assoc_data = kzalloc(sizeof(*assoc_data) + req->ie_len, GFP_KERNEL);
3300 if (!assoc_data)
Johannes Bergaf6b6372009-12-23 13:15:35 +01003301 return -ENOMEM;
Johannes Berg77fdaa12009-07-07 03:45:17 +02003302
Johannes Berg66e67e42012-01-20 13:55:27 +01003303 mutex_lock(&ifmgd->mtx);
3304
3305 if (ifmgd->associated)
Johannes Berg37ad3882012-02-24 13:50:54 +01003306 ieee80211_set_disassoc(sdata, 0, 0, false, NULL);
Johannes Berg66e67e42012-01-20 13:55:27 +01003307
3308 if (ifmgd->auth_data && !ifmgd->auth_data->done) {
3309 err = -EBUSY;
3310 goto err_free;
Guy Eilam2a33bee2011-08-17 15:18:15 +03003311 }
3312
Johannes Berg66e67e42012-01-20 13:55:27 +01003313 if (ifmgd->assoc_data) {
3314 err = -EBUSY;
3315 goto err_free;
3316 }
3317
3318 if (ifmgd->auth_data) {
3319 bool match;
3320
3321 /* keep sta info, bssid if matching */
Joe Perchesb203ca32012-05-08 18:56:52 +00003322 match = ether_addr_equal(ifmgd->bssid, req->bss->bssid);
Johannes Berg66e67e42012-01-20 13:55:27 +01003323 ieee80211_destroy_auth_data(sdata, match);
3324 }
3325
3326 /* prepare assoc data */
3327
Johannes Berg77fdaa12009-07-07 03:45:17 +02003328 ifmgd->flags &= ~IEEE80211_STA_DISABLE_11N;
Vivek Natarajan375177b2010-02-09 14:50:28 +05303329 ifmgd->flags &= ~IEEE80211_STA_NULLFUNC_ACKED;
Johannes Berg77fdaa12009-07-07 03:45:17 +02003330
Juuso Oikarinend8ec4432010-10-01 16:02:31 +03003331 ifmgd->beacon_crc_valid = false;
3332
Johannes Bergde5036a2012-03-08 15:02:03 +01003333 /*
3334 * IEEE802.11n does not allow TKIP/WEP as pairwise ciphers in HT mode.
3335 * We still associate in non-HT mode (11a/b/g) if any one of these
3336 * ciphers is configured as pairwise.
3337 * We can set this to true for non-11n hardware, that'll be checked
3338 * separately along with the peer capabilities.
3339 */
Johannes Berg77fdaa12009-07-07 03:45:17 +02003340 for (i = 0; i < req->crypto.n_ciphers_pairwise; i++)
3341 if (req->crypto.ciphers_pairwise[i] == WLAN_CIPHER_SUITE_WEP40 ||
3342 req->crypto.ciphers_pairwise[i] == WLAN_CIPHER_SUITE_TKIP ||
3343 req->crypto.ciphers_pairwise[i] == WLAN_CIPHER_SUITE_WEP104)
3344 ifmgd->flags |= IEEE80211_STA_DISABLE_11N;
3345
Ben Greearef96a8422011-11-18 11:32:00 -08003346 if (req->flags & ASSOC_REQ_DISABLE_HT)
3347 ifmgd->flags |= IEEE80211_STA_DISABLE_11N;
3348
Johannes Berg4e74bfd2012-03-08 15:02:04 +01003349 /* Also disable HT if we don't support it or the AP doesn't use WMM */
3350 sband = local->hw.wiphy->bands[req->bss->channel->band];
3351 if (!sband->ht_cap.ht_supported ||
Johannes Berg32c50572012-03-28 11:04:29 +02003352 local->hw.queues < IEEE80211_NUM_ACS || !bss->wmm_used)
Johannes Berg4e74bfd2012-03-08 15:02:04 +01003353 ifmgd->flags |= IEEE80211_STA_DISABLE_11N;
3354
Ben Greearef96a8422011-11-18 11:32:00 -08003355 memcpy(&ifmgd->ht_capa, &req->ht_capa, sizeof(ifmgd->ht_capa));
3356 memcpy(&ifmgd->ht_capa_mask, &req->ht_capa_mask,
3357 sizeof(ifmgd->ht_capa_mask));
3358
Johannes Berg77fdaa12009-07-07 03:45:17 +02003359 if (req->ie && req->ie_len) {
Johannes Berg66e67e42012-01-20 13:55:27 +01003360 memcpy(assoc_data->ie, req->ie, req->ie_len);
3361 assoc_data->ie_len = req->ie_len;
3362 }
Johannes Berg77fdaa12009-07-07 03:45:17 +02003363
Johannes Berg66e67e42012-01-20 13:55:27 +01003364 assoc_data->bss = req->bss;
Johannes Bergf679f652009-12-23 13:15:34 +01003365
Johannes Bergaf6b6372009-12-23 13:15:35 +01003366 if (ifmgd->req_smps == IEEE80211_SMPS_AUTOMATIC) {
3367 if (ifmgd->powersave)
3368 ifmgd->ap_smps = IEEE80211_SMPS_DYNAMIC;
3369 else
3370 ifmgd->ap_smps = IEEE80211_SMPS_OFF;
3371 } else
3372 ifmgd->ap_smps = ifmgd->req_smps;
3373
Johannes Berg66e67e42012-01-20 13:55:27 +01003374 assoc_data->capability = req->bss->capability;
Johannes Berg32c50572012-03-28 11:04:29 +02003375 assoc_data->wmm = bss->wmm_used &&
3376 (local->hw.queues >= IEEE80211_NUM_ACS);
Johannes Berg66e67e42012-01-20 13:55:27 +01003377 assoc_data->supp_rates = bss->supp_rates;
3378 assoc_data->supp_rates_len = bss->supp_rates_len;
Johannes Berg074d46d2012-03-15 19:45:16 +01003379 assoc_data->ht_operation_ie =
3380 ieee80211_bss_get_ie(req->bss, WLAN_EID_HT_OPERATION);
Johannes Berg63f170e2009-12-23 13:15:33 +01003381
Kalle Valoab133152010-01-12 10:42:31 +02003382 if (bss->wmm_used && bss->uapsd_supported &&
3383 (sdata->local->hw.flags & IEEE80211_HW_SUPPORTS_UAPSD)) {
Johannes Berg76f03032012-03-08 15:02:05 +01003384 assoc_data->uapsd = true;
Kalle Valoab133152010-01-12 10:42:31 +02003385 ifmgd->flags |= IEEE80211_STA_UAPSD_ENABLED;
3386 } else {
Johannes Berg76f03032012-03-08 15:02:05 +01003387 assoc_data->uapsd = false;
Kalle Valoab133152010-01-12 10:42:31 +02003388 ifmgd->flags &= ~IEEE80211_STA_UAPSD_ENABLED;
3389 }
3390
Johannes Berg66e67e42012-01-20 13:55:27 +01003391 memcpy(assoc_data->ssid, ssidie + 2, ssidie[1]);
3392 assoc_data->ssid_len = ssidie[1];
Johannes Berg63f170e2009-12-23 13:15:33 +01003393
Johannes Berg77fdaa12009-07-07 03:45:17 +02003394 if (req->prev_bssid)
Johannes Berg66e67e42012-01-20 13:55:27 +01003395 memcpy(assoc_data->prev_bssid, req->prev_bssid, ETH_ALEN);
Johannes Berg77fdaa12009-07-07 03:45:17 +02003396
3397 if (req->use_mfp) {
3398 ifmgd->mfp = IEEE80211_MFP_REQUIRED;
3399 ifmgd->flags |= IEEE80211_STA_MFP_ENABLED;
3400 } else {
3401 ifmgd->mfp = IEEE80211_MFP_DISABLED;
3402 ifmgd->flags &= ~IEEE80211_STA_MFP_ENABLED;
3403 }
3404
3405 if (req->crypto.control_port)
3406 ifmgd->flags |= IEEE80211_STA_CONTROL_PORT;
3407 else
3408 ifmgd->flags &= ~IEEE80211_STA_CONTROL_PORT;
3409
Johannes Berga621fa42010-08-27 14:26:54 +03003410 sdata->control_port_protocol = req->crypto.control_port_ethertype;
3411 sdata->control_port_no_encrypt = req->crypto.control_port_no_encrypt;
3412
Johannes Berg66e67e42012-01-20 13:55:27 +01003413 /* kick off associate process */
3414
3415 ifmgd->assoc_data = assoc_data;
3416
Johannes Berga1cf7752012-03-08 15:02:07 +01003417 err = ieee80211_prep_connection(sdata, req->bss, true);
3418 if (err)
3419 goto err_clear;
Johannes Berg66e67e42012-01-20 13:55:27 +01003420
3421 if (!bss->dtim_period &&
3422 sdata->local->hw.flags & IEEE80211_HW_NEED_DTIM_PERIOD) {
3423 /*
3424 * Wait up to one beacon interval ...
3425 * should this be more if we miss one?
3426 */
3427 printk(KERN_DEBUG "%s: waiting for beacon from %pM\n",
3428 sdata->name, ifmgd->bssid);
Johannes Berg3f9768a2012-03-28 21:02:46 +02003429 assoc_data->timeout = TU_TO_EXP_TIME(req->bss->beacon_interval);
Johannes Berg66e67e42012-01-20 13:55:27 +01003430 } else {
3431 assoc_data->have_beacon = true;
3432 assoc_data->sent_assoc = false;
3433 assoc_data->timeout = jiffies;
3434 }
3435 run_again(ifmgd, assoc_data->timeout);
3436
Paul Stewartfcff4f12012-02-23 17:59:53 -08003437 if (bss->corrupt_data) {
3438 char *corrupt_type = "data";
3439 if (bss->corrupt_data & IEEE80211_BSS_CORRUPT_BEACON) {
3440 if (bss->corrupt_data &
3441 IEEE80211_BSS_CORRUPT_PROBE_RESP)
3442 corrupt_type = "beacon and probe response";
3443 else
3444 corrupt_type = "beacon";
3445 } else if (bss->corrupt_data & IEEE80211_BSS_CORRUPT_PROBE_RESP)
3446 corrupt_type = "probe response";
3447 printk(KERN_DEBUG "%s: associating with AP with corrupt %s\n",
3448 sdata->name, corrupt_type);
3449 }
3450
Johannes Berg66e67e42012-01-20 13:55:27 +01003451 err = 0;
3452 goto out;
3453 err_clear:
3454 ifmgd->assoc_data = NULL;
3455 err_free:
3456 kfree(assoc_data);
3457 out:
3458 mutex_unlock(&ifmgd->mtx);
3459
3460 return err;
Johannes Berg77fdaa12009-07-07 03:45:17 +02003461}
3462
3463int ieee80211_mgd_deauth(struct ieee80211_sub_if_data *sdata,
Johannes Berg63c9c5e2012-02-24 13:50:51 +01003464 struct cfg80211_deauth_request *req)
Johannes Berg77fdaa12009-07-07 03:45:17 +02003465{
3466 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
Johannes Berg5fef7db2012-02-24 13:50:52 +01003467 u8 frame_buf[DEAUTH_DISASSOC_LEN];
Johannes Berg77fdaa12009-07-07 03:45:17 +02003468
Johannes Berg77fdaa12009-07-07 03:45:17 +02003469 mutex_lock(&ifmgd->mtx);
3470
Johannes Berg37ad3882012-02-24 13:50:54 +01003471 if (ifmgd->auth_data) {
Johannes Berg66e67e42012-01-20 13:55:27 +01003472 ieee80211_destroy_auth_data(sdata, false);
Johannes Bergaf6b6372009-12-23 13:15:35 +01003473 mutex_unlock(&ifmgd->mtx);
Johannes Berg66e67e42012-01-20 13:55:27 +01003474 return 0;
Johannes Bergaf6b6372009-12-23 13:15:35 +01003475 }
Johannes Berg77fdaa12009-07-07 03:45:17 +02003476
Johannes Berg37ad3882012-02-24 13:50:54 +01003477 printk(KERN_DEBUG
3478 "%s: deauthenticating from %pM by local choice (reason=%d)\n",
Johannes Berg95de8172012-01-20 13:55:25 +01003479 sdata->name, req->bssid, req->reason_code);
Johannes Berg0ff71612009-09-26 14:45:41 +02003480
Johannes Berg37ad3882012-02-24 13:50:54 +01003481 if (ifmgd->associated &&
Joe Perchesb203ca32012-05-08 18:56:52 +00003482 ether_addr_equal(ifmgd->associated->bssid, req->bssid))
Johannes Berg37ad3882012-02-24 13:50:54 +01003483 ieee80211_set_disassoc(sdata, IEEE80211_STYPE_DEAUTH,
Johannes Berg5fef7db2012-02-24 13:50:52 +01003484 req->reason_code, true, frame_buf);
Johannes Berg37ad3882012-02-24 13:50:54 +01003485 else
3486 ieee80211_send_deauth_disassoc(sdata, req->bssid,
3487 IEEE80211_STYPE_DEAUTH,
3488 req->reason_code, true,
3489 frame_buf);
3490 mutex_unlock(&ifmgd->mtx);
3491
Johannes Berg5fef7db2012-02-24 13:50:52 +01003492 __cfg80211_send_deauth(sdata->dev, frame_buf, DEAUTH_DISASSOC_LEN);
Johannes Berg77fdaa12009-07-07 03:45:17 +02003493
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}
3500
3501int ieee80211_mgd_disassoc(struct ieee80211_sub_if_data *sdata,
Johannes Berg63c9c5e2012-02-24 13:50:51 +01003502 struct cfg80211_disassoc_request *req)
Johannes Berg77fdaa12009-07-07 03:45:17 +02003503{
3504 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
Jouni Malinene69e95d2010-03-29 23:29:31 -07003505 u8 bssid[ETH_ALEN];
Johannes Berg5fef7db2012-02-24 13:50:52 +01003506 u8 frame_buf[DEAUTH_DISASSOC_LEN];
Johannes Berg77fdaa12009-07-07 03:45:17 +02003507
Johannes Berg77fdaa12009-07-07 03:45:17 +02003508 mutex_lock(&ifmgd->mtx);
3509
Johannes Berg8d8b2612009-07-25 11:58:36 +02003510 /*
3511 * cfg80211 should catch this ... but it's racy since
3512 * we can receive a disassoc frame, process it, hand it
3513 * to cfg80211 while that's in a locked section already
3514 * trying to tell us that the user wants to disconnect.
3515 */
Johannes Berg0c1ad2c2009-12-23 13:15:39 +01003516 if (ifmgd->associated != req->bss) {
Johannes Berg77fdaa12009-07-07 03:45:17 +02003517 mutex_unlock(&ifmgd->mtx);
3518 return -ENOLINK;
3519 }
3520
Johannes Berg0ff71612009-09-26 14:45:41 +02003521 printk(KERN_DEBUG "%s: disassociating from %pM by local choice (reason=%d)\n",
Johannes Berg47846c92009-11-25 17:46:19 +01003522 sdata->name, req->bss->bssid, req->reason_code);
Johannes Berg0ff71612009-09-26 14:45:41 +02003523
Jouni Malinene69e95d2010-03-29 23:29:31 -07003524 memcpy(bssid, req->bss->bssid, ETH_ALEN);
Johannes Berg37ad3882012-02-24 13:50:54 +01003525 ieee80211_set_disassoc(sdata, IEEE80211_STYPE_DISASSOC,
3526 req->reason_code, !req->local_state_change,
3527 frame_buf);
Johannes Berg77fdaa12009-07-07 03:45:17 +02003528 mutex_unlock(&ifmgd->mtx);
3529
Johannes Berg5fef7db2012-02-24 13:50:52 +01003530 __cfg80211_send_disassoc(sdata->dev, frame_buf, DEAUTH_DISASSOC_LEN);
Johannes Bergbc83b682009-11-29 12:19:06 +01003531
Johannes Berg7da7cc12010-08-05 17:02:38 +02003532 mutex_lock(&sdata->local->mtx);
Johannes Bergbc83b682009-11-29 12:19:06 +01003533 ieee80211_recalc_idle(sdata->local);
Johannes Berg7da7cc12010-08-05 17:02:38 +02003534 mutex_unlock(&sdata->local->mtx);
Johannes Bergbc83b682009-11-29 12:19:06 +01003535
Johannes Berg77fdaa12009-07-07 03:45:17 +02003536 return 0;
3537}
Jouni Malinen026331c2010-02-15 12:53:10 +02003538
Eliad Pellerafa762f2012-04-23 14:45:15 +03003539void ieee80211_mgd_stop(struct ieee80211_sub_if_data *sdata)
Johannes Berg54e4ffb2012-02-25 21:48:08 +01003540{
3541 struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
3542
3543 mutex_lock(&ifmgd->mtx);
3544 if (ifmgd->assoc_data)
3545 ieee80211_destroy_assoc_data(sdata, false);
3546 if (ifmgd->auth_data)
3547 ieee80211_destroy_auth_data(sdata, false);
3548 del_timer_sync(&ifmgd->timer);
3549 mutex_unlock(&ifmgd->mtx);
3550}
3551
Juuso Oikarinena97c13c2010-03-23 09:02:34 +02003552void ieee80211_cqm_rssi_notify(struct ieee80211_vif *vif,
3553 enum nl80211_cqm_rssi_threshold_event rssi_event,
3554 gfp_t gfp)
3555{
3556 struct ieee80211_sub_if_data *sdata = vif_to_sdata(vif);
3557
Johannes Bergb5878a22010-04-07 16:48:40 +02003558 trace_api_cqm_rssi_notify(sdata, rssi_event);
3559
Juuso Oikarinena97c13c2010-03-23 09:02:34 +02003560 cfg80211_cqm_rssi_notify(sdata->dev, rssi_event, gfp);
3561}
3562EXPORT_SYMBOL(ieee80211_cqm_rssi_notify);
Eliad Peller1d34d102011-06-06 12:59:29 +03003563
3564unsigned char ieee80211_get_operstate(struct ieee80211_vif *vif)
3565{
3566 struct ieee80211_sub_if_data *sdata = vif_to_sdata(vif);
3567 return sdata->dev->operstate;
3568}
3569EXPORT_SYMBOL(ieee80211_get_operstate);