projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
rtlwifi: rtl8821ae: Make sure loop counter is signed on all architectures
[deliverable/linux.git] / drivers / net / wireless / broadcom / brcm80211 / brcmfmac / cfg80211.c
CommitLineData
5b435de0
AS		 1/*
2 * Copyright (c) 2010 Broadcom Corporation
3 *
4 * Permission to use, copy, modify, and/or distribute this software for any
5 * purpose with or without fee is hereby granted, provided that the above
6 * copyright notice and this permission notice appear in all copies.
7 *
8 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
9 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
10 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
11 * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
12 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
13 * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
14 * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
15 */
16
17/* Toplevel file. Relies on dhd_linux.c to send commands to the dongle. */
18
19#include <linux/kernel.h>
5b435de0 20#include <linux/etherdevice.h>
68ca395f 21#include <linux/module.h>
1bacb048 22#include <linux/vmalloc.h>
5b435de0 23#include <net/cfg80211.h>
cbaa177d 24#include <net/netlink.h>
5b435de0
AS		 25
26#include <brcmu_utils.h>
27#include <defs.h>
28#include <brcmu_wifi.h>
122d3d04 29#include "core.h"
a8e8ed34 30#include "debug.h"
40c1c249 31#include "tracepoint.h"
7a5c1f64 32#include "fwil_types.h"
9f440b7b 33#include "p2p.h"
61730d4d 34#include "btcoex.h"
bfe81975 35#include "cfg80211.h"
c08437b4 36#include "feature.h"
81f5dcb8 37#include "fwil.h"
8851cce0 38#include "proto.h"
1bacb048 39#include "vendor.h"
d14f78b9 40#include "bus.h"
6b89dcb3 41#include "common.h"
5b435de0 42
e5806072
AS		 43#define BRCMF_SCAN_IE_LEN_MAX 2048
44#define BRCMF_PNO_VERSION 2
45#define BRCMF_PNO_TIME 30
46#define BRCMF_PNO_REPEAT 4
47#define BRCMF_PNO_FREQ_EXPO_MAX 3
48#define BRCMF_PNO_MAX_PFN_COUNT 16
49#define BRCMF_PNO_ENABLE_ADAPTSCAN_BIT 6
50#define BRCMF_PNO_HIDDEN_BIT 2
51#define BRCMF_PNO_WPA_AUTH_ANY 0xFFFFFFFF
52#define BRCMF_PNO_SCAN_COMPLETE 1
53#define BRCMF_PNO_SCAN_INCOMPLETE 0
54
1a873342
HM		 55#define WPA_OUI "\x00\x50\xF2" /* WPA OUI */
56#define WPA_OUI_TYPE 1
57#define RSN_OUI "\x00\x0F\xAC" /* RSN OUI */
58#define WME_OUI_TYPE 2
89286dc9 59#define WPS_OUI_TYPE 4
1a873342
HM		 60
61#define VS_IE_FIXED_HDR_LEN 6
62#define WPA_IE_VERSION_LEN 2
63#define WPA_IE_MIN_OUI_LEN 4
64#define WPA_IE_SUITE_COUNT_LEN 2
65
66#define WPA_CIPHER_NONE 0 /* None */
67#define WPA_CIPHER_WEP_40 1 /* WEP (40-bit) */
68#define WPA_CIPHER_TKIP 2 /* TKIP: default for WPA */
69#define WPA_CIPHER_AES_CCM 4 /* AES (CCM) */
70#define WPA_CIPHER_WEP_104 5 /* WEP (104-bit) */
71
72#define RSN_AKM_NONE 0 /* None (IBSS) */
73#define RSN_AKM_UNSPECIFIED 1 /* Over 802.1x */
74#define RSN_AKM_PSK 2 /* Pre-shared Key */
240d61a9
HM		 75#define RSN_AKM_SHA256_1X 5 /* SHA256, 802.1X */
76#define RSN_AKM_SHA256_PSK 6 /* SHA256, Pre-shared Key */
1a873342 77#define RSN_CAP_LEN 2 /* Length of RSN capabilities */
240d61a9
HM		 78#define RSN_CAP_PTK_REPLAY_CNTR_MASK (BIT(2) | BIT(3))
79#define RSN_CAP_MFPR_MASK BIT(6)
80#define RSN_CAP_MFPC_MASK BIT(7)
81#define RSN_PMKID_COUNT_LEN 2
1a873342
HM		 82
83#define VNDR_IE_CMD_LEN 4 /* length of the set command
84 * string :"add", "del" (+ NUL)
85 */
86#define VNDR_IE_COUNT_OFFSET 4
87#define VNDR_IE_PKTFLAG_OFFSET 8
88#define VNDR_IE_VSIE_OFFSET 12
89#define VNDR_IE_HDR_SIZE 12
9f440b7b 90#define VNDR_IE_PARSE_LIMIT 5
1a873342
HM		 91
92#define DOT11_MGMT_HDR_LEN 24 /* d11 management header len */
93#define DOT11_BCN_PRB_FIXED_LEN 12 /* beacon/probe fixed length */
04012895 94
89286dc9
HM		 95#define BRCMF_SCAN_JOIN_ACTIVE_DWELL_TIME_MS 320
96#define BRCMF_SCAN_JOIN_PASSIVE_DWELL_TIME_MS 400
97#define BRCMF_SCAN_JOIN_PROBE_INTERVAL_MS 20
98
1678ba8e
HM		 99#define BRCMF_SCAN_CHANNEL_TIME 40
100#define BRCMF_SCAN_UNASSOC_TIME 40
101#define BRCMF_SCAN_PASSIVE_TIME 120
102
3021ad9a
HM		 103#define BRCMF_ND_INFO_TIMEOUT msecs_to_jiffies(2000)
104
5b435de0
AS		 105#define BRCMF_ASSOC_PARAMS_FIXED_SIZE \
106 (sizeof(struct brcmf_assoc_params_le) - sizeof(u16))
107
ce81e317 108static bool check_vif_up(struct brcmf_cfg80211_vif *vif)
5b435de0 109{
c1179033 110 if (!test_bit(BRCMF_VIF_STATUS_READY, &vif->sme_state)) {
647c9ae0
AS		 111 brcmf_dbg(INFO, "device is not ready : status (%lu)\n",
112 vif->sme_state);
5b435de0
AS		 113 return false;
114 }
115 return true;
116}
117
5b435de0
AS		 118#define RATE_TO_BASE100KBPS(rate) (((rate) * 10) / 2)
119#define RATETAB_ENT(_rateid, _flags) \
120 { \
121 .bitrate = RATE_TO_BASE100KBPS(_rateid), \
122 .hw_value = (_rateid), \
123 .flags = (_flags), \
124 }
125
126static struct ieee80211_rate __wl_rates[] = {
127 RATETAB_ENT(BRCM_RATE_1M, 0),
128 RATETAB_ENT(BRCM_RATE_2M, IEEE80211_RATE_SHORT_PREAMBLE),
129 RATETAB_ENT(BRCM_RATE_5M5, IEEE80211_RATE_SHORT_PREAMBLE),
130 RATETAB_ENT(BRCM_RATE_11M, IEEE80211_RATE_SHORT_PREAMBLE),
131 RATETAB_ENT(BRCM_RATE_6M, 0),
132 RATETAB_ENT(BRCM_RATE_9M, 0),
133 RATETAB_ENT(BRCM_RATE_12M, 0),
134 RATETAB_ENT(BRCM_RATE_18M, 0),
135 RATETAB_ENT(BRCM_RATE_24M, 0),
136 RATETAB_ENT(BRCM_RATE_36M, 0),
137 RATETAB_ENT(BRCM_RATE_48M, 0),
138 RATETAB_ENT(BRCM_RATE_54M, 0),
139};
140
5b435de0 141#define wl_g_rates (__wl_rates + 0)
58de92d2
AS		 142#define wl_g_rates_size ARRAY_SIZE(__wl_rates)
143#define wl_a_rates (__wl_rates + 4)
144#define wl_a_rates_size (wl_g_rates_size - 4)
145
146#define CHAN2G(_channel, _freq) { \
57fbcce3 147 .band = NL80211_BAND_2GHZ, \
58de92d2
AS		 148 .center_freq = (_freq), \
149 .hw_value = (_channel), \
150 .flags = IEEE80211_CHAN_DISABLED, \
151 .max_antenna_gain = 0, \
152 .max_power = 30, \
153}
154
155#define CHAN5G(_channel) { \
57fbcce3 156 .band = NL80211_BAND_5GHZ, \
58de92d2
AS		 157 .center_freq = 5000 + (5 * (_channel)), \
158 .hw_value = (_channel), \
159 .flags = IEEE80211_CHAN_DISABLED, \
160 .max_antenna_gain = 0, \
161 .max_power = 30, \
162}
163
164static struct ieee80211_channel __wl_2ghz_channels[] = {
165 CHAN2G(1, 2412), CHAN2G(2, 2417), CHAN2G(3, 2422), CHAN2G(4, 2427),
166 CHAN2G(5, 2432), CHAN2G(6, 2437), CHAN2G(7, 2442), CHAN2G(8, 2447),
167 CHAN2G(9, 2452), CHAN2G(10, 2457), CHAN2G(11, 2462), CHAN2G(12, 2467),
168 CHAN2G(13, 2472), CHAN2G(14, 2484)
169};
170
171static struct ieee80211_channel __wl_5ghz_channels[] = {
172 CHAN5G(34), CHAN5G(36), CHAN5G(38), CHAN5G(40), CHAN5G(42),
173 CHAN5G(44), CHAN5G(46), CHAN5G(48), CHAN5G(52), CHAN5G(56),
174 CHAN5G(60), CHAN5G(64), CHAN5G(100), CHAN5G(104), CHAN5G(108),
175 CHAN5G(112), CHAN5G(116), CHAN5G(120), CHAN5G(124), CHAN5G(128),
176 CHAN5G(132), CHAN5G(136), CHAN5G(140), CHAN5G(144), CHAN5G(149),
177 CHAN5G(153), CHAN5G(157), CHAN5G(161), CHAN5G(165)
178};
5b435de0 179
b48d8916 180/* Band templates duplicated per wiphy. The channel info
58de92d2 181 * above is added to the band during setup.
b48d8916
AS		 182 */
183static const struct ieee80211_supported_band __wl_band_2ghz = {
57fbcce3 184 .band = NL80211_BAND_2GHZ,
5b435de0
AS		 185 .bitrates = wl_g_rates,
186 .n_bitrates = wl_g_rates_size,
187};
188
58de92d2 189static const struct ieee80211_supported_band __wl_band_5ghz = {
57fbcce3 190 .band = NL80211_BAND_5GHZ,
5b435de0
AS		 191 .bitrates = wl_a_rates,
192 .n_bitrates = wl_a_rates_size,
193};
194
d48200ba
HM		 195/* This is to override regulatory domains defined in cfg80211 module (reg.c)
196 * By default world regulatory domain defined in reg.c puts the flags
8fe02e16
LR		 197 * NL80211_RRF_NO_IR for 5GHz channels (for * 36..48 and 149..165).
198 * With respect to these flags, wpa_supplicant doesn't * start p2p
199 * operations on 5GHz channels. All the changes in world regulatory
d48200ba
HM		 200 * domain are to be done here.
201 */
202static const struct ieee80211_regdomain brcmf_regdom = {
203 .n_reg_rules = 4,
204 .alpha2 = "99",
205 .reg_rules = {
206 /* IEEE 802.11b/g, channels 1..11 */
207 REG_RULE(2412-10, 2472+10, 40, 6, 20, 0),
208 /* If any */
209 /* IEEE 802.11 channel 14 - Only JP enables
210 * this and for 802.11b only
211 */
212 REG_RULE(2484-10, 2484+10, 20, 6, 20, 0),
213 /* IEEE 802.11a, channel 36..64 */
c555ecde 214 REG_RULE(5150-10, 5350+10, 80, 6, 20, 0),
d48200ba 215 /* IEEE 802.11a, channel 100..165 */
c555ecde 216 REG_RULE(5470-10, 5850+10, 80, 6, 20, 0), }
5b435de0
AS		 217};
218
240d61a9
HM		 219/* Note: brcmf_cipher_suites is an array of int defining which cipher suites
220 * are supported. A pointer to this array and the number of entries is passed
221 * on to upper layers. AES_CMAC defines whether or not the driver supports MFP.
222 * So the cipher suite AES_CMAC has to be the last one in the array, and when
223 * device does not support MFP then the number of suites will be decreased by 1
224 */
225static const u32 brcmf_cipher_suites[] = {
5b435de0
AS		 226 WLAN_CIPHER_SUITE_WEP40,
227 WLAN_CIPHER_SUITE_WEP104,
228 WLAN_CIPHER_SUITE_TKIP,
229 WLAN_CIPHER_SUITE_CCMP,
240d61a9
HM		 230 /* Keep as last entry: */
231 WLAN_CIPHER_SUITE_AES_CMAC
5b435de0
AS		 232};
233
1a873342
HM		 234/* Vendor specific ie. id = 221, oui and type defines exact ie */
235struct brcmf_vs_tlv {
236 u8 id;
237 u8 len;
238 u8 oui[3];
239 u8 oui_type;
240};
241
242struct parsed_vndr_ie_info {
243 u8 *ie_ptr;
244 u32 ie_len; /* total length including id & length field */
245 struct brcmf_vs_tlv vndrie;
246};
247
248struct parsed_vndr_ies {
249 u32 count;
9f440b7b 250 struct parsed_vndr_ie_info ie_info[VNDR_IE_PARSE_LIMIT];
1a873342
HM		 251};
252
5a394eba
AS		 253static u16 chandef_to_chanspec(struct brcmu_d11inf *d11inf,
254 struct cfg80211_chan_def *ch)
600a897d
AS		 255{
256 struct brcmu_chan ch_inf;
257 s32 primary_offset;
258
259 brcmf_dbg(TRACE, "chandef: control %d center %d width %d\n",
260 ch->chan->center_freq, ch->center_freq1, ch->width);
261 ch_inf.chnum = ieee80211_frequency_to_channel(ch->center_freq1);
36e8072e 262 primary_offset = ch->chan->center_freq - ch->center_freq1;
600a897d
AS		 263 switch (ch->width) {
264 case NL80211_CHAN_WIDTH_20:
0cd75b19 265 case NL80211_CHAN_WIDTH_20_NOHT:
600a897d
AS		 266 ch_inf.bw = BRCMU_CHAN_BW_20;
267 WARN_ON(primary_offset != 0);
268 break;
269 case NL80211_CHAN_WIDTH_40:
270 ch_inf.bw = BRCMU_CHAN_BW_40;
36e8072e 271 if (primary_offset > 0)
600a897d
AS		 272 ch_inf.sb = BRCMU_CHAN_SB_U;
273 else
274 ch_inf.sb = BRCMU_CHAN_SB_L;
275 break;
276 case NL80211_CHAN_WIDTH_80:
277 ch_inf.bw = BRCMU_CHAN_BW_80;
36e8072e
RM		 278 if (primary_offset == -30)
279 ch_inf.sb = BRCMU_CHAN_SB_LL;
280 else if (primary_offset == -10)
281 ch_inf.sb = BRCMU_CHAN_SB_LU;
282 else if (primary_offset == 10)
283 ch_inf.sb = BRCMU_CHAN_SB_UL;
284 else
285 ch_inf.sb = BRCMU_CHAN_SB_UU;
600a897d 286 break;
0cd75b19
AS		 287 case NL80211_CHAN_WIDTH_80P80:
288 case NL80211_CHAN_WIDTH_160:
289 case NL80211_CHAN_WIDTH_5:
290 case NL80211_CHAN_WIDTH_10:
600a897d
AS		 291 default:
292 WARN_ON_ONCE(1);
293 }
294 switch (ch->chan->band) {
57fbcce3 295 case NL80211_BAND_2GHZ:
600a897d
AS		 296 ch_inf.band = BRCMU_CHAN_BAND_2G;
297 break;
57fbcce3 298 case NL80211_BAND_5GHZ:
600a897d
AS		 299 ch_inf.band = BRCMU_CHAN_BAND_5G;
300 break;
57fbcce3 301 case NL80211_BAND_60GHZ:
600a897d
AS		 302 default:
303 WARN_ON_ONCE(1);
304 }
305 d11inf->encchspec(&ch_inf);
306
307 return ch_inf.chspec;
308}
309
83cf17aa
FL		 310u16 channel_to_chanspec(struct brcmu_d11inf *d11inf,
311 struct ieee80211_channel *ch)
6e186166 312{
83cf17aa 313 struct brcmu_chan ch_inf;
6e186166 314
83cf17aa
FL		 315 ch_inf.chnum = ieee80211_frequency_to_channel(ch->center_freq);
316 ch_inf.bw = BRCMU_CHAN_BW_20;
317 d11inf->encchspec(&ch_inf);
6e186166 318
83cf17aa 319 return ch_inf.chspec;
6e186166
AS		 320}
321
89286dc9
HM		 322/* Traverse a string of 1-byte tag/1-byte length/variable-length value
323 * triples, returning a pointer to the substring whose first element
324 * matches tag
325 */
4b5800fe
JB		 326const struct brcmf_tlv *
327brcmf_parse_tlvs(const void *buf, int buflen, uint key)
89286dc9 328{
4b5800fe
JB		 329 const struct brcmf_tlv *elt = buf;
330 int totlen = buflen;
89286dc9
HM		 331
332 /* find tagged parameter */
333 while (totlen >= TLV_HDR_LEN) {
334 int len = elt->len;
335
336 /* validate remaining totlen */
337 if ((elt->id == key) && (totlen >= (len + TLV_HDR_LEN)))
338 return elt;
339
340 elt = (struct brcmf_tlv *)((u8 *)elt + (len + TLV_HDR_LEN));
341 totlen -= (len + TLV_HDR_LEN);
342 }
343
344 return NULL;
345}
346
347/* Is any of the tlvs the expected entry? If
348 * not update the tlvs buffer pointer/length.
349 */
350static bool
4b5800fe
JB		 351brcmf_tlv_has_ie(const u8 *ie, const u8 **tlvs, u32 *tlvs_len,
352 const u8 *oui, u32 oui_len, u8 type)
89286dc9
HM		 353{
354 /* If the contents match the OUI and the type */
355 if (ie[TLV_LEN_OFF] >= oui_len + 1 &&
356 !memcmp(&ie[TLV_BODY_OFF], oui, oui_len) &&
357 type == ie[TLV_BODY_OFF + oui_len]) {
358 return true;
359 }
360
361 if (tlvs == NULL)
362 return false;
363 /* point to the next ie */
364 ie += ie[TLV_LEN_OFF] + TLV_HDR_LEN;
365 /* calculate the length of the rest of the buffer */
366 *tlvs_len -= (int)(ie - *tlvs);
367 /* update the pointer to the start of the buffer */
368 *tlvs = ie;
369
370 return false;
371}
372
373static struct brcmf_vs_tlv *
4b5800fe 374brcmf_find_wpaie(const u8 *parse, u32 len)
89286dc9 375{
4b5800fe 376 const struct brcmf_tlv *ie;
89286dc9
HM		 377
378 while ((ie = brcmf_parse_tlvs(parse, len, WLAN_EID_VENDOR_SPECIFIC))) {
4b5800fe 379 if (brcmf_tlv_has_ie((const u8 *)ie, &parse, &len,
89286dc9
HM		 380 WPA_OUI, TLV_OUI_LEN, WPA_OUI_TYPE))
381 return (struct brcmf_vs_tlv *)ie;
382 }
383 return NULL;
384}
385
386static struct brcmf_vs_tlv *
4b5800fe 387brcmf_find_wpsie(const u8 *parse, u32 len)
89286dc9 388{
4b5800fe 389 const struct brcmf_tlv *ie;
89286dc9
HM		 390
391 while ((ie = brcmf_parse_tlvs(parse, len, WLAN_EID_VENDOR_SPECIFIC))) {
392 if (brcmf_tlv_has_ie((u8 *)ie, &parse, &len,
393 WPA_OUI, TLV_OUI_LEN, WPS_OUI_TYPE))
394 return (struct brcmf_vs_tlv *)ie;
395 }
396 return NULL;
397}
398
39504a2d
AS		 399static int brcmf_vif_change_validate(struct brcmf_cfg80211_info *cfg,
400 struct brcmf_cfg80211_vif *vif,
401 enum nl80211_iftype new_type)
402{
403 int iftype_num[NUM_NL80211_IFTYPES];
404 struct brcmf_cfg80211_vif *pos;
353c46ac
AS		 405 bool check_combos = false;
406 int ret = 0;
39504a2d
AS		 407
408 memset(&iftype_num[0], 0, sizeof(iftype_num));
409 list_for_each_entry(pos, &cfg->vif_list, list)
353c46ac 410 if (pos == vif) {
39504a2d 411 iftype_num[new_type]++;
353c46ac
AS		 412 } else {
413 /* concurrent interfaces so need check combinations */
414 check_combos = true;
39504a2d 415 iftype_num[pos->wdev.iftype]++;
353c46ac
AS		 416 }
417
418 if (check_combos)
419 ret = cfg80211_check_combinations(cfg->wiphy, 1, 0, iftype_num);
39504a2d 420
353c46ac 421 return ret;
39504a2d
AS		 422}
423
424static int brcmf_vif_add_validate(struct brcmf_cfg80211_info *cfg,
425 enum nl80211_iftype new_type)
426{
427 int iftype_num[NUM_NL80211_IFTYPES];
428 struct brcmf_cfg80211_vif *pos;
429
430 memset(&iftype_num[0], 0, sizeof(iftype_num));
431 list_for_each_entry(pos, &cfg->vif_list, list)
432 iftype_num[pos->wdev.iftype]++;
433
434 iftype_num[new_type]++;
435 return cfg80211_check_combinations(cfg->wiphy, 1, 0, iftype_num);
436}
89286dc9 437
5b435de0
AS		 438static void convert_key_from_CPU(struct brcmf_wsec_key *key,
439 struct brcmf_wsec_key_le *key_le)
440{
441 key_le->index = cpu_to_le32(key->index);
442 key_le->len = cpu_to_le32(key->len);
443 key_le->algo = cpu_to_le32(key->algo);
444 key_le->flags = cpu_to_le32(key->flags);
445 key_le->rxiv.hi = cpu_to_le32(key->rxiv.hi);
446 key_le->rxiv.lo = cpu_to_le16(key->rxiv.lo);
447 key_le->iv_initialized = cpu_to_le32(key->iv_initialized);
448 memcpy(key_le->data, key->data, sizeof(key->data));
449 memcpy(key_le->ea, key->ea, sizeof(key->ea));
450}
451
f09d0c02 452static int
118eb304 453send_key_to_dongle(struct brcmf_if *ifp, struct brcmf_wsec_key *key)
5b435de0
AS		 454{
455 int err;
456 struct brcmf_wsec_key_le key_le;
457
458 convert_key_from_CPU(key, &key_le);
f09d0c02 459
118eb304 460 brcmf_netdev_wait_pend8021x(ifp);
81f5dcb8 461
118eb304 462 err = brcmf_fil_bsscfg_data_set(ifp, "wsec_key", &key_le,
81f5dcb8 463 sizeof(key_le));
f09d0c02 464
5b435de0 465 if (err)
57d6e91a 466 brcmf_err("wsec_key error (%d)\n", err);
5b435de0
AS		 467 return err;
468}
469
b3657453 470static s32
52f22fb2 471brcmf_configure_arp_nd_offload(struct brcmf_if *ifp, bool enable)
b3657453
HM		 472{
473 s32 err;
474 u32 mode;
475
476 if (enable)
477 mode = BRCMF_ARP_OL_AGENT | BRCMF_ARP_OL_PEER_AUTO_REPLY;
478 else
479 mode = 0;
480
481 /* Try to set and enable ARP offload feature, this may fail, then it */
482 /* is simply not supported and err 0 will be returned */
483 err = brcmf_fil_iovar_int_set(ifp, "arp_ol", mode);
484 if (err) {
485 brcmf_dbg(TRACE, "failed to set ARP offload mode to 0x%x, err = %d\n",
486 mode, err);
487 err = 0;
488 } else {
489 err = brcmf_fil_iovar_int_set(ifp, "arpoe", enable);
490 if (err) {
491 brcmf_dbg(TRACE, "failed to configure (%d) ARP offload err = %d\n",
492 enable, err);
493 err = 0;
494 } else
495 brcmf_dbg(TRACE, "successfully configured (%d) ARP offload to 0x%x\n",
496 enable, mode);
497 }
498
52f22fb2
FL		 499 err = brcmf_fil_iovar_int_set(ifp, "ndoe", enable);
500 if (err) {
501 brcmf_dbg(TRACE, "failed to configure (%d) ND offload err = %d\n",
502 enable, err);
503 err = 0;
504 } else
505 brcmf_dbg(TRACE, "successfully configured (%d) ND offload to 0x%x\n",
506 enable, mode);
507
b3657453
HM		 508 return err;
509}
510
8851cce0
HM		 511static void
512brcmf_cfg80211_update_proto_addr_mode(struct wireless_dev *wdev)
513{
8f2b4597
AS		 514 struct brcmf_cfg80211_vif *vif;
515 struct brcmf_if *ifp;
516
517 vif = container_of(wdev, struct brcmf_cfg80211_vif, wdev);
518 ifp = vif->ifp;
8851cce0
HM		 519
520 if ((wdev->iftype == NL80211_IFTYPE_ADHOC) ||
521 (wdev->iftype == NL80211_IFTYPE_AP) ||
522 (wdev->iftype == NL80211_IFTYPE_P2P_GO))
523 brcmf_proto_configure_addr_mode(ifp->drvr, ifp->ifidx,
524 ADDR_DIRECT);
525 else
526 brcmf_proto_configure_addr_mode(ifp->drvr, ifp->ifidx,
527 ADDR_INDIRECT);
528}
529
a44aa400
HM		 530static int brcmf_cfg80211_request_ap_if(struct brcmf_if *ifp)
531{
532 struct brcmf_mbss_ssid_le mbss_ssid_le;
533 int bsscfgidx;
534 int err;
535
536 memset(&mbss_ssid_le, 0, sizeof(mbss_ssid_le));
537 bsscfgidx = brcmf_get_next_free_bsscfgidx(ifp->drvr);
538 if (bsscfgidx < 0)
539 return bsscfgidx;
540
541 mbss_ssid_le.bsscfgidx = cpu_to_le32(bsscfgidx);
542 mbss_ssid_le.SSID_len = cpu_to_le32(5);
543 sprintf(mbss_ssid_le.SSID, "ssid%d" , bsscfgidx);
544
545 err = brcmf_fil_bsscfg_data_set(ifp, "bsscfg:ssid", &mbss_ssid_le,
546 sizeof(mbss_ssid_le));
547 if (err < 0)
548 brcmf_err("setting ssid failed %d\n", err);
549
550 return err;
551}
552
553/**
554 * brcmf_ap_add_vif() - create a new AP virtual interface for multiple BSS
555 *
556 * @wiphy: wiphy device of new interface.
557 * @name: name of the new interface.
558 * @flags: not used.
559 * @params: contains mac address for AP device.
560 */
561static
562struct wireless_dev *brcmf_ap_add_vif(struct wiphy *wiphy, const char *name,
563 u32 *flags, struct vif_params *params)
564{
565 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy);
566 struct brcmf_if *ifp = netdev_priv(cfg_to_ndev(cfg));
567 struct brcmf_cfg80211_vif *vif;
568 int err;
569
570 if (brcmf_cfg80211_vif_event_armed(cfg))
571 return ERR_PTR(-EBUSY);
572
573 brcmf_dbg(INFO, "Adding vif \"%s\"\n", name);
574
575 vif = brcmf_alloc_vif(cfg, NL80211_IFTYPE_AP, false);
576 if (IS_ERR(vif))
577 return (struct wireless_dev *)vif;
578
579 brcmf_cfg80211_arm_vif_event(cfg, vif);
580
581 err = brcmf_cfg80211_request_ap_if(ifp);
582 if (err) {
583 brcmf_cfg80211_arm_vif_event(cfg, NULL);
584 goto fail;
585 }
586
587 /* wait for firmware event */
a9eb0c4b
AS		 588 err = brcmf_cfg80211_wait_vif_event(cfg, BRCMF_E_IF_ADD,
589 BRCMF_VIF_EVENT_TIMEOUT);
a44aa400
HM		 590 brcmf_cfg80211_arm_vif_event(cfg, NULL);
591 if (!err) {
592 brcmf_err("timeout occurred\n");
593 err = -EIO;
594 goto fail;
595 }
596
597 /* interface created in firmware */
598 ifp = vif->ifp;
599 if (!ifp) {
600 brcmf_err("no if pointer provided\n");
601 err = -ENOENT;
602 goto fail;
603 }
604
605 strncpy(ifp->ndev->name, name, sizeof(ifp->ndev->name) - 1);
606 err = brcmf_net_attach(ifp, true);
607 if (err) {
608 brcmf_err("Registering netdevice failed\n");
609 goto fail;
610 }
611
612 return &ifp->vif->wdev;
613
614fail:
615 brcmf_free_vif(vif);
616 return ERR_PTR(err);
617}
618
967fe2c8
AS		 619static bool brcmf_is_apmode(struct brcmf_cfg80211_vif *vif)
620{
621 enum nl80211_iftype iftype;
622
623 iftype = vif->wdev.iftype;
624 return iftype == NL80211_IFTYPE_AP || iftype == NL80211_IFTYPE_P2P_GO;
625}
626
627static bool brcmf_is_ibssmode(struct brcmf_cfg80211_vif *vif)
628{
629 return vif->wdev.iftype == NL80211_IFTYPE_ADHOC;
630}
631
9f440b7b
AS		 632static struct wireless_dev *brcmf_cfg80211_add_iface(struct wiphy *wiphy,
633 const char *name,
6bab2e19 634 unsigned char name_assign_type,
9f440b7b
AS		 635 enum nl80211_iftype type,
636 u32 *flags,
637 struct vif_params *params)
638{
8851cce0 639 struct wireless_dev *wdev;
39504a2d 640 int err;
8851cce0 641
9f440b7b 642 brcmf_dbg(TRACE, "enter: %s type %d\n", name, type);
39504a2d
AS		 643 err = brcmf_vif_add_validate(wiphy_to_cfg(wiphy), type);
644 if (err) {
645 brcmf_err("iface validation failed: err=%d\n", err);
646 return ERR_PTR(err);
647 }
9f440b7b
AS		 648 switch (type) {
649 case NL80211_IFTYPE_ADHOC:
650 case NL80211_IFTYPE_STATION:
9f440b7b
AS		 651 case NL80211_IFTYPE_AP_VLAN:
652 case NL80211_IFTYPE_WDS:
653 case NL80211_IFTYPE_MONITOR:
654 case NL80211_IFTYPE_MESH_POINT:
655 return ERR_PTR(-EOPNOTSUPP);
a44aa400
HM		 656 case NL80211_IFTYPE_AP:
657 wdev = brcmf_ap_add_vif(wiphy, name, flags, params);
658 if (!IS_ERR(wdev))
659 brcmf_cfg80211_update_proto_addr_mode(wdev);
660 return wdev;
9f440b7b
AS		 661 case NL80211_IFTYPE_P2P_CLIENT:
662 case NL80211_IFTYPE_P2P_GO:
27f10e38 663 case NL80211_IFTYPE_P2P_DEVICE:
6bab2e19 664 wdev = brcmf_p2p_add_vif(wiphy, name, name_assign_type, type, flags, params);
8851cce0
HM		 665 if (!IS_ERR(wdev))
666 brcmf_cfg80211_update_proto_addr_mode(wdev);
667 return wdev;
9f440b7b 668 case NL80211_IFTYPE_UNSPECIFIED:
9f440b7b
AS		 669 default:
670 return ERR_PTR(-EINVAL);
671 }
672}
673
5e787f75
DK		 674static void brcmf_scan_config_mpc(struct brcmf_if *ifp, int mpc)
675{
c08437b4 676 if (brcmf_feat_is_quirk_enabled(ifp, BRCMF_FEAT_QUIRK_NEED_MPC))
5e787f75
DK		 677 brcmf_set_mpc(ifp, mpc);
678}
679
f96aa07e 680void brcmf_set_mpc(struct brcmf_if *ifp, int mpc)
5f4f9f11 681{
5f4f9f11
AS		 682 s32 err = 0;
683
684 if (check_vif_up(ifp->vif)) {
685 err = brcmf_fil_iovar_int_set(ifp, "mpc", mpc);
686 if (err) {
687 brcmf_err("fail to set mpc\n");
688 return;
689 }
690 brcmf_dbg(INFO, "MPC : %d\n", mpc);
691 }
692}
693
a0f472ac
AS		 694s32 brcmf_notify_escan_complete(struct brcmf_cfg80211_info *cfg,
695 struct brcmf_if *ifp, bool aborted,
696 bool fw_abort)
5f4f9f11
AS		 697{
698 struct brcmf_scan_params_le params_le;
699 struct cfg80211_scan_request *scan_request;
700 s32 err = 0;
701
702 brcmf_dbg(SCAN, "Enter\n");
703
704 /* clear scan request, because the FW abort can cause a second call */
705 /* to this functon and might cause a double cfg80211_scan_done */
706 scan_request = cfg->scan_request;
707 cfg->scan_request = NULL;
708
709 if (timer_pending(&cfg->escan_timeout))
710 del_timer_sync(&cfg->escan_timeout);
711
712 if (fw_abort) {
713 /* Do a scan abort to stop the driver's scan engine */
714 brcmf_dbg(SCAN, "ABORT scan in firmware\n");
715 memset(&params_le, 0, sizeof(params_le));
93803b33 716 eth_broadcast_addr(params_le.bssid);
5f4f9f11
AS		 717 params_le.bss_type = DOT11_BSSTYPE_ANY;
718 params_le.scan_type = 0;
719 params_le.channel_num = cpu_to_le32(1);
720 params_le.nprobes = cpu_to_le32(1);
721 params_le.active_time = cpu_to_le32(-1);
722 params_le.passive_time = cpu_to_le32(-1);
723 params_le.home_time = cpu_to_le32(-1);
724 /* Scan is aborted by setting channel_list[0] to -1 */
725 params_le.channel_list[0] = cpu_to_le16(-1);
726 /* E-Scan (or anyother type) can be aborted by SCAN */
f96aa07e 727 err = brcmf_fil_cmd_data_set(ifp, BRCMF_C_SCAN,
5f4f9f11
AS		 728 &params_le, sizeof(params_le));
729 if (err)
730 brcmf_err("Scan abort failed\n");
731 }
0f0fe990 732
5e787f75 733 brcmf_scan_config_mpc(ifp, 1);
0f0fe990 734
5f4f9f11
AS		 735 /*
736 * e-scan can be initiated by scheduled scan
737 * which takes precedence.
738 */
739 if (cfg->sched_escan) {
740 brcmf_dbg(SCAN, "scheduled scan completed\n");
741 cfg->sched_escan = false;
742 if (!aborted)
743 cfg80211_sched_scan_results(cfg_to_wiphy(cfg));
5f4f9f11
AS		 744 } else if (scan_request) {
745 brcmf_dbg(SCAN, "ESCAN Completed scan: %s\n",
746 aborted ? "Aborted" : "Done");
747 cfg80211_scan_done(scan_request, aborted);
5f4f9f11 748 }
6eda4e2c
HM		 749 if (!test_and_clear_bit(BRCMF_SCAN_STATUS_BUSY, &cfg->scan_status))
750 brcmf_dbg(SCAN, "Scan complete, probably P2P scan\n");
5f4f9f11
AS		 751
752 return err;
753}
754
9f440b7b
AS		 755static
756int brcmf_cfg80211_del_iface(struct wiphy *wiphy, struct wireless_dev *wdev)
757{
5f4f9f11
AS		 758 struct brcmf_cfg80211_info *cfg = wiphy_priv(wiphy);
759 struct net_device *ndev = wdev->netdev;
760
761 /* vif event pending in firmware */
762 if (brcmf_cfg80211_vif_event_armed(cfg))
763 return -EBUSY;
764
765 if (ndev) {
766 if (test_bit(BRCMF_SCAN_STATUS_BUSY, &cfg->scan_status) &&
a0f472ac
AS		 767 cfg->escan_info.ifp == netdev_priv(ndev))
768 brcmf_notify_escan_complete(cfg, netdev_priv(ndev),
769 true, true);
5f4f9f11
AS		 770
771 brcmf_fil_iovar_int_set(netdev_priv(ndev), "mpc", 1);
772 }
773
9f440b7b
AS		 774 switch (wdev->iftype) {
775 case NL80211_IFTYPE_ADHOC:
776 case NL80211_IFTYPE_STATION:
777 case NL80211_IFTYPE_AP:
778 case NL80211_IFTYPE_AP_VLAN:
779 case NL80211_IFTYPE_WDS:
780 case NL80211_IFTYPE_MONITOR:
781 case NL80211_IFTYPE_MESH_POINT:
782 return -EOPNOTSUPP;
783 case NL80211_IFTYPE_P2P_CLIENT:
784 case NL80211_IFTYPE_P2P_GO:
27f10e38 785 case NL80211_IFTYPE_P2P_DEVICE:
9f440b7b
AS		 786 return brcmf_p2p_del_vif(wiphy, wdev);
787 case NL80211_IFTYPE_UNSPECIFIED:
9f440b7b
AS		 788 default:
789 return -EINVAL;
790 }
791 return -EOPNOTSUPP;
792}
793
5b435de0
AS		 794static s32
795brcmf_cfg80211_change_iface(struct wiphy *wiphy, struct net_device *ndev,
796 enum nl80211_iftype type, u32 *flags,
797 struct vif_params *params)
798{
7a5c1f64 799 struct brcmf_cfg80211_info *cfg = wiphy_priv(wiphy);
c1179033 800 struct brcmf_if *ifp = netdev_priv(ndev);
128ce3b6 801 struct brcmf_cfg80211_vif *vif = ifp->vif;
5b435de0 802 s32 infra = 0;
1a873342 803 s32 ap = 0;
5b435de0
AS		 804 s32 err = 0;
805
37a869ec
HM		 806 brcmf_dbg(TRACE, "Enter, bsscfgidx=%d, type=%d\n", ifp->bsscfgidx,
807 type);
178e9ef9
HM		 808
809 /* WAR: There are a number of p2p interface related problems which
810 * need to be handled initially (before doing the validate).
811 * wpa_supplicant tends to do iface changes on p2p device/client/go
812 * which are not always possible/allowed. However we need to return
813 * OK otherwise the wpa_supplicant wont start. The situation differs
814 * on configuration and setup (p2pon=1 module param). The first check
815 * is to see if the request is a change to station for p2p iface.
816 */
817 if ((type == NL80211_IFTYPE_STATION) &&
818 ((vif->wdev.iftype == NL80211_IFTYPE_P2P_CLIENT) ||
819 (vif->wdev.iftype == NL80211_IFTYPE_P2P_GO) ||
820 (vif->wdev.iftype == NL80211_IFTYPE_P2P_DEVICE))) {
821 brcmf_dbg(TRACE, "Ignoring cmd for p2p if\n");
822 /* Now depending on whether module param p2pon=1 was used the
823 * response needs to be either 0 or EOPNOTSUPP. The reason is
824 * that if p2pon=1 is used, but a newer supplicant is used then
825 * we should return an error, as this combination wont work.
826 * In other situations 0 is returned and supplicant will start
827 * normally. It will give a trace in cfg80211, but it is the
828 * only way to get it working. Unfortunately this will result
829 * in situation where we wont support new supplicant in
830 * combination with module param p2pon=1, but that is the way
831 * it is. If the user tries this then unloading of driver might
832 * fail/lock.
833 */
834 if (cfg->p2p.p2pdev_dynamically)
835 return -EOPNOTSUPP;
836 else
837 return 0;
838 }
39504a2d
AS		 839 err = brcmf_vif_change_validate(wiphy_to_cfg(wiphy), vif, type);
840 if (err) {
841 brcmf_err("iface validation failed: err=%d\n", err);
842 return err;
843 }
5b435de0
AS		 844 switch (type) {
845 case NL80211_IFTYPE_MONITOR:
846 case NL80211_IFTYPE_WDS:
57d6e91a
AS		 847 brcmf_err("type (%d) : currently we do not support this type\n",
848 type);
5b435de0
AS		 849 return -EOPNOTSUPP;
850 case NL80211_IFTYPE_ADHOC:
5b435de0
AS		 851 infra = 0;
852 break;
853 case NL80211_IFTYPE_STATION:
5b435de0
AS		 854 infra = 1;
855 break;
1a873342 856 case NL80211_IFTYPE_AP:
7a5c1f64 857 case NL80211_IFTYPE_P2P_GO:
1a873342
HM		 858 ap = 1;
859 break;
5b435de0
AS		 860 default:
861 err = -EINVAL;
862 goto done;
863 }
864
1a873342 865 if (ap) {
7a5c1f64
HM		 866 if (type == NL80211_IFTYPE_P2P_GO) {
867 brcmf_dbg(INFO, "IF Type = P2P GO\n");
868 err = brcmf_p2p_ifchange(cfg, BRCMF_FIL_P2P_IF_GO);
869 }
870 if (!err) {
7a5c1f64
HM		 871 brcmf_dbg(INFO, "IF Type = AP\n");
872 }
5b435de0 873 } else {
128ce3b6 874 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_INFRA, infra);
1a873342 875 if (err) {
57d6e91a 876 brcmf_err("WLC_SET_INFRA error (%d)\n", err);
1a873342
HM		 877 err = -EAGAIN;
878 goto done;
879 }
967fe2c8 880 brcmf_dbg(INFO, "IF Type = %s\n", brcmf_is_ibssmode(vif) ?
647c9ae0 881 "Adhoc" : "Infra");
5b435de0 882 }
1a873342 883 ndev->ieee80211_ptr->iftype = type;
5b435de0 884
8851cce0
HM		 885 brcmf_cfg80211_update_proto_addr_mode(&vif->wdev);
886
5b435de0 887done:
d96b801f 888 brcmf_dbg(TRACE, "Exit\n");
5b435de0
AS		 889
890 return err;
891}
892
83cf17aa
FL		 893static void brcmf_escan_prep(struct brcmf_cfg80211_info *cfg,
894 struct brcmf_scan_params_le *params_le,
e756af5b
HM		 895 struct cfg80211_scan_request *request)
896{
897 u32 n_ssids;
898 u32 n_channels;
899 s32 i;
900 s32 offset;
029591f3 901 u16 chanspec;
e756af5b 902 char *ptr;
029591f3 903 struct brcmf_ssid_le ssid_le;
e756af5b 904
93803b33 905 eth_broadcast_addr(params_le->bssid);
e756af5b
HM		 906 params_le->bss_type = DOT11_BSSTYPE_ANY;
907 params_le->scan_type = 0;
908 params_le->channel_num = 0;
909 params_le->nprobes = cpu_to_le32(-1);
910 params_le->active_time = cpu_to_le32(-1);
911 params_le->passive_time = cpu_to_le32(-1);
912 params_le->home_time = cpu_to_le32(-1);
913 memset(&params_le->ssid_le, 0, sizeof(params_le->ssid_le));
914
915 /* if request is null exit so it will be all channel broadcast scan */
916 if (!request)
917 return;
918
919 n_ssids = request->n_ssids;
920 n_channels = request->n_channels;
921 /* Copy channel array if applicable */
4e8a008e
AS		 922 brcmf_dbg(SCAN, "### List of channelspecs to scan ### %d\n",
923 n_channels);
e756af5b
HM		 924 if (n_channels > 0) {
925 for (i = 0; i < n_channels; i++) {
83cf17aa
FL		 926 chanspec = channel_to_chanspec(&cfg->d11inf,
927 request->channels[i]);
4e8a008e
AS		 928 brcmf_dbg(SCAN, "Chan : %d, Channel spec: %x\n",
929 request->channels[i]->hw_value, chanspec);
029591f3 930 params_le->channel_list[i] = cpu_to_le16(chanspec);
e756af5b
HM		 931 }
932 } else {
4e8a008e 933 brcmf_dbg(SCAN, "Scanning all channels\n");
e756af5b
HM		 934 }
935 /* Copy ssid array if applicable */
4e8a008e 936 brcmf_dbg(SCAN, "### List of SSIDs to scan ### %d\n", n_ssids);
e756af5b
HM		 937 if (n_ssids > 0) {
938 offset = offsetof(struct brcmf_scan_params_le, channel_list) +
939 n_channels * sizeof(u16);
940 offset = roundup(offset, sizeof(u32));
941 ptr = (char *)params_le + offset;
942 for (i = 0; i < n_ssids; i++) {
029591f3
AS		 943 memset(&ssid_le, 0, sizeof(ssid_le));
944 ssid_le.SSID_len =
945 cpu_to_le32(request->ssids[i].ssid_len);
946 memcpy(ssid_le.SSID, request->ssids[i].ssid,
947 request->ssids[i].ssid_len);
948 if (!ssid_le.SSID_len)
4e8a008e 949 brcmf_dbg(SCAN, "%d: Broadcast scan\n", i);
e756af5b 950 else
4e8a008e
AS		 951 brcmf_dbg(SCAN, "%d: scan for %s size =%d\n",
952 i, ssid_le.SSID, ssid_le.SSID_len);
029591f3
AS		 953 memcpy(ptr, &ssid_le, sizeof(ssid_le));
954 ptr += sizeof(ssid_le);
e756af5b
HM		 955 }
956 } else {
4e8a008e 957 brcmf_dbg(SCAN, "Broadcast scan %p\n", request->ssids);
e756af5b 958 if ((request->ssids) && request->ssids->ssid_len) {
4e8a008e
AS		 959 brcmf_dbg(SCAN, "SSID %s len=%d\n",
960 params_le->ssid_le.SSID,
961 request->ssids->ssid_len);
e756af5b
HM		 962 params_le->ssid_le.SSID_len =
963 cpu_to_le32(request->ssids->ssid_len);
964 memcpy(&params_le->ssid_le.SSID, request->ssids->ssid,
965 request->ssids->ssid_len);
966 }
967 }
968 /* Adding mask to channel numbers */
969 params_le->channel_num =
970 cpu_to_le32((n_ssids << BRCMF_SCAN_PARAMS_NSSID_SHIFT) |
971 (n_channels & BRCMF_SCAN_PARAMS_COUNT_MASK));
972}
973
e756af5b 974static s32
a0f472ac 975brcmf_run_escan(struct brcmf_cfg80211_info *cfg, struct brcmf_if *ifp,
c4958106 976 struct cfg80211_scan_request *request)
e756af5b
HM		 977{
978 s32 params_size = BRCMF_SCAN_PARAMS_FIXED_SIZE +
979 offsetof(struct brcmf_escan_params_le, params_le);
980 struct brcmf_escan_params_le *params;
981 s32 err = 0;
982
4e8a008e 983 brcmf_dbg(SCAN, "E-SCAN START\n");
e756af5b
HM		 984
985 if (request != NULL) {
986 /* Allocate space for populating ssids in struct */
987 params_size += sizeof(u32) * ((request->n_channels + 1) / 2);
988
989 /* Allocate space for populating ssids in struct */
e9a6ca82 990 params_size += sizeof(struct brcmf_ssid_le) * request->n_ssids;
e756af5b
HM		 991 }
992
993 params = kzalloc(params_size, GFP_KERNEL);
994 if (!params) {
995 err = -ENOMEM;
996 goto exit;
997 }
998 BUG_ON(params_size + sizeof("escan") >= BRCMF_DCMD_MEDLEN);
83cf17aa 999 brcmf_escan_prep(cfg, &params->params_le, request);
e756af5b 1000 params->version = cpu_to_le32(BRCMF_ESCAN_REQ_VERSION);
c4958106 1001 params->action = cpu_to_le16(WL_ESCAN_ACTION_START);
e756af5b
HM		 1002 params->sync_id = cpu_to_le16(0x1234);
1003
a0f472ac 1004 err = brcmf_fil_iovar_data_set(ifp, "escan", params, params_size);
e756af5b
HM		 1005 if (err) {
1006 if (err == -EBUSY)
647c9ae0 1007 brcmf_dbg(INFO, "system busy : escan canceled\n");
e756af5b 1008 else
57d6e91a 1009 brcmf_err("error (%d)\n", err);
e756af5b
HM		 1010 }
1011
1012 kfree(params);
1013exit:
1014 return err;
1015}
1016
1017static s32
27a68fe3 1018brcmf_do_escan(struct brcmf_cfg80211_info *cfg, struct wiphy *wiphy,
a0f472ac 1019 struct brcmf_if *ifp, struct cfg80211_scan_request *request)
e756af5b
HM		 1020{
1021 s32 err;
81f5dcb8 1022 u32 passive_scan;
e756af5b 1023 struct brcmf_scan_results *results;
9f440b7b 1024 struct escan_info *escan = &cfg->escan_info;
e756af5b 1025
4e8a008e 1026 brcmf_dbg(SCAN, "Enter\n");
a0f472ac 1027 escan->ifp = ifp;
9f440b7b
AS		 1028 escan->wiphy = wiphy;
1029 escan->escan_state = WL_ESCAN_STATE_SCANNING;
81f5dcb8 1030 passive_scan = cfg->active_scan ? 0 : 1;
f96aa07e 1031 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_PASSIVE_SCAN,
81f5dcb8 1032 passive_scan);
e756af5b 1033 if (err) {
57d6e91a 1034 brcmf_err("error (%d)\n", err);
e756af5b
HM		 1035 return err;
1036 }
5e787f75 1037 brcmf_scan_config_mpc(ifp, 0);
27a68fe3 1038 results = (struct brcmf_scan_results *)cfg->escan_info.escan_buf;
e756af5b
HM		 1039 results->version = 0;
1040 results->count = 0;
1041 results->buflen = WL_ESCAN_RESULTS_FIXED_SIZE;
1042
c4958106 1043 err = escan->run(cfg, ifp, request);
e756af5b 1044 if (err)
5e787f75 1045 brcmf_scan_config_mpc(ifp, 1);
e756af5b
HM		 1046 return err;
1047}
1048
1049static s32
a0f472ac 1050brcmf_cfg80211_escan(struct wiphy *wiphy, struct brcmf_cfg80211_vif *vif,
e756af5b
HM		 1051 struct cfg80211_scan_request *request,
1052 struct cfg80211_ssid *this_ssid)
1053{
a0f472ac
AS		 1054 struct brcmf_if *ifp = vif->ifp;
1055 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy);
e756af5b 1056 struct cfg80211_ssid *ssids;
81f5dcb8 1057 u32 passive_scan;
e756af5b
HM		 1058 bool escan_req;
1059 bool spec_scan;
1060 s32 err;
675f5d82 1061 struct brcmf_ssid_le ssid_le;
e756af5b
HM		 1062 u32 SSID_len;
1063
4e8a008e 1064 brcmf_dbg(SCAN, "START ESCAN\n");
e756af5b 1065
c1179033 1066 if (test_bit(BRCMF_SCAN_STATUS_BUSY, &cfg->scan_status)) {
57d6e91a 1067 brcmf_err("Scanning already: status (%lu)\n", cfg->scan_status);
e756af5b
HM		 1068 return -EAGAIN;
1069 }
c1179033 1070 if (test_bit(BRCMF_SCAN_STATUS_ABORT, &cfg->scan_status)) {
57d6e91a
AS		 1071 brcmf_err("Scanning being aborted: status (%lu)\n",
1072 cfg->scan_status);
e756af5b
HM		 1073 return -EAGAIN;
1074 }
1687eee2
AS		 1075 if (test_bit(BRCMF_SCAN_STATUS_SUPPRESS, &cfg->scan_status)) {
1076 brcmf_err("Scanning suppressed: status (%lu)\n",
1077 cfg->scan_status);
1078 return -EAGAIN;
1079 }
c1179033 1080 if (test_bit(BRCMF_VIF_STATUS_CONNECTING, &ifp->vif->sme_state)) {
57d6e91a 1081 brcmf_err("Connecting: status (%lu)\n", ifp->vif->sme_state);
e756af5b
HM		 1082 return -EAGAIN;
1083 }
1084
0f8ffe17 1085 /* If scan req comes for p2p0, send it over primary I/F */
a0f472ac
AS		 1086 if (vif == cfg->p2p.bss_idx[P2PAPI_BSSCFG_DEVICE].vif)
1087 vif = cfg->p2p.bss_idx[P2PAPI_BSSCFG_PRIMARY].vif;
0f8ffe17 1088
e756af5b
HM		 1089 escan_req = false;
1090 if (request) {
1091 /* scan bss */
1092 ssids = request->ssids;
1093 escan_req = true;
1094 } else {
1095 /* scan in ibss */
1096 /* we don't do escan in ibss */
1097 ssids = this_ssid;
1098 }
1099
27a68fe3 1100 cfg->scan_request = request;
c1179033 1101 set_bit(BRCMF_SCAN_STATUS_BUSY, &cfg->scan_status);
e756af5b 1102 if (escan_req) {
9f440b7b 1103 cfg->escan_info.run = brcmf_run_escan;
a0f472ac 1104 err = brcmf_p2p_scan_prep(wiphy, request, vif);
9f440b7b
AS		 1105 if (err)
1106 goto scan_out;
1107
a0f472ac 1108 err = brcmf_do_escan(cfg, wiphy, vif->ifp, request);
2cb941c0 1109 if (err)
e756af5b
HM		 1110 goto scan_out;
1111 } else {
4e8a008e
AS		 1112 brcmf_dbg(SCAN, "ssid \"%s\", ssid_len (%d)\n",
1113 ssids->ssid, ssids->ssid_len);
675f5d82
HM		 1114 memset(&ssid_le, 0, sizeof(ssid_le));
1115 SSID_len = min_t(u8, sizeof(ssid_le.SSID), ssids->ssid_len);
1116 ssid_le.SSID_len = cpu_to_le32(0);
e756af5b
HM		 1117 spec_scan = false;
1118 if (SSID_len) {
675f5d82
HM		 1119 memcpy(ssid_le.SSID, ssids->ssid, SSID_len);
1120 ssid_le.SSID_len = cpu_to_le32(SSID_len);
e756af5b
HM		 1121 spec_scan = true;
1122 } else
4e8a008e 1123 brcmf_dbg(SCAN, "Broadcast scan\n");
e756af5b 1124
81f5dcb8 1125 passive_scan = cfg->active_scan ? 0 : 1;
c1179033 1126 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_PASSIVE_SCAN,
81f5dcb8 1127 passive_scan);
e756af5b 1128 if (err) {
57d6e91a 1129 brcmf_err("WLC_SET_PASSIVE_SCAN error (%d)\n", err);
e756af5b
HM		 1130 goto scan_out;
1131 }
5e787f75 1132 brcmf_scan_config_mpc(ifp, 0);
675f5d82
HM		 1133 err = brcmf_fil_cmd_data_set(ifp, BRCMF_C_SCAN, &ssid_le,
1134 sizeof(ssid_le));
e756af5b
HM		 1135 if (err) {
1136 if (err == -EBUSY)
647c9ae0 1137 brcmf_dbg(INFO, "BUSY: scan for \"%s\" canceled\n",
675f5d82 1138 ssid_le.SSID);
e756af5b 1139 else
57d6e91a 1140 brcmf_err("WLC_SCAN error (%d)\n", err);
e756af5b 1141
5e787f75 1142 brcmf_scan_config_mpc(ifp, 1);
e756af5b
HM		 1143 goto scan_out;
1144 }
1145 }
1146
661fa95d
HM		 1147 /* Arm scan timeout timer */
1148 mod_timer(&cfg->escan_timeout, jiffies +
d5367334 1149 BRCMF_ESCAN_TIMER_INTERVAL_MS * HZ / 1000);
661fa95d 1150
e756af5b
HM		 1151 return 0;
1152
1153scan_out:
c1179033 1154 clear_bit(BRCMF_SCAN_STATUS_BUSY, &cfg->scan_status);
27a68fe3 1155 cfg->scan_request = NULL;
e756af5b
HM		 1156 return err;
1157}
1158
5b435de0 1159static s32
0abb5f21 1160brcmf_cfg80211_scan(struct wiphy *wiphy, struct cfg80211_scan_request *request)
5b435de0 1161{
a0f472ac 1162 struct brcmf_cfg80211_vif *vif;
5b435de0
AS		 1163 s32 err = 0;
1164
d96b801f 1165 brcmf_dbg(TRACE, "Enter\n");
a0f472ac
AS		 1166 vif = container_of(request->wdev, struct brcmf_cfg80211_vif, wdev);
1167 if (!check_vif_up(vif))
5b435de0
AS		 1168 return -EIO;
1169
a0f472ac 1170 err = brcmf_cfg80211_escan(wiphy, vif, request, NULL);
e756af5b 1171
5b435de0 1172 if (err)
57d6e91a 1173 brcmf_err("scan error (%d)\n", err);
5b435de0 1174
d96b801f 1175 brcmf_dbg(TRACE, "Exit\n");
5b435de0
AS		 1176 return err;
1177}
1178
1179static s32 brcmf_set_rts(struct net_device *ndev, u32 rts_threshold)
1180{
1181 s32 err = 0;
1182
ac24be6f
AS		 1183 err = brcmf_fil_iovar_int_set(netdev_priv(ndev), "rtsthresh",
1184 rts_threshold);
5b435de0 1185 if (err)
57d6e91a 1186 brcmf_err("Error (%d)\n", err);
5b435de0
AS		 1187
1188 return err;
1189}
1190
1191static s32 brcmf_set_frag(struct net_device *ndev, u32 frag_threshold)
1192{
1193 s32 err = 0;
1194
ac24be6f
AS		 1195 err = brcmf_fil_iovar_int_set(netdev_priv(ndev), "fragthresh",
1196 frag_threshold);
5b435de0 1197 if (err)
57d6e91a 1198 brcmf_err("Error (%d)\n", err);
5b435de0
AS		 1199
1200 return err;
1201}
1202
1203static s32 brcmf_set_retry(struct net_device *ndev, u32 retry, bool l)
1204{
1205 s32 err = 0;
b87e2c48 1206 u32 cmd = (l ? BRCMF_C_SET_LRL : BRCMF_C_SET_SRL);
5b435de0 1207
ac24be6f 1208 err = brcmf_fil_cmd_int_set(netdev_priv(ndev), cmd, retry);
5b435de0 1209 if (err) {
57d6e91a 1210 brcmf_err("cmd (%d) , error (%d)\n", cmd, err);
5b435de0
AS		 1211 return err;
1212 }
1213 return err;
1214}
1215
1216static s32 brcmf_cfg80211_set_wiphy_params(struct wiphy *wiphy, u32 changed)
1217{
27a68fe3
AS		 1218 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy);
1219 struct net_device *ndev = cfg_to_ndev(cfg);
0abb5f21 1220 struct brcmf_if *ifp = netdev_priv(ndev);
5b435de0
AS		 1221 s32 err = 0;
1222
d96b801f 1223 brcmf_dbg(TRACE, "Enter\n");
ce81e317 1224 if (!check_vif_up(ifp->vif))
5b435de0
AS		 1225 return -EIO;
1226
1227 if (changed & WIPHY_PARAM_RTS_THRESHOLD &&
27a68fe3
AS		 1228 (cfg->conf->rts_threshold != wiphy->rts_threshold)) {
1229 cfg->conf->rts_threshold = wiphy->rts_threshold;
1230 err = brcmf_set_rts(ndev, cfg->conf->rts_threshold);
5b435de0
AS		 1231 if (!err)
1232 goto done;
1233 }
1234 if (changed & WIPHY_PARAM_FRAG_THRESHOLD &&
27a68fe3
AS		 1235 (cfg->conf->frag_threshold != wiphy->frag_threshold)) {
1236 cfg->conf->frag_threshold = wiphy->frag_threshold;
1237 err = brcmf_set_frag(ndev, cfg->conf->frag_threshold);
5b435de0
AS		 1238 if (!err)
1239 goto done;
1240 }
1241 if (changed & WIPHY_PARAM_RETRY_LONG
27a68fe3
AS		 1242 && (cfg->conf->retry_long != wiphy->retry_long)) {
1243 cfg->conf->retry_long = wiphy->retry_long;
1244 err = brcmf_set_retry(ndev, cfg->conf->retry_long, true);
5b435de0
AS		 1245 if (!err)
1246 goto done;
1247 }
1248 if (changed & WIPHY_PARAM_RETRY_SHORT
27a68fe3
AS		 1249 && (cfg->conf->retry_short != wiphy->retry_short)) {
1250 cfg->conf->retry_short = wiphy->retry_short;
1251 err = brcmf_set_retry(ndev, cfg->conf->retry_short, false);
5b435de0
AS		 1252 if (!err)
1253 goto done;
1254 }
1255
1256done:
d96b801f 1257 brcmf_dbg(TRACE, "Exit\n");
5b435de0
AS		 1258 return err;
1259}
1260
5b435de0
AS		 1261static void brcmf_init_prof(struct brcmf_cfg80211_profile *prof)
1262{
1263 memset(prof, 0, sizeof(*prof));
1264}
1265
9b7a0ddc
AS		 1266static u16 brcmf_map_fw_linkdown_reason(const struct brcmf_event_msg *e)
1267{
1268 u16 reason;
1269
1270 switch (e->event_code) {
1271 case BRCMF_E_DEAUTH:
1272 case BRCMF_E_DEAUTH_IND:
1273 case BRCMF_E_DISASSOC_IND:
1274 reason = e->reason;
1275 break;
1276 case BRCMF_E_LINK:
1277 default:
1278 reason = 0;
1279 break;
1280 }
1281 return reason;
1282}
1283
1284static void brcmf_link_down(struct brcmf_cfg80211_vif *vif, u16 reason)
5b435de0 1285{
61730d4d 1286 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(vif->wdev.wiphy);
5b435de0
AS		 1287 s32 err = 0;
1288
d96b801f 1289 brcmf_dbg(TRACE, "Enter\n");
5b435de0 1290
b0a79088 1291 if (test_and_clear_bit(BRCMF_VIF_STATUS_CONNECTED, &vif->sme_state)) {
647c9ae0 1292 brcmf_dbg(INFO, "Call WLC_DISASSOC to stop excess roaming\n ");
903e0eee 1293 err = brcmf_fil_cmd_data_set(vif->ifp,
ac24be6f 1294 BRCMF_C_DISASSOC, NULL, 0);
a538ae31 1295 if (err) {
57d6e91a 1296 brcmf_err("WLC_DISASSOC failed (%d)\n", err);
a538ae31 1297 }
b0a79088
HM		 1298 if ((vif->wdev.iftype == NL80211_IFTYPE_STATION) ||
1299 (vif->wdev.iftype == NL80211_IFTYPE_P2P_CLIENT))
1300 cfg80211_disconnected(vif->wdev.netdev, reason, NULL, 0,
1301 true, GFP_KERNEL);
5b435de0 1302 }
903e0eee 1303 clear_bit(BRCMF_VIF_STATUS_CONNECTING, &vif->sme_state);
61730d4d
PH		 1304 clear_bit(BRCMF_SCAN_STATUS_SUPPRESS, &cfg->scan_status);
1305 brcmf_btcoex_set_mode(vif, BRCMF_BTCOEX_ENABLED, 0);
d96b801f 1306 brcmf_dbg(TRACE, "Exit\n");
5b435de0
AS		 1307}
1308
1309static s32
1310brcmf_cfg80211_join_ibss(struct wiphy *wiphy, struct net_device *ndev,
1311 struct cfg80211_ibss_params *params)
1312{
27a68fe3 1313 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy);
0abb5f21
AS		 1314 struct brcmf_if *ifp = netdev_priv(ndev);
1315 struct brcmf_cfg80211_profile *profile = &ifp->vif->profile;
5b435de0
AS		 1316 struct brcmf_join_params join_params;
1317 size_t join_params_size = 0;
1318 s32 err = 0;
1319 s32 wsec = 0;
1320 s32 bcnprd;
1701261d 1321 u16 chanspec;
e9a6ca82 1322 u32 ssid_len;
5b435de0 1323
d96b801f 1324 brcmf_dbg(TRACE, "Enter\n");
ce81e317 1325 if (!check_vif_up(ifp->vif))
5b435de0
AS		 1326 return -EIO;
1327
1328 if (params->ssid)
16886735 1329 brcmf_dbg(CONN, "SSID: %s\n", params->ssid);
5b435de0 1330 else {
16886735 1331 brcmf_dbg(CONN, "SSID: NULL, Not supported\n");
5b435de0
AS		 1332 return -EOPNOTSUPP;
1333 }
1334
c1179033 1335 set_bit(BRCMF_VIF_STATUS_CONNECTING, &ifp->vif->sme_state);
5b435de0
AS		 1336
1337 if (params->bssid)
16886735 1338 brcmf_dbg(CONN, "BSSID: %pM\n", params->bssid);
5b435de0 1339 else
16886735 1340 brcmf_dbg(CONN, "No BSSID specified\n");
5b435de0 1341
683b6d3b 1342 if (params->chandef.chan)
16886735
AS		 1343 brcmf_dbg(CONN, "channel: %d\n",
1344 params->chandef.chan->center_freq);
5b435de0 1345 else
16886735 1346 brcmf_dbg(CONN, "no channel specified\n");
5b435de0
AS		 1347
1348 if (params->channel_fixed)
16886735 1349 brcmf_dbg(CONN, "fixed channel required\n");
5b435de0 1350 else
16886735 1351 brcmf_dbg(CONN, "no fixed channel required\n");
5b435de0
AS		 1352
1353 if (params->ie && params->ie_len)
16886735 1354 brcmf_dbg(CONN, "ie len: %d\n", params->ie_len);
5b435de0 1355 else
16886735 1356 brcmf_dbg(CONN, "no ie specified\n");
5b435de0
AS		 1357
1358 if (params->beacon_interval)
16886735
AS		 1359 brcmf_dbg(CONN, "beacon interval: %d\n",
1360 params->beacon_interval);
5b435de0 1361 else
16886735 1362 brcmf_dbg(CONN, "no beacon interval specified\n");
5b435de0
AS		 1363
1364 if (params->basic_rates)
16886735 1365 brcmf_dbg(CONN, "basic rates: %08X\n", params->basic_rates);
5b435de0 1366 else
16886735 1367 brcmf_dbg(CONN, "no basic rates specified\n");
5b435de0
AS		 1368
1369 if (params->privacy)
16886735 1370 brcmf_dbg(CONN, "privacy required\n");
5b435de0 1371 else
16886735 1372 brcmf_dbg(CONN, "no privacy required\n");
5b435de0
AS		 1373
1374 /* Configure Privacy for starter */
1375 if (params->privacy)
1376 wsec |= WEP_ENABLED;
1377
c1179033 1378 err = brcmf_fil_iovar_int_set(ifp, "wsec", wsec);
5b435de0 1379 if (err) {
57d6e91a 1380 brcmf_err("wsec failed (%d)\n", err);
5b435de0
AS		 1381 goto done;
1382 }
1383
1384 /* Configure Beacon Interval for starter */
1385 if (params->beacon_interval)
1386 bcnprd = params->beacon_interval;
1387 else
1388 bcnprd = 100;
1389
b87e2c48 1390 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_BCNPRD, bcnprd);
5b435de0 1391 if (err) {
57d6e91a 1392 brcmf_err("WLC_SET_BCNPRD failed (%d)\n", err);
5b435de0
AS		 1393 goto done;
1394 }
1395
1396 /* Configure required join parameter */
1397 memset(&join_params, 0, sizeof(struct brcmf_join_params));
1398
1399 /* SSID */
e9a6ca82
HM		 1400 ssid_len = min_t(u32, params->ssid_len, IEEE80211_MAX_SSID_LEN);
1401 memcpy(join_params.ssid_le.SSID, params->ssid, ssid_len);
1402 join_params.ssid_le.SSID_len = cpu_to_le32(ssid_len);
5b435de0 1403 join_params_size = sizeof(join_params.ssid_le);
5b435de0
AS		 1404
1405 /* BSSID */
1406 if (params->bssid) {
1407 memcpy(join_params.params_le.bssid, params->bssid, ETH_ALEN);
e9a6ca82 1408 join_params_size += BRCMF_ASSOC_PARAMS_FIXED_SIZE;
6c8c4f72 1409 memcpy(profile->bssid, params->bssid, ETH_ALEN);
5b435de0 1410 } else {
93803b33
JP		 1411 eth_broadcast_addr(join_params.params_le.bssid);
1412 eth_zero_addr(profile->bssid);
5b435de0
AS		 1413 }
1414
5b435de0 1415 /* Channel */
683b6d3b 1416 if (params->chandef.chan) {
5b435de0
AS		 1417 u32 target_channel;
1418
27a68fe3 1419 cfg->channel =
5b435de0 1420 ieee80211_frequency_to_channel(
683b6d3b 1421 params->chandef.chan->center_freq);
5b435de0
AS		 1422 if (params->channel_fixed) {
1423 /* adding chanspec */
600a897d
AS		 1424 chanspec = chandef_to_chanspec(&cfg->d11inf,
1425 &params->chandef);
1701261d
HM		 1426 join_params.params_le.chanspec_list[0] =
1427 cpu_to_le16(chanspec);
1428 join_params.params_le.chanspec_num = cpu_to_le32(1);
1429 join_params_size += sizeof(join_params.params_le);
5b435de0
AS		 1430 }
1431
1432 /* set channel for starter */
27a68fe3 1433 target_channel = cfg->channel;
b87e2c48 1434 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_CHANNEL,
81f5dcb8 1435 target_channel);
5b435de0 1436 if (err) {
57d6e91a 1437 brcmf_err("WLC_SET_CHANNEL failed (%d)\n", err);
5b435de0
AS		 1438 goto done;
1439 }
1440 } else
27a68fe3 1441 cfg->channel = 0;
5b435de0 1442
27a68fe3 1443 cfg->ibss_starter = false;
5b435de0
AS		 1444
1445
c1179033 1446 err = brcmf_fil_cmd_data_set(ifp, BRCMF_C_SET_SSID,
81f5dcb8 1447 &join_params, join_params_size);
5b435de0 1448 if (err) {
57d6e91a 1449 brcmf_err("WLC_SET_SSID failed (%d)\n", err);
5b435de0
AS		 1450 goto done;
1451 }
1452
1453done:
1454 if (err)
c1179033 1455 clear_bit(BRCMF_VIF_STATUS_CONNECTING, &ifp->vif->sme_state);
d96b801f 1456 brcmf_dbg(TRACE, "Exit\n");
5b435de0
AS		 1457 return err;
1458}
1459
1460static s32
1461brcmf_cfg80211_leave_ibss(struct wiphy *wiphy, struct net_device *ndev)
1462{
0abb5f21 1463 struct brcmf_if *ifp = netdev_priv(ndev);
5b435de0 1464
d96b801f 1465 brcmf_dbg(TRACE, "Enter\n");
6a98d64a
HM		 1466 if (!check_vif_up(ifp->vif)) {
1467 /* When driver is being unloaded, it can end up here. If an
1468 * error is returned then later on a debug trace in the wireless
1469 * core module will be printed. To avoid this 0 is returned.
1470 */
1471 return 0;
1472 }
5b435de0 1473
9b7a0ddc 1474 brcmf_link_down(ifp->vif, WLAN_REASON_DEAUTH_LEAVING);
42e0ed0d 1475 brcmf_net_setcarrier(ifp, false);
5b435de0 1476
d96b801f 1477 brcmf_dbg(TRACE, "Exit\n");
5b435de0 1478
12f32370 1479 return 0;
5b435de0
AS		 1480}
1481
1482static s32 brcmf_set_wpa_version(struct net_device *ndev,
1483 struct cfg80211_connect_params *sme)
1484{
6ac4f4ed 1485 struct brcmf_cfg80211_profile *profile = ndev_to_prof(ndev);
5b435de0
AS		 1486 struct brcmf_cfg80211_security *sec;
1487 s32 val = 0;
1488 s32 err = 0;
1489
1490 if (sme->crypto.wpa_versions & NL80211_WPA_VERSION_1)
1491 val = WPA_AUTH_PSK | WPA_AUTH_UNSPECIFIED;
1492 else if (sme->crypto.wpa_versions & NL80211_WPA_VERSION_2)
1493 val = WPA2_AUTH_PSK | WPA2_AUTH_UNSPECIFIED;
1494 else
1495 val = WPA_AUTH_DISABLED;
16886735 1496 brcmf_dbg(CONN, "setting wpa_auth to 0x%0x\n", val);
89286dc9 1497 err = brcmf_fil_bsscfg_int_set(netdev_priv(ndev), "wpa_auth", val);
5b435de0 1498 if (err) {
57d6e91a 1499 brcmf_err("set wpa_auth failed (%d)\n", err);
5b435de0
AS		 1500 return err;
1501 }
06bb123e 1502 sec = &profile->sec;
5b435de0
AS		 1503 sec->wpa_versions = sme->crypto.wpa_versions;
1504 return err;
1505}
1506
1507static s32 brcmf_set_auth_type(struct net_device *ndev,
1508 struct cfg80211_connect_params *sme)
1509{
6ac4f4ed 1510 struct brcmf_cfg80211_profile *profile = ndev_to_prof(ndev);
5b435de0
AS		 1511 struct brcmf_cfg80211_security *sec;
1512 s32 val = 0;
1513 s32 err = 0;
1514
1515 switch (sme->auth_type) {
1516 case NL80211_AUTHTYPE_OPEN_SYSTEM:
1517 val = 0;
16886735 1518 brcmf_dbg(CONN, "open system\n");
5b435de0
AS		 1519 break;
1520 case NL80211_AUTHTYPE_SHARED_KEY:
1521 val = 1;
16886735 1522 brcmf_dbg(CONN, "shared key\n");
5b435de0
AS		 1523 break;
1524 case NL80211_AUTHTYPE_AUTOMATIC:
1525 val = 2;
16886735 1526 brcmf_dbg(CONN, "automatic\n");
5b435de0
AS		 1527 break;
1528 case NL80211_AUTHTYPE_NETWORK_EAP:
16886735 1529 brcmf_dbg(CONN, "network eap\n");
5b435de0
AS		 1530 default:
1531 val = 2;
57d6e91a 1532 brcmf_err("invalid auth type (%d)\n", sme->auth_type);
5b435de0
AS		 1533 break;
1534 }
1535
89286dc9 1536 err = brcmf_fil_bsscfg_int_set(netdev_priv(ndev), "auth", val);
5b435de0 1537 if (err) {
57d6e91a 1538 brcmf_err("set auth failed (%d)\n", err);
5b435de0
AS		 1539 return err;
1540 }
06bb123e 1541 sec = &profile->sec;
5b435de0
AS		 1542 sec->auth_type = sme->auth_type;
1543 return err;
1544}
1545
1546static s32
87b7e9e2 1547brcmf_set_wsec_mode(struct net_device *ndev,
240d61a9 1548 struct cfg80211_connect_params *sme)
5b435de0 1549{
6ac4f4ed 1550 struct brcmf_cfg80211_profile *profile = ndev_to_prof(ndev);
5b435de0
AS		 1551 struct brcmf_cfg80211_security *sec;
1552 s32 pval = 0;
1553 s32 gval = 0;
87b7e9e2 1554 s32 wsec;
5b435de0
AS		 1555 s32 err = 0;
1556
1557 if (sme->crypto.n_ciphers_pairwise) {
1558 switch (sme->crypto.ciphers_pairwise[0]) {
1559 case WLAN_CIPHER_SUITE_WEP40:
1560 case WLAN_CIPHER_SUITE_WEP104:
1561 pval = WEP_ENABLED;
1562 break;
1563 case WLAN_CIPHER_SUITE_TKIP:
1564 pval = TKIP_ENABLED;
1565 break;
1566 case WLAN_CIPHER_SUITE_CCMP:
1567 pval = AES_ENABLED;
1568 break;
1569 case WLAN_CIPHER_SUITE_AES_CMAC:
1570 pval = AES_ENABLED;
1571 break;
1572 default:
57d6e91a
AS		 1573 brcmf_err("invalid cipher pairwise (%d)\n",
1574 sme->crypto.ciphers_pairwise[0]);
5b435de0
AS		 1575 return -EINVAL;
1576 }
1577 }
1578 if (sme->crypto.cipher_group) {
1579 switch (sme->crypto.cipher_group) {
1580 case WLAN_CIPHER_SUITE_WEP40:
1581 case WLAN_CIPHER_SUITE_WEP104:
1582 gval = WEP_ENABLED;
1583 break;
1584 case WLAN_CIPHER_SUITE_TKIP:
1585 gval = TKIP_ENABLED;
1586 break;
1587 case WLAN_CIPHER_SUITE_CCMP:
1588 gval = AES_ENABLED;
1589 break;
1590 case WLAN_CIPHER_SUITE_AES_CMAC:
1591 gval = AES_ENABLED;
1592 break;
1593 default:
57d6e91a
AS		 1594 brcmf_err("invalid cipher group (%d)\n",
1595 sme->crypto.cipher_group);
5b435de0
AS		 1596 return -EINVAL;
1597 }
1598 }
1599
16886735 1600 brcmf_dbg(CONN, "pval (%d) gval (%d)\n", pval, gval);
89286dc9
HM		 1601 /* In case of privacy, but no security and WPS then simulate */
1602 /* setting AES. WPS-2.0 allows no security */
1603 if (brcmf_find_wpsie(sme->ie, sme->ie_len) && !pval && !gval &&
1604 sme->privacy)
1605 pval = AES_ENABLED;
87b7e9e2 1606
240d61a9 1607 wsec = pval | gval;
87b7e9e2 1608 err = brcmf_fil_bsscfg_int_set(netdev_priv(ndev), "wsec", wsec);
5b435de0 1609 if (err) {
57d6e91a 1610 brcmf_err("error (%d)\n", err);
5b435de0
AS		 1611 return err;
1612 }
1613
06bb123e 1614 sec = &profile->sec;
5b435de0
AS		 1615 sec->cipher_pairwise = sme->crypto.ciphers_pairwise[0];
1616 sec->cipher_group = sme->crypto.cipher_group;
1617
1618 return err;
1619}
1620
1621static s32
1622brcmf_set_key_mgmt(struct net_device *ndev, struct cfg80211_connect_params *sme)
1623{
240d61a9
HM		 1624 struct brcmf_if *ifp = netdev_priv(ndev);
1625 s32 val;
1626 s32 err;
1627 const struct brcmf_tlv *rsn_ie;
1628 const u8 *ie;
1629 u32 ie_len;
1630 u32 offset;
1631 u16 rsn_cap;
1632 u32 mfp;
1633 u16 count;
5b435de0 1634
240d61a9
HM		 1635 if (!sme->crypto.n_akm_suites)
1636 return 0;
1637
1638 err = brcmf_fil_bsscfg_int_get(netdev_priv(ndev), "wpa_auth", &val);
1639 if (err) {
1640 brcmf_err("could not get wpa_auth (%d)\n", err);
1641 return err;
1642 }
1643 if (val & (WPA_AUTH_PSK | WPA_AUTH_UNSPECIFIED)) {
1644 switch (sme->crypto.akm_suites[0]) {
1645 case WLAN_AKM_SUITE_8021X:
1646 val = WPA_AUTH_UNSPECIFIED;
1647 break;
1648 case WLAN_AKM_SUITE_PSK:
1649 val = WPA_AUTH_PSK;
1650 break;
1651 default:
1652 brcmf_err("invalid cipher group (%d)\n",
1653 sme->crypto.cipher_group);
1654 return -EINVAL;
5b435de0 1655 }
240d61a9
HM		 1656 } else if (val & (WPA2_AUTH_PSK | WPA2_AUTH_UNSPECIFIED)) {
1657 switch (sme->crypto.akm_suites[0]) {
1658 case WLAN_AKM_SUITE_8021X:
1659 val = WPA2_AUTH_UNSPECIFIED;
1660 break;
1661 case WLAN_AKM_SUITE_8021X_SHA256:
1662 val = WPA2_AUTH_1X_SHA256;
1663 break;
1664 case WLAN_AKM_SUITE_PSK_SHA256:
1665 val = WPA2_AUTH_PSK_SHA256;
1666 break;
1667 case WLAN_AKM_SUITE_PSK:
1668 val = WPA2_AUTH_PSK;
1669 break;
1670 default:
1671 brcmf_err("invalid cipher group (%d)\n",
1672 sme->crypto.cipher_group);
1673 return -EINVAL;
5b435de0 1674 }
240d61a9 1675 }
5b435de0 1676
240d61a9
HM		 1677 if (!brcmf_feat_is_enabled(ifp, BRCMF_FEAT_MFP))
1678 goto skip_mfp_config;
1679 /* The MFP mode (1 or 2) needs to be determined, parse IEs. The
1680 * IE will not be verified, just a quick search for MFP config
1681 */
1682 rsn_ie = brcmf_parse_tlvs((const u8 *)sme->ie, sme->ie_len,
1683 WLAN_EID_RSN);
1684 if (!rsn_ie)
1685 goto skip_mfp_config;
1686 ie = (const u8 *)rsn_ie;
1687 ie_len = rsn_ie->len + TLV_HDR_LEN;
1688 /* Skip unicast suite */
1689 offset = TLV_HDR_LEN + WPA_IE_VERSION_LEN + WPA_IE_MIN_OUI_LEN;
1690 if (offset + WPA_IE_SUITE_COUNT_LEN >= ie_len)
1691 goto skip_mfp_config;
1692 /* Skip multicast suite */
1693 count = ie[offset] + (ie[offset + 1] << 8);
1694 offset += WPA_IE_SUITE_COUNT_LEN + (count * WPA_IE_MIN_OUI_LEN);
1695 if (offset + WPA_IE_SUITE_COUNT_LEN >= ie_len)
1696 goto skip_mfp_config;
1697 /* Skip auth key management suite(s) */
1698 count = ie[offset] + (ie[offset + 1] << 8);
1699 offset += WPA_IE_SUITE_COUNT_LEN + (count * WPA_IE_MIN_OUI_LEN);
1700 if (offset + WPA_IE_SUITE_COUNT_LEN > ie_len)
1701 goto skip_mfp_config;
1702 /* Ready to read capabilities */
1703 mfp = BRCMF_MFP_NONE;
1704 rsn_cap = ie[offset] + (ie[offset + 1] << 8);
1705 if (rsn_cap & RSN_CAP_MFPR_MASK)
1706 mfp = BRCMF_MFP_REQUIRED;
1707 else if (rsn_cap & RSN_CAP_MFPC_MASK)
1708 mfp = BRCMF_MFP_CAPABLE;
1709 brcmf_fil_bsscfg_int_set(netdev_priv(ndev), "mfp", mfp);
1710
1711skip_mfp_config:
1712 brcmf_dbg(CONN, "setting wpa_auth to %d\n", val);
1713 err = brcmf_fil_bsscfg_int_set(netdev_priv(ndev), "wpa_auth", val);
1714 if (err) {
1715 brcmf_err("could not set wpa_auth (%d)\n", err);
1716 return err;
5b435de0 1717 }
5b435de0
AS		 1718
1719 return err;
1720}
1721
1722static s32
f09d0c02
HM		 1723brcmf_set_sharedkey(struct net_device *ndev,
1724 struct cfg80211_connect_params *sme)
5b435de0 1725{
6ac4f4ed 1726 struct brcmf_cfg80211_profile *profile = ndev_to_prof(ndev);
5b435de0
AS		 1727 struct brcmf_cfg80211_security *sec;
1728 struct brcmf_wsec_key key;
1729 s32 val;
1730 s32 err = 0;
1731
16886735 1732 brcmf_dbg(CONN, "key len (%d)\n", sme->key_len);
5b435de0 1733
a718e2fe
RV		 1734 if (sme->key_len == 0)
1735 return 0;
1736
06bb123e 1737 sec = &profile->sec;
16886735
AS		 1738 brcmf_dbg(CONN, "wpa_versions 0x%x cipher_pairwise 0x%x\n",
1739 sec->wpa_versions, sec->cipher_pairwise);
a718e2fe
RV		 1740
1741 if (sec->wpa_versions & (NL80211_WPA_VERSION_1 | NL80211_WPA_VERSION_2))
1742 return 0;
1743
f09d0c02
HM		 1744 if (!(sec->cipher_pairwise &
1745 (WLAN_CIPHER_SUITE_WEP40 | WLAN_CIPHER_SUITE_WEP104)))
1746 return 0;
a718e2fe 1747
f09d0c02
HM		 1748 memset(&key, 0, sizeof(key));
1749 key.len = (u32) sme->key_len;
1750 key.index = (u32) sme->key_idx;
1751 if (key.len > sizeof(key.data)) {
57d6e91a 1752 brcmf_err("Too long key length (%u)\n", key.len);
f09d0c02
HM		 1753 return -EINVAL;
1754 }
1755 memcpy(key.data, sme->key, key.len);
1756 key.flags = BRCMF_PRIMARY_KEY;
1757 switch (sec->cipher_pairwise) {
1758 case WLAN_CIPHER_SUITE_WEP40:
1759 key.algo = CRYPTO_ALGO_WEP1;
1760 break;
1761 case WLAN_CIPHER_SUITE_WEP104:
1762 key.algo = CRYPTO_ALGO_WEP128;
1763 break;
1764 default:
57d6e91a
AS		 1765 brcmf_err("Invalid algorithm (%d)\n",
1766 sme->crypto.ciphers_pairwise[0]);
f09d0c02
HM		 1767 return -EINVAL;
1768 }
1769 /* Set the new key/index */
16886735
AS		 1770 brcmf_dbg(CONN, "key length (%d) key index (%d) algo (%d)\n",
1771 key.len, key.index, key.algo);
1772 brcmf_dbg(CONN, "key \"%s\"\n", key.data);
118eb304 1773 err = send_key_to_dongle(netdev_priv(ndev), &key);
f09d0c02
HM		 1774 if (err)
1775 return err;
1776
1777 if (sec->auth_type == NL80211_AUTHTYPE_SHARED_KEY) {
16886735 1778 brcmf_dbg(CONN, "set auth_type to shared key\n");
f09d0c02 1779 val = WL_AUTH_SHARED_KEY; /* shared key */
ac24be6f 1780 err = brcmf_fil_bsscfg_int_set(netdev_priv(ndev), "auth", val);
f09d0c02 1781 if (err)
57d6e91a 1782 brcmf_err("set auth failed (%d)\n", err);
5b435de0
AS		 1783 }
1784 return err;
1785}
1786
cbb1ec94
AS		 1787static
1788enum nl80211_auth_type brcmf_war_auth_type(struct brcmf_if *ifp,
1789 enum nl80211_auth_type type)
1790{
c08437b4
AS		 1791 if (type == NL80211_AUTHTYPE_AUTOMATIC &&
1792 brcmf_feat_is_quirk_enabled(ifp, BRCMF_FEAT_QUIRK_AUTO_AUTH)) {
1793 brcmf_dbg(CONN, "WAR: use OPEN instead of AUTO\n");
1794 type = NL80211_AUTHTYPE_OPEN_SYSTEM;
cbb1ec94
AS		 1795 }
1796 return type;
1797}
1798
5b435de0
AS		 1799static s32
1800brcmf_cfg80211_connect(struct wiphy *wiphy, struct net_device *ndev,
cbb1ec94 1801 struct cfg80211_connect_params *sme)
5b435de0 1802{
27a68fe3 1803 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy);
0abb5f21 1804 struct brcmf_if *ifp = netdev_priv(ndev);
5b435de0
AS		 1805 struct ieee80211_channel *chan = sme->channel;
1806 struct brcmf_join_params join_params;
1807 size_t join_params_size;
4b5800fe
JB		 1808 const struct brcmf_tlv *rsn_ie;
1809 const struct brcmf_vs_tlv *wpa_ie;
1810 const void *ie;
89286dc9
HM		 1811 u32 ie_len;
1812 struct brcmf_ext_join_params_le *ext_join_params;
1701261d 1813 u16 chanspec;
5b435de0 1814 s32 err = 0;
e9a6ca82 1815 u32 ssid_len;
5b435de0 1816
d96b801f 1817 brcmf_dbg(TRACE, "Enter\n");
ce81e317 1818 if (!check_vif_up(ifp->vif))
5b435de0
AS		 1819 return -EIO;
1820
1821 if (!sme->ssid) {
57d6e91a 1822 brcmf_err("Invalid ssid\n");
5b435de0
AS		 1823 return -EOPNOTSUPP;
1824 }
1825
89286dc9
HM		 1826 if (ifp->vif == cfg->p2p.bss_idx[P2PAPI_BSSCFG_PRIMARY].vif) {
1827 /* A normal (non P2P) connection request setup. */
1828 ie = NULL;
1829 ie_len = 0;
1830 /* find the WPA_IE */
1831 wpa_ie = brcmf_find_wpaie((u8 *)sme->ie, sme->ie_len);
1832 if (wpa_ie) {
1833 ie = wpa_ie;
1834 ie_len = wpa_ie->len + TLV_HDR_LEN;
1835 } else {
1836 /* find the RSN_IE */
4b5800fe
JB		 1837 rsn_ie = brcmf_parse_tlvs((const u8 *)sme->ie,
1838 sme->ie_len,
89286dc9
HM		 1839 WLAN_EID_RSN);
1840 if (rsn_ie) {
1841 ie = rsn_ie;
1842 ie_len = rsn_ie->len + TLV_HDR_LEN;
1843 }
1844 }
1845 brcmf_fil_iovar_data_set(ifp, "wpaie", ie, ie_len);
1846 }
1847
1848 err = brcmf_vif_set_mgmt_ie(ifp->vif, BRCMF_VNDR_IE_ASSOCREQ_FLAG,
1849 sme->ie, sme->ie_len);
1850 if (err)
1851 brcmf_err("Set Assoc REQ IE Failed\n");
1852 else
1853 brcmf_dbg(TRACE, "Applied Vndr IEs for Assoc request\n");
1854
c1179033 1855 set_bit(BRCMF_VIF_STATUS_CONNECTING, &ifp->vif->sme_state);
5b435de0
AS		 1856
1857 if (chan) {
27a68fe3 1858 cfg->channel =
5b435de0 1859 ieee80211_frequency_to_channel(chan->center_freq);
83cf17aa 1860 chanspec = channel_to_chanspec(&cfg->d11inf, chan);
1701261d
HM		 1861 brcmf_dbg(CONN, "channel=%d, center_req=%d, chanspec=0x%04x\n",
1862 cfg->channel, chan->center_freq, chanspec);
1863 } else {
27a68fe3 1864 cfg->channel = 0;
1701261d
HM		 1865 chanspec = 0;
1866 }
5b435de0 1867
647c9ae0 1868 brcmf_dbg(INFO, "ie (%p), ie_len (%zd)\n", sme->ie, sme->ie_len);
5b435de0
AS		 1869
1870 err = brcmf_set_wpa_version(ndev, sme);
1871 if (err) {
57d6e91a 1872 brcmf_err("wl_set_wpa_version failed (%d)\n", err);
5b435de0
AS		 1873 goto done;
1874 }
1875
cbb1ec94 1876 sme->auth_type = brcmf_war_auth_type(ifp, sme->auth_type);
5b435de0
AS		 1877 err = brcmf_set_auth_type(ndev, sme);
1878 if (err) {
57d6e91a 1879 brcmf_err("wl_set_auth_type failed (%d)\n", err);
5b435de0
AS		 1880 goto done;
1881 }
1882
240d61a9 1883 err = brcmf_set_wsec_mode(ndev, sme);
5b435de0 1884 if (err) {
57d6e91a 1885 brcmf_err("wl_set_set_cipher failed (%d)\n", err);
5b435de0
AS		 1886 goto done;
1887 }
1888
1889 err = brcmf_set_key_mgmt(ndev, sme);
1890 if (err) {
57d6e91a 1891 brcmf_err("wl_set_key_mgmt failed (%d)\n", err);
5b435de0
AS		 1892 goto done;
1893 }
1894
f09d0c02 1895 err = brcmf_set_sharedkey(ndev, sme);
5b435de0 1896 if (err) {
57d6e91a 1897 brcmf_err("brcmf_set_sharedkey failed (%d)\n", err);
5b435de0
AS		 1898 goto done;
1899 }
1900
89286dc9
HM		 1901 /* Join with specific BSSID and cached SSID
1902 * If SSID is zero join based on BSSID only
1903 */
1904 join_params_size = offsetof(struct brcmf_ext_join_params_le, assoc_le) +
1905 offsetof(struct brcmf_assoc_params_le, chanspec_list);
1906 if (cfg->channel)
1907 join_params_size += sizeof(u16);
1908 ext_join_params = kzalloc(join_params_size, GFP_KERNEL);
1909 if (ext_join_params == NULL) {
1910 err = -ENOMEM;
1911 goto done;
1912 }
e9a6ca82
HM		 1913 ssid_len = min_t(u32, sme->ssid_len, IEEE80211_MAX_SSID_LEN);
1914 ext_join_params->ssid_le.SSID_len = cpu_to_le32(ssid_len);
1915 memcpy(&ext_join_params->ssid_le.SSID, sme->ssid, ssid_len);
1916 if (ssid_len < IEEE80211_MAX_SSID_LEN)
1917 brcmf_dbg(CONN, "SSID \"%s\", len (%d)\n",
1918 ext_join_params->ssid_le.SSID, ssid_len);
63dd99e6 1919
89286dc9
HM		 1920 /* Set up join scan parameters */
1921 ext_join_params->scan_le.scan_type = -1;
89286dc9
HM		 1922 ext_join_params->scan_le.home_time = cpu_to_le32(-1);
1923
1924 if (sme->bssid)
1925 memcpy(&ext_join_params->assoc_le.bssid, sme->bssid, ETH_ALEN);
1926 else
93803b33 1927 eth_broadcast_addr(ext_join_params->assoc_le.bssid);
89286dc9
HM		 1928
1929 if (cfg->channel) {
1930 ext_join_params->assoc_le.chanspec_num = cpu_to_le32(1);
1931
1932 ext_join_params->assoc_le.chanspec_list[0] =
1933 cpu_to_le16(chanspec);
63dd99e6
HM		 1934 /* Increase dwell time to receive probe response or detect
1935 * beacon from target AP at a noisy air only during connect
1936 * command.
1937 */
1938 ext_join_params->scan_le.active_time =
1939 cpu_to_le32(BRCMF_SCAN_JOIN_ACTIVE_DWELL_TIME_MS);
1940 ext_join_params->scan_le.passive_time =
1941 cpu_to_le32(BRCMF_SCAN_JOIN_PASSIVE_DWELL_TIME_MS);
1942 /* To sync with presence period of VSDB GO send probe request
1943 * more frequently. Probe request will be stopped when it gets
1944 * probe response from target AP/GO.
1945 */
1946 ext_join_params->scan_le.nprobes =
1947 cpu_to_le32(BRCMF_SCAN_JOIN_ACTIVE_DWELL_TIME_MS /
1948 BRCMF_SCAN_JOIN_PROBE_INTERVAL_MS);
1949 } else {
1950 ext_join_params->scan_le.active_time = cpu_to_le32(-1);
1951 ext_join_params->scan_le.passive_time = cpu_to_le32(-1);
1952 ext_join_params->scan_le.nprobes = cpu_to_le32(-1);
89286dc9
HM		 1953 }
1954
1955 err = brcmf_fil_bsscfg_data_set(ifp, "join", ext_join_params,
1956 join_params_size);
1957 kfree(ext_join_params);
1958 if (!err)
1959 /* This is it. join command worked, we are done */
1960 goto done;
1961
1962 /* join command failed, fallback to set ssid */
5b435de0
AS		 1963 memset(&join_params, 0, sizeof(join_params));
1964 join_params_size = sizeof(join_params.ssid_le);
1965
e9a6ca82
HM		 1966 memcpy(&join_params.ssid_le.SSID, sme->ssid, ssid_len);
1967 join_params.ssid_le.SSID_len = cpu_to_le32(ssid_len);
5b435de0 1968
89286dc9
HM		 1969 if (sme->bssid)
1970 memcpy(join_params.params_le.bssid, sme->bssid, ETH_ALEN);
1971 else
93803b33 1972 eth_broadcast_addr(join_params.params_le.bssid);
5b435de0 1973
1701261d
HM		 1974 if (cfg->channel) {
1975 join_params.params_le.chanspec_list[0] = cpu_to_le16(chanspec);
1976 join_params.params_le.chanspec_num = cpu_to_le32(1);
1977 join_params_size += sizeof(join_params.params_le);
1978 }
c1179033 1979 err = brcmf_fil_cmd_data_set(ifp, BRCMF_C_SET_SSID,
81f5dcb8 1980 &join_params, join_params_size);
5b435de0 1981 if (err)
89286dc9 1982 brcmf_err("BRCMF_C_SET_SSID failed (%d)\n", err);
5b435de0
AS		 1983
1984done:
1985 if (err)
c1179033 1986 clear_bit(BRCMF_VIF_STATUS_CONNECTING, &ifp->vif->sme_state);
d96b801f 1987 brcmf_dbg(TRACE, "Exit\n");
5b435de0
AS		 1988 return err;
1989}
1990
1991static s32
1992brcmf_cfg80211_disconnect(struct wiphy *wiphy, struct net_device *ndev,
1993 u16 reason_code)
1994{
0abb5f21
AS		 1995 struct brcmf_if *ifp = netdev_priv(ndev);
1996 struct brcmf_cfg80211_profile *profile = &ifp->vif->profile;
5b435de0
AS		 1997 struct brcmf_scb_val_le scbval;
1998 s32 err = 0;
1999
d96b801f 2000 brcmf_dbg(TRACE, "Enter. Reason code = %d\n", reason_code);
ce81e317 2001 if (!check_vif_up(ifp->vif))
5b435de0
AS		 2002 return -EIO;
2003
c1179033 2004 clear_bit(BRCMF_VIF_STATUS_CONNECTED, &ifp->vif->sme_state);
4f3fff14 2005 clear_bit(BRCMF_VIF_STATUS_CONNECTING, &ifp->vif->sme_state);
80279fb7 2006 cfg80211_disconnected(ndev, reason_code, NULL, 0, true, GFP_KERNEL);
5b435de0 2007
06bb123e 2008 memcpy(&scbval.ea, &profile->bssid, ETH_ALEN);
5b435de0 2009 scbval.val = cpu_to_le32(reason_code);
c1179033 2010 err = brcmf_fil_cmd_data_set(ifp, BRCMF_C_DISASSOC,
ac24be6f 2011 &scbval, sizeof(scbval));
5b435de0 2012 if (err)
57d6e91a 2013 brcmf_err("error (%d)\n", err);
5b435de0 2014
d96b801f 2015 brcmf_dbg(TRACE, "Exit\n");
5b435de0
AS		 2016 return err;
2017}
2018
2019static s32
c8442118 2020brcmf_cfg80211_set_tx_power(struct wiphy *wiphy, struct wireless_dev *wdev,
d3f31134 2021 enum nl80211_tx_power_setting type, s32 mbm)
5b435de0 2022{
27a68fe3 2023 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy);
0abb5f21
AS		 2024 struct net_device *ndev = cfg_to_ndev(cfg);
2025 struct brcmf_if *ifp = netdev_priv(ndev);
60dc35ef
HM		 2026 s32 err;
2027 s32 disable;
2028 u32 qdbm = 127;
5b435de0 2029
60dc35ef 2030 brcmf_dbg(TRACE, "Enter %d %d\n", type, mbm);
ce81e317 2031 if (!check_vif_up(ifp->vif))
5b435de0
AS		 2032 return -EIO;
2033
2034 switch (type) {
2035 case NL80211_TX_POWER_AUTOMATIC:
2036 break;
2037 case NL80211_TX_POWER_LIMITED:
5b435de0 2038 case NL80211_TX_POWER_FIXED:
60dc35ef 2039 if (mbm < 0) {
57d6e91a 2040 brcmf_err("TX_POWER_FIXED - dbm is negative\n");
5b435de0
AS		 2041 err = -EINVAL;
2042 goto done;
2043 }
60dc35ef
HM		 2044 qdbm = MBM_TO_DBM(4 * mbm);
2045 if (qdbm > 127)
2046 qdbm = 127;
2047 qdbm |= WL_TXPWR_OVERRIDE;
5b435de0 2048 break;
60dc35ef
HM		 2049 default:
2050 brcmf_err("Unsupported type %d\n", type);
2051 err = -EINVAL;
2052 goto done;
5b435de0
AS		 2053 }
2054 /* Make sure radio is off or on as far as software is concerned */
2055 disable = WL_RADIO_SW_DISABLE << 16;
ac24be6f 2056 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_RADIO, disable);
5b435de0 2057 if (err)
57d6e91a 2058 brcmf_err("WLC_SET_RADIO error (%d)\n", err);
5b435de0 2059
60dc35ef 2060 err = brcmf_fil_iovar_int_set(ifp, "qtxpower", qdbm);
5b435de0 2061 if (err)
57d6e91a 2062 brcmf_err("qtxpower error (%d)\n", err);
5b435de0
AS		 2063
2064done:
60dc35ef 2065 brcmf_dbg(TRACE, "Exit %d (qdbm)\n", qdbm & ~WL_TXPWR_OVERRIDE);
5b435de0
AS		 2066 return err;
2067}
2068
60dc35ef
HM		 2069static s32
2070brcmf_cfg80211_get_tx_power(struct wiphy *wiphy, struct wireless_dev *wdev,
2071 s32 *dbm)
5b435de0 2072{
27a68fe3 2073 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy);
60dc35ef
HM		 2074 struct net_device *ndev = cfg_to_ndev(cfg);
2075 struct brcmf_if *ifp = netdev_priv(ndev);
2076 s32 qdbm = 0;
2077 s32 err;
5b435de0 2078
d96b801f 2079 brcmf_dbg(TRACE, "Enter\n");
ce81e317 2080 if (!check_vif_up(ifp->vif))
5b435de0
AS		 2081 return -EIO;
2082
60dc35ef 2083 err = brcmf_fil_iovar_int_get(ifp, "qtxpower", &qdbm);
5b435de0 2084 if (err) {
57d6e91a 2085 brcmf_err("error (%d)\n", err);
5b435de0
AS		 2086 goto done;
2087 }
60dc35ef 2088 *dbm = (qdbm & ~WL_TXPWR_OVERRIDE) / 4;
5b435de0
AS		 2089
2090done:
60dc35ef 2091 brcmf_dbg(TRACE, "Exit (0x%x %d)\n", qdbm, *dbm);
5b435de0
AS		 2092 return err;
2093}
2094
2095static s32
2096brcmf_cfg80211_config_default_key(struct wiphy *wiphy, struct net_device *ndev,
60dc35ef 2097 u8 key_idx, bool unicast, bool multicast)
5b435de0 2098{
0abb5f21 2099 struct brcmf_if *ifp = netdev_priv(ndev);
5b435de0
AS		 2100 u32 index;
2101 u32 wsec;
2102 s32 err = 0;
2103
d96b801f 2104 brcmf_dbg(TRACE, "Enter\n");
16886735 2105 brcmf_dbg(CONN, "key index (%d)\n", key_idx);
ce81e317 2106 if (!check_vif_up(ifp->vif))
5b435de0
AS		 2107 return -EIO;
2108
0abb5f21 2109 err = brcmf_fil_bsscfg_int_get(ifp, "wsec", &wsec);
5b435de0 2110 if (err) {
57d6e91a 2111 brcmf_err("WLC_GET_WSEC error (%d)\n", err);
5b435de0
AS		 2112 goto done;
2113 }
2114
2115 if (wsec & WEP_ENABLED) {
2116 /* Just select a new current key */
2117 index = key_idx;
0abb5f21 2118 err = brcmf_fil_cmd_int_set(ifp,
ac24be6f 2119 BRCMF_C_SET_KEY_PRIMARY, index);
5b435de0 2120 if (err)
57d6e91a 2121 brcmf_err("error (%d)\n", err);
5b435de0
AS		 2122 }
2123done:
d96b801f 2124 brcmf_dbg(TRACE, "Exit\n");
5b435de0
AS		 2125 return err;
2126}
2127
2128static s32
219e0f74
HM		 2129brcmf_cfg80211_del_key(struct wiphy *wiphy, struct net_device *ndev,
2130 u8 key_idx, bool pairwise, const u8 *mac_addr)
5b435de0 2131{
992f6068 2132 struct brcmf_if *ifp = netdev_priv(ndev);
240d61a9
HM		 2133 struct brcmf_wsec_key *key;
2134 s32 err;
219e0f74
HM		 2135
2136 brcmf_dbg(TRACE, "Enter\n");
240d61a9
HM		 2137 brcmf_dbg(CONN, "key index (%d)\n", key_idx);
2138
219e0f74
HM		 2139 if (!check_vif_up(ifp->vif))
2140 return -EIO;
2141
2142 if (key_idx >= BRCMF_MAX_DEFAULT_KEYS) {
2143 /* we ignore this key index in this case */
2144 return -EINVAL;
2145 }
5b435de0 2146
240d61a9 2147 key = &ifp->vif->profile.key[key_idx];
5b435de0 2148
240d61a9
HM		 2149 if (key->algo == CRYPTO_ALGO_OFF) {
2150 brcmf_dbg(CONN, "Ignore clearing of (never configured) key\n");
2151 return -EINVAL;
2152 }
5b435de0 2153
240d61a9
HM		 2154 memset(key, 0, sizeof(*key));
2155 key->index = (u32)key_idx;
2156 key->flags = BRCMF_PRIMARY_KEY;
5b435de0 2157
240d61a9
HM		 2158 /* Clear the key/index */
2159 err = send_key_to_dongle(ifp, key);
5b435de0 2160
219e0f74 2161 brcmf_dbg(TRACE, "Exit\n");
5b435de0
AS		 2162 return err;
2163}
2164
2165static s32
2166brcmf_cfg80211_add_key(struct wiphy *wiphy, struct net_device *ndev,
240d61a9
HM		 2167 u8 key_idx, bool pairwise, const u8 *mac_addr,
2168 struct key_params *params)
5b435de0 2169{
0abb5f21 2170 struct brcmf_if *ifp = netdev_priv(ndev);
118eb304 2171 struct brcmf_wsec_key *key;
5b435de0
AS		 2172 s32 val;
2173 s32 wsec;
219e0f74 2174 s32 err;
5b435de0 2175 u8 keybuf[8];
219e0f74 2176 bool ext_key;
5b435de0 2177
d96b801f 2178 brcmf_dbg(TRACE, "Enter\n");
16886735 2179 brcmf_dbg(CONN, "key index (%d)\n", key_idx);
ce81e317 2180 if (!check_vif_up(ifp->vif))
5b435de0
AS		 2181 return -EIO;
2182
118eb304
HM		 2183 if (key_idx >= BRCMF_MAX_DEFAULT_KEYS) {
2184 /* we ignore this key index in this case */
2185 brcmf_err("invalid key index (%d)\n", key_idx);
2186 return -EINVAL;
2187 }
2188
219e0f74
HM		 2189 if (params->key_len == 0)
2190 return brcmf_cfg80211_del_key(wiphy, ndev, key_idx, pairwise,
2191 mac_addr);
5b435de0 2192
118eb304
HM		 2193 if (params->key_len > sizeof(key->data)) {
2194 brcmf_err("Too long key length (%u)\n", params->key_len);
219e0f74 2195 return -EINVAL;
5b435de0 2196 }
219e0f74
HM		 2197
2198 ext_key = false;
2199 if (mac_addr && (params->cipher != WLAN_CIPHER_SUITE_WEP40) &&
2200 (params->cipher != WLAN_CIPHER_SUITE_WEP104)) {
2201 brcmf_dbg(TRACE, "Ext key, mac %pM", mac_addr);
2202 ext_key = true;
2203 }
2204
2205 key = &ifp->vif->profile.key[key_idx];
2206 memset(key, 0, sizeof(*key));
2207 if ((ext_key) && (!is_multicast_ether_addr(mac_addr)))
2208 memcpy((char *)&key->ea, (void *)mac_addr, ETH_ALEN);
118eb304
HM		 2209 key->len = params->key_len;
2210 key->index = key_idx;
118eb304 2211 memcpy(key->data, params->key, key->len);
219e0f74
HM		 2212 if (!ext_key)
2213 key->flags = BRCMF_PRIMARY_KEY;
118eb304 2214
5b435de0
AS		 2215 switch (params->cipher) {
2216 case WLAN_CIPHER_SUITE_WEP40:
118eb304 2217 key->algo = CRYPTO_ALGO_WEP1;
f09d0c02 2218 val = WEP_ENABLED;
16886735 2219 brcmf_dbg(CONN, "WLAN_CIPHER_SUITE_WEP40\n");
5b435de0
AS		 2220 break;
2221 case WLAN_CIPHER_SUITE_WEP104:
118eb304 2222 key->algo = CRYPTO_ALGO_WEP128;
f09d0c02 2223 val = WEP_ENABLED;
16886735 2224 brcmf_dbg(CONN, "WLAN_CIPHER_SUITE_WEP104\n");
5b435de0
AS		 2225 break;
2226 case WLAN_CIPHER_SUITE_TKIP:
967fe2c8 2227 if (!brcmf_is_apmode(ifp->vif)) {
992f6068 2228 brcmf_dbg(CONN, "Swapping RX/TX MIC key\n");
118eb304
HM		 2229 memcpy(keybuf, &key->data[24], sizeof(keybuf));
2230 memcpy(&key->data[24], &key->data[16], sizeof(keybuf));
2231 memcpy(&key->data[16], keybuf, sizeof(keybuf));
1a873342 2232 }
118eb304 2233 key->algo = CRYPTO_ALGO_TKIP;
f09d0c02 2234 val = TKIP_ENABLED;
16886735 2235 brcmf_dbg(CONN, "WLAN_CIPHER_SUITE_TKIP\n");
5b435de0
AS		 2236 break;
2237 case WLAN_CIPHER_SUITE_AES_CMAC:
118eb304 2238 key->algo = CRYPTO_ALGO_AES_CCM;
f09d0c02 2239 val = AES_ENABLED;
16886735 2240 brcmf_dbg(CONN, "WLAN_CIPHER_SUITE_AES_CMAC\n");
5b435de0
AS		 2241 break;
2242 case WLAN_CIPHER_SUITE_CCMP:
118eb304 2243 key->algo = CRYPTO_ALGO_AES_CCM;
f09d0c02 2244 val = AES_ENABLED;
16886735 2245 brcmf_dbg(CONN, "WLAN_CIPHER_SUITE_CCMP\n");
5b435de0
AS		 2246 break;
2247 default:
57d6e91a 2248 brcmf_err("Invalid cipher (0x%x)\n", params->cipher);
5b435de0
AS		 2249 err = -EINVAL;
2250 goto done;
2251 }
2252
118eb304 2253 err = send_key_to_dongle(ifp, key);
219e0f74 2254 if (ext_key || err)
5b435de0
AS		 2255 goto done;
2256
0abb5f21 2257 err = brcmf_fil_bsscfg_int_get(ifp, "wsec", &wsec);
5b435de0 2258 if (err) {
57d6e91a 2259 brcmf_err("get wsec error (%d)\n", err);
5b435de0
AS		 2260 goto done;
2261 }
5b435de0 2262 wsec |= val;
0abb5f21 2263 err = brcmf_fil_bsscfg_int_set(ifp, "wsec", wsec);
5b435de0 2264 if (err) {
57d6e91a 2265 brcmf_err("set wsec error (%d)\n", err);
5b435de0
AS		 2266 goto done;
2267 }
2268
5b435de0 2269done:
d96b801f 2270 brcmf_dbg(TRACE, "Exit\n");
5b435de0
AS		 2271 return err;
2272}
2273
5b435de0 2274static s32
240d61a9
HM		 2275brcmf_cfg80211_get_key(struct wiphy *wiphy, struct net_device *ndev, u8 key_idx,
2276 bool pairwise, const u8 *mac_addr, void *cookie,
2277 void (*callback)(void *cookie,
2278 struct key_params *params))
5b435de0
AS		 2279{
2280 struct key_params params;
0abb5f21
AS		 2281 struct brcmf_if *ifp = netdev_priv(ndev);
2282 struct brcmf_cfg80211_profile *profile = &ifp->vif->profile;
5b435de0
AS		 2283 struct brcmf_cfg80211_security *sec;
2284 s32 wsec;
2285 s32 err = 0;
2286
d96b801f 2287 brcmf_dbg(TRACE, "Enter\n");
16886735 2288 brcmf_dbg(CONN, "key index (%d)\n", key_idx);
ce81e317 2289 if (!check_vif_up(ifp->vif))
5b435de0
AS		 2290 return -EIO;
2291
2292 memset(&params, 0, sizeof(params));
2293
0abb5f21 2294 err = brcmf_fil_bsscfg_int_get(ifp, "wsec", &wsec);
5b435de0 2295 if (err) {
57d6e91a 2296 brcmf_err("WLC_GET_WSEC error (%d)\n", err);
5b435de0
AS		 2297 /* Ignore this error, may happen during DISASSOC */
2298 err = -EAGAIN;
2299 goto done;
2300 }
c5bf53a8 2301 if (wsec & WEP_ENABLED) {
06bb123e 2302 sec = &profile->sec;
5b435de0
AS		 2303 if (sec->cipher_pairwise & WLAN_CIPHER_SUITE_WEP40) {
2304 params.cipher = WLAN_CIPHER_SUITE_WEP40;
16886735 2305 brcmf_dbg(CONN, "WLAN_CIPHER_SUITE_WEP40\n");
5b435de0
AS		 2306 } else if (sec->cipher_pairwise & WLAN_CIPHER_SUITE_WEP104) {
2307 params.cipher = WLAN_CIPHER_SUITE_WEP104;
16886735 2308 brcmf_dbg(CONN, "WLAN_CIPHER_SUITE_WEP104\n");
5b435de0 2309 }
c5bf53a8 2310 } else if (wsec & TKIP_ENABLED) {
5b435de0 2311 params.cipher = WLAN_CIPHER_SUITE_TKIP;
16886735 2312 brcmf_dbg(CONN, "WLAN_CIPHER_SUITE_TKIP\n");
c5bf53a8 2313 } else if (wsec & AES_ENABLED) {
5b435de0 2314 params.cipher = WLAN_CIPHER_SUITE_AES_CMAC;
16886735 2315 brcmf_dbg(CONN, "WLAN_CIPHER_SUITE_AES_CMAC\n");
c5bf53a8 2316 } else {
57d6e91a 2317 brcmf_err("Invalid algo (0x%x)\n", wsec);
5b435de0
AS		 2318 err = -EINVAL;
2319 goto done;
2320 }
2321 callback(cookie, &params);
2322
2323done:
d96b801f 2324 brcmf_dbg(TRACE, "Exit\n");
5b435de0
AS		 2325 return err;
2326}
2327
2328static s32
2329brcmf_cfg80211_config_default_mgmt_key(struct wiphy *wiphy,
240d61a9 2330 struct net_device *ndev, u8 key_idx)
5b435de0 2331{
240d61a9
HM		 2332 struct brcmf_if *ifp = netdev_priv(ndev);
2333
2334 brcmf_dbg(TRACE, "Enter key_idx %d\n", key_idx);
2335
2336 if (brcmf_feat_is_enabled(ifp, BRCMF_FEAT_MFP))
2337 return 0;
2338
647c9ae0 2339 brcmf_dbg(INFO, "Not supported\n");
5b435de0
AS		 2340
2341 return -EOPNOTSUPP;
2342}
2343
118eb304
HM		 2344static void
2345brcmf_cfg80211_reconfigure_wep(struct brcmf_if *ifp)
2346{
2347 s32 err;
2348 u8 key_idx;
2349 struct brcmf_wsec_key *key;
2350 s32 wsec;
2351
2352 for (key_idx = 0; key_idx < BRCMF_MAX_DEFAULT_KEYS; key_idx++) {
2353 key = &ifp->vif->profile.key[key_idx];
2354 if ((key->algo == CRYPTO_ALGO_WEP1) ||
2355 (key->algo == CRYPTO_ALGO_WEP128))
2356 break;
2357 }
2358 if (key_idx == BRCMF_MAX_DEFAULT_KEYS)
2359 return;
2360
2361 err = send_key_to_dongle(ifp, key);
2362 if (err) {
2363 brcmf_err("Setting WEP key failed (%d)\n", err);
2364 return;
2365 }
2366 err = brcmf_fil_bsscfg_int_get(ifp, "wsec", &wsec);
2367 if (err) {
2368 brcmf_err("get wsec error (%d)\n", err);
2369 return;
2370 }
2371 wsec |= WEP_ENABLED;
2372 err = brcmf_fil_bsscfg_int_set(ifp, "wsec", wsec);
2373 if (err)
2374 brcmf_err("set wsec error (%d)\n", err);
2375}
2376
1f0dc59a
AS		 2377static void brcmf_convert_sta_flags(u32 fw_sta_flags, struct station_info *si)
2378{
2379 struct nl80211_sta_flag_update *sfu;
2380
2381 brcmf_dbg(TRACE, "flags %08x\n", fw_sta_flags);
2382 si->filled |= BIT(NL80211_STA_INFO_STA_FLAGS);
2383 sfu = &si->sta_flags;
2384 sfu->mask = BIT(NL80211_STA_FLAG_WME) |
2385 BIT(NL80211_STA_FLAG_AUTHENTICATED) |
2386 BIT(NL80211_STA_FLAG_ASSOCIATED) |
2387 BIT(NL80211_STA_FLAG_AUTHORIZED);
2388 if (fw_sta_flags & BRCMF_STA_WME)
2389 sfu->set |= BIT(NL80211_STA_FLAG_WME);
2390 if (fw_sta_flags & BRCMF_STA_AUTHE)
2391 sfu->set |= BIT(NL80211_STA_FLAG_AUTHENTICATED);
2392 if (fw_sta_flags & BRCMF_STA_ASSOC)
2393 sfu->set |= BIT(NL80211_STA_FLAG_ASSOCIATED);
2394 if (fw_sta_flags & BRCMF_STA_AUTHO)
2395 sfu->set |= BIT(NL80211_STA_FLAG_AUTHORIZED);
2396}
2397
2398static void brcmf_fill_bss_param(struct brcmf_if *ifp, struct station_info *si)
2399{
2400 struct {
2401 __le32 len;
2402 struct brcmf_bss_info_le bss_le;
2403 } *buf;
2404 u16 capability;
2405 int err;
2406
2407 buf = kzalloc(WL_BSS_INFO_MAX, GFP_KERNEL);
2408 if (!buf)
2409 return;
2410
2411 buf->len = cpu_to_le32(WL_BSS_INFO_MAX);
2412 err = brcmf_fil_cmd_data_get(ifp, BRCMF_C_GET_BSS_INFO, buf,
2413 WL_BSS_INFO_MAX);
2414 if (err) {
2415 brcmf_err("Failed to get bss info (%d)\n", err);
2416 return;
2417 }
2418 si->filled |= BIT(NL80211_STA_INFO_BSS_PARAM);
2419 si->bss_param.beacon_interval = le16_to_cpu(buf->bss_le.beacon_period);
2420 si->bss_param.dtim_period = buf->bss_le.dtim_period;
2421 capability = le16_to_cpu(buf->bss_le.capability);
2422 if (capability & IEEE80211_HT_STBC_PARAM_DUAL_CTS_PROT)
2423 si->bss_param.flags |= BSS_PARAM_FLAGS_CTS_PROT;
2424 if (capability & WLAN_CAPABILITY_SHORT_PREAMBLE)
2425 si->bss_param.flags |= BSS_PARAM_FLAGS_SHORT_PREAMBLE;
2426 if (capability & WLAN_CAPABILITY_SHORT_SLOT_TIME)
2427 si->bss_param.flags |= BSS_PARAM_FLAGS_SHORT_SLOT_TIME;
2428}
2429
3f5893d1
HM		 2430static s32
2431brcmf_cfg80211_get_station_ibss(struct brcmf_if *ifp,
2432 struct station_info *sinfo)
2433{
2434 struct brcmf_scb_val_le scbval;
2435 struct brcmf_pktcnt_le pktcnt;
2436 s32 err;
2437 u32 rate;
2438 u32 rssi;
2439
2440 /* Get the current tx rate */
2441 err = brcmf_fil_cmd_int_get(ifp, BRCMF_C_GET_RATE, &rate);
2442 if (err < 0) {
2443 brcmf_err("BRCMF_C_GET_RATE error (%d)\n", err);
2444 return err;
2445 }
2446 sinfo->filled |= BIT(NL80211_STA_INFO_TX_BITRATE);
2447 sinfo->txrate.legacy = rate * 5;
2448
2449 memset(&scbval, 0, sizeof(scbval));
2450 err = brcmf_fil_cmd_data_get(ifp, BRCMF_C_GET_RSSI, &scbval,
2451 sizeof(scbval));
2452 if (err) {
2453 brcmf_err("BRCMF_C_GET_RSSI error (%d)\n", err);
2454 return err;
2455 }
2456 rssi = le32_to_cpu(scbval.val);
2457 sinfo->filled |= BIT(NL80211_STA_INFO_SIGNAL);
2458 sinfo->signal = rssi;
2459
2460 err = brcmf_fil_cmd_data_get(ifp, BRCMF_C_GET_GET_PKTCNTS, &pktcnt,
2461 sizeof(pktcnt));
2462 if (err) {
2463 brcmf_err("BRCMF_C_GET_GET_PKTCNTS error (%d)\n", err);
2464 return err;
2465 }
2466 sinfo->filled |= BIT(NL80211_STA_INFO_RX_PACKETS) |
2467 BIT(NL80211_STA_INFO_RX_DROP_MISC) |
2468 BIT(NL80211_STA_INFO_TX_PACKETS) |
2469 BIT(NL80211_STA_INFO_TX_FAILED);
2470 sinfo->rx_packets = le32_to_cpu(pktcnt.rx_good_pkt);
2471 sinfo->rx_dropped_misc = le32_to_cpu(pktcnt.rx_bad_pkt);
2472 sinfo->tx_packets = le32_to_cpu(pktcnt.tx_good_pkt);
2473 sinfo->tx_failed = le32_to_cpu(pktcnt.tx_bad_pkt);
2474
2475 return 0;
2476}
2477
5b435de0
AS		 2478static s32
2479brcmf_cfg80211_get_station(struct wiphy *wiphy, struct net_device *ndev,
3b3a0162 2480 const u8 *mac, struct station_info *sinfo)
5b435de0 2481{
0abb5f21 2482 struct brcmf_if *ifp = netdev_priv(ndev);
5b435de0 2483 s32 err = 0;
81f5dcb8 2484 struct brcmf_sta_info_le sta_info_le;
1f0dc59a
AS		 2485 u32 sta_flags;
2486 u32 is_tdls_peer;
cae355dc
HM		 2487 s32 total_rssi;
2488 s32 count_rssi;
2489 u32 i;
5b435de0 2490
d96b801f 2491 brcmf_dbg(TRACE, "Enter, MAC %pM\n", mac);
ce81e317 2492 if (!check_vif_up(ifp->vif))
5b435de0
AS		 2493 return -EIO;
2494
3f5893d1
HM		 2495 if (brcmf_is_ibssmode(ifp->vif))
2496 return brcmf_cfg80211_get_station_ibss(ifp, sinfo);
2497
1f0dc59a
AS		 2498 memset(&sta_info_le, 0, sizeof(sta_info_le));
2499 memcpy(&sta_info_le, mac, ETH_ALEN);
2500 err = brcmf_fil_iovar_data_get(ifp, "tdls_sta_info",
2501 &sta_info_le,
2502 sizeof(sta_info_le));
2503 is_tdls_peer = !err;
2504 if (err) {
0abb5f21 2505 err = brcmf_fil_iovar_data_get(ifp, "sta_info",
ac24be6f 2506 &sta_info_le,
81f5dcb8 2507 sizeof(sta_info_le));
1a873342 2508 if (err < 0) {
57d6e91a 2509 brcmf_err("GET STA INFO failed, %d\n", err);
1a873342
HM		 2510 goto done;
2511 }
1f0dc59a
AS		 2512 }
2513 brcmf_dbg(TRACE, "version %d\n", le16_to_cpu(sta_info_le.ver));
2514 sinfo->filled = BIT(NL80211_STA_INFO_INACTIVE_TIME);
2515 sinfo->inactive_time = le32_to_cpu(sta_info_le.idle) * 1000;
2516 sta_flags = le32_to_cpu(sta_info_le.flags);
2517 brcmf_convert_sta_flags(sta_flags, sinfo);
2518 sinfo->sta_flags.mask |= BIT(NL80211_STA_FLAG_TDLS_PEER);
2519 if (is_tdls_peer)
2520 sinfo->sta_flags.set |= BIT(NL80211_STA_FLAG_TDLS_PEER);
2521 else
2522 sinfo->sta_flags.set &= ~BIT(NL80211_STA_FLAG_TDLS_PEER);
2523 if (sta_flags & BRCMF_STA_ASSOC) {
2524 sinfo->filled |= BIT(NL80211_STA_INFO_CONNECTED_TIME);
2525 sinfo->connected_time = le32_to_cpu(sta_info_le.in);
2526 brcmf_fill_bss_param(ifp, sinfo);
2527 }
2528 if (sta_flags & BRCMF_STA_SCBSTATS) {
2529 sinfo->filled |= BIT(NL80211_STA_INFO_TX_FAILED);
2530 sinfo->tx_failed = le32_to_cpu(sta_info_le.tx_failures);
2531 sinfo->filled |= BIT(NL80211_STA_INFO_TX_PACKETS);
2532 sinfo->tx_packets = le32_to_cpu(sta_info_le.tx_pkts);
2533 sinfo->tx_packets += le32_to_cpu(sta_info_le.tx_mcast_pkts);
2534 sinfo->filled |= BIT(NL80211_STA_INFO_RX_PACKETS);
2535 sinfo->rx_packets = le32_to_cpu(sta_info_le.rx_ucast_pkts);
2536 sinfo->rx_packets += le32_to_cpu(sta_info_le.rx_mcast_pkts);
2537 if (sinfo->tx_packets) {
319090bf 2538 sinfo->filled |= BIT(NL80211_STA_INFO_TX_BITRATE);
124d5172
HM		 2539 sinfo->txrate.legacy =
2540 le32_to_cpu(sta_info_le.tx_rate) / 100;
7f6c562d 2541 }
1f0dc59a
AS		 2542 if (sinfo->rx_packets) {
2543 sinfo->filled |= BIT(NL80211_STA_INFO_RX_BITRATE);
124d5172
HM		 2544 sinfo->rxrate.legacy =
2545 le32_to_cpu(sta_info_le.rx_rate) / 100;
1a873342 2546 }
1f0dc59a
AS		 2547 if (le16_to_cpu(sta_info_le.ver) >= 4) {
2548 sinfo->filled |= BIT(NL80211_STA_INFO_TX_BYTES);
2549 sinfo->tx_bytes = le64_to_cpu(sta_info_le.tx_tot_bytes);
2550 sinfo->filled |= BIT(NL80211_STA_INFO_RX_BYTES);
2551 sinfo->rx_bytes = le64_to_cpu(sta_info_le.rx_tot_bytes);
2552 }
cae355dc
HM		 2553 total_rssi = 0;
2554 count_rssi = 0;
2555 for (i = 0; i < BRCMF_ANT_MAX; i++) {
2556 if (sta_info_le.rssi[i]) {
2557 sinfo->chain_signal_avg[count_rssi] =
2558 sta_info_le.rssi[i];
2559 sinfo->chain_signal[count_rssi] =
2560 sta_info_le.rssi[i];
2561 total_rssi += sta_info_le.rssi[i];
2562 count_rssi++;
2563 }
2564 }
2565 if (count_rssi) {
2566 sinfo->filled |= BIT(NL80211_STA_INFO_CHAIN_SIGNAL);
2567 sinfo->chains = count_rssi;
2568
2569 sinfo->filled |= BIT(NL80211_STA_INFO_SIGNAL);
2570 total_rssi /= count_rssi;
2571 sinfo->signal = total_rssi;
2572 }
1f0dc59a 2573 }
5b435de0 2574done:
d96b801f 2575 brcmf_dbg(TRACE, "Exit\n");
5b435de0
AS		 2576 return err;
2577}
2578
bf2a7e04
HM		 2579static int
2580brcmf_cfg80211_dump_station(struct wiphy *wiphy, struct net_device *ndev,
2581 int idx, u8 *mac, struct station_info *sinfo)
2582{
2583 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy);
2584 struct brcmf_if *ifp = netdev_priv(ndev);
2585 s32 err;
2586
2587 brcmf_dbg(TRACE, "Enter, idx %d\n", idx);
2588
2589 if (idx == 0) {
2590 cfg->assoclist.count = cpu_to_le32(BRCMF_MAX_ASSOCLIST);
2591 err = brcmf_fil_cmd_data_get(ifp, BRCMF_C_GET_ASSOCLIST,
2592 &cfg->assoclist,
2593 sizeof(cfg->assoclist));
2594 if (err) {
2595 brcmf_err("BRCMF_C_GET_ASSOCLIST unsupported, err=%d\n",
2596 err);
2597 cfg->assoclist.count = 0;
2598 return -EOPNOTSUPP;
2599 }
2600 }
2601 if (idx < le32_to_cpu(cfg->assoclist.count)) {
2602 memcpy(mac, cfg->assoclist.mac[idx], ETH_ALEN);
2603 return brcmf_cfg80211_get_station(wiphy, ndev, mac, sinfo);
2604 }
2605 return -ENOENT;
2606}
2607
5b435de0
AS		 2608static s32
2609brcmf_cfg80211_set_power_mgmt(struct wiphy *wiphy, struct net_device *ndev,
2610 bool enabled, s32 timeout)
2611{
2612 s32 pm;
2613 s32 err = 0;
27a68fe3 2614 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy);
c1179033 2615 struct brcmf_if *ifp = netdev_priv(ndev);
5b435de0 2616
d96b801f 2617 brcmf_dbg(TRACE, "Enter\n");
5b435de0
AS		 2618
2619 /*
2620 * Powersave enable/disable request is coming from the
2621 * cfg80211 even before the interface is up. In that
2622 * scenario, driver will be storing the power save
27a68fe3 2623 * preference in cfg struct to apply this to
5b435de0
AS		 2624 * FW later while initializing the dongle
2625 */
27a68fe3 2626 cfg->pwr_save = enabled;
ce81e317 2627 if (!check_vif_up(ifp->vif)) {
5b435de0 2628
647c9ae0 2629 brcmf_dbg(INFO, "Device is not ready, storing the value in cfg_info struct\n");
5b435de0
AS		 2630 goto done;
2631 }
2632
2633 pm = enabled ? PM_FAST : PM_OFF;
102fd0d6
HM		 2634 /* Do not enable the power save after assoc if it is a p2p interface */
2635 if (ifp->vif->wdev.iftype == NL80211_IFTYPE_P2P_CLIENT) {
2636 brcmf_dbg(INFO, "Do not enable power save for P2P clients\n");
2637 pm = PM_OFF;
2638 }
647c9ae0 2639 brcmf_dbg(INFO, "power save %s\n", (pm ? "enabled" : "disabled"));
5b435de0 2640
c1179033 2641 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_PM, pm);
5b435de0
AS		 2642 if (err) {
2643 if (err == -ENODEV)
57d6e91a 2644 brcmf_err("net_device is not ready yet\n");
5b435de0 2645 else
57d6e91a 2646 brcmf_err("error (%d)\n", err);
5b435de0
AS		 2647 }
2648done:
d96b801f 2649 brcmf_dbg(TRACE, "Exit\n");
5b435de0
AS		 2650 return err;
2651}
2652
27a68fe3 2653static s32 brcmf_inform_single_bss(struct brcmf_cfg80211_info *cfg,
d34bf64f 2654 struct brcmf_bss_info_le *bi)
5b435de0 2655{
27a68fe3 2656 struct wiphy *wiphy = cfg_to_wiphy(cfg);
5b435de0
AS		 2657 struct ieee80211_channel *notify_channel;
2658 struct cfg80211_bss *bss;
2659 struct ieee80211_supported_band *band;
83cf17aa 2660 struct brcmu_chan ch;
5b435de0
AS		 2661 u16 channel;
2662 u32 freq;
5b435de0
AS		 2663 u16 notify_capability;
2664 u16 notify_interval;
2665 u8 *notify_ie;
2666 size_t notify_ielen;
2667 s32 notify_signal;
2668
2669 if (le32_to_cpu(bi->length) > WL_BSS_INFO_MAX) {
57d6e91a 2670 brcmf_err("Bss info is larger than buffer. Discarding\n");
5b435de0
AS		 2671 return 0;
2672 }
2673
83cf17aa
FL		 2674 if (!bi->ctl_ch) {
2675 ch.chspec = le16_to_cpu(bi->chanspec);
2676 cfg->d11inf.decchspec(&ch);
2677 bi->ctl_ch = ch.chnum;
2678 }
2679 channel = bi->ctl_ch;
5b435de0
AS		 2680
2681 if (channel <= CH_MAX_2G_CHANNEL)
57fbcce3 2682 band = wiphy->bands[NL80211_BAND_2GHZ];
5b435de0 2683 else
57fbcce3 2684 band = wiphy->bands[NL80211_BAND_5GHZ];
5b435de0
AS		 2685
2686 freq = ieee80211_channel_to_frequency(channel, band->band);
2687 notify_channel = ieee80211_get_channel(wiphy, freq);
2688
5b435de0
AS		 2689 notify_capability = le16_to_cpu(bi->capability);
2690 notify_interval = le16_to_cpu(bi->beacon_period);
2691 notify_ie = (u8 *)bi + le16_to_cpu(bi->ie_offset);
2692 notify_ielen = le32_to_cpu(bi->ie_length);
2693 notify_signal = (s16)le16_to_cpu(bi->RSSI) * 100;
2694
16886735
AS		 2695 brcmf_dbg(CONN, "bssid: %pM\n", bi->BSSID);
2696 brcmf_dbg(CONN, "Channel: %d(%d)\n", channel, freq);
2697 brcmf_dbg(CONN, "Capability: %X\n", notify_capability);
2698 brcmf_dbg(CONN, "Beacon interval: %d\n", notify_interval);
2699 brcmf_dbg(CONN, "Signal: %d\n", notify_signal);
5b435de0 2700
5bc8c1f2
JB		 2701 bss = cfg80211_inform_bss(wiphy, notify_channel,
2702 CFG80211_BSS_FTYPE_UNKNOWN,
2703 (const u8 *)bi->BSSID,
2704 0, notify_capability,
2705 notify_interval, notify_ie,
2706 notify_ielen, notify_signal,
2707 GFP_KERNEL);
5b435de0 2708
e78946e1
FL		 2709 if (!bss)
2710 return -ENOMEM;
2711
5b112d3d 2712 cfg80211_put_bss(wiphy, bss);
5b435de0 2713
12f32370 2714 return 0;
5b435de0
AS		 2715}
2716
6f09be0a
RV		 2717static struct brcmf_bss_info_le *
2718next_bss_le(struct brcmf_scan_results *list, struct brcmf_bss_info_le *bss)
2719{
2720 if (bss == NULL)
2721 return list->bss_info_le;
2722 return (struct brcmf_bss_info_le *)((unsigned long)bss +
2723 le32_to_cpu(bss->length));
2724}
2725
27a68fe3 2726static s32 brcmf_inform_bss(struct brcmf_cfg80211_info *cfg)
5b435de0
AS		 2727{
2728 struct brcmf_scan_results *bss_list;
d34bf64f 2729 struct brcmf_bss_info_le *bi = NULL; /* must be initialized */
5b435de0
AS		 2730 s32 err = 0;
2731 int i;
2732
ef8596e1 2733 bss_list = (struct brcmf_scan_results *)cfg->escan_info.escan_buf;
0ecd8164
AS		 2734 if (bss_list->count != 0 &&
2735 bss_list->version != BRCMF_BSS_INFO_VERSION) {
57d6e91a
AS		 2736 brcmf_err("Version %d != WL_BSS_INFO_VERSION\n",
2737 bss_list->version);
5b435de0
AS		 2738 return -EOPNOTSUPP;
2739 }
4e8a008e 2740 brcmf_dbg(SCAN, "scanned AP count (%d)\n", bss_list->count);
f0799895 2741 for (i = 0; i < bss_list->count; i++) {
6f09be0a 2742 bi = next_bss_le(bss_list, bi);
27a68fe3 2743 err = brcmf_inform_single_bss(cfg, bi);
5b435de0
AS		 2744 if (err)
2745 break;
2746 }
2747 return err;
2748}
2749
b0a79088
HM		 2750static s32 brcmf_inform_ibss(struct brcmf_cfg80211_info *cfg,
2751 struct net_device *ndev, const u8 *bssid)
5b435de0 2752{
27a68fe3 2753 struct wiphy *wiphy = cfg_to_wiphy(cfg);
5b435de0 2754 struct ieee80211_channel *notify_channel;
d34bf64f 2755 struct brcmf_bss_info_le *bi = NULL;
5b435de0 2756 struct ieee80211_supported_band *band;
e78946e1 2757 struct cfg80211_bss *bss;
83cf17aa 2758 struct brcmu_chan ch;
5b435de0
AS		 2759 u8 *buf = NULL;
2760 s32 err = 0;
5b435de0 2761 u32 freq;
5b435de0
AS		 2762 u16 notify_capability;
2763 u16 notify_interval;
2764 u8 *notify_ie;
2765 size_t notify_ielen;
2766 s32 notify_signal;
2767
d96b801f 2768 brcmf_dbg(TRACE, "Enter\n");
5b435de0
AS		 2769
2770 buf = kzalloc(WL_BSS_INFO_MAX, GFP_KERNEL);
2771 if (buf == NULL) {
2772 err = -ENOMEM;
2773 goto CleanUp;
2774 }
2775
2776 *(__le32 *)buf = cpu_to_le32(WL_BSS_INFO_MAX);
2777
ac24be6f
AS		 2778 err = brcmf_fil_cmd_data_get(netdev_priv(ndev), BRCMF_C_GET_BSS_INFO,
2779 buf, WL_BSS_INFO_MAX);
5b435de0 2780 if (err) {
57d6e91a 2781 brcmf_err("WLC_GET_BSS_INFO failed: %d\n", err);
5b435de0
AS		 2782 goto CleanUp;
2783 }
2784
d34bf64f 2785 bi = (struct brcmf_bss_info_le *)(buf + 4);
5b435de0 2786
83cf17aa
FL		 2787 ch.chspec = le16_to_cpu(bi->chanspec);
2788 cfg->d11inf.decchspec(&ch);
5b435de0 2789
83cf17aa 2790 if (ch.band == BRCMU_CHAN_BAND_2G)
57fbcce3 2791 band = wiphy->bands[NL80211_BAND_2GHZ];
5b435de0 2792 else
57fbcce3 2793 band = wiphy->bands[NL80211_BAND_5GHZ];
5b435de0 2794
83cf17aa 2795 freq = ieee80211_channel_to_frequency(ch.chnum, band->band);
b0a79088 2796 cfg->channel = freq;
5b435de0
AS		 2797 notify_channel = ieee80211_get_channel(wiphy, freq);
2798
5b435de0
AS		 2799 notify_capability = le16_to_cpu(bi->capability);
2800 notify_interval = le16_to_cpu(bi->beacon_period);
2801 notify_ie = (u8 *)bi + le16_to_cpu(bi->ie_offset);
2802 notify_ielen = le32_to_cpu(bi->ie_length);
2803 notify_signal = (s16)le16_to_cpu(bi->RSSI) * 100;
2804
83cf17aa 2805 brcmf_dbg(CONN, "channel: %d(%d)\n", ch.chnum, freq);
16886735
AS		 2806 brcmf_dbg(CONN, "capability: %X\n", notify_capability);
2807 brcmf_dbg(CONN, "beacon interval: %d\n", notify_interval);
2808 brcmf_dbg(CONN, "signal: %d\n", notify_signal);
5b435de0 2809
5bc8c1f2
JB		 2810 bss = cfg80211_inform_bss(wiphy, notify_channel,
2811 CFG80211_BSS_FTYPE_UNKNOWN, bssid, 0,
2812 notify_capability, notify_interval,
2813 notify_ie, notify_ielen, notify_signal,
2814 GFP_KERNEL);
5b435de0 2815
e78946e1
FL		 2816 if (!bss) {
2817 err = -ENOMEM;
2818 goto CleanUp;
2819 }
2820
5b112d3d 2821 cfg80211_put_bss(wiphy, bss);
e78946e1 2822
5b435de0
AS		 2823CleanUp:
2824
2825 kfree(buf);
2826
d96b801f 2827 brcmf_dbg(TRACE, "Exit\n");
5b435de0
AS		 2828
2829 return err;
2830}
2831
89286dc9
HM		 2832static s32 brcmf_update_bss_info(struct brcmf_cfg80211_info *cfg,
2833 struct brcmf_if *ifp)
1a873342 2834{
d34bf64f 2835 struct brcmf_bss_info_le *bi;
4b5800fe 2836 const struct brcmf_tlv *tim;
5b435de0
AS		 2837 u16 beacon_interval;
2838 u8 dtim_period;
2839 size_t ie_len;
2840 u8 *ie;
2841 s32 err = 0;
2842
d96b801f 2843 brcmf_dbg(TRACE, "Enter\n");
128ce3b6 2844 if (brcmf_is_ibssmode(ifp->vif))
5b435de0
AS		 2845 return err;
2846
27a68fe3 2847 *(__le32 *)cfg->extra_buf = cpu_to_le32(WL_EXTRA_BUF_MAX);
ac24be6f 2848 err = brcmf_fil_cmd_data_get(ifp, BRCMF_C_GET_BSS_INFO,
81f5dcb8 2849 cfg->extra_buf, WL_EXTRA_BUF_MAX);
5b435de0 2850 if (err) {
57d6e91a 2851 brcmf_err("Could not get bss info %d\n", err);
5b435de0
AS		 2852 goto update_bss_info_out;
2853 }
2854
27a68fe3
AS		 2855 bi = (struct brcmf_bss_info_le *)(cfg->extra_buf + 4);
2856 err = brcmf_inform_single_bss(cfg, bi);
5b435de0
AS		 2857 if (err)
2858 goto update_bss_info_out;
2859
2860 ie = ((u8 *)bi) + le16_to_cpu(bi->ie_offset);
2861 ie_len = le32_to_cpu(bi->ie_length);
2862 beacon_interval = le16_to_cpu(bi->beacon_period);
2863
f8e4b412 2864 tim = brcmf_parse_tlvs(ie, ie_len, WLAN_EID_TIM);
5b435de0
AS		 2865 if (tim)
2866 dtim_period = tim->data[1];
2867 else {
2868 /*
2869 * active scan was done so we could not get dtim
2870 * information out of probe response.
2871 * so we speficially query dtim information to dongle.
2872 */
2873 u32 var;
ac24be6f 2874 err = brcmf_fil_iovar_int_get(ifp, "dtim_assoc", &var);
5b435de0 2875 if (err) {
57d6e91a 2876 brcmf_err("wl dtim_assoc failed (%d)\n", err);
5b435de0
AS		 2877 goto update_bss_info_out;
2878 }
2879 dtim_period = (u8)var;
2880 }
2881
5b435de0 2882update_bss_info_out:
d96b801f 2883 brcmf_dbg(TRACE, "Exit");
5b435de0
AS		 2884 return err;
2885}
2886
18e2f61d 2887void brcmf_abort_scanning(struct brcmf_cfg80211_info *cfg)
5b435de0 2888{
27a68fe3 2889 struct escan_info *escan = &cfg->escan_info;
5b435de0 2890
c1179033 2891 set_bit(BRCMF_SCAN_STATUS_ABORT, &cfg->scan_status);
f0799895 2892 if (cfg->scan_request) {
108a4bee 2893 escan->escan_state = WL_ESCAN_STATE_IDLE;
a0f472ac 2894 brcmf_notify_escan_complete(cfg, escan->ifp, true, true);
5b435de0 2895 }
c1179033
AS		 2896 clear_bit(BRCMF_SCAN_STATUS_BUSY, &cfg->scan_status);
2897 clear_bit(BRCMF_SCAN_STATUS_ABORT, &cfg->scan_status);
5b435de0
AS		 2898}
2899
e756af5b
HM		 2900static void brcmf_cfg80211_escan_timeout_worker(struct work_struct *work)
2901{
27a68fe3
AS		 2902 struct brcmf_cfg80211_info *cfg =
2903 container_of(work, struct brcmf_cfg80211_info,
e756af5b
HM		 2904 escan_timeout_work);
2905
ef8596e1 2906 brcmf_inform_bss(cfg);
a0f472ac 2907 brcmf_notify_escan_complete(cfg, cfg->escan_info.ifp, true, true);
e756af5b
HM		 2908}
2909
2910static void brcmf_escan_timeout(unsigned long data)
2911{
27a68fe3
AS		 2912 struct brcmf_cfg80211_info *cfg =
2913 (struct brcmf_cfg80211_info *)data;
e756af5b 2914
27a68fe3 2915 if (cfg->scan_request) {
57d6e91a 2916 brcmf_err("timer expired\n");
f0799895 2917 schedule_work(&cfg->escan_timeout_work);
e756af5b
HM		 2918 }
2919}
2920
2921static s32
83cf17aa
FL		 2922brcmf_compare_update_same_bss(struct brcmf_cfg80211_info *cfg,
2923 struct brcmf_bss_info_le *bss,
e756af5b
HM		 2924 struct brcmf_bss_info_le *bss_info_le)
2925{
83cf17aa
FL		 2926 struct brcmu_chan ch_bss, ch_bss_info_le;
2927
2928 ch_bss.chspec = le16_to_cpu(bss->chanspec);
2929 cfg->d11inf.decchspec(&ch_bss);
2930 ch_bss_info_le.chspec = le16_to_cpu(bss_info_le->chanspec);
2931 cfg->d11inf.decchspec(&ch_bss_info_le);
2932
e756af5b 2933 if (!memcmp(&bss_info_le->BSSID, &bss->BSSID, ETH_ALEN) &&
83cf17aa 2934 ch_bss.band == ch_bss_info_le.band &&
e756af5b
HM		 2935 bss_info_le->SSID_len == bss->SSID_len &&
2936 !memcmp(bss_info_le->SSID, bss->SSID, bss_info_le->SSID_len)) {
6f5838a4
AS		 2937 if ((bss->flags & BRCMF_BSS_RSSI_ON_CHANNEL) ==
2938 (bss_info_le->flags & BRCMF_BSS_RSSI_ON_CHANNEL)) {
029591f3
AS		 2939 s16 bss_rssi = le16_to_cpu(bss->RSSI);
2940 s16 bss_info_rssi = le16_to_cpu(bss_info_le->RSSI);
2941
e756af5b
HM		 2942 /* preserve max RSSI if the measurements are
2943 * both on-channel or both off-channel
2944 */
029591f3 2945 if (bss_info_rssi > bss_rssi)
e756af5b 2946 bss->RSSI = bss_info_le->RSSI;
6f5838a4
AS		 2947 } else if ((bss->flags & BRCMF_BSS_RSSI_ON_CHANNEL) &&
2948 (bss_info_le->flags & BRCMF_BSS_RSSI_ON_CHANNEL) == 0) {
e756af5b
HM		 2949 /* preserve the on-channel rssi measurement
2950 * if the new measurement is off channel
2951 */
2952 bss->RSSI = bss_info_le->RSSI;
6f5838a4 2953 bss->flags |= BRCMF_BSS_RSSI_ON_CHANNEL;
e756af5b
HM		 2954 }
2955 return 1;
2956 }
2957 return 0;
2958}
2959
2960static s32
1993732e 2961brcmf_cfg80211_escan_handler(struct brcmf_if *ifp,
e756af5b
HM		 2962 const struct brcmf_event_msg *e, void *data)
2963{
1993732e 2964 struct brcmf_cfg80211_info *cfg = ifp->drvr->config;
e756af5b 2965 s32 status;
e756af5b
HM		 2966 struct brcmf_escan_result_le *escan_result_le;
2967 struct brcmf_bss_info_le *bss_info_le;
2968 struct brcmf_bss_info_le *bss = NULL;
2969 u32 bi_length;
2970 struct brcmf_scan_results *list;
2971 u32 i;
97ed15c7 2972 bool aborted;
e756af5b 2973
5c36b99a 2974 status = e->status;
e756af5b 2975
a0f472ac 2976 if (!test_bit(BRCMF_SCAN_STATUS_BUSY, &cfg->scan_status)) {
37a869ec 2977 brcmf_err("scan not ready, bsscfgidx=%d\n", ifp->bsscfgidx);
e756af5b
HM		 2978 return -EPERM;
2979 }
2980
2981 if (status == BRCMF_E_STATUS_PARTIAL) {
4e8a008e 2982 brcmf_dbg(SCAN, "ESCAN Partial result\n");
e756af5b
HM		 2983 escan_result_le = (struct brcmf_escan_result_le *) data;
2984 if (!escan_result_le) {
57d6e91a 2985 brcmf_err("Invalid escan result (NULL pointer)\n");
e756af5b
HM		 2986 goto exit;
2987 }
e756af5b 2988 if (le16_to_cpu(escan_result_le->bss_count) != 1) {
57d6e91a
AS		 2989 brcmf_err("Invalid bss_count %d: ignoring\n",
2990 escan_result_le->bss_count);
e756af5b
HM		 2991 goto exit;
2992 }
2993 bss_info_le = &escan_result_le->bss_info_le;
2994
6eda4e2c
HM		 2995 if (brcmf_p2p_scan_finding_common_channel(cfg, bss_info_le))
2996 goto exit;
2997
2998 if (!cfg->scan_request) {
2999 brcmf_dbg(SCAN, "result without cfg80211 request\n");
3000 goto exit;
3001 }
3002
e756af5b
HM		 3003 bi_length = le32_to_cpu(bss_info_le->length);
3004 if (bi_length != (le32_to_cpu(escan_result_le->buflen) -
3005 WL_ESCAN_RESULTS_FIXED_SIZE)) {
57d6e91a
AS		 3006 brcmf_err("Invalid bss_info length %d: ignoring\n",
3007 bi_length);
e756af5b
HM		 3008 goto exit;
3009 }
3010
27a68fe3 3011 if (!(cfg_to_wiphy(cfg)->interface_modes &
e756af5b
HM		 3012 BIT(NL80211_IFTYPE_ADHOC))) {
3013 if (le16_to_cpu(bss_info_le->capability) &
3014 WLAN_CAPABILITY_IBSS) {
57d6e91a 3015 brcmf_err("Ignoring IBSS result\n");
e756af5b
HM		 3016 goto exit;
3017 }
3018 }
3019
3020 list = (struct brcmf_scan_results *)
27a68fe3 3021 cfg->escan_info.escan_buf;
d5367334 3022 if (bi_length > BRCMF_ESCAN_BUF_SIZE - list->buflen) {
57d6e91a 3023 brcmf_err("Buffer is too small: ignoring\n");
e756af5b
HM		 3024 goto exit;
3025 }
3026
3027 for (i = 0; i < list->count; i++) {
3028 bss = bss ? (struct brcmf_bss_info_le *)
3029 ((unsigned char *)bss +
3030 le32_to_cpu(bss->length)) : list->bss_info_le;
83cf17aa
FL		 3031 if (brcmf_compare_update_same_bss(cfg, bss,
3032 bss_info_le))
e756af5b
HM		 3033 goto exit;
3034 }
d5367334
HM		 3035 memcpy(&cfg->escan_info.escan_buf[list->buflen], bss_info_le,
3036 bi_length);
e756af5b
HM		 3037 list->version = le32_to_cpu(bss_info_le->version);
3038 list->buflen += bi_length;
3039 list->count++;
3040 } else {
27a68fe3 3041 cfg->escan_info.escan_state = WL_ESCAN_STATE_IDLE;
6eda4e2c
HM		 3042 if (brcmf_p2p_scan_finding_common_channel(cfg, NULL))
3043 goto exit;
27a68fe3 3044 if (cfg->scan_request) {
27a68fe3 3045 brcmf_inform_bss(cfg);
97ed15c7 3046 aborted = status != BRCMF_E_STATUS_SUCCESS;
ef8596e1 3047 brcmf_notify_escan_complete(cfg, ifp, aborted, false);
e756af5b 3048 } else
6eda4e2c
HM		 3049 brcmf_dbg(SCAN, "Ignored scan complete result 0x%x\n",
3050 status);
e756af5b
HM		 3051 }
3052exit:
12f32370 3053 return 0;
e756af5b
HM		 3054}
3055
27a68fe3 3056static void brcmf_init_escan(struct brcmf_cfg80211_info *cfg)
e756af5b 3057{
5c36b99a
AS		 3058 brcmf_fweh_register(cfg->pub, BRCMF_E_ESCAN_RESULT,
3059 brcmf_cfg80211_escan_handler);
f0799895
HM		 3060 cfg->escan_info.escan_state = WL_ESCAN_STATE_IDLE;
3061 /* Init scan_timeout timer */
3062 init_timer(&cfg->escan_timeout);
3063 cfg->escan_timeout.data = (unsigned long) cfg;
3064 cfg->escan_timeout.function = brcmf_escan_timeout;
3065 INIT_WORK(&cfg->escan_timeout_work,
3066 brcmf_cfg80211_escan_timeout_worker);
e756af5b
HM		 3067}
3068
5419f7f1
HM		 3069/* PFN result doesn't have all the info which are required by the supplicant
3070 * (For e.g IEs) Do a target Escan so that sched scan results are reported
3071 * via wl_inform_single_bss in the required format. Escan does require the
3072 * scan request in the form of cfg80211_scan_request. For timebeing, create
3073 * cfg80211_scan_request one out of the received PNO event.
3074 */
3021ad9a 3075static s32
5419f7f1
HM		 3076brcmf_notify_sched_scan_results(struct brcmf_if *ifp,
3077 const struct brcmf_event_msg *e, void *data)
3021ad9a
HM		 3078{
3079 struct brcmf_cfg80211_info *cfg = ifp->drvr->config;
5419f7f1
HM		 3080 struct brcmf_pno_net_info_le *netinfo, *netinfo_start;
3081 struct cfg80211_scan_request *request = NULL;
3082 struct cfg80211_ssid *ssid = NULL;
3083 struct ieee80211_channel *channel = NULL;
3084 struct wiphy *wiphy = cfg_to_wiphy(cfg);
3085 int err = 0;
3086 int channel_req = 0;
3087 int band = 0;
3021ad9a 3088 struct brcmf_pno_scanresults_le *pfn_result;
5419f7f1
HM		 3089 u32 result_count;
3090 u32 status;
3021ad9a
HM		 3091
3092 brcmf_dbg(SCAN, "Enter\n");
3093
0aedbcaf
HM		 3094 if (e->datalen < (sizeof(*pfn_result) + sizeof(*netinfo))) {
3095 brcmf_dbg(SCAN, "Event data to small. Ignore\n");
3096 return 0;
3097 }
3098
3021ad9a 3099 if (e->event_code == BRCMF_E_PFN_NET_LOST) {
5419f7f1 3100 brcmf_dbg(SCAN, "PFN NET LOST event. Do Nothing\n");
3021ad9a
HM		 3101 return 0;
3102 }
3103
5419f7f1
HM		 3104 pfn_result = (struct brcmf_pno_scanresults_le *)data;
3105 result_count = le32_to_cpu(pfn_result->count);
3106 status = le32_to_cpu(pfn_result->status);
3021ad9a 3107
5419f7f1
HM		 3108 /* PFN event is limited to fit 512 bytes so we may get
3109 * multiple NET_FOUND events. For now place a warning here.
3110 */
3111 WARN_ON(status != BRCMF_PNO_SCAN_COMPLETE);
3112 brcmf_dbg(SCAN, "PFN NET FOUND event. count: %d\n", result_count);
3113 if (result_count > 0) {
3114 int i;
3021ad9a 3115
5419f7f1
HM		 3116 request = kzalloc(sizeof(*request), GFP_KERNEL);
3117 ssid = kcalloc(result_count, sizeof(*ssid), GFP_KERNEL);
3118 channel = kcalloc(result_count, sizeof(*channel), GFP_KERNEL);
3119 if (!request || !ssid || !channel) {
3120 err = -ENOMEM;
3121 goto out_err;
3122 }
3021ad9a 3123
5419f7f1
HM		 3124 request->wiphy = wiphy;
3125 data += sizeof(struct brcmf_pno_scanresults_le);
3126 netinfo_start = (struct brcmf_pno_net_info_le *)data;
3021ad9a 3127
5419f7f1
HM		 3128 for (i = 0; i < result_count; i++) {
3129 netinfo = &netinfo_start[i];
3130 if (!netinfo) {
3131 brcmf_err("Invalid netinfo ptr. index: %d\n",
3132 i);
3133 err = -EINVAL;
3134 goto out_err;
3135 }
aeb64225 3136
5419f7f1
HM		 3137 brcmf_dbg(SCAN, "SSID:%s Channel:%d\n",
3138 netinfo->SSID, netinfo->channel);
3139 memcpy(ssid[i].ssid, netinfo->SSID, netinfo->SSID_len);
3140 ssid[i].ssid_len = netinfo->SSID_len;
3141 request->n_ssids++;
aeb64225 3142
5419f7f1
HM		 3143 channel_req = netinfo->channel;
3144 if (channel_req <= CH_MAX_2G_CHANNEL)
3145 band = NL80211_BAND_2GHZ;
3146 else
3147 band = NL80211_BAND_5GHZ;
3148 channel[i].center_freq =
3149 ieee80211_channel_to_frequency(channel_req,
3150 band);
3151 channel[i].band = band;
3152 channel[i].flags |= IEEE80211_CHAN_NO_HT40;
3153 request->channels[i] = &channel[i];
3154 request->n_channels++;
3155 }
aeb64225 3156
5419f7f1
HM		 3157 /* assign parsed ssid array */
3158 if (request->n_ssids)
3159 request->ssids = &ssid[0];
aeb64225 3160
5419f7f1
HM		 3161 if (test_bit(BRCMF_SCAN_STATUS_BUSY, &cfg->scan_status)) {
3162 /* Abort any on-going scan */
3163 brcmf_abort_scanning(cfg);
aeb64225 3164 }
5419f7f1
HM		 3165
3166 set_bit(BRCMF_SCAN_STATUS_BUSY, &cfg->scan_status);
3167 cfg->escan_info.run = brcmf_run_escan;
3168 err = brcmf_do_escan(cfg, wiphy, ifp, request);
3169 if (err) {
3170 clear_bit(BRCMF_SCAN_STATUS_BUSY, &cfg->scan_status);
3171 goto out_err;
3021ad9a 3172 }
5419f7f1
HM		 3173 cfg->sched_escan = true;
3174 cfg->scan_request = request;
aeb64225 3175 } else {
5419f7f1
HM		 3176 brcmf_err("FALSE PNO Event. (pfn_count == 0)\n");
3177 goto out_err;
aeb64225 3178 }
aeb64225 3179
5419f7f1
HM		 3180 kfree(ssid);
3181 kfree(channel);
3182 kfree(request);
3183 return 0;
aeb64225 3184
5419f7f1
HM		 3185out_err:
3186 kfree(ssid);
3187 kfree(channel);
3188 kfree(request);
3189 cfg80211_sched_scan_stopped(wiphy);
3190 return err;
aeb64225
HM		 3191}
3192
5419f7f1 3193static int brcmf_dev_pno_clean(struct net_device *ndev)
5b435de0 3194{
5419f7f1 3195 int ret;
4eb3af7c 3196
5419f7f1
HM		 3197 /* Disable pfn */
3198 ret = brcmf_fil_iovar_int_set(netdev_priv(ndev), "pfn", 0);
3199 if (ret == 0) {
3200 /* clear pfn */
3201 ret = brcmf_fil_iovar_data_set(netdev_priv(ndev), "pfnclear",
3202 NULL, 0);
3203 }
3204 if (ret < 0)
3205 brcmf_err("failed code %d\n", ret);
5b435de0 3206
5419f7f1
HM		 3207 return ret;
3208}
3209
3210static int brcmf_dev_pno_config(struct brcmf_if *ifp,
3211 struct cfg80211_sched_scan_request *request)
3212{
3213 struct brcmf_pno_param_le pfn_param;
3214 struct brcmf_pno_macaddr_le pfn_mac;
3215 s32 err;
3216 u8 *mac_mask;
3217 int i;
3218
3219 memset(&pfn_param, 0, sizeof(pfn_param));
3220 pfn_param.version = cpu_to_le32(BRCMF_PNO_VERSION);
3221
3222 /* set extra pno params */
3223 pfn_param.flags = cpu_to_le16(1 << BRCMF_PNO_ENABLE_ADAPTSCAN_BIT);
3224 pfn_param.repeat = BRCMF_PNO_REPEAT;
3225 pfn_param.exp = BRCMF_PNO_FREQ_EXPO_MAX;
3226
3227 /* set up pno scan fr */
3228 pfn_param.scan_freq = cpu_to_le32(BRCMF_PNO_TIME);
3229
3230 err = brcmf_fil_iovar_data_set(ifp, "pfn_set", &pfn_param,
3231 sizeof(pfn_param));
3232 if (err) {
3233 brcmf_err("pfn_set failed, err=%d\n", err);
3234 return err;
3235 }
3236
3237 /* Find out if mac randomization should be turned on */
3238 if (!(request->flags & NL80211_SCAN_FLAG_RANDOM_ADDR))
3239 return 0;
3240
3241 pfn_mac.version = BRCMF_PFN_MACADDR_CFG_VER;
3242 pfn_mac.flags = BRCMF_PFN_MAC_OUI_ONLY | BRCMF_PFN_SET_MAC_UNASSOC;
3243
3244 memcpy(pfn_mac.mac, request->mac_addr, ETH_ALEN);
3245 mac_mask = request->mac_addr_mask;
3246 for (i = 0; i < ETH_ALEN; i++) {
3247 pfn_mac.mac[i] &= mac_mask[i];
3248 pfn_mac.mac[i] |= get_random_int() & ~(mac_mask[i]);
3249 }
3250 /* Clear multi bit */
3251 pfn_mac.mac[0] &= 0xFE;
3252 /* Set locally administered */
3253 pfn_mac.mac[0] |= 0x02;
3254
3255 err = brcmf_fil_iovar_data_set(ifp, "pfn_macaddr", &pfn_mac,
3256 sizeof(pfn_mac));
3257 if (err)
3258 brcmf_err("pfn_macaddr failed, err=%d\n", err);
3259
3260 return err;
3261}
3262
3263static int
3264brcmf_cfg80211_sched_scan_start(struct wiphy *wiphy,
3265 struct net_device *ndev,
3266 struct cfg80211_sched_scan_request *request)
3267{
3268 struct brcmf_if *ifp = netdev_priv(ndev);
3269 struct brcmf_cfg80211_info *cfg = wiphy_priv(wiphy);
3270 struct brcmf_pno_net_param_le pfn;
3271 int i;
3272 int ret = 0;
3273
3274 brcmf_dbg(SCAN, "Enter n_match_sets:%d n_ssids:%d\n",
3275 request->n_match_sets, request->n_ssids);
3276 if (test_bit(BRCMF_SCAN_STATUS_BUSY, &cfg->scan_status)) {
3277 brcmf_err("Scanning already: status (%lu)\n", cfg->scan_status);
3278 return -EAGAIN;
3279 }
3280 if (test_bit(BRCMF_SCAN_STATUS_SUPPRESS, &cfg->scan_status)) {
3281 brcmf_err("Scanning suppressed: status (%lu)\n",
3282 cfg->scan_status);
3283 return -EAGAIN;
3284 }
3285
3286 if (!request->n_ssids || !request->n_match_sets) {
3287 brcmf_dbg(SCAN, "Invalid sched scan req!! n_ssids:%d\n",
3288 request->n_ssids);
3289 return -EINVAL;
3290 }
3291
3292 if (request->n_ssids > 0) {
3293 for (i = 0; i < request->n_ssids; i++) {
3294 /* Active scan req for ssids */
3295 brcmf_dbg(SCAN, ">>> Active scan req for ssid (%s)\n",
3296 request->ssids[i].ssid);
3297
3298 /* match_set ssids is a supert set of n_ssid list,
3299 * so we need not add these set separately.
3300 */
3301 }
3302 }
3303
3304 if (request->n_match_sets > 0) {
3305 /* clean up everything */
3306 ret = brcmf_dev_pno_clean(ndev);
3307 if (ret < 0) {
3308 brcmf_err("failed error=%d\n", ret);
3309 return ret;
3310 }
3311
3312 /* configure pno */
3313 if (brcmf_dev_pno_config(ifp, request))
3314 return -EINVAL;
3315
3316 /* configure each match set */
3317 for (i = 0; i < request->n_match_sets; i++) {
3318 struct cfg80211_ssid *ssid;
3319 u32 ssid_len;
3320
3321 ssid = &request->match_sets[i].ssid;
3322 ssid_len = ssid->ssid_len;
3323
3324 if (!ssid_len) {
3325 brcmf_err("skip broadcast ssid\n");
3326 continue;
3327 }
3328 pfn.auth = cpu_to_le32(WLAN_AUTH_OPEN);
3329 pfn.wpa_auth = cpu_to_le32(BRCMF_PNO_WPA_AUTH_ANY);
3330 pfn.wsec = cpu_to_le32(0);
3331 pfn.infra = cpu_to_le32(1);
3332 pfn.flags = cpu_to_le32(1 << BRCMF_PNO_HIDDEN_BIT);
3333 pfn.ssid.SSID_len = cpu_to_le32(ssid_len);
3334 memcpy(pfn.ssid.SSID, ssid->ssid, ssid_len);
3335 ret = brcmf_fil_iovar_data_set(ifp, "pfn_add", &pfn,
3336 sizeof(pfn));
3337 brcmf_dbg(SCAN, ">>> PNO filter %s for ssid (%s)\n",
3338 ret == 0 ? "set" : "failed", ssid->ssid);
3339 }
3340 /* Enable the PNO */
3341 if (brcmf_fil_iovar_int_set(ifp, "pfn", 1) < 0) {
3342 brcmf_err("PNO enable failed!! ret=%d\n", ret);
3343 return -EINVAL;
3344 }
3345 } else {
3346 return -EINVAL;
3347 }
3348
3349 return 0;
3350}
3351
3352static int brcmf_cfg80211_sched_scan_stop(struct wiphy *wiphy,
3353 struct net_device *ndev)
3354{
3355 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy);
3356
3357 brcmf_dbg(SCAN, "enter\n");
3358 brcmf_dev_pno_clean(ndev);
3359 if (cfg->sched_escan)
3360 brcmf_notify_escan_complete(cfg, netdev_priv(ndev), true, true);
3361 return 0;
3362}
3363
3364static __always_inline void brcmf_delay(u32 ms)
3365{
3366 if (ms < 1000 / HZ) {
3367 cond_resched();
3368 mdelay(ms);
3369 } else {
3370 msleep(ms);
3371 }
3372}
3373
3374static s32 brcmf_config_wowl_pattern(struct brcmf_if *ifp, u8 cmd[4],
3375 u8 *pattern, u32 patternsize, u8 *mask,
3376 u32 packet_offset)
3377{
3378 struct brcmf_fil_wowl_pattern_le *filter;
3379 u32 masksize;
3380 u32 patternoffset;
3381 u8 *buf;
3382 u32 bufsize;
3383 s32 ret;
3384
3385 masksize = (patternsize + 7) / 8;
3386 patternoffset = sizeof(*filter) - sizeof(filter->cmd) + masksize;
3387
3388 bufsize = sizeof(*filter) + patternsize + masksize;
3389 buf = kzalloc(bufsize, GFP_KERNEL);
3390 if (!buf)
3391 return -ENOMEM;
3392 filter = (struct brcmf_fil_wowl_pattern_le *)buf;
3393
3394 memcpy(filter->cmd, cmd, 4);
3395 filter->masksize = cpu_to_le32(masksize);
3396 filter->offset = cpu_to_le32(packet_offset);
3397 filter->patternoffset = cpu_to_le32(patternoffset);
3398 filter->patternsize = cpu_to_le32(patternsize);
3399 filter->type = cpu_to_le32(BRCMF_WOWL_PATTERN_TYPE_BITMAP);
3400
3401 if ((mask) && (masksize))
3402 memcpy(buf + sizeof(*filter), mask, masksize);
3403 if ((pattern) && (patternsize))
3404 memcpy(buf + sizeof(*filter) + masksize, pattern, patternsize);
3405
3406 ret = brcmf_fil_iovar_data_set(ifp, "wowl_pattern", buf, bufsize);
3407
3408 kfree(buf);
3409 return ret;
3410}
3411
3412static s32
3413brcmf_wowl_nd_results(struct brcmf_if *ifp, const struct brcmf_event_msg *e,
3414 void *data)
3415{
3416 struct brcmf_cfg80211_info *cfg = ifp->drvr->config;
3417 struct brcmf_pno_scanresults_le *pfn_result;
3418 struct brcmf_pno_net_info_le *netinfo;
3419
3420 brcmf_dbg(SCAN, "Enter\n");
3421
0aedbcaf
HM		 3422 if (e->datalen < (sizeof(*pfn_result) + sizeof(*netinfo))) {
3423 brcmf_dbg(SCAN, "Event data to small. Ignore\n");
3424 return 0;
3425 }
3426
5419f7f1
HM		 3427 pfn_result = (struct brcmf_pno_scanresults_le *)data;
3428
3429 if (e->event_code == BRCMF_E_PFN_NET_LOST) {
3430 brcmf_dbg(SCAN, "PFN NET LOST event. Ignore\n");
3431 return 0;
3432 }
3433
3434 if (le32_to_cpu(pfn_result->count) < 1) {
3435 brcmf_err("Invalid result count, expected 1 (%d)\n",
3436 le32_to_cpu(pfn_result->count));
3437 return -EINVAL;
3438 }
3439
3440 data += sizeof(struct brcmf_pno_scanresults_le);
3441 netinfo = (struct brcmf_pno_net_info_le *)data;
3442 memcpy(cfg->wowl.nd->ssid.ssid, netinfo->SSID, netinfo->SSID_len);
3443 cfg->wowl.nd->ssid.ssid_len = netinfo->SSID_len;
3444 cfg->wowl.nd->n_channels = 1;
3445 cfg->wowl.nd->channels[0] =
3446 ieee80211_channel_to_frequency(netinfo->channel,
3447 netinfo->channel <= CH_MAX_2G_CHANNEL ?
3448 NL80211_BAND_2GHZ : NL80211_BAND_5GHZ);
3449 cfg->wowl.nd_info->n_matches = 1;
3450 cfg->wowl.nd_info->matches[0] = cfg->wowl.nd;
3451
3452 /* Inform (the resume task) that the net detect information was recvd */
3453 cfg->wowl.nd_data_completed = true;
3454 wake_up(&cfg->wowl.nd_data_wait);
3455
3456 return 0;
3457}
3458
3459#ifdef CONFIG_PM
3460
3461static void brcmf_report_wowl_wakeind(struct wiphy *wiphy, struct brcmf_if *ifp)
3462{
3463 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy);
3464 struct brcmf_wowl_wakeind_le wake_ind_le;
3465 struct cfg80211_wowlan_wakeup wakeup_data;
3466 struct cfg80211_wowlan_wakeup *wakeup;
3467 u32 wakeind;
3468 s32 err;
3469 int timeout;
3470
3471 err = brcmf_fil_iovar_data_get(ifp, "wowl_wakeind", &wake_ind_le,
3472 sizeof(wake_ind_le));
3473 if (err) {
3474 brcmf_err("Get wowl_wakeind failed, err = %d\n", err);
3475 return;
3476 }
3477
3478 wakeind = le32_to_cpu(wake_ind_le.ucode_wakeind);
3479 if (wakeind & (BRCMF_WOWL_MAGIC | BRCMF_WOWL_DIS | BRCMF_WOWL_BCN |
3480 BRCMF_WOWL_RETR | BRCMF_WOWL_NET |
3481 BRCMF_WOWL_PFN_FOUND)) {
3482 wakeup = &wakeup_data;
3483 memset(&wakeup_data, 0, sizeof(wakeup_data));
3484 wakeup_data.pattern_idx = -1;
3485
3486 if (wakeind & BRCMF_WOWL_MAGIC) {
3487 brcmf_dbg(INFO, "WOWL Wake indicator: BRCMF_WOWL_MAGIC\n");
3488 wakeup_data.magic_pkt = true;
3489 }
3490 if (wakeind & BRCMF_WOWL_DIS) {
3491 brcmf_dbg(INFO, "WOWL Wake indicator: BRCMF_WOWL_DIS\n");
3492 wakeup_data.disconnect = true;
3493 }
3494 if (wakeind & BRCMF_WOWL_BCN) {
3495 brcmf_dbg(INFO, "WOWL Wake indicator: BRCMF_WOWL_BCN\n");
3496 wakeup_data.disconnect = true;
3497 }
3498 if (wakeind & BRCMF_WOWL_RETR) {
3499 brcmf_dbg(INFO, "WOWL Wake indicator: BRCMF_WOWL_RETR\n");
3500 wakeup_data.disconnect = true;
3501 }
3502 if (wakeind & BRCMF_WOWL_NET) {
3503 brcmf_dbg(INFO, "WOWL Wake indicator: BRCMF_WOWL_NET\n");
3504 /* For now always map to pattern 0, no API to get
3505 * correct information available at the moment.
3506 */
3507 wakeup_data.pattern_idx = 0;
3508 }
3509 if (wakeind & BRCMF_WOWL_PFN_FOUND) {
3510 brcmf_dbg(INFO, "WOWL Wake indicator: BRCMF_WOWL_PFN_FOUND\n");
3511 timeout = wait_event_timeout(cfg->wowl.nd_data_wait,
3512 cfg->wowl.nd_data_completed,
3513 BRCMF_ND_INFO_TIMEOUT);
3514 if (!timeout)
3515 brcmf_err("No result for wowl net detect\n");
3516 else
3517 wakeup_data.net_detect = cfg->wowl.nd_info;
3518 }
5c22fb85
HM		 3519 if (wakeind & BRCMF_WOWL_GTK_FAILURE) {
3520 brcmf_dbg(INFO, "WOWL Wake indicator: BRCMF_WOWL_GTK_FAILURE\n");
3521 wakeup_data.gtk_rekey_failure = true;
3522 }
5419f7f1
HM		 3523 } else {
3524 wakeup = NULL;
3525 }
3526 cfg80211_report_wowlan_wakeup(&ifp->vif->wdev, wakeup, GFP_KERNEL);
3527}
3528
3529#else
3530
3531static void brcmf_report_wowl_wakeind(struct wiphy *wiphy, struct brcmf_if *ifp)
3532{
3533}
3534
3535#endif /* CONFIG_PM */
3536
3537static s32 brcmf_cfg80211_resume(struct wiphy *wiphy)
3538{
3539 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy);
3540 struct net_device *ndev = cfg_to_ndev(cfg);
3541 struct brcmf_if *ifp = netdev_priv(ndev);
3542
3543 brcmf_dbg(TRACE, "Enter\n");
3544
3545 if (cfg->wowl.active) {
3546 brcmf_report_wowl_wakeind(wiphy, ifp);
3547 brcmf_fil_iovar_int_set(ifp, "wowl_clear", 0);
3548 brcmf_config_wowl_pattern(ifp, "clr", NULL, 0, NULL, 0);
73ef9e64
HM		 3549 if (!brcmf_feat_is_enabled(ifp, BRCMF_FEAT_WOWL_ARP_ND))
3550 brcmf_configure_arp_nd_offload(ifp, true);
4eb3af7c 3551 brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_PM,
3021ad9a
HM		 3552 cfg->wowl.pre_pmmode);
3553 cfg->wowl.active = false;
3554 if (cfg->wowl.nd_enabled) {
3555 brcmf_cfg80211_sched_scan_stop(cfg->wiphy, ifp->ndev);
3556 brcmf_fweh_unregister(cfg->pub, BRCMF_E_PFN_NET_FOUND);
3557 brcmf_fweh_register(cfg->pub, BRCMF_E_PFN_NET_FOUND,
3558 brcmf_notify_sched_scan_results);
3559 cfg->wowl.nd_enabled = false;
3560 }
4eb3af7c 3561 }
5b435de0
AS		 3562 return 0;
3563}
3564
4eb3af7c
HM		 3565static void brcmf_configure_wowl(struct brcmf_cfg80211_info *cfg,
3566 struct brcmf_if *ifp,
3567 struct cfg80211_wowlan *wowl)
3568{
3569 u32 wowl_config;
b9a82f89 3570 u32 i;
4eb3af7c
HM		 3571
3572 brcmf_dbg(TRACE, "Suspend, wowl config.\n");
3573
73ef9e64
HM		 3574 if (!brcmf_feat_is_enabled(ifp, BRCMF_FEAT_WOWL_ARP_ND))
3575 brcmf_configure_arp_nd_offload(ifp, false);
3021ad9a 3576 brcmf_fil_cmd_int_get(ifp, BRCMF_C_GET_PM, &cfg->wowl.pre_pmmode);
4eb3af7c
HM		 3577 brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_PM, PM_MAX);
3578
3579 wowl_config = 0;
3580 if (wowl->disconnect)
b9a82f89 3581 wowl_config = BRCMF_WOWL_DIS | BRCMF_WOWL_BCN | BRCMF_WOWL_RETR;
4eb3af7c 3582 if (wowl->magic_pkt)
b9a82f89
HM		 3583 wowl_config |= BRCMF_WOWL_MAGIC;
3584 if ((wowl->patterns) && (wowl->n_patterns)) {
3585 wowl_config |= BRCMF_WOWL_NET;
3586 for (i = 0; i < wowl->n_patterns; i++) {
3587 brcmf_config_wowl_pattern(ifp, "add",
3588 (u8 *)wowl->patterns[i].pattern,
3589 wowl->patterns[i].pattern_len,
3590 (u8 *)wowl->patterns[i].mask,
3591 wowl->patterns[i].pkt_offset);
3592 }
3593 }
3021ad9a
HM		 3594 if (wowl->nd_config) {
3595 brcmf_cfg80211_sched_scan_start(cfg->wiphy, ifp->ndev,
3596 wowl->nd_config);
3597 wowl_config |= BRCMF_WOWL_PFN_FOUND;
3598
3599 cfg->wowl.nd_data_completed = false;
3600 cfg->wowl.nd_enabled = true;
3601 /* Now reroute the event for PFN to the wowl function. */
3602 brcmf_fweh_unregister(cfg->pub, BRCMF_E_PFN_NET_FOUND);
3603 brcmf_fweh_register(cfg->pub, BRCMF_E_PFN_NET_FOUND,
3604 brcmf_wowl_nd_results);
3605 }
5c22fb85
HM		 3606 if (wowl->gtk_rekey_failure)
3607 wowl_config |= BRCMF_WOWL_GTK_FAILURE;
3021ad9a
HM		 3608 if (!test_bit(BRCMF_VIF_STATUS_CONNECTED, &ifp->vif->sme_state))
3609 wowl_config |= BRCMF_WOWL_UNASSOC;
3610
28b285a6
HM		 3611 brcmf_fil_iovar_data_set(ifp, "wowl_wakeind", "clear",
3612 sizeof(struct brcmf_wowl_wakeind_le));
4eb3af7c
HM		 3613 brcmf_fil_iovar_int_set(ifp, "wowl", wowl_config);
3614 brcmf_fil_iovar_int_set(ifp, "wowl_activate", 1);
3615 brcmf_bus_wowl_config(cfg->pub->bus_if, true);
3021ad9a 3616 cfg->wowl.active = true;
4eb3af7c
HM		 3617}
3618
5b435de0 3619static s32 brcmf_cfg80211_suspend(struct wiphy *wiphy,
4eb3af7c 3620 struct cfg80211_wowlan *wowl)
5b435de0 3621{
27a68fe3
AS		 3622 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy);
3623 struct net_device *ndev = cfg_to_ndev(cfg);
4eb3af7c 3624 struct brcmf_if *ifp = netdev_priv(ndev);
7d641072 3625 struct brcmf_cfg80211_vif *vif;
5b435de0 3626
d96b801f 3627 brcmf_dbg(TRACE, "Enter\n");
5b435de0 3628
4eb3af7c 3629 /* if the primary net_device is not READY there is nothing
7d641072 3630 * we can do but pray resume goes smoothly.
5b435de0 3631 */
4eb3af7c 3632 if (!check_vif_up(ifp->vif))
7d641072 3633 goto exit;
5b435de0 3634
3021ad9a
HM		 3635 /* Stop scheduled scan */
3636 if (brcmf_feat_is_enabled(ifp, BRCMF_FEAT_PNO))
3637 brcmf_cfg80211_sched_scan_stop(wiphy, ndev);
3638
7d641072
AS		 3639 /* end any scanning */
3640 if (test_bit(BRCMF_SCAN_STATUS_BUSY, &cfg->scan_status))
27a68fe3 3641 brcmf_abort_scanning(cfg);
5b435de0 3642
4eb3af7c
HM		 3643 if (wowl == NULL) {
3644 brcmf_bus_wowl_config(cfg->pub->bus_if, false);
3645 list_for_each_entry(vif, &cfg->vif_list, list) {
3646 if (!test_bit(BRCMF_VIF_STATUS_READY, &vif->sme_state))
3647 continue;
3648 /* While going to suspend if associated with AP
3649 * disassociate from AP to save power while system is
3650 * in suspended state
3651 */
9b7a0ddc 3652 brcmf_link_down(vif, WLAN_REASON_UNSPECIFIED);
4eb3af7c
HM		 3653 /* Make sure WPA_Supplicant receives all the event
3654 * generated due to DISASSOC call to the fw to keep
5419f7f1
HM		 3655 * the state fw and WPA_Supplicant state consistent
3656 */
3657 brcmf_delay(500);
e5806072 3658 }
5419f7f1
HM		 3659 /* Configure MPC */
3660 brcmf_set_mpc(ifp, 1);
e5806072 3661
e5806072 3662 } else {
5419f7f1
HM		 3663 /* Configure WOWL paramaters */
3664 brcmf_configure_wowl(cfg, ifp, wowl);
e5806072
AS		 3665 }
3666
5419f7f1
HM		 3667exit:
3668 brcmf_dbg(TRACE, "Exit\n");
3669 /* clear any scanning activity */
3670 cfg->scan_status = 0;
e5806072 3671 return 0;
e5806072
AS		 3672}
3673
5419f7f1
HM		 3674static __used s32
3675brcmf_update_pmklist(struct brcmf_cfg80211_info *cfg, struct brcmf_if *ifp)
e5806072 3676{
5419f7f1 3677 struct brcmf_pmk_list_le *pmk_list;
48ed16e8 3678 int i;
5419f7f1
HM		 3679 u32 npmk;
3680 s32 err;
e5806072 3681
5419f7f1
HM		 3682 pmk_list = &cfg->pmk_list;
3683 npmk = le32_to_cpu(pmk_list->npmk);
48ed16e8 3684
5419f7f1
HM		 3685 brcmf_dbg(CONN, "No of elements %d\n", npmk);
3686 for (i = 0; i < npmk; i++)
3687 brcmf_dbg(CONN, "PMK[%d]: %pM\n", i, &pmk_list->pmk[i].bssid);
48ed16e8 3688
5419f7f1
HM		 3689 err = brcmf_fil_iovar_data_set(ifp, "pmkid_info", pmk_list,
3690 sizeof(*pmk_list));
48ed16e8
HM		 3691
3692 return err;
e5806072
AS		 3693}
3694
5419f7f1
HM		 3695static s32
3696brcmf_cfg80211_set_pmksa(struct wiphy *wiphy, struct net_device *ndev,
3697 struct cfg80211_pmksa *pmksa)
e5806072 3698{
5419f7f1 3699 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy);
c1179033 3700 struct brcmf_if *ifp = netdev_priv(ndev);
5419f7f1
HM		 3701 struct brcmf_pmksa *pmk = &cfg->pmk_list.pmk[0];
3702 s32 err;
3703 u32 npmk, i;
e5806072 3704
5419f7f1
HM		 3705 brcmf_dbg(TRACE, "Enter\n");
3706 if (!check_vif_up(ifp->vif))
3707 return -EIO;
e5806072 3708
5419f7f1
HM		 3709 npmk = le32_to_cpu(cfg->pmk_list.npmk);
3710 for (i = 0; i < npmk; i++)
3711 if (!memcmp(pmksa->bssid, pmk[i].bssid, ETH_ALEN))
3712 break;
3713 if (i < BRCMF_MAXPMKID) {
3714 memcpy(pmk[i].bssid, pmksa->bssid, ETH_ALEN);
3715 memcpy(pmk[i].pmkid, pmksa->pmkid, WLAN_PMKID_LEN);
3716 if (i == npmk) {
3717 npmk++;
3718 cfg->pmk_list.npmk = cpu_to_le32(npmk);
3719 }
3720 } else {
3721 brcmf_err("Too many PMKSA entries cached %d\n", npmk);
e5806072
AS		 3722 return -EINVAL;
3723 }
3724
5419f7f1
HM		 3725 brcmf_dbg(CONN, "set_pmksa - PMK bssid: %pM =\n", pmk[npmk].bssid);
3726 for (i = 0; i < WLAN_PMKID_LEN; i += 4)
3727 brcmf_dbg(CONN, "%02x %02x %02x %02x\n", pmk[npmk].pmkid[i],
3728 pmk[npmk].pmkid[i + 1], pmk[npmk].pmkid[i + 2],
3729 pmk[npmk].pmkid[i + 3]);
e5806072 3730
5419f7f1 3731 err = brcmf_update_pmklist(cfg, ifp);
e5806072 3732
5419f7f1
HM		 3733 brcmf_dbg(TRACE, "Exit\n");
3734 return err;
3735}
e5806072 3736
5419f7f1
HM		 3737static s32
3738brcmf_cfg80211_del_pmksa(struct wiphy *wiphy, struct net_device *ndev,
3739 struct cfg80211_pmksa *pmksa)
3740{
3741 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy);
3742 struct brcmf_if *ifp = netdev_priv(ndev);
3743 struct brcmf_pmksa *pmk = &cfg->pmk_list.pmk[0];
3744 s32 err;
3745 u32 npmk, i;
e5806072 3746
5419f7f1
HM		 3747 brcmf_dbg(TRACE, "Enter\n");
3748 if (!check_vif_up(ifp->vif))
3749 return -EIO;
e5806072 3750
5419f7f1 3751 brcmf_dbg(CONN, "del_pmksa - PMK bssid = %pM\n", &pmksa->bssid);
e5806072 3752
5419f7f1
HM		 3753 npmk = le32_to_cpu(cfg->pmk_list.npmk);
3754 for (i = 0; i < npmk; i++)
3755 if (!memcmp(&pmksa->bssid, &pmk[i].bssid, ETH_ALEN))
3756 break;
3757
3758 if ((npmk > 0) && (i < npmk)) {
3759 for (; i < (npmk - 1); i++) {
3760 memcpy(&pmk[i].bssid, &pmk[i + 1].bssid, ETH_ALEN);
3761 memcpy(&pmk[i].pmkid, &pmk[i + 1].pmkid,
3762 WLAN_PMKID_LEN);
e5806072 3763 }
5419f7f1
HM		 3764 memset(&pmk[i], 0, sizeof(*pmk));
3765 cfg->pmk_list.npmk = cpu_to_le32(npmk - 1);
e5806072 3766 } else {
5419f7f1 3767 brcmf_err("Cache entry not found\n");
e5806072
AS		 3768 return -EINVAL;
3769 }
3770
5419f7f1
HM		 3771 err = brcmf_update_pmklist(cfg, ifp);
3772
3773 brcmf_dbg(TRACE, "Exit\n");
3774 return err;
3775
e5806072
AS		 3776}
3777
5419f7f1
HM		 3778static s32
3779brcmf_cfg80211_flush_pmksa(struct wiphy *wiphy, struct net_device *ndev)
e5806072 3780{
27a68fe3 3781 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy);
5419f7f1
HM		 3782 struct brcmf_if *ifp = netdev_priv(ndev);
3783 s32 err;
3784
3785 brcmf_dbg(TRACE, "Enter\n");
3786 if (!check_vif_up(ifp->vif))
3787 return -EIO;
3788
3789 memset(&cfg->pmk_list, 0, sizeof(cfg->pmk_list));
3790 err = brcmf_update_pmklist(cfg, ifp);
3791
3792 brcmf_dbg(TRACE, "Exit\n");
3793 return err;
e5806072 3794
e5806072 3795}
e5806072 3796
1f170110 3797static s32 brcmf_configure_opensecurity(struct brcmf_if *ifp)
1a873342
HM		 3798{
3799 s32 err;
3800
3801 /* set auth */
ac24be6f 3802 err = brcmf_fil_bsscfg_int_set(ifp, "auth", 0);
1a873342 3803 if (err < 0) {
57d6e91a 3804 brcmf_err("auth error %d\n", err);
1a873342
HM		 3805 return err;
3806 }
3807 /* set wsec */
ac24be6f 3808 err = brcmf_fil_bsscfg_int_set(ifp, "wsec", 0);
1a873342 3809 if (err < 0) {
57d6e91a 3810 brcmf_err("wsec error %d\n", err);
1a873342
HM		 3811 return err;
3812 }
3813 /* set upper-layer auth */
ac24be6f 3814 err = brcmf_fil_bsscfg_int_set(ifp, "wpa_auth", WPA_AUTH_NONE);
1a873342 3815 if (err < 0) {
57d6e91a 3816 brcmf_err("wpa_auth error %d\n", err);
1a873342
HM		 3817 return err;
3818 }
3819
3820 return 0;
3821}
3822
3823static bool brcmf_valid_wpa_oui(u8 *oui, bool is_rsn_ie)
3824{
3825 if (is_rsn_ie)
3826 return (memcmp(oui, RSN_OUI, TLV_OUI_LEN) == 0);
3827
3828 return (memcmp(oui, WPA_OUI, TLV_OUI_LEN) == 0);
3829}
3830
3831static s32
a44aa400 3832brcmf_configure_wpaie(struct brcmf_if *ifp,
4b5800fe
JB		 3833 const struct brcmf_vs_tlv *wpa_ie,
3834 bool is_rsn_ie)
1a873342
HM		 3835{
3836 u32 auth = 0; /* d11 open authentication */
3837 u16 count;
3838 s32 err = 0;
240d61a9 3839 s32 len;
1a873342
HM		 3840 u32 i;
3841 u32 wsec;
3842 u32 pval = 0;
3843 u32 gval = 0;
3844 u32 wpa_auth = 0;
3845 u32 offset;
3846 u8 *data;
3847 u16 rsn_cap;
3848 u32 wme_bss_disable;
240d61a9 3849 u32 mfp;
1a873342 3850
d96b801f 3851 brcmf_dbg(TRACE, "Enter\n");
1a873342
HM		 3852 if (wpa_ie == NULL)
3853 goto exit;
3854
3855 len = wpa_ie->len + TLV_HDR_LEN;
3856 data = (u8 *)wpa_ie;
619c5a9a 3857 offset = TLV_HDR_LEN;
1a873342
HM		 3858 if (!is_rsn_ie)
3859 offset += VS_IE_FIXED_HDR_LEN;
619c5a9a
HM		 3860 else
3861 offset += WPA_IE_VERSION_LEN;
1a873342
HM		 3862
3863 /* check for multicast cipher suite */
3864 if (offset + WPA_IE_MIN_OUI_LEN > len) {
3865 err = -EINVAL;
57d6e91a 3866 brcmf_err("no multicast cipher suite\n");
1a873342
HM		 3867 goto exit;
3868 }
3869
3870 if (!brcmf_valid_wpa_oui(&data[offset], is_rsn_ie)) {
3871 err = -EINVAL;
57d6e91a 3872 brcmf_err("ivalid OUI\n");
1a873342
HM		 3873 goto exit;
3874 }
3875 offset += TLV_OUI_LEN;
3876
3877 /* pick up multicast cipher */
3878 switch (data[offset]) {
3879 case WPA_CIPHER_NONE:
3880 gval = 0;
3881 break;
3882 case WPA_CIPHER_WEP_40:
3883 case WPA_CIPHER_WEP_104:
3884 gval = WEP_ENABLED;
3885 break;
3886 case WPA_CIPHER_TKIP:
3887 gval = TKIP_ENABLED;
3888 break;
3889 case WPA_CIPHER_AES_CCM:
3890 gval = AES_ENABLED;
3891 break;
3892 default:
3893 err = -EINVAL;
57d6e91a 3894 brcmf_err("Invalid multi cast cipher info\n");
1a873342
HM		 3895 goto exit;
3896 }
3897
3898 offset++;
3899 /* walk thru unicast cipher list and pick up what we recognize */
3900 count = data[offset] + (data[offset + 1] << 8);
3901 offset += WPA_IE_SUITE_COUNT_LEN;
3902 /* Check for unicast suite(s) */
3903 if (offset + (WPA_IE_MIN_OUI_LEN * count) > len) {
3904 err = -EINVAL;
57d6e91a 3905 brcmf_err("no unicast cipher suite\n");
1a873342
HM		 3906 goto exit;
3907 }
3908 for (i = 0; i < count; i++) {
3909 if (!brcmf_valid_wpa_oui(&data[offset], is_rsn_ie)) {
3910 err = -EINVAL;
57d6e91a 3911 brcmf_err("ivalid OUI\n");
1a873342
HM		 3912 goto exit;
3913 }
3914 offset += TLV_OUI_LEN;
3915 switch (data[offset]) {
3916 case WPA_CIPHER_NONE:
3917 break;
3918 case WPA_CIPHER_WEP_40:
3919 case WPA_CIPHER_WEP_104:
3920 pval |= WEP_ENABLED;
3921 break;
3922 case WPA_CIPHER_TKIP:
3923 pval |= TKIP_ENABLED;
3924 break;
3925 case WPA_CIPHER_AES_CCM:
3926 pval |= AES_ENABLED;
3927 break;
3928 default:
57d6e91a 3929 brcmf_err("Ivalid unicast security info\n");
1a873342
HM		 3930 }
3931 offset++;
3932 }
3933 /* walk thru auth management suite list and pick up what we recognize */
3934 count = data[offset] + (data[offset + 1] << 8);
3935 offset += WPA_IE_SUITE_COUNT_LEN;
3936 /* Check for auth key management suite(s) */
3937 if (offset + (WPA_IE_MIN_OUI_LEN * count) > len) {
3938 err = -EINVAL;
57d6e91a 3939 brcmf_err("no auth key mgmt suite\n");
1a873342
HM		 3940 goto exit;
3941 }
3942 for (i = 0; i < count; i++) {
3943 if (!brcmf_valid_wpa_oui(&data[offset], is_rsn_ie)) {
3944 err = -EINVAL;
57d6e91a 3945 brcmf_err("ivalid OUI\n");
1a873342
HM		 3946 goto exit;
3947 }
3948 offset += TLV_OUI_LEN;
3949 switch (data[offset]) {
3950 case RSN_AKM_NONE:
d96b801f 3951 brcmf_dbg(TRACE, "RSN_AKM_NONE\n");
1a873342
HM		 3952 wpa_auth |= WPA_AUTH_NONE;
3953 break;
3954 case RSN_AKM_UNSPECIFIED:
d96b801f 3955 brcmf_dbg(TRACE, "RSN_AKM_UNSPECIFIED\n");
1a873342
HM		 3956 is_rsn_ie ? (wpa_auth |= WPA2_AUTH_UNSPECIFIED) :
3957 (wpa_auth |= WPA_AUTH_UNSPECIFIED);
3958 break;
3959 case RSN_AKM_PSK:
d96b801f 3960 brcmf_dbg(TRACE, "RSN_AKM_PSK\n");
1a873342
HM		 3961 is_rsn_ie ? (wpa_auth |= WPA2_AUTH_PSK) :
3962 (wpa_auth |= WPA_AUTH_PSK);
3963 break;
240d61a9
HM		 3964 case RSN_AKM_SHA256_PSK:
3965 brcmf_dbg(TRACE, "RSN_AKM_MFP_PSK\n");
3966 wpa_auth |= WPA2_AUTH_PSK_SHA256;
3967 break;
3968 case RSN_AKM_SHA256_1X:
3969 brcmf_dbg(TRACE, "RSN_AKM_MFP_1X\n");
3970 wpa_auth |= WPA2_AUTH_1X_SHA256;
3971 break;
1a873342 3972 default:
57d6e91a 3973 brcmf_err("Ivalid key mgmt info\n");
1a873342
HM		 3974 }
3975 offset++;
3976 }
3977
240d61a9 3978 mfp = BRCMF_MFP_NONE;
1a873342
HM		 3979 if (is_rsn_ie) {
3980 wme_bss_disable = 1;
3981 if ((offset + RSN_CAP_LEN) <= len) {
3982 rsn_cap = data[offset] + (data[offset + 1] << 8);
3983 if (rsn_cap & RSN_CAP_PTK_REPLAY_CNTR_MASK)
3984 wme_bss_disable = 0;
240d61a9
HM		 3985 if (rsn_cap & RSN_CAP_MFPR_MASK) {
3986 brcmf_dbg(TRACE, "MFP Required\n");
3987 mfp = BRCMF_MFP_REQUIRED;
3988 /* Firmware only supports mfp required in
3989 * combination with WPA2_AUTH_PSK_SHA256 or
3990 * WPA2_AUTH_1X_SHA256.
3991 */
3992 if (!(wpa_auth & (WPA2_AUTH_PSK_SHA256 |
3993 WPA2_AUTH_1X_SHA256))) {
3994 err = -EINVAL;
3995 goto exit;
3996 }
3997 /* Firmware has requirement that WPA2_AUTH_PSK/
3998 * WPA2_AUTH_UNSPECIFIED be set, if SHA256 OUI
3999 * is to be included in the rsn ie.
4000 */
4001 if (wpa_auth & WPA2_AUTH_PSK_SHA256)
4002 wpa_auth |= WPA2_AUTH_PSK;
4003 else if (wpa_auth & WPA2_AUTH_1X_SHA256)
4004 wpa_auth |= WPA2_AUTH_UNSPECIFIED;
4005 } else if (rsn_cap & RSN_CAP_MFPC_MASK) {
4006 brcmf_dbg(TRACE, "MFP Capable\n");
4007 mfp = BRCMF_MFP_CAPABLE;
4008 }
1a873342 4009 }
240d61a9 4010 offset += RSN_CAP_LEN;
1a873342 4011 /* set wme_bss_disable to sync RSN Capabilities */
ac24be6f 4012 err = brcmf_fil_bsscfg_int_set(ifp, "wme_bss_disable",
81f5dcb8 4013 wme_bss_disable);
1a873342 4014 if (err < 0) {
57d6e91a 4015 brcmf_err("wme_bss_disable error %d\n", err);
1a873342
HM		 4016 goto exit;
4017 }
240d61a9
HM		 4018
4019 /* Skip PMKID cnt as it is know to be 0 for AP. */
4020 offset += RSN_PMKID_COUNT_LEN;
4021
4022 /* See if there is BIP wpa suite left for MFP */
4023 if (brcmf_feat_is_enabled(ifp, BRCMF_FEAT_MFP) &&
4024 ((offset + WPA_IE_MIN_OUI_LEN) <= len)) {
4025 err = brcmf_fil_bsscfg_data_set(ifp, "bip",
4026 &data[offset],
4027 WPA_IE_MIN_OUI_LEN);
4028 if (err < 0) {
4029 brcmf_err("bip error %d\n", err);
4030 goto exit;
4031 }
4032 }
1a873342
HM		 4033 }
4034 /* FOR WPS , set SES_OW_ENABLED */
4035 wsec = (pval | gval | SES_OW_ENABLED);
4036
4037 /* set auth */
ac24be6f 4038 err = brcmf_fil_bsscfg_int_set(ifp, "auth", auth);
1a873342 4039 if (err < 0) {
57d6e91a 4040 brcmf_err("auth error %d\n", err);
1a873342
HM		 4041 goto exit;
4042 }
4043 /* set wsec */
ac24be6f 4044 err = brcmf_fil_bsscfg_int_set(ifp, "wsec", wsec);
1a873342 4045 if (err < 0) {
57d6e91a 4046 brcmf_err("wsec error %d\n", err);
1a873342
HM		 4047 goto exit;
4048 }
240d61a9
HM		 4049 /* Configure MFP, this needs to go after wsec otherwise the wsec command
4050 * will overwrite the values set by MFP
4051 */
4052 if (brcmf_feat_is_enabled(ifp, BRCMF_FEAT_MFP)) {
4053 err = brcmf_fil_bsscfg_int_set(ifp, "mfp", mfp);
4054 if (err < 0) {
4055 brcmf_err("mfp error %d\n", err);
4056 goto exit;
4057 }
4058 }
1a873342 4059 /* set upper-layer auth */
ac24be6f 4060 err = brcmf_fil_bsscfg_int_set(ifp, "wpa_auth", wpa_auth);
1a873342 4061 if (err < 0) {
57d6e91a 4062 brcmf_err("wpa_auth error %d\n", err);
1a873342
HM		 4063 goto exit;
4064 }
4065
4066exit:
4067 return err;
4068}
4069
4070static s32
3082b9be 4071brcmf_parse_vndr_ies(const u8 *vndr_ie_buf, u32 vndr_ie_len,
1a873342
HM		 4072 struct parsed_vndr_ies *vndr_ies)
4073{
1a873342
HM		 4074 struct brcmf_vs_tlv *vndrie;
4075 struct brcmf_tlv *ie;
4076 struct parsed_vndr_ie_info *parsed_info;
4077 s32 remaining_len;
4078
4079 remaining_len = (s32)vndr_ie_len;
4080 memset(vndr_ies, 0, sizeof(*vndr_ies));
4081
4082 ie = (struct brcmf_tlv *)vndr_ie_buf;
4083 while (ie) {
4084 if (ie->id != WLAN_EID_VENDOR_SPECIFIC)
4085 goto next;
4086 vndrie = (struct brcmf_vs_tlv *)ie;
4087 /* len should be bigger than OUI length + one */
4088 if (vndrie->len < (VS_IE_FIXED_HDR_LEN - TLV_HDR_LEN + 1)) {
57d6e91a
AS		 4089 brcmf_err("invalid vndr ie. length is too small %d\n",
4090 vndrie->len);
1a873342
HM		 4091 goto next;
4092 }
4093 /* if wpa or wme ie, do not add ie */
4094 if (!memcmp(vndrie->oui, (u8 *)WPA_OUI, TLV_OUI_LEN) &&
4095 ((vndrie->oui_type == WPA_OUI_TYPE) ||
4096 (vndrie->oui_type == WME_OUI_TYPE))) {
d96b801f 4097 brcmf_dbg(TRACE, "Found WPA/WME oui. Do not add it\n");
1a873342
HM		 4098 goto next;
4099 }
4100
4101 parsed_info = &vndr_ies->ie_info[vndr_ies->count];
4102
4103 /* save vndr ie information */
4104 parsed_info->ie_ptr = (char *)vndrie;
4105 parsed_info->ie_len = vndrie->len + TLV_HDR_LEN;
4106 memcpy(&parsed_info->vndrie, vndrie, sizeof(*vndrie));
4107
4108 vndr_ies->count++;
4109
d96b801f
AS		 4110 brcmf_dbg(TRACE, "** OUI %02x %02x %02x, type 0x%02x\n",
4111 parsed_info->vndrie.oui[0],
4112 parsed_info->vndrie.oui[1],
4113 parsed_info->vndrie.oui[2],
4114 parsed_info->vndrie.oui_type);
1a873342 4115
9f440b7b 4116 if (vndr_ies->count >= VNDR_IE_PARSE_LIMIT)
1a873342
HM		 4117 break;
4118next:
b41fc3d7
HM		 4119 remaining_len -= (ie->len + TLV_HDR_LEN);
4120 if (remaining_len <= TLV_HDR_LEN)
1a873342
HM		 4121 ie = NULL;
4122 else
b41fc3d7
HM		 4123 ie = (struct brcmf_tlv *)(((u8 *)ie) + ie->len +
4124 TLV_HDR_LEN);
1a873342 4125 }
12f32370 4126 return 0;
1a873342
HM		 4127}
4128
4129static u32
4130brcmf_vndr_ie(u8 *iebuf, s32 pktflag, u8 *ie_ptr, u32 ie_len, s8 *add_del_cmd)
4131{
4132
1a873342
HM		 4133 strncpy(iebuf, add_del_cmd, VNDR_IE_CMD_LEN - 1);
4134 iebuf[VNDR_IE_CMD_LEN - 1] = '\0';
4135
362126cd 4136 put_unaligned_le32(1, &iebuf[VNDR_IE_COUNT_OFFSET]);
1a873342 4137
362126cd 4138 put_unaligned_le32(pktflag, &iebuf[VNDR_IE_PKTFLAG_OFFSET]);
1a873342
HM		 4139
4140 memcpy(&iebuf[VNDR_IE_VSIE_OFFSET], ie_ptr, ie_len);
4141
4142 return ie_len + VNDR_IE_HDR_SIZE;
4143}
4144
1332e26e
AS		 4145s32 brcmf_vif_set_mgmt_ie(struct brcmf_cfg80211_vif *vif, s32 pktflag,
4146 const u8 *vndr_ie_buf, u32 vndr_ie_len)
1a873342 4147{
1332e26e
AS		 4148 struct brcmf_if *ifp;
4149 struct vif_saved_ie *saved_ie;
1a873342
HM		 4150 s32 err = 0;
4151 u8 *iovar_ie_buf;
4152 u8 *curr_ie_buf;
4153 u8 *mgmt_ie_buf = NULL;
3e4f319d 4154 int mgmt_ie_buf_len;
81118d16 4155 u32 *mgmt_ie_len;
1a873342
HM		 4156 u32 del_add_ie_buf_len = 0;
4157 u32 total_ie_buf_len = 0;
4158 u32 parsed_ie_buf_len = 0;
4159 struct parsed_vndr_ies old_vndr_ies;
4160 struct parsed_vndr_ies new_vndr_ies;
4161 struct parsed_vndr_ie_info *vndrie_info;
4162 s32 i;
4163 u8 *ptr;
3e4f319d 4164 int remained_buf_len;
1a873342 4165
1332e26e
AS		 4166 if (!vif)
4167 return -ENODEV;
4168 ifp = vif->ifp;
4169 saved_ie = &vif->saved_ie;
4170
37a869ec
HM		 4171 brcmf_dbg(TRACE, "bsscfgidx %d, pktflag : 0x%02X\n", ifp->bsscfgidx,
4172 pktflag);
1a873342
HM		 4173 iovar_ie_buf = kzalloc(WL_EXTRA_BUF_MAX, GFP_KERNEL);
4174 if (!iovar_ie_buf)
4175 return -ENOMEM;
4176 curr_ie_buf = iovar_ie_buf;
89286dc9
HM		 4177 switch (pktflag) {
4178 case BRCMF_VNDR_IE_PRBREQ_FLAG:
4179 mgmt_ie_buf = saved_ie->probe_req_ie;
4180 mgmt_ie_len = &saved_ie->probe_req_ie_len;
4181 mgmt_ie_buf_len = sizeof(saved_ie->probe_req_ie);
4182 break;
4183 case BRCMF_VNDR_IE_PRBRSP_FLAG:
4184 mgmt_ie_buf = saved_ie->probe_res_ie;
4185 mgmt_ie_len = &saved_ie->probe_res_ie_len;
4186 mgmt_ie_buf_len = sizeof(saved_ie->probe_res_ie);
4187 break;
4188 case BRCMF_VNDR_IE_BEACON_FLAG:
4189 mgmt_ie_buf = saved_ie->beacon_ie;
4190 mgmt_ie_len = &saved_ie->beacon_ie_len;
4191 mgmt_ie_buf_len = sizeof(saved_ie->beacon_ie);
4192 break;
4193 case BRCMF_VNDR_IE_ASSOCREQ_FLAG:
4194 mgmt_ie_buf = saved_ie->assoc_req_ie;
4195 mgmt_ie_len = &saved_ie->assoc_req_ie_len;
4196 mgmt_ie_buf_len = sizeof(saved_ie->assoc_req_ie);
4197 break;
4198 default:
4199 err = -EPERM;
4200 brcmf_err("not suitable type\n");
4201 goto exit;
1a873342
HM		 4202 }
4203
4204 if (vndr_ie_len > mgmt_ie_buf_len) {
4205 err = -ENOMEM;
57d6e91a 4206 brcmf_err("extra IE size too big\n");
1a873342
HM		 4207 goto exit;
4208 }
4209
4210 /* parse and save new vndr_ie in curr_ie_buff before comparing it */
4211 if (vndr_ie_buf && vndr_ie_len && curr_ie_buf) {
4212 ptr = curr_ie_buf;
4213 brcmf_parse_vndr_ies(vndr_ie_buf, vndr_ie_len, &new_vndr_ies);
4214 for (i = 0; i < new_vndr_ies.count; i++) {
4215 vndrie_info = &new_vndr_ies.ie_info[i];
4216 memcpy(ptr + parsed_ie_buf_len, vndrie_info->ie_ptr,
4217 vndrie_info->ie_len);
4218 parsed_ie_buf_len += vndrie_info->ie_len;
4219 }
4220 }
4221
b41fc3d7 4222 if (mgmt_ie_buf && *mgmt_ie_len) {
1a873342
HM		 4223 if (parsed_ie_buf_len && (parsed_ie_buf_len == *mgmt_ie_len) &&
4224 (memcmp(mgmt_ie_buf, curr_ie_buf,
4225 parsed_ie_buf_len) == 0)) {
d96b801f 4226 brcmf_dbg(TRACE, "Previous mgmt IE equals to current IE\n");
1a873342
HM		 4227 goto exit;
4228 }
4229
4230 /* parse old vndr_ie */
4231 brcmf_parse_vndr_ies(mgmt_ie_buf, *mgmt_ie_len, &old_vndr_ies);
4232
4233 /* make a command to delete old ie */
4234 for (i = 0; i < old_vndr_ies.count; i++) {
4235 vndrie_info = &old_vndr_ies.ie_info[i];
4236
d96b801f
AS		 4237 brcmf_dbg(TRACE, "DEL ID : %d, Len: %d , OUI:%02x:%02x:%02x\n",
4238 vndrie_info->vndrie.id,
4239 vndrie_info->vndrie.len,
4240 vndrie_info->vndrie.oui[0],
4241 vndrie_info->vndrie.oui[1],
4242 vndrie_info->vndrie.oui[2]);
1a873342
HM		 4243
4244 del_add_ie_buf_len = brcmf_vndr_ie(curr_ie_buf, pktflag,
4245 vndrie_info->ie_ptr,
4246 vndrie_info->ie_len,
4247 "del");
4248 curr_ie_buf += del_add_ie_buf_len;
4249 total_ie_buf_len += del_add_ie_buf_len;
4250 }
4251 }
4252
4253 *mgmt_ie_len = 0;
4254 /* Add if there is any extra IE */
4255 if (mgmt_ie_buf && parsed_ie_buf_len) {
4256 ptr = mgmt_ie_buf;
4257
4258 remained_buf_len = mgmt_ie_buf_len;
4259
4260 /* make a command to add new ie */
4261 for (i = 0; i < new_vndr_ies.count; i++) {
4262 vndrie_info = &new_vndr_ies.ie_info[i];
4263
b41fc3d7
HM		 4264 /* verify remained buf size before copy data */
4265 if (remained_buf_len < (vndrie_info->vndrie.len +
4266 VNDR_IE_VSIE_OFFSET)) {
57d6e91a
AS		 4267 brcmf_err("no space in mgmt_ie_buf: len left %d",
4268 remained_buf_len);
b41fc3d7
HM		 4269 break;
4270 }
4271 remained_buf_len -= (vndrie_info->ie_len +
4272 VNDR_IE_VSIE_OFFSET);
4273
d96b801f
AS		 4274 brcmf_dbg(TRACE, "ADDED ID : %d, Len: %d, OUI:%02x:%02x:%02x\n",
4275 vndrie_info->vndrie.id,
4276 vndrie_info->vndrie.len,
4277 vndrie_info->vndrie.oui[0],
4278 vndrie_info->vndrie.oui[1],
4279 vndrie_info->vndrie.oui[2]);
1a873342
HM		 4280
4281 del_add_ie_buf_len = brcmf_vndr_ie(curr_ie_buf, pktflag,
4282 vndrie_info->ie_ptr,
4283 vndrie_info->ie_len,
4284 "add");
1a873342
HM		 4285
4286 /* save the parsed IE in wl struct */
4287 memcpy(ptr + (*mgmt_ie_len), vndrie_info->ie_ptr,
4288 vndrie_info->ie_len);
4289 *mgmt_ie_len += vndrie_info->ie_len;
4290
4291 curr_ie_buf += del_add_ie_buf_len;
4292 total_ie_buf_len += del_add_ie_buf_len;
4293 }
4294 }
4295 if (total_ie_buf_len) {
c1179033 4296 err = brcmf_fil_bsscfg_data_set(ifp, "vndr_ie", iovar_ie_buf,
81f5dcb8 4297 total_ie_buf_len);
1a873342 4298 if (err)
57d6e91a 4299 brcmf_err("vndr ie set error : %d\n", err);
1a873342
HM		 4300 }
4301
4302exit:
4303 kfree(iovar_ie_buf);
4304 return err;
4305}
4306
5f4f9f11
AS		 4307s32 brcmf_vif_clear_mgmt_ies(struct brcmf_cfg80211_vif *vif)
4308{
4309 s32 pktflags[] = {
4310 BRCMF_VNDR_IE_PRBREQ_FLAG,
4311 BRCMF_VNDR_IE_PRBRSP_FLAG,
4312 BRCMF_VNDR_IE_BEACON_FLAG
4313 };
4314 int i;
4315
4316 for (i = 0; i < ARRAY_SIZE(pktflags); i++)
4317 brcmf_vif_set_mgmt_ie(vif, pktflags[i], NULL, 0);
4318
4319 memset(&vif->saved_ie, 0, sizeof(vif->saved_ie));
4320 return 0;
4321}
4322
a0f07959
HM		 4323static s32
4324brcmf_config_ap_mgmt_ie(struct brcmf_cfg80211_vif *vif,
4325 struct cfg80211_beacon_data *beacon)
4326{
4327 s32 err;
4328
4329 /* Set Beacon IEs to FW */
4330 err = brcmf_vif_set_mgmt_ie(vif, BRCMF_VNDR_IE_BEACON_FLAG,
4331 beacon->tail, beacon->tail_len);
4332 if (err) {
4333 brcmf_err("Set Beacon IE Failed\n");
4334 return err;
4335 }
4336 brcmf_dbg(TRACE, "Applied Vndr IEs for Beacon\n");
4337
4338 /* Set Probe Response IEs to FW */
4339 err = brcmf_vif_set_mgmt_ie(vif, BRCMF_VNDR_IE_PRBRSP_FLAG,
4340 beacon->proberesp_ies,
4341 beacon->proberesp_ies_len);
4342 if (err)
4343 brcmf_err("Set Probe Resp IE Failed\n");
4344 else
4345 brcmf_dbg(TRACE, "Applied Vndr IEs for Probe Resp\n");
4346
4347 return err;
4348}
4349
1a873342
HM		 4350static s32
4351brcmf_cfg80211_start_ap(struct wiphy *wiphy, struct net_device *ndev,
4352 struct cfg80211_ap_settings *settings)
4353{
4354 s32 ie_offset;
1c9d30cf 4355 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy);
ac24be6f 4356 struct brcmf_if *ifp = netdev_priv(ndev);
4b5800fe 4357 const struct brcmf_tlv *ssid_ie;
98027769 4358 const struct brcmf_tlv *country_ie;
1a873342 4359 struct brcmf_ssid_le ssid_le;
1a873342 4360 s32 err = -EPERM;
4b5800fe
JB		 4361 const struct brcmf_tlv *rsn_ie;
4362 const struct brcmf_vs_tlv *wpa_ie;
1a873342 4363 struct brcmf_join_params join_params;
a0f07959
HM		 4364 enum nl80211_iftype dev_role;
4365 struct brcmf_fil_bss_enable_le bss_enable;
06c01585 4366 u16 chanspec;
a44aa400 4367 bool mbss;
98027769 4368 int is_11d;
1a873342 4369
06c01585
AS		 4370 brcmf_dbg(TRACE, "ctrlchn=%d, center=%d, bw=%d, beacon_interval=%d, dtim_period=%d,\n",
4371 settings->chandef.chan->hw_value,
4372 settings->chandef.center_freq1, settings->chandef.width,
a9a56878 4373 settings->beacon_interval, settings->dtim_period);
d96b801f
AS		 4374 brcmf_dbg(TRACE, "ssid=%s(%zu), auth_type=%d, inactivity_timeout=%d\n",
4375 settings->ssid, settings->ssid_len, settings->auth_type,
4376 settings->inactivity_timeout);
426d0a56 4377 dev_role = ifp->vif->wdev.iftype;
a44aa400 4378 mbss = ifp->vif->mbss;
1a873342 4379
98027769
AS		 4380 /* store current 11d setting */
4381 brcmf_fil_cmd_int_get(ifp, BRCMF_C_GET_REGULATORY, &ifp->vif->is_11d);
4382 country_ie = brcmf_parse_tlvs((u8 *)settings->beacon.tail,
4383 settings->beacon.tail_len,
4384 WLAN_EID_COUNTRY);
4385 is_11d = country_ie ? 1 : 0;
4386
1a873342
HM		 4387 memset(&ssid_le, 0, sizeof(ssid_le));
4388 if (settings->ssid == NULL || settings->ssid_len == 0) {
4389 ie_offset = DOT11_MGMT_HDR_LEN + DOT11_BCN_PRB_FIXED_LEN;
4390 ssid_ie = brcmf_parse_tlvs(
4391 (u8 *)&settings->beacon.head[ie_offset],
4392 settings->beacon.head_len - ie_offset,
4393 WLAN_EID_SSID);
4394 if (!ssid_ie)
4395 return -EINVAL;
4396
4397 memcpy(ssid_le.SSID, ssid_ie->data, ssid_ie->len);
4398 ssid_le.SSID_len = cpu_to_le32(ssid_ie->len);
d96b801f 4399 brcmf_dbg(TRACE, "SSID is (%s) in Head\n", ssid_le.SSID);
1a873342
HM		 4400 } else {
4401 memcpy(ssid_le.SSID, settings->ssid, settings->ssid_len);
4402 ssid_le.SSID_len = cpu_to_le32((u32)settings->ssid_len);
4403 }
4404
a44aa400
HM		 4405 if (!mbss) {
4406 brcmf_set_mpc(ifp, 0);
52f22fb2 4407 brcmf_configure_arp_nd_offload(ifp, false);
a44aa400 4408 }
1a873342
HM		 4409
4410 /* find the RSN_IE */
4411 rsn_ie = brcmf_parse_tlvs((u8 *)settings->beacon.tail,
4412 settings->beacon.tail_len, WLAN_EID_RSN);
4413
4414 /* find the WPA_IE */
4415 wpa_ie = brcmf_find_wpaie((u8 *)settings->beacon.tail,
4416 settings->beacon.tail_len);
4417
1a873342 4418 if ((wpa_ie != NULL || rsn_ie != NULL)) {
d96b801f 4419 brcmf_dbg(TRACE, "WPA(2) IE is found\n");
1a873342
HM		 4420 if (wpa_ie != NULL) {
4421 /* WPA IE */
a44aa400 4422 err = brcmf_configure_wpaie(ifp, wpa_ie, false);
1a873342
HM		 4423 if (err < 0)
4424 goto exit;
1a873342 4425 } else {
a44aa400
HM		 4426 struct brcmf_vs_tlv *tmp_ie;
4427
4428 tmp_ie = (struct brcmf_vs_tlv *)rsn_ie;
4429
1a873342 4430 /* RSN IE */
a44aa400 4431 err = brcmf_configure_wpaie(ifp, tmp_ie, true);
1a873342
HM		 4432 if (err < 0)
4433 goto exit;
1a873342 4434 }
1a873342 4435 } else {
d96b801f 4436 brcmf_dbg(TRACE, "No WPA(2) IEs found\n");
1f170110 4437 brcmf_configure_opensecurity(ifp);
1a873342 4438 }
1a873342 4439
a0f07959 4440 brcmf_config_ap_mgmt_ie(ifp->vif, &settings->beacon);
1a873342 4441
a44aa400
HM		 4442 if (!mbss) {
4443 chanspec = chandef_to_chanspec(&cfg->d11inf,
4444 &settings->chandef);
4445 err = brcmf_fil_iovar_int_set(ifp, "chanspec", chanspec);
1a873342 4446 if (err < 0) {
a44aa400
HM		 4447 brcmf_err("Set Channel failed: chspec=%d, %d\n",
4448 chanspec, err);
1a873342
HM		 4449 goto exit;
4450 }
a44aa400 4451
98027769
AS		 4452 if (is_11d != ifp->vif->is_11d) {
4453 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_REGULATORY,
4454 is_11d);
4455 if (err < 0) {
4456 brcmf_err("Regulatory Set Error, %d\n", err);
4457 goto exit;
4458 }
4459 }
a44aa400
HM		 4460 if (settings->beacon_interval) {
4461 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_BCNPRD,
4462 settings->beacon_interval);
4463 if (err < 0) {
4464 brcmf_err("Beacon Interval Set Error, %d\n",
4465 err);
4466 goto exit;
4467 }
4468 }
4469 if (settings->dtim_period) {
4470 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_DTIMPRD,
4471 settings->dtim_period);
4472 if (err < 0) {
4473 brcmf_err("DTIM Interval Set Error, %d\n", err);
4474 goto exit;
4475 }
1a873342 4476 }
a0f07959 4477
8abffd81
HM		 4478 if ((dev_role == NL80211_IFTYPE_AP) &&
4479 ((ifp->ifidx == 0) ||
4480 !brcmf_feat_is_enabled(ifp, BRCMF_FEAT_RSDB))) {
a44aa400
HM		 4481 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_DOWN, 1);
4482 if (err < 0) {
4483 brcmf_err("BRCMF_C_DOWN error %d\n", err);
4484 goto exit;
4485 }
4486 brcmf_fil_iovar_int_set(ifp, "apsta", 0);
4487 }
4488
4489 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_INFRA, 1);
a0f07959 4490 if (err < 0) {
a44aa400 4491 brcmf_err("SET INFRA error %d\n", err);
a0f07959
HM		 4492 goto exit;
4493 }
98027769
AS		 4494 } else if (WARN_ON(is_11d != ifp->vif->is_11d)) {
4495 /* Multiple-BSS should use same 11d configuration */
4496 err = -EINVAL;
4497 goto exit;
1a873342 4498 }
a0f07959 4499 if (dev_role == NL80211_IFTYPE_AP) {
a44aa400
HM		 4500 if ((brcmf_feat_is_enabled(ifp, BRCMF_FEAT_MBSS)) && (!mbss))
4501 brcmf_fil_iovar_int_set(ifp, "mbss", 1);
4502
a0f07959
HM		 4503 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_AP, 1);
4504 if (err < 0) {
4505 brcmf_err("setting AP mode failed %d\n", err);
4506 goto exit;
4507 }
4508 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_UP, 1);
4509 if (err < 0) {
4510 brcmf_err("BRCMF_C_UP error (%d)\n", err);
4511 goto exit;
4512 }
118eb304
HM		 4513 /* On DOWN the firmware removes the WEP keys, reconfigure
4514 * them if they were set.
4515 */
4516 brcmf_cfg80211_reconfigure_wep(ifp);
a0f07959
HM		 4517
4518 memset(&join_params, 0, sizeof(join_params));
4519 /* join parameters starts with ssid */
4520 memcpy(&join_params.ssid_le, &ssid_le, sizeof(ssid_le));
4521 /* create softap */
4522 err = brcmf_fil_cmd_data_set(ifp, BRCMF_C_SET_SSID,
4523 &join_params, sizeof(join_params));
4524 if (err < 0) {
4525 brcmf_err("SET SSID error (%d)\n", err);
4526 goto exit;
4527 }
4528 brcmf_dbg(TRACE, "AP mode configuration complete\n");
4529 } else {
4530 err = brcmf_fil_bsscfg_data_set(ifp, "ssid", &ssid_le,
4531 sizeof(ssid_le));
4532 if (err < 0) {
4533 brcmf_err("setting ssid failed %d\n", err);
4534 goto exit;
4535 }
37a869ec 4536 bss_enable.bsscfgidx = cpu_to_le32(ifp->bsscfgidx);
a0f07959
HM		 4537 bss_enable.enable = cpu_to_le32(1);
4538 err = brcmf_fil_iovar_data_set(ifp, "bss", &bss_enable,
4539 sizeof(bss_enable));
4540 if (err < 0) {
4541 brcmf_err("bss_enable config failed %d\n", err);
4542 goto exit;
4543 }
4544
4545 brcmf_dbg(TRACE, "GO mode configuration complete\n");
4546 }
c1179033 4547 set_bit(BRCMF_VIF_STATUS_AP_CREATED, &ifp->vif->sme_state);
92121e69 4548 brcmf_net_setcarrier(ifp, true);
1a873342
HM		 4549
4550exit:
a44aa400 4551 if ((err) && (!mbss)) {
f96aa07e 4552 brcmf_set_mpc(ifp, 1);
52f22fb2 4553 brcmf_configure_arp_nd_offload(ifp, true);
b3657453 4554 }
1a873342
HM		 4555 return err;
4556}
4557
4558static int brcmf_cfg80211_stop_ap(struct wiphy *wiphy, struct net_device *ndev)
4559{
c1179033 4560 struct brcmf_if *ifp = netdev_priv(ndev);
5c33a942 4561 s32 err;
426d0a56 4562 struct brcmf_fil_bss_enable_le bss_enable;
5c33a942 4563 struct brcmf_join_params join_params;
1a873342 4564
d96b801f 4565 brcmf_dbg(TRACE, "Enter\n");
1a873342 4566
426d0a56 4567 if (ifp->vif->wdev.iftype == NL80211_IFTYPE_AP) {
1a873342
HM		 4568 /* Due to most likely deauths outstanding we sleep */
4569 /* first to make sure they get processed by fw. */
4570 msleep(400);
5c33a942 4571
a44aa400
HM		 4572 if (ifp->vif->mbss) {
4573 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_DOWN, 1);
4574 return err;
4575 }
4576
5c33a942
HM		 4577 memset(&join_params, 0, sizeof(join_params));
4578 err = brcmf_fil_cmd_data_set(ifp, BRCMF_C_SET_SSID,
4579 &join_params, sizeof(join_params));
4580 if (err < 0)
4581 brcmf_err("SET SSID error (%d)\n", err);
a44aa400 4582 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_DOWN, 1);
5c33a942 4583 if (err < 0)
a44aa400 4584 brcmf_err("BRCMF_C_DOWN error %d\n", err);
5c33a942
HM		 4585 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_AP, 0);
4586 if (err < 0)
4587 brcmf_err("setting AP mode failed %d\n", err);
4588 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_INFRA, 0);
4589 if (err < 0)
4590 brcmf_err("setting INFRA mode failed %d\n", err);
a44aa400
HM		 4591 if (brcmf_feat_is_enabled(ifp, BRCMF_FEAT_MBSS))
4592 brcmf_fil_iovar_int_set(ifp, "mbss", 0);
98027769
AS		 4593 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_REGULATORY,
4594 ifp->vif->is_11d);
4595 if (err < 0)
4596 brcmf_err("restoring REGULATORY setting failed %d\n",
4597 err);
a44aa400
HM		 4598 /* Bring device back up so it can be used again */
4599 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_UP, 1);
4600 if (err < 0)
4601 brcmf_err("BRCMF_C_UP error %d\n", err);
426d0a56 4602 } else {
37a869ec 4603 bss_enable.bsscfgidx = cpu_to_le32(ifp->bsscfgidx);
426d0a56
HM		 4604 bss_enable.enable = cpu_to_le32(0);
4605 err = brcmf_fil_iovar_data_set(ifp, "bss", &bss_enable,
4606 sizeof(bss_enable));
4607 if (err < 0)
4608 brcmf_err("bss_enable config failed %d\n", err);
1a873342 4609 }
f96aa07e 4610 brcmf_set_mpc(ifp, 1);
52f22fb2 4611 brcmf_configure_arp_nd_offload(ifp, true);
426d0a56 4612 clear_bit(BRCMF_VIF_STATUS_AP_CREATED, &ifp->vif->sme_state);
92121e69 4613 brcmf_net_setcarrier(ifp, false);
426d0a56 4614
1a873342
HM		 4615 return err;
4616}
4617
a0f07959
HM		 4618static s32
4619brcmf_cfg80211_change_beacon(struct wiphy *wiphy, struct net_device *ndev,
4620 struct cfg80211_beacon_data *info)
4621{
a0f07959
HM		 4622 struct brcmf_if *ifp = netdev_priv(ndev);
4623 s32 err;
4624
4625 brcmf_dbg(TRACE, "Enter\n");
4626
a0f07959
HM		 4627 err = brcmf_config_ap_mgmt_ie(ifp->vif, info);
4628
4629 return err;
4630}
4631
1a873342
HM		 4632static int
4633brcmf_cfg80211_del_station(struct wiphy *wiphy, struct net_device *ndev,
89c771e5 4634 struct station_del_parameters *params)
1a873342 4635{
a0f07959 4636 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy);
1a873342 4637 struct brcmf_scb_val_le scbval;
0abb5f21 4638 struct brcmf_if *ifp = netdev_priv(ndev);
1a873342
HM		 4639 s32 err;
4640
89c771e5 4641 if (!params->mac)
1a873342
HM		 4642 return -EFAULT;
4643
89c771e5 4644 brcmf_dbg(TRACE, "Enter %pM\n", params->mac);
1a873342 4645
a0f07959
HM		 4646 if (ifp->vif == cfg->p2p.bss_idx[P2PAPI_BSSCFG_DEVICE].vif)
4647 ifp = cfg->p2p.bss_idx[P2PAPI_BSSCFG_PRIMARY].vif->ifp;
ce81e317 4648 if (!check_vif_up(ifp->vif))
1a873342
HM		 4649 return -EIO;
4650
89c771e5 4651 memcpy(&scbval.ea, params->mac, ETH_ALEN);
ba8b6ae6 4652 scbval.val = cpu_to_le32(params->reason_code);
0abb5f21 4653 err = brcmf_fil_cmd_data_set(ifp, BRCMF_C_SCB_DEAUTHENTICATE_FOR_REASON,
81f5dcb8 4654 &scbval, sizeof(scbval));
1a873342 4655 if (err)
57d6e91a 4656 brcmf_err("SCB_DEAUTHENTICATE_FOR_REASON failed %d\n", err);
7ab6acd0 4657
d96b801f 4658 brcmf_dbg(TRACE, "Exit\n");
1a873342
HM		 4659 return err;
4660}
4661
6b89dcb3
HM		 4662static int
4663brcmf_cfg80211_change_station(struct wiphy *wiphy, struct net_device *ndev,
4664 const u8 *mac, struct station_parameters *params)
4665{
4666 struct brcmf_if *ifp = netdev_priv(ndev);
4667 s32 err;
4668
4669 brcmf_dbg(TRACE, "Enter, MAC %pM, mask 0x%04x set 0x%04x\n", mac,
4670 params->sta_flags_mask, params->sta_flags_set);
4671
4672 /* Ignore all 00 MAC */
4673 if (is_zero_ether_addr(mac))
4674 return 0;
4675
4676 if (!(params->sta_flags_mask & BIT(NL80211_STA_FLAG_AUTHORIZED)))
4677 return 0;
4678
4679 if (params->sta_flags_set & BIT(NL80211_STA_FLAG_AUTHORIZED))
4680 err = brcmf_fil_cmd_data_set(ifp, BRCMF_C_SET_SCB_AUTHORIZE,
4681 (void *)mac, ETH_ALEN);
4682 else
4683 err = brcmf_fil_cmd_data_set(ifp, BRCMF_C_SET_SCB_DEAUTHORIZE,
4684 (void *)mac, ETH_ALEN);
4685 if (err < 0)
4686 brcmf_err("Setting SCB (de-)authorize failed, %d\n", err);
4687
4688 return err;
4689}
0de8aace
HM		 4690
4691static void
4692brcmf_cfg80211_mgmt_frame_register(struct wiphy *wiphy,
4693 struct wireless_dev *wdev,
4694 u16 frame_type, bool reg)
4695{
7fa2e352 4696 struct brcmf_cfg80211_vif *vif;
0de8aace
HM		 4697 u16 mgmt_type;
4698
4699 brcmf_dbg(TRACE, "Enter, frame_type %04x, reg=%d\n", frame_type, reg);
4700
4701 mgmt_type = (frame_type & IEEE80211_FCTL_STYPE) >> 4;
7fa2e352 4702 vif = container_of(wdev, struct brcmf_cfg80211_vif, wdev);
0de8aace
HM		 4703 if (reg)
4704 vif->mgmt_rx_reg |= BIT(mgmt_type);
4705 else
318a64ce 4706 vif->mgmt_rx_reg &= ~BIT(mgmt_type);
0de8aace
HM		 4707}
4708
4709
4710static int
4711brcmf_cfg80211_mgmt_tx(struct wiphy *wiphy, struct wireless_dev *wdev,
b176e629 4712 struct cfg80211_mgmt_tx_params *params, u64 *cookie)
0de8aace
HM		 4713{
4714 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy);
b176e629
AO		 4715 struct ieee80211_channel *chan = params->chan;
4716 const u8 *buf = params->buf;
4717 size_t len = params->len;
0de8aace
HM		 4718 const struct ieee80211_mgmt *mgmt;
4719 struct brcmf_cfg80211_vif *vif;
4720 s32 err = 0;
4721 s32 ie_offset;
4722 s32 ie_len;
18e2f61d
HM		 4723 struct brcmf_fil_action_frame_le *action_frame;
4724 struct brcmf_fil_af_params_le *af_params;
4725 bool ack;
4726 s32 chan_nr;
c2ff8cad 4727 u32 freq;
0de8aace
HM		 4728
4729 brcmf_dbg(TRACE, "Enter\n");
4730
4731 *cookie = 0;
4732
4733 mgmt = (const struct ieee80211_mgmt *)buf;
4734
a0f07959
HM		 4735 if (!ieee80211_is_mgmt(mgmt->frame_control)) {
4736 brcmf_err("Driver only allows MGMT packet type\n");
4737 return -EPERM;
4738 }
0de8aace 4739
c2ff8cad
AQ		 4740 vif = container_of(wdev, struct brcmf_cfg80211_vif, wdev);
4741
a0f07959
HM		 4742 if (ieee80211_is_probe_resp(mgmt->frame_control)) {
4743 /* Right now the only reason to get a probe response */
4744 /* is for p2p listen response or for p2p GO from */
4745 /* wpa_supplicant. Unfortunately the probe is send */
4746 /* on primary ndev, while dongle wants it on the p2p */
4747 /* vif. Since this is only reason for a probe */
4748 /* response to be sent, the vif is taken from cfg. */
4749 /* If ever desired to send proberesp for non p2p */
4750 /* response then data should be checked for */
4751 /* "DIRECT-". Note in future supplicant will take */
4752 /* dedicated p2p wdev to do this and then this 'hack'*/
4753 /* is not needed anymore. */
4754 ie_offset = DOT11_MGMT_HDR_LEN +
4755 DOT11_BCN_PRB_FIXED_LEN;
4756 ie_len = len - ie_offset;
a0f07959 4757 if (vif == cfg->p2p.bss_idx[P2PAPI_BSSCFG_PRIMARY].vif)
0de8aace 4758 vif = cfg->p2p.bss_idx[P2PAPI_BSSCFG_DEVICE].vif;
a0f07959
HM		 4759 err = brcmf_vif_set_mgmt_ie(vif,
4760 BRCMF_VNDR_IE_PRBRSP_FLAG,
4761 &buf[ie_offset],
4762 ie_len);
4763 cfg80211_mgmt_tx_status(wdev, *cookie, buf, len, true,
4764 GFP_KERNEL);
18e2f61d
HM		 4765 } else if (ieee80211_is_action(mgmt->frame_control)) {
4766 af_params = kzalloc(sizeof(*af_params), GFP_KERNEL);
4767 if (af_params == NULL) {
4768 brcmf_err("unable to allocate frame\n");
4769 err = -ENOMEM;
4770 goto exit;
4771 }
4772 action_frame = &af_params->action_frame;
4773 /* Add the packet Id */
4774 action_frame->packet_id = cpu_to_le32(*cookie);
4775 /* Add BSSID */
4776 memcpy(&action_frame->da[0], &mgmt->da[0], ETH_ALEN);
4777 memcpy(&af_params->bssid[0], &mgmt->bssid[0], ETH_ALEN);
4778 /* Add the length exepted for 802.11 header */
4779 action_frame->len = cpu_to_le16(len - DOT11_MGMT_HDR_LEN);
c2ff8cad
AQ		 4780 /* Add the channel. Use the one specified as parameter if any or
4781 * the current one (got from the firmware) otherwise
4782 */
4783 if (chan)
4784 freq = chan->center_freq;
4785 else
4786 brcmf_fil_cmd_int_get(vif->ifp, BRCMF_C_GET_CHANNEL,
4787 &freq);
4788 chan_nr = ieee80211_frequency_to_channel(freq);
18e2f61d
HM		 4789 af_params->channel = cpu_to_le32(chan_nr);
4790
4791 memcpy(action_frame->data, &buf[DOT11_MGMT_HDR_LEN],
4792 le16_to_cpu(action_frame->len));
4793
4794 brcmf_dbg(TRACE, "Action frame, cookie=%lld, len=%d, freq=%d\n",
86a9c4a2 4795 *cookie, le16_to_cpu(action_frame->len), freq);
18e2f61d 4796
7fa2e352 4797 ack = brcmf_p2p_send_action_frame(cfg, cfg_to_ndev(cfg),
18e2f61d
HM		 4798 af_params);
4799
4800 cfg80211_mgmt_tx_status(wdev, *cookie, buf, len, ack,
4801 GFP_KERNEL);
4802 kfree(af_params);
a0f07959
HM		 4803 } else {
4804 brcmf_dbg(TRACE, "Unhandled, fc=%04x!!\n", mgmt->frame_control);
4805 brcmf_dbg_hex_dump(true, buf, len, "payload, len=%Zu\n", len);
0de8aace 4806 }
a0f07959 4807
18e2f61d 4808exit:
0de8aace
HM		 4809 return err;
4810}
4811
4812
4813static int
4814brcmf_cfg80211_cancel_remain_on_channel(struct wiphy *wiphy,
4815 struct wireless_dev *wdev,
4816 u64 cookie)
4817{
4818 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy);
4819 struct brcmf_cfg80211_vif *vif;
4820 int err = 0;
4821
4822 brcmf_dbg(TRACE, "Enter p2p listen cancel\n");
4823
4824 vif = cfg->p2p.bss_idx[P2PAPI_BSSCFG_DEVICE].vif;
4825 if (vif == NULL) {
4826 brcmf_err("No p2p device available for probe response\n");
4827 err = -ENODEV;
4828 goto exit;
4829 }
4830 brcmf_p2p_cancel_remain_on_channel(vif->ifp);
4831exit:
4832 return err;
4833}
4834
61730d4d
PH		 4835static int brcmf_cfg80211_crit_proto_start(struct wiphy *wiphy,
4836 struct wireless_dev *wdev,
4837 enum nl80211_crit_proto_id proto,
4838 u16 duration)
4839{
4840 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy);
4841 struct brcmf_cfg80211_vif *vif;
4842
4843 vif = container_of(wdev, struct brcmf_cfg80211_vif, wdev);
4844
4845 /* only DHCP support for now */
4846 if (proto != NL80211_CRIT_PROTO_DHCP)
4847 return -EINVAL;
4848
4849 /* suppress and abort scanning */
4850 set_bit(BRCMF_SCAN_STATUS_SUPPRESS, &cfg->scan_status);
4851 brcmf_abort_scanning(cfg);
4852
4853 return brcmf_btcoex_set_mode(vif, BRCMF_BTCOEX_DISABLED, duration);
4854}
4855
4856static void brcmf_cfg80211_crit_proto_stop(struct wiphy *wiphy,
4857 struct wireless_dev *wdev)
4858{
4859 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy);
4860 struct brcmf_cfg80211_vif *vif;
4861
4862 vif = container_of(wdev, struct brcmf_cfg80211_vif, wdev);
4863
4864 brcmf_btcoex_set_mode(vif, BRCMF_BTCOEX_ENABLED, 0);
4865 clear_bit(BRCMF_SCAN_STATUS_SUPPRESS, &cfg->scan_status);
4866}
4867
70b7d94b
HM		 4868static s32
4869brcmf_notify_tdls_peer_event(struct brcmf_if *ifp,
4870 const struct brcmf_event_msg *e, void *data)
4871{
4872 switch (e->reason) {
4873 case BRCMF_E_REASON_TDLS_PEER_DISCOVERED:
4874 brcmf_dbg(TRACE, "TDLS Peer Discovered\n");
4875 break;
4876 case BRCMF_E_REASON_TDLS_PEER_CONNECTED:
4877 brcmf_dbg(TRACE, "TDLS Peer Connected\n");
4878 brcmf_proto_add_tdls_peer(ifp->drvr, ifp->ifidx, (u8 *)e->addr);
4879 break;
4880 case BRCMF_E_REASON_TDLS_PEER_DISCONNECTED:
4881 brcmf_dbg(TRACE, "TDLS Peer Disconnected\n");
4882 brcmf_proto_delete_peer(ifp->drvr, ifp->ifidx, (u8 *)e->addr);
4883 break;
4884 }
4885
4886 return 0;
4887}
4888
89c2f382
AS		 4889static int brcmf_convert_nl80211_tdls_oper(enum nl80211_tdls_operation oper)
4890{
4891 int ret;
4892
4893 switch (oper) {
4894 case NL80211_TDLS_DISCOVERY_REQ:
4895 ret = BRCMF_TDLS_MANUAL_EP_DISCOVERY;
4896 break;
4897 case NL80211_TDLS_SETUP:
4898 ret = BRCMF_TDLS_MANUAL_EP_CREATE;
4899 break;
4900 case NL80211_TDLS_TEARDOWN:
4901 ret = BRCMF_TDLS_MANUAL_EP_DELETE;
4902 break;
4903 default:
4904 brcmf_err("unsupported operation: %d\n", oper);
4905 ret = -EOPNOTSUPP;
4906 }
4907 return ret;
4908}
4909
4910static int brcmf_cfg80211_tdls_oper(struct wiphy *wiphy,
3b3a0162 4911 struct net_device *ndev, const u8 *peer,
89c2f382
AS		 4912 enum nl80211_tdls_operation oper)
4913{
4914 struct brcmf_if *ifp;
4915 struct brcmf_tdls_iovar_le info;
4916 int ret = 0;
4917
4918 ret = brcmf_convert_nl80211_tdls_oper(oper);
4919 if (ret < 0)
4920 return ret;
4921
4922 ifp = netdev_priv(ndev);
4923 memset(&info, 0, sizeof(info));
4924 info.mode = (u8)ret;
4925 if (peer)
4926 memcpy(info.ea, peer, ETH_ALEN);
4927
4928 ret = brcmf_fil_iovar_data_set(ifp, "tdls_endpoint",
4929 &info, sizeof(info));
4930 if (ret < 0)
4931 brcmf_err("tdls_endpoint iovar failed: ret=%d\n", ret);
4932
4933 return ret;
4934}
4935
5c22fb85
HM		 4936#ifdef CONFIG_PM
4937static int
4938brcmf_cfg80211_set_rekey_data(struct wiphy *wiphy, struct net_device *ndev,
4939 struct cfg80211_gtk_rekey_data *gtk)
4940{
4941 struct brcmf_if *ifp = netdev_priv(ndev);
4942 struct brcmf_gtk_keyinfo_le gtk_le;
4943 int ret;
4944
4945 brcmf_dbg(TRACE, "Enter, bssidx=%d\n", ifp->bsscfgidx);
4946
4947 memcpy(gtk_le.kck, gtk->kck, sizeof(gtk_le.kck));
4948 memcpy(gtk_le.kek, gtk->kek, sizeof(gtk_le.kek));
4949 memcpy(gtk_le.replay_counter, gtk->replay_ctr,
4950 sizeof(gtk_le.replay_counter));
4951
4952 ret = brcmf_fil_iovar_data_set(ifp, "gtk_key_info", &gtk_le,
4953 sizeof(gtk_le));
4954 if (ret < 0)
4955 brcmf_err("gtk_key_info iovar failed: ret=%d\n", ret);
4956
4957 return ret;
4958}
4959#endif
4960
4961static struct cfg80211_ops brcmf_cfg80211_ops = {
9f440b7b
AS		 4962 .add_virtual_intf = brcmf_cfg80211_add_iface,
4963 .del_virtual_intf = brcmf_cfg80211_del_iface,
5b435de0
AS		 4964 .change_virtual_intf = brcmf_cfg80211_change_iface,
4965 .scan = brcmf_cfg80211_scan,
4966 .set_wiphy_params = brcmf_cfg80211_set_wiphy_params,
4967 .join_ibss = brcmf_cfg80211_join_ibss,
4968 .leave_ibss = brcmf_cfg80211_leave_ibss,
4969 .get_station = brcmf_cfg80211_get_station,
bf2a7e04 4970 .dump_station = brcmf_cfg80211_dump_station,
5b435de0
AS		 4971 .set_tx_power = brcmf_cfg80211_set_tx_power,
4972 .get_tx_power = brcmf_cfg80211_get_tx_power,
4973 .add_key = brcmf_cfg80211_add_key,
4974 .del_key = brcmf_cfg80211_del_key,
4975 .get_key = brcmf_cfg80211_get_key,
4976 .set_default_key = brcmf_cfg80211_config_default_key,
4977 .set_default_mgmt_key = brcmf_cfg80211_config_default_mgmt_key,
4978 .set_power_mgmt = brcmf_cfg80211_set_power_mgmt,
5b435de0
AS		 4979 .connect = brcmf_cfg80211_connect,
4980 .disconnect = brcmf_cfg80211_disconnect,
4981 .suspend = brcmf_cfg80211_suspend,
4982 .resume = brcmf_cfg80211_resume,
4983 .set_pmksa = brcmf_cfg80211_set_pmksa,
4984 .del_pmksa = brcmf_cfg80211_del_pmksa,
cbaa177d 4985 .flush_pmksa = brcmf_cfg80211_flush_pmksa,
1a873342
HM		 4986 .start_ap = brcmf_cfg80211_start_ap,
4987 .stop_ap = brcmf_cfg80211_stop_ap,
a0f07959 4988 .change_beacon = brcmf_cfg80211_change_beacon,
1a873342 4989 .del_station = brcmf_cfg80211_del_station,
6b89dcb3 4990 .change_station = brcmf_cfg80211_change_station,
e5806072
AS		 4991 .sched_scan_start = brcmf_cfg80211_sched_scan_start,
4992 .sched_scan_stop = brcmf_cfg80211_sched_scan_stop,
0de8aace
HM		 4993 .mgmt_frame_register = brcmf_cfg80211_mgmt_frame_register,
4994 .mgmt_tx = brcmf_cfg80211_mgmt_tx,
4995 .remain_on_channel = brcmf_p2p_remain_on_channel,
4996 .cancel_remain_on_channel = brcmf_cfg80211_cancel_remain_on_channel,
27f10e38
AS		 4997 .start_p2p_device = brcmf_p2p_start_device,
4998 .stop_p2p_device = brcmf_p2p_stop_device,
61730d4d
PH		 4999 .crit_proto_start = brcmf_cfg80211_crit_proto_start,
5000 .crit_proto_stop = brcmf_cfg80211_crit_proto_stop,
89c2f382 5001 .tdls_oper = brcmf_cfg80211_tdls_oper,
5b435de0
AS		 5002};
5003
3eacf866 5004struct brcmf_cfg80211_vif *brcmf_alloc_vif(struct brcmf_cfg80211_info *cfg,
9f440b7b
AS		 5005 enum nl80211_iftype type,
5006 bool pm_block)
3eacf866 5007{
a44aa400 5008 struct brcmf_cfg80211_vif *vif_walk;
3eacf866 5009 struct brcmf_cfg80211_vif *vif;
a44aa400 5010 bool mbss;
5b435de0 5011
33a6b157 5012 brcmf_dbg(TRACE, "allocating virtual interface (size=%zu)\n",
9f440b7b 5013 sizeof(*vif));
3eacf866
AS		 5014 vif = kzalloc(sizeof(*vif), GFP_KERNEL);
5015 if (!vif)
5016 return ERR_PTR(-ENOMEM);
5017
5018 vif->wdev.wiphy = cfg->wiphy;
9f440b7b 5019 vif->wdev.iftype = type;
5b435de0 5020
3eacf866 5021 vif->pm_block = pm_block;
3eacf866 5022
6ac4f4ed
AS		 5023 brcmf_init_prof(&vif->profile);
5024
a44aa400
HM		 5025 if (type == NL80211_IFTYPE_AP) {
5026 mbss = false;
5027 list_for_each_entry(vif_walk, &cfg->vif_list, list) {
5028 if (vif_walk->wdev.iftype == NL80211_IFTYPE_AP) {
5029 mbss = true;
5030 break;
5031 }
5032 }
5033 vif->mbss = mbss;
5034 }
5035
3eacf866 5036 list_add_tail(&vif->list, &cfg->vif_list);
3eacf866 5037 return vif;
5b435de0
AS		 5038}
5039
427dec5f 5040void brcmf_free_vif(struct brcmf_cfg80211_vif *vif)
5b435de0 5041{
3eacf866 5042 list_del(&vif->list);
3eacf866 5043 kfree(vif);
5b435de0
AS		 5044}
5045
9df4d542
AS		 5046void brcmf_cfg80211_free_netdev(struct net_device *ndev)
5047{
5048 struct brcmf_cfg80211_vif *vif;
5049 struct brcmf_if *ifp;
5050
5051 ifp = netdev_priv(ndev);
5052 vif = ifp->vif;
5053
95ef1239
AS		 5054 if (vif)
5055 brcmf_free_vif(vif);
9df4d542
AS		 5056 free_netdev(ndev);
5057}
5058
903e0eee 5059static bool brcmf_is_linkup(const struct brcmf_event_msg *e)
5b435de0 5060{
5c36b99a
AS		 5061 u32 event = e->event_code;
5062 u32 status = e->status;
5b435de0
AS		 5063
5064 if (event == BRCMF_E_SET_SSID && status == BRCMF_E_STATUS_SUCCESS) {
16886735 5065 brcmf_dbg(CONN, "Processing set ssid\n");
5b435de0
AS		 5066 return true;
5067 }
5068
5069 return false;
5070}
5071
903e0eee 5072static bool brcmf_is_linkdown(const struct brcmf_event_msg *e)
5b435de0 5073{
5c36b99a
AS		 5074 u32 event = e->event_code;
5075 u16 flags = e->flags;
5b435de0 5076
68ca395f
HM		 5077 if ((event == BRCMF_E_DEAUTH) || (event == BRCMF_E_DEAUTH_IND) ||
5078 (event == BRCMF_E_DISASSOC_IND) ||
5079 ((event == BRCMF_E_LINK) && (!(flags & BRCMF_EVENT_MSG_LINK)))) {
16886735 5080 brcmf_dbg(CONN, "Processing link down\n");
5b435de0
AS		 5081 return true;
5082 }
5083 return false;
5084}
5085
27a68fe3 5086static bool brcmf_is_nonetwork(struct brcmf_cfg80211_info *cfg,
5b435de0
AS		 5087 const struct brcmf_event_msg *e)
5088{
5c36b99a
AS		 5089 u32 event = e->event_code;
5090 u32 status = e->status;
5b435de0
AS		 5091
5092 if (event == BRCMF_E_LINK && status == BRCMF_E_STATUS_NO_NETWORKS) {
16886735
AS		 5093 brcmf_dbg(CONN, "Processing Link %s & no network found\n",
5094 e->flags & BRCMF_EVENT_MSG_LINK ? "up" : "down");
5b435de0
AS		 5095 return true;
5096 }
5097
5098 if (event == BRCMF_E_SET_SSID && status != BRCMF_E_STATUS_SUCCESS) {
16886735 5099 brcmf_dbg(CONN, "Processing connecting & no network found\n");
5b435de0
AS		 5100 return true;
5101 }
5102
5103 return false;
5104}
5105
27a68fe3 5106static void brcmf_clear_assoc_ies(struct brcmf_cfg80211_info *cfg)
5b435de0 5107{
27a68fe3 5108 struct brcmf_cfg80211_connect_info *conn_info = cfg_to_conn(cfg);
5b435de0
AS		 5109
5110 kfree(conn_info->req_ie);
5111 conn_info->req_ie = NULL;
5112 conn_info->req_ie_len = 0;
5113 kfree(conn_info->resp_ie);
5114 conn_info->resp_ie = NULL;
5115 conn_info->resp_ie_len = 0;
5116}
5117
89286dc9
HM		 5118static s32 brcmf_get_assoc_ies(struct brcmf_cfg80211_info *cfg,
5119 struct brcmf_if *ifp)
5b435de0 5120{
c4e382d2 5121 struct brcmf_cfg80211_assoc_ielen_le *assoc_info;
27a68fe3 5122 struct brcmf_cfg80211_connect_info *conn_info = cfg_to_conn(cfg);
5b435de0
AS		 5123 u32 req_len;
5124 u32 resp_len;
5125 s32 err = 0;
5126
27a68fe3 5127 brcmf_clear_assoc_ies(cfg);
5b435de0 5128
ac24be6f
AS		 5129 err = brcmf_fil_iovar_data_get(ifp, "assoc_info",
5130 cfg->extra_buf, WL_ASSOC_INFO_MAX);
5b435de0 5131 if (err) {
57d6e91a 5132 brcmf_err("could not get assoc info (%d)\n", err);
5b435de0
AS		 5133 return err;
5134 }
c4e382d2 5135 assoc_info =
27a68fe3 5136 (struct brcmf_cfg80211_assoc_ielen_le *)cfg->extra_buf;
c4e382d2
AS		 5137 req_len = le32_to_cpu(assoc_info->req_len);
5138 resp_len = le32_to_cpu(assoc_info->resp_len);
5b435de0 5139 if (req_len) {
ac24be6f 5140 err = brcmf_fil_iovar_data_get(ifp, "assoc_req_ies",
81f5dcb8
HM		 5141 cfg->extra_buf,
5142 WL_ASSOC_INFO_MAX);
5b435de0 5143 if (err) {
57d6e91a 5144 brcmf_err("could not get assoc req (%d)\n", err);
5b435de0
AS		 5145 return err;
5146 }
5147 conn_info->req_ie_len = req_len;
5148 conn_info->req_ie =
27a68fe3 5149 kmemdup(cfg->extra_buf, conn_info->req_ie_len,
5b435de0
AS		 5150 GFP_KERNEL);
5151 } else {
5152 conn_info->req_ie_len = 0;
5153 conn_info->req_ie = NULL;
5154 }
5155 if (resp_len) {
ac24be6f 5156 err = brcmf_fil_iovar_data_get(ifp, "assoc_resp_ies",
81f5dcb8
HM		 5157 cfg->extra_buf,
5158 WL_ASSOC_INFO_MAX);
5b435de0 5159 if (err) {
57d6e91a 5160 brcmf_err("could not get assoc resp (%d)\n", err);
5b435de0
AS		 5161 return err;
5162 }
5163 conn_info->resp_ie_len = resp_len;
5164 conn_info->resp_ie =
27a68fe3 5165 kmemdup(cfg->extra_buf, conn_info->resp_ie_len,
5b435de0
AS		 5166 GFP_KERNEL);
5167 } else {
5168 conn_info->resp_ie_len = 0;
5169 conn_info->resp_ie = NULL;
5170 }
16886735
AS		 5171 brcmf_dbg(CONN, "req len (%d) resp len (%d)\n",
5172 conn_info->req_ie_len, conn_info->resp_ie_len);
5b435de0
AS		 5173
5174 return err;
5175}
5176
5177static s32
27a68fe3 5178brcmf_bss_roaming_done(struct brcmf_cfg80211_info *cfg,
5b435de0
AS		 5179 struct net_device *ndev,
5180 const struct brcmf_event_msg *e)
5181{
c1179033
AS		 5182 struct brcmf_if *ifp = netdev_priv(ndev);
5183 struct brcmf_cfg80211_profile *profile = &ifp->vif->profile;
27a68fe3
AS		 5184 struct brcmf_cfg80211_connect_info *conn_info = cfg_to_conn(cfg);
5185 struct wiphy *wiphy = cfg_to_wiphy(cfg);
a180b83b 5186 struct ieee80211_channel *notify_channel = NULL;
5b435de0 5187 struct ieee80211_supported_band *band;
a180b83b 5188 struct brcmf_bss_info_le *bi;
83cf17aa 5189 struct brcmu_chan ch;
5b435de0
AS		 5190 u32 freq;
5191 s32 err = 0;
a180b83b 5192 u8 *buf;
5b435de0 5193
d96b801f 5194 brcmf_dbg(TRACE, "Enter\n");
5b435de0 5195
89286dc9 5196 brcmf_get_assoc_ies(cfg, ifp);
6c8c4f72 5197 memcpy(profile->bssid, e->addr, ETH_ALEN);
89286dc9 5198 brcmf_update_bss_info(cfg, ifp);
5b435de0 5199
a180b83b
FL		 5200 buf = kzalloc(WL_BSS_INFO_MAX, GFP_KERNEL);
5201 if (buf == NULL) {
5202 err = -ENOMEM;
5203 goto done;
5204 }
5205
5206 /* data sent to dongle has to be little endian */
5207 *(__le32 *)buf = cpu_to_le32(WL_BSS_INFO_MAX);
c1179033 5208 err = brcmf_fil_cmd_data_get(ifp, BRCMF_C_GET_BSS_INFO,
ac24be6f 5209 buf, WL_BSS_INFO_MAX);
a180b83b
FL		 5210
5211 if (err)
5212 goto done;
5b435de0 5213
a180b83b 5214 bi = (struct brcmf_bss_info_le *)(buf + 4);
83cf17aa
FL		 5215 ch.chspec = le16_to_cpu(bi->chanspec);
5216 cfg->d11inf.decchspec(&ch);
5b435de0 5217
83cf17aa 5218 if (ch.band == BRCMU_CHAN_BAND_2G)
57fbcce3 5219 band = wiphy->bands[NL80211_BAND_2GHZ];
5b435de0 5220 else
57fbcce3 5221 band = wiphy->bands[NL80211_BAND_5GHZ];
5b435de0 5222
83cf17aa 5223 freq = ieee80211_channel_to_frequency(ch.chnum, band->band);
5b435de0
AS		 5224 notify_channel = ieee80211_get_channel(wiphy, freq);
5225
a180b83b
FL		 5226done:
5227 kfree(buf);
06bb123e 5228 cfg80211_roamed(ndev, notify_channel, (u8 *)profile->bssid,
5b435de0
AS		 5229 conn_info->req_ie, conn_info->req_ie_len,
5230 conn_info->resp_ie, conn_info->resp_ie_len, GFP_KERNEL);
16886735 5231 brcmf_dbg(CONN, "Report roaming result\n");
5b435de0 5232
c1179033 5233 set_bit(BRCMF_VIF_STATUS_CONNECTED, &ifp->vif->sme_state);
d96b801f 5234 brcmf_dbg(TRACE, "Exit\n");
5b435de0
AS		 5235 return err;
5236}
5237
5238static s32
27a68fe3 5239brcmf_bss_connect_done(struct brcmf_cfg80211_info *cfg,
5b435de0
AS		 5240 struct net_device *ndev, const struct brcmf_event_msg *e,
5241 bool completed)
5242{
c1179033
AS		 5243 struct brcmf_if *ifp = netdev_priv(ndev);
5244 struct brcmf_cfg80211_profile *profile = &ifp->vif->profile;
27a68fe3 5245 struct brcmf_cfg80211_connect_info *conn_info = cfg_to_conn(cfg);
5b435de0 5246
d96b801f 5247 brcmf_dbg(TRACE, "Enter\n");
5b435de0 5248
c1179033
AS		 5249 if (test_and_clear_bit(BRCMF_VIF_STATUS_CONNECTING,
5250 &ifp->vif->sme_state)) {
5b435de0 5251 if (completed) {
89286dc9 5252 brcmf_get_assoc_ies(cfg, ifp);
6c8c4f72 5253 memcpy(profile->bssid, e->addr, ETH_ALEN);
89286dc9
HM		 5254 brcmf_update_bss_info(cfg, ifp);
5255 set_bit(BRCMF_VIF_STATUS_CONNECTED,
5256 &ifp->vif->sme_state);
5b435de0
AS		 5257 }
5258 cfg80211_connect_result(ndev,
06bb123e 5259 (u8 *)profile->bssid,
5b435de0
AS		 5260 conn_info->req_ie,
5261 conn_info->req_ie_len,
5262 conn_info->resp_ie,
5263 conn_info->resp_ie_len,
5264 completed ? WLAN_STATUS_SUCCESS :
5265 WLAN_STATUS_AUTH_TIMEOUT,
5266 GFP_KERNEL);
16886735
AS		 5267 brcmf_dbg(CONN, "Report connect result - connection %s\n",
5268 completed ? "succeeded" : "failed");
5b435de0 5269 }
d96b801f 5270 brcmf_dbg(TRACE, "Exit\n");
12f32370 5271 return 0;
5b435de0
AS		 5272}
5273
5274static s32
27a68fe3 5275brcmf_notify_connect_status_ap(struct brcmf_cfg80211_info *cfg,
1a873342
HM		 5276 struct net_device *ndev,
5277 const struct brcmf_event_msg *e, void *data)
5278{
a44aa400 5279 struct brcmf_if *ifp = netdev_priv(ndev);
7ee29602 5280 static int generation;
5c36b99a
AS		 5281 u32 event = e->event_code;
5282 u32 reason = e->reason;
1a873342
HM		 5283 struct station_info sinfo;
5284
16886735 5285 brcmf_dbg(CONN, "event %d, reason %d\n", event, reason);
5f4f9f11
AS		 5286 if (event == BRCMF_E_LINK && reason == BRCMF_E_REASON_LINK_BSSCFG_DIS &&
5287 ndev != cfg_to_ndev(cfg)) {
5288 brcmf_dbg(CONN, "AP mode link down\n");
5289 complete(&cfg->vif_disabled);
a44aa400 5290 if (ifp->vif->mbss)
ee6e3a34 5291 brcmf_remove_interface(ifp);
5f4f9f11
AS		 5292 return 0;
5293 }
1a873342 5294
1a873342 5295 if (((event == BRCMF_E_ASSOC_IND) || (event == BRCMF_E_REASSOC_IND)) &&
7ee29602
HM		 5296 (reason == BRCMF_E_STATUS_SUCCESS)) {
5297 memset(&sinfo, 0, sizeof(sinfo));
1a873342 5298 if (!data) {
57d6e91a 5299 brcmf_err("No IEs present in ASSOC/REASSOC_IND");
1a873342
HM		 5300 return -EINVAL;
5301 }
5302 sinfo.assoc_req_ies = data;
7ee29602 5303 sinfo.assoc_req_ies_len = e->datalen;
1a873342
HM		 5304 generation++;
5305 sinfo.generation = generation;
7ee29602 5306 cfg80211_new_sta(ndev, e->addr, &sinfo, GFP_KERNEL);
1a873342
HM		 5307 } else if ((event == BRCMF_E_DISASSOC_IND) ||
5308 (event == BRCMF_E_DEAUTH_IND) ||
5309 (event == BRCMF_E_DEAUTH)) {
7ee29602 5310 cfg80211_del_sta(ndev, e->addr, GFP_KERNEL);
1a873342 5311 }
7ee29602 5312 return 0;
1a873342
HM		 5313}
5314
5b435de0 5315static s32
1993732e 5316brcmf_notify_connect_status(struct brcmf_if *ifp,
5b435de0
AS		 5317 const struct brcmf_event_msg *e, void *data)
5318{
1993732e
AS		 5319 struct brcmf_cfg80211_info *cfg = ifp->drvr->config;
5320 struct net_device *ndev = ifp->ndev;
c1179033 5321 struct brcmf_cfg80211_profile *profile = &ifp->vif->profile;
fe94f3a4 5322 struct ieee80211_channel *chan;
5b435de0
AS		 5323 s32 err = 0;
5324
8851cce0
HM		 5325 if ((e->event_code == BRCMF_E_DEAUTH) ||
5326 (e->event_code == BRCMF_E_DEAUTH_IND) ||
5327 (e->event_code == BRCMF_E_DISASSOC_IND) ||
5328 ((e->event_code == BRCMF_E_LINK) && (!e->flags))) {
5329 brcmf_proto_delete_peer(ifp->drvr, ifp->ifidx, (u8 *)e->addr);
5330 }
5331
967fe2c8 5332 if (brcmf_is_apmode(ifp->vif)) {
27a68fe3 5333 err = brcmf_notify_connect_status_ap(cfg, ndev, e, data);
903e0eee 5334 } else if (brcmf_is_linkup(e)) {
16886735 5335 brcmf_dbg(CONN, "Linkup\n");
128ce3b6 5336 if (brcmf_is_ibssmode(ifp->vif)) {
b0a79088 5337 brcmf_inform_ibss(cfg, ndev, e->addr);
fe94f3a4 5338 chan = ieee80211_get_channel(cfg->wiphy, cfg->channel);
6c8c4f72 5339 memcpy(profile->bssid, e->addr, ETH_ALEN);
fe94f3a4 5340 cfg80211_ibss_joined(ndev, e->addr, chan, GFP_KERNEL);
c1179033
AS		 5341 clear_bit(BRCMF_VIF_STATUS_CONNECTING,
5342 &ifp->vif->sme_state);
5343 set_bit(BRCMF_VIF_STATUS_CONNECTED,
5344 &ifp->vif->sme_state);
5b435de0 5345 } else
27a68fe3 5346 brcmf_bss_connect_done(cfg, ndev, e, true);
92121e69 5347 brcmf_net_setcarrier(ifp, true);
903e0eee 5348 } else if (brcmf_is_linkdown(e)) {
16886735 5349 brcmf_dbg(CONN, "Linkdown\n");
128ce3b6 5350 if (!brcmf_is_ibssmode(ifp->vif)) {
27a68fe3 5351 brcmf_bss_connect_done(cfg, ndev, e, false);
42e0ed0d
HM		 5352 brcmf_link_down(ifp->vif,
5353 brcmf_map_fw_linkdown_reason(e));
5354 brcmf_init_prof(ndev_to_prof(ndev));
5355 if (ndev != cfg_to_ndev(cfg))
5356 complete(&cfg->vif_disabled);
5357 brcmf_net_setcarrier(ifp, false);
5b435de0 5358 }
27a68fe3 5359 } else if (brcmf_is_nonetwork(cfg, e)) {
128ce3b6 5360 if (brcmf_is_ibssmode(ifp->vif))
c1179033
AS		 5361 clear_bit(BRCMF_VIF_STATUS_CONNECTING,
5362 &ifp->vif->sme_state);
5b435de0 5363 else
27a68fe3 5364 brcmf_bss_connect_done(cfg, ndev, e, false);
5b435de0
AS		 5365 }
5366
5367 return err;
5368}
5369
5370static s32
1993732e 5371brcmf_notify_roaming_status(struct brcmf_if *ifp,
5b435de0
AS		 5372 const struct brcmf_event_msg *e, void *data)
5373{
1993732e 5374 struct brcmf_cfg80211_info *cfg = ifp->drvr->config;
5c36b99a
AS		 5375 u32 event = e->event_code;
5376 u32 status = e->status;
5b435de0
AS		 5377
5378 if (event == BRCMF_E_ROAM && status == BRCMF_E_STATUS_SUCCESS) {
c1179033 5379 if (test_bit(BRCMF_VIF_STATUS_CONNECTED, &ifp->vif->sme_state))
1993732e 5380 brcmf_bss_roaming_done(cfg, ifp->ndev, e);
5b435de0 5381 else
1993732e 5382 brcmf_bss_connect_done(cfg, ifp->ndev, e, true);
5b435de0
AS		 5383 }
5384
12f32370 5385 return 0;
5b435de0
AS		 5386}
5387
5388static s32
1993732e 5389brcmf_notify_mic_status(struct brcmf_if *ifp,
5b435de0
AS		 5390 const struct brcmf_event_msg *e, void *data)
5391{
5c36b99a 5392 u16 flags = e->flags;
5b435de0
AS		 5393 enum nl80211_key_type key_type;
5394
5395 if (flags & BRCMF_EVENT_MSG_GROUP)
5396 key_type = NL80211_KEYTYPE_GROUP;
5397 else
5398 key_type = NL80211_KEYTYPE_PAIRWISE;
5399
1993732e 5400 cfg80211_michael_mic_failure(ifp->ndev, (u8 *)&e->addr, key_type, -1,
5b435de0
AS		 5401 NULL, GFP_KERNEL);
5402
5403 return 0;
5404}
5405
d3c0b633
AS		 5406static s32 brcmf_notify_vif_event(struct brcmf_if *ifp,
5407 const struct brcmf_event_msg *e, void *data)
5408{
5409 struct brcmf_cfg80211_info *cfg = ifp->drvr->config;
5410 struct brcmf_if_event *ifevent = (struct brcmf_if_event *)data;
5411 struct brcmf_cfg80211_vif_event *event = &cfg->vif_event;
5412 struct brcmf_cfg80211_vif *vif;
5413
37a869ec 5414 brcmf_dbg(TRACE, "Enter: action %u flags %u ifidx %u bsscfgidx %u\n",
d3c0b633 5415 ifevent->action, ifevent->flags, ifevent->ifidx,
37a869ec 5416 ifevent->bsscfgidx);
d3c0b633 5417
d3c0b633
AS		 5418 mutex_lock(&event->vif_event_lock);
5419 event->action = ifevent->action;
5420 vif = event->vif;
5421
5422 switch (ifevent->action) {
5423 case BRCMF_E_IF_ADD:
5424 /* waiting process may have timed out */
dc4a787c
WY		 5425 if (!cfg->vif_event.vif) {
5426 mutex_unlock(&event->vif_event_lock);
d3c0b633 5427 return -EBADF;
dc4a787c 5428 }
d3c0b633
AS		 5429
5430 ifp->vif = vif;
5431 vif->ifp = ifp;
01b8e7db
AS		 5432 if (ifp->ndev) {
5433 vif->wdev.netdev = ifp->ndev;
5434 ifp->ndev->ieee80211_ptr = &vif->wdev;
5435 SET_NETDEV_DEV(ifp->ndev, wiphy_dev(cfg->wiphy));
5436 }
d3c0b633
AS		 5437 mutex_unlock(&event->vif_event_lock);
5438 wake_up(&event->vif_wq);
4b3a89de 5439 return 0;
d3c0b633
AS		 5440
5441 case BRCMF_E_IF_DEL:
d3c0b633
AS		 5442 mutex_unlock(&event->vif_event_lock);
5443 /* event may not be upon user request */
5444 if (brcmf_cfg80211_vif_event_armed(cfg))
5445 wake_up(&event->vif_wq);
5446 return 0;
5447
7a5c1f64
HM		 5448 case BRCMF_E_IF_CHANGE:
5449 mutex_unlock(&event->vif_event_lock);
5450 wake_up(&event->vif_wq);
5451 return 0;
5452
d3c0b633
AS		 5453 default:
5454 mutex_unlock(&event->vif_event_lock);
5455 break;
5456 }
5457 return -EINVAL;
5458}
5459
5b435de0
AS		 5460static void brcmf_init_conf(struct brcmf_cfg80211_conf *conf)
5461{
5b435de0
AS		 5462 conf->frag_threshold = (u32)-1;
5463 conf->rts_threshold = (u32)-1;
5464 conf->retry_short = (u32)-1;
5465 conf->retry_long = (u32)-1;
5b435de0
AS		 5466}
5467
5c36b99a 5468static void brcmf_register_event_handlers(struct brcmf_cfg80211_info *cfg)
5b435de0 5469{
5c36b99a
AS		 5470 brcmf_fweh_register(cfg->pub, BRCMF_E_LINK,
5471 brcmf_notify_connect_status);
5472 brcmf_fweh_register(cfg->pub, BRCMF_E_DEAUTH_IND,
5473 brcmf_notify_connect_status);
5474 brcmf_fweh_register(cfg->pub, BRCMF_E_DEAUTH,
5475 brcmf_notify_connect_status);
5476 brcmf_fweh_register(cfg->pub, BRCMF_E_DISASSOC_IND,
5477 brcmf_notify_connect_status);
5478 brcmf_fweh_register(cfg->pub, BRCMF_E_ASSOC_IND,
5479 brcmf_notify_connect_status);
5480 brcmf_fweh_register(cfg->pub, BRCMF_E_REASSOC_IND,
5481 brcmf_notify_connect_status);
5482 brcmf_fweh_register(cfg->pub, BRCMF_E_ROAM,
5483 brcmf_notify_roaming_status);
5484 brcmf_fweh_register(cfg->pub, BRCMF_E_MIC_ERROR,
5485 brcmf_notify_mic_status);
5486 brcmf_fweh_register(cfg->pub, BRCMF_E_SET_SSID,
5487 brcmf_notify_connect_status);
5488 brcmf_fweh_register(cfg->pub, BRCMF_E_PFN_NET_FOUND,
5489 brcmf_notify_sched_scan_results);
d3c0b633
AS		 5490 brcmf_fweh_register(cfg->pub, BRCMF_E_IF,
5491 brcmf_notify_vif_event);
0de8aace 5492 brcmf_fweh_register(cfg->pub, BRCMF_E_P2P_PROBEREQ_MSG,
6eda4e2c 5493 brcmf_p2p_notify_rx_mgmt_p2p_probereq);
0de8aace
HM		 5494 brcmf_fweh_register(cfg->pub, BRCMF_E_P2P_DISC_LISTEN_COMPLETE,
5495 brcmf_p2p_notify_listen_complete);
e6da3400
HM		 5496 brcmf_fweh_register(cfg->pub, BRCMF_E_ACTION_FRAME_RX,
5497 brcmf_p2p_notify_action_frame_rx);
18e2f61d
HM		 5498 brcmf_fweh_register(cfg->pub, BRCMF_E_ACTION_FRAME_COMPLETE,
5499 brcmf_p2p_notify_action_tx_complete);
6eda4e2c
HM		 5500 brcmf_fweh_register(cfg->pub, BRCMF_E_ACTION_FRAME_OFF_CHAN_COMPLETE,
5501 brcmf_p2p_notify_action_tx_complete);
5b435de0
AS		 5502}
5503
27a68fe3
AS		 5504static void brcmf_deinit_priv_mem(struct brcmf_cfg80211_info *cfg)
5505{
27a68fe3
AS		 5506 kfree(cfg->conf);
5507 cfg->conf = NULL;
27a68fe3
AS		 5508 kfree(cfg->extra_buf);
5509 cfg->extra_buf = NULL;
3021ad9a
HM		 5510 kfree(cfg->wowl.nd);
5511 cfg->wowl.nd = NULL;
5512 kfree(cfg->wowl.nd_info);
5513 cfg->wowl.nd_info = NULL;
d5367334
HM		 5514 kfree(cfg->escan_info.escan_buf);
5515 cfg->escan_info.escan_buf = NULL;
27a68fe3
AS		 5516}
5517
5518static s32 brcmf_init_priv_mem(struct brcmf_cfg80211_info *cfg)
5519{
27a68fe3
AS		 5520 cfg->conf = kzalloc(sizeof(*cfg->conf), GFP_KERNEL);
5521 if (!cfg->conf)
5b435de0 5522 goto init_priv_mem_out;
27a68fe3
AS		 5523 cfg->extra_buf = kzalloc(WL_EXTRA_BUF_MAX, GFP_KERNEL);
5524 if (!cfg->extra_buf)
5b435de0 5525 goto init_priv_mem_out;
3021ad9a
HM		 5526 cfg->wowl.nd = kzalloc(sizeof(*cfg->wowl.nd) + sizeof(u32), GFP_KERNEL);
5527 if (!cfg->wowl.nd)
5528 goto init_priv_mem_out;
5529 cfg->wowl.nd_info = kzalloc(sizeof(*cfg->wowl.nd_info) +
5530 sizeof(struct cfg80211_wowlan_nd_match *),
5531 GFP_KERNEL);
5532 if (!cfg->wowl.nd_info)
5533 goto init_priv_mem_out;
d5367334
HM		 5534 cfg->escan_info.escan_buf = kzalloc(BRCMF_ESCAN_BUF_SIZE, GFP_KERNEL);
5535 if (!cfg->escan_info.escan_buf)
5536 goto init_priv_mem_out;
5b435de0
AS		 5537
5538 return 0;
5539
5540init_priv_mem_out:
27a68fe3 5541 brcmf_deinit_priv_mem(cfg);
5b435de0
AS		 5542
5543 return -ENOMEM;
5544}
5545
27a68fe3 5546static s32 wl_init_priv(struct brcmf_cfg80211_info *cfg)
5b435de0
AS		 5547{
5548 s32 err = 0;
5549
27a68fe3
AS		 5550 cfg->scan_request = NULL;
5551 cfg->pwr_save = true;
68ca395f
HM		 5552 cfg->active_scan = true; /* we do active scan per default */
5553 cfg->dongle_up = false; /* dongle is not up yet */
27a68fe3 5554 err = brcmf_init_priv_mem(cfg);
5b435de0
AS		 5555 if (err)
5556 return err;
5c36b99a 5557 brcmf_register_event_handlers(cfg);
27a68fe3 5558 mutex_init(&cfg->usr_sync);
27a68fe3
AS		 5559 brcmf_init_escan(cfg);
5560 brcmf_init_conf(cfg->conf);
5f4f9f11 5561 init_completion(&cfg->vif_disabled);
5b435de0
AS		 5562 return err;
5563}
5564
27a68fe3 5565static void wl_deinit_priv(struct brcmf_cfg80211_info *cfg)
5b435de0 5566{
27a68fe3 5567 cfg->dongle_up = false; /* dongle down */
27a68fe3
AS		 5568 brcmf_abort_scanning(cfg);
5569 brcmf_deinit_priv_mem(cfg);
5b435de0
AS		 5570}
5571
d3c0b633
AS		 5572static void init_vif_event(struct brcmf_cfg80211_vif_event *event)
5573{
5574 init_waitqueue_head(&event->vif_wq);
d3c0b633
AS		 5575 mutex_init(&event->vif_event_lock);
5576}
5577
1119e23e 5578static s32 brcmf_dongle_roam(struct brcmf_if *ifp)
5b435de0 5579{
1119e23e
HM		 5580 s32 err;
5581 u32 bcn_timeout;
f588bc0c
AS		 5582 __le32 roamtrigger[2];
5583 __le32 roam_delta[2];
5b435de0 5584
1119e23e 5585 /* Configure beacon timeout value based upon roaming setting */
7d34b056 5586 if (ifp->drvr->settings->roamoff)
1119e23e
HM		 5587 bcn_timeout = BRCMF_DEFAULT_BCN_TIMEOUT_ROAM_OFF;
5588 else
5589 bcn_timeout = BRCMF_DEFAULT_BCN_TIMEOUT_ROAM_ON;
5590 err = brcmf_fil_iovar_int_set(ifp, "bcn_timeout", bcn_timeout);
5591 if (err) {
5592 brcmf_err("bcn_timeout error (%d)\n", err);
5593 goto roam_setup_done;
5b435de0
AS		 5594 }
5595
1119e23e
HM		 5596 /* Enable/Disable built-in roaming to allow supplicant to take care of
5597 * roaming.
5b435de0 5598 */
68ca395f 5599 brcmf_dbg(INFO, "Internal Roaming = %s\n",
7d34b056
HM		 5600 ifp->drvr->settings->roamoff ? "Off" : "On");
5601 err = brcmf_fil_iovar_int_set(ifp, "roam_off",
5602 ifp->drvr->settings->roamoff);
5b435de0 5603 if (err) {
57d6e91a 5604 brcmf_err("roam_off error (%d)\n", err);
1119e23e 5605 goto roam_setup_done;
5b435de0
AS		 5606 }
5607
f588bc0c
AS		 5608 roamtrigger[0] = cpu_to_le32(WL_ROAM_TRIGGER_LEVEL);
5609 roamtrigger[1] = cpu_to_le32(BRCM_BAND_ALL);
ac24be6f 5610 err = brcmf_fil_cmd_data_set(ifp, BRCMF_C_SET_ROAM_TRIGGER,
81f5dcb8 5611 (void *)roamtrigger, sizeof(roamtrigger));
5b435de0 5612 if (err) {
57d6e91a 5613 brcmf_err("WLC_SET_ROAM_TRIGGER error (%d)\n", err);
1119e23e 5614 goto roam_setup_done;
5b435de0
AS		 5615 }
5616
f588bc0c
AS		 5617 roam_delta[0] = cpu_to_le32(WL_ROAM_DELTA);
5618 roam_delta[1] = cpu_to_le32(BRCM_BAND_ALL);
ac24be6f 5619 err = brcmf_fil_cmd_data_set(ifp, BRCMF_C_SET_ROAM_DELTA,
81f5dcb8 5620 (void *)roam_delta, sizeof(roam_delta));
5b435de0 5621 if (err) {
57d6e91a 5622 brcmf_err("WLC_SET_ROAM_DELTA error (%d)\n", err);
1119e23e 5623 goto roam_setup_done;
5b435de0
AS		 5624 }
5625
1119e23e 5626roam_setup_done:
5b435de0
AS		 5627 return err;
5628}
5629
5630static s32
1678ba8e 5631brcmf_dongle_scantime(struct brcmf_if *ifp)
5b435de0
AS		 5632{
5633 s32 err = 0;
5634
ac24be6f 5635 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_SCAN_CHANNEL_TIME,
1678ba8e 5636 BRCMF_SCAN_CHANNEL_TIME);
5b435de0 5637 if (err) {
1678ba8e 5638 brcmf_err("Scan assoc time error (%d)\n", err);
5b435de0
AS		 5639 goto dongle_scantime_out;
5640 }
ac24be6f 5641 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_SCAN_UNASSOC_TIME,
1678ba8e 5642 BRCMF_SCAN_UNASSOC_TIME);
5b435de0 5643 if (err) {
1678ba8e 5644 brcmf_err("Scan unassoc time error (%d)\n", err);
5b435de0
AS		 5645 goto dongle_scantime_out;
5646 }
5647
ac24be6f 5648 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_SCAN_PASSIVE_TIME,
1678ba8e 5649 BRCMF_SCAN_PASSIVE_TIME);
5b435de0 5650 if (err) {
1678ba8e 5651 brcmf_err("Scan passive time error (%d)\n", err);
5b435de0
AS		 5652 goto dongle_scantime_out;
5653 }
5654
5655dongle_scantime_out:
5656 return err;
5657}
5658
b48d8916
AS		 5659static void brcmf_update_bw40_channel_flag(struct ieee80211_channel *channel,
5660 struct brcmu_chan *ch)
5661{
5662 u32 ht40_flag;
d48200ba 5663
b48d8916
AS		 5664 ht40_flag = channel->flags & IEEE80211_CHAN_NO_HT40;
5665 if (ch->sb == BRCMU_CHAN_SB_U) {
5666 if (ht40_flag == IEEE80211_CHAN_NO_HT40)
5667 channel->flags &= ~IEEE80211_CHAN_NO_HT40;
5668 channel->flags |= IEEE80211_CHAN_NO_HT40PLUS;
5669 } else {
5670 /* It should be one of
5671 * IEEE80211_CHAN_NO_HT40 or
5672 * IEEE80211_CHAN_NO_HT40PLUS
5673 */
5674 channel->flags &= ~IEEE80211_CHAN_NO_HT40;
5675 if (ht40_flag == IEEE80211_CHAN_NO_HT40)
5676 channel->flags |= IEEE80211_CHAN_NO_HT40MINUS;
5677 }
5678}
5679
5680static int brcmf_construct_chaninfo(struct brcmf_cfg80211_info *cfg,
5681 u32 bw_cap[])
d48200ba
HM		 5682{
5683 struct brcmf_if *ifp = netdev_priv(cfg_to_ndev(cfg));
b48d8916
AS		 5684 struct ieee80211_supported_band *band;
5685 struct ieee80211_channel *channel;
5686 struct wiphy *wiphy;
d48200ba 5687 struct brcmf_chanspec_list *list;
83cf17aa 5688 struct brcmu_chan ch;
b48d8916 5689 int err;
d48200ba
HM		 5690 u8 *pbuf;
5691 u32 i, j;
5692 u32 total;
b48d8916 5693 u32 chaninfo;
d48200ba 5694 u32 index;
d48200ba
HM		 5695
5696 pbuf = kzalloc(BRCMF_DCMD_MEDLEN, GFP_KERNEL);
5697
5698 if (pbuf == NULL)
5699 return -ENOMEM;
5700
5701 list = (struct brcmf_chanspec_list *)pbuf;
5702
5703 err = brcmf_fil_iovar_data_get(ifp, "chanspecs", pbuf,
5704 BRCMF_DCMD_MEDLEN);
5705 if (err) {
5706 brcmf_err("get chanspecs error (%d)\n", err);
b48d8916 5707 goto fail_pbuf;
d48200ba
HM		 5708 }
5709
b48d8916 5710 wiphy = cfg_to_wiphy(cfg);
57fbcce3 5711 band = wiphy->bands[NL80211_BAND_2GHZ];
58de92d2
AS		 5712 if (band)
5713 for (i = 0; i < band->n_channels; i++)
5714 band->channels[i].flags = IEEE80211_CHAN_DISABLED;
57fbcce3 5715 band = wiphy->bands[NL80211_BAND_5GHZ];
58de92d2
AS		 5716 if (band)
5717 for (i = 0; i < band->n_channels; i++)
5718 band->channels[i].flags = IEEE80211_CHAN_DISABLED;
d48200ba
HM		 5719
5720 total = le32_to_cpu(list->count);
5721 for (i = 0; i < total; i++) {
83cf17aa
FL		 5722 ch.chspec = (u16)le32_to_cpu(list->element[i]);
5723 cfg->d11inf.decchspec(&ch);
d48200ba 5724
83cf17aa 5725 if (ch.band == BRCMU_CHAN_BAND_2G) {
57fbcce3 5726 band = wiphy->bands[NL80211_BAND_2GHZ];
83cf17aa 5727 } else if (ch.band == BRCMU_CHAN_BAND_5G) {
57fbcce3 5728 band = wiphy->bands[NL80211_BAND_5GHZ];
d48200ba 5729 } else {
2375d970 5730 brcmf_err("Invalid channel Spec. 0x%x.\n", ch.chspec);
d48200ba
HM		 5731 continue;
5732 }
58de92d2
AS		 5733 if (!band)
5734 continue;
b48d8916 5735 if (!(bw_cap[band->band] & WLC_BW_40MHZ_BIT) &&
2375d970 5736 ch.bw == BRCMU_CHAN_BW_40)
d48200ba 5737 continue;
b48d8916 5738 if (!(bw_cap[band->band] & WLC_BW_80MHZ_BIT) &&
ee942ecc
AS		 5739 ch.bw == BRCMU_CHAN_BW_80)
5740 continue;
b48d8916
AS		 5741
5742 channel = band->channels;
5743 index = band->n_channels;
5744 for (j = 0; j < band->n_channels; j++) {
5745 if (channel[j].hw_value == ch.chnum) {
5746 index = j;
d48200ba
HM		 5747 break;
5748 }
5749 }
b48d8916
AS		 5750 channel[index].center_freq =
5751 ieee80211_channel_to_frequency(ch.chnum, band->band);
5752 channel[index].hw_value = ch.chnum;
5753
5754 /* assuming the chanspecs order is HT20,
5755 * HT40 upper, HT40 lower, and VHT80.
5756 */
5757 if (ch.bw == BRCMU_CHAN_BW_80) {
5758 channel[index].flags &= ~IEEE80211_CHAN_NO_80MHZ;
5759 } else if (ch.bw == BRCMU_CHAN_BW_40) {
5760 brcmf_update_bw40_channel_flag(&channel[index], &ch);
5761 } else {
58de92d2
AS		 5762 /* enable the channel and disable other bandwidths
5763 * for now as mentioned order assure they are enabled
5764 * for subsequent chanspecs.
ee942ecc 5765 */
b48d8916
AS		 5766 channel[index].flags = IEEE80211_CHAN_NO_HT40 |
5767 IEEE80211_CHAN_NO_80MHZ;
5768 ch.bw = BRCMU_CHAN_BW_20;
5769 cfg->d11inf.encchspec(&ch);
5770 chaninfo = ch.chspec;
5771 err = brcmf_fil_bsscfg_int_get(ifp, "per_chan_info",
5772 &chaninfo);
5773 if (!err) {
5774 if (chaninfo & WL_CHAN_RADAR)
5775 channel[index].flags |=
5776 (IEEE80211_CHAN_RADAR |
5777 IEEE80211_CHAN_NO_IR);
5778 if (chaninfo & WL_CHAN_PASSIVE)
5779 channel[index].flags |=
5780 IEEE80211_CHAN_NO_IR;
d48200ba 5781 }
d48200ba
HM		 5782 }
5783 }
b48d8916 5784
b48d8916 5785fail_pbuf:
d48200ba
HM		 5786 kfree(pbuf);
5787 return err;
5788}
5789
b48d8916 5790static int brcmf_enable_bw40_2g(struct brcmf_cfg80211_info *cfg)
aa70b4fa 5791{
b48d8916
AS		 5792 struct brcmf_if *ifp = netdev_priv(cfg_to_ndev(cfg));
5793 struct ieee80211_supported_band *band;
aa70b4fa 5794 struct brcmf_fil_bwcap_le band_bwcap;
b48d8916
AS		 5795 struct brcmf_chanspec_list *list;
5796 u8 *pbuf;
aa70b4fa
AS		 5797 u32 val;
5798 int err;
b48d8916
AS		 5799 struct brcmu_chan ch;
5800 u32 num_chan;
5801 int i, j;
aa70b4fa
AS		 5802
5803 /* verify support for bw_cap command */
5804 val = WLC_BAND_5G;
5805 err = brcmf_fil_iovar_int_get(ifp, "bw_cap", &val);
5806
5807 if (!err) {
5808 /* only set 2G bandwidth using bw_cap command */
5809 band_bwcap.band = cpu_to_le32(WLC_BAND_2G);
5810 band_bwcap.bw_cap = cpu_to_le32(WLC_BW_CAP_40MHZ);
5811 err = brcmf_fil_iovar_data_set(ifp, "bw_cap", &band_bwcap,
5812 sizeof(band_bwcap));
5813 } else {
5814 brcmf_dbg(INFO, "fallback to mimo_bw_cap\n");
5815 val = WLC_N_BW_40ALL;
5816 err = brcmf_fil_iovar_int_set(ifp, "mimo_bw_cap", val);
5817 }
b48d8916
AS		 5818
5819 if (!err) {
5820 /* update channel info in 2G band */
5821 pbuf = kzalloc(BRCMF_DCMD_MEDLEN, GFP_KERNEL);
5822
5823 if (pbuf == NULL)
5824 return -ENOMEM;
5825
5826 ch.band = BRCMU_CHAN_BAND_2G;
5827 ch.bw = BRCMU_CHAN_BW_40;
fac7d2a3 5828 ch.sb = BRCMU_CHAN_SB_NONE;
b48d8916
AS		 5829 ch.chnum = 0;
5830 cfg->d11inf.encchspec(&ch);
5831
5832 /* pass encoded chanspec in query */
5833 *(__le16 *)pbuf = cpu_to_le16(ch.chspec);
5834
5835 err = brcmf_fil_iovar_data_get(ifp, "chanspecs", pbuf,
5836 BRCMF_DCMD_MEDLEN);
5837 if (err) {
5838 brcmf_err("get chanspecs error (%d)\n", err);
5839 kfree(pbuf);
5840 return err;
5841 }
5842
57fbcce3 5843 band = cfg_to_wiphy(cfg)->bands[NL80211_BAND_2GHZ];
b48d8916
AS		 5844 list = (struct brcmf_chanspec_list *)pbuf;
5845 num_chan = le32_to_cpu(list->count);
5846 for (i = 0; i < num_chan; i++) {
5847 ch.chspec = (u16)le32_to_cpu(list->element[i]);
5848 cfg->d11inf.decchspec(&ch);
5849 if (WARN_ON(ch.band != BRCMU_CHAN_BAND_2G))
5850 continue;
5851 if (WARN_ON(ch.bw != BRCMU_CHAN_BW_40))
5852 continue;
5853 for (j = 0; j < band->n_channels; j++) {
5854 if (band->channels[j].hw_value == ch.chnum)
5855 break;
5856 }
5857 if (WARN_ON(j == band->n_channels))
5858 continue;
5859
5860 brcmf_update_bw40_channel_flag(&band->channels[j], &ch);
5861 }
fac7d2a3 5862 kfree(pbuf);
b48d8916 5863 }
aa70b4fa
AS		 5864 return err;
5865}
5866
2375d970
AS		 5867static void brcmf_get_bwcap(struct brcmf_if *ifp, u32 bw_cap[])
5868{
5869 u32 band, mimo_bwcap;
5870 int err;
5871
5872 band = WLC_BAND_2G;
5873 err = brcmf_fil_iovar_int_get(ifp, "bw_cap", &band);
5874 if (!err) {
57fbcce3 5875 bw_cap[NL80211_BAND_2GHZ] = band;
2375d970
AS		 5876 band = WLC_BAND_5G;
5877 err = brcmf_fil_iovar_int_get(ifp, "bw_cap", &band);
5878 if (!err) {
57fbcce3 5879 bw_cap[NL80211_BAND_5GHZ] = band;
2375d970
AS		 5880 return;
5881 }
5882 WARN_ON(1);
5883 return;
5884 }
5885 brcmf_dbg(INFO, "fallback to mimo_bw_cap info\n");
5886 mimo_bwcap = 0;
5887 err = brcmf_fil_iovar_int_get(ifp, "mimo_bw_cap", &mimo_bwcap);
5888 if (err)
5889 /* assume 20MHz if firmware does not give a clue */
5890 mimo_bwcap = WLC_N_BW_20ALL;
5891
5892 switch (mimo_bwcap) {
5893 case WLC_N_BW_40ALL:
57fbcce3 5894 bw_cap[NL80211_BAND_2GHZ] |= WLC_BW_40MHZ_BIT;
2375d970
AS		 5895 /* fall-thru */
5896 case WLC_N_BW_20IN2G_40IN5G:
57fbcce3 5897 bw_cap[NL80211_BAND_5GHZ] |= WLC_BW_40MHZ_BIT;
2375d970
AS		 5898 /* fall-thru */
5899 case WLC_N_BW_20ALL:
57fbcce3
JB		 5900 bw_cap[NL80211_BAND_2GHZ] |= WLC_BW_20MHZ_BIT;
5901 bw_cap[NL80211_BAND_5GHZ] |= WLC_BW_20MHZ_BIT;
2375d970
AS		 5902 break;
5903 default:
5904 brcmf_err("invalid mimo_bw_cap value\n");
5905 }
5906}
d48200ba 5907
18d6c535
AS		 5908static void brcmf_update_ht_cap(struct ieee80211_supported_band *band,
5909 u32 bw_cap[2], u32 nchain)
5910{
5911 band->ht_cap.ht_supported = true;
5912 if (bw_cap[band->band] & WLC_BW_40MHZ_BIT) {
5913 band->ht_cap.cap |= IEEE80211_HT_CAP_SGI_40;
5914 band->ht_cap.cap |= IEEE80211_HT_CAP_SUP_WIDTH_20_40;
5915 }
5916 band->ht_cap.cap |= IEEE80211_HT_CAP_SGI_20;
5917 band->ht_cap.cap |= IEEE80211_HT_CAP_DSSSCCK40;
5918 band->ht_cap.ampdu_factor = IEEE80211_HT_MAX_AMPDU_64K;
5919 band->ht_cap.ampdu_density = IEEE80211_HT_MPDU_DENSITY_16;
5920 memset(band->ht_cap.mcs.rx_mask, 0xff, nchain);
5921 band->ht_cap.mcs.tx_params = IEEE80211_HT_MCS_TX_DEFINED;
5922}
5923
5924static __le16 brcmf_get_mcs_map(u32 nchain, enum ieee80211_vht_mcs_support supp)
5925{
5926 u16 mcs_map;
5927 int i;
5928
5929 for (i = 0, mcs_map = 0xFFFF; i < nchain; i++)
5930 mcs_map = (mcs_map << 2) | supp;
5931
5932 return cpu_to_le16(mcs_map);
5933}
5934
5935static void brcmf_update_vht_cap(struct ieee80211_supported_band *band,
7bf65aa9
HM		 5936 u32 bw_cap[2], u32 nchain, u32 txstreams,
5937 u32 txbf_bfe_cap, u32 txbf_bfr_cap)
18d6c535
AS		 5938{
5939 __le16 mcs_map;
5940
5941 /* not allowed in 2.4G band */
57fbcce3 5942 if (band->band == NL80211_BAND_2GHZ)
18d6c535
AS		 5943 return;
5944
5945 band->vht_cap.vht_supported = true;
5946 /* 80MHz is mandatory */
5947 band->vht_cap.cap |= IEEE80211_VHT_CAP_SHORT_GI_80;
5948 if (bw_cap[band->band] & WLC_BW_160MHZ_BIT) {
5949 band->vht_cap.cap |= IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160MHZ;
5950 band->vht_cap.cap |= IEEE80211_VHT_CAP_SHORT_GI_160;
5951 }
5952 /* all support 256-QAM */
5953 mcs_map = brcmf_get_mcs_map(nchain, IEEE80211_VHT_MCS_SUPPORT_0_9);
5954 band->vht_cap.vht_mcs.rx_mcs_map = mcs_map;
5955 band->vht_cap.vht_mcs.tx_mcs_map = mcs_map;
7bf65aa9
HM		 5956
5957 /* Beamforming support information */
5958 if (txbf_bfe_cap & BRCMF_TXBF_SU_BFE_CAP)
5959 band->vht_cap.cap |= IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE;
5960 if (txbf_bfe_cap & BRCMF_TXBF_MU_BFE_CAP)
5961 band->vht_cap.cap |= IEEE80211_VHT_CAP_MU_BEAMFORMEE_CAPABLE;
5962 if (txbf_bfr_cap & BRCMF_TXBF_SU_BFR_CAP)
5963 band->vht_cap.cap |= IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE;
5964 if (txbf_bfr_cap & BRCMF_TXBF_MU_BFR_CAP)
5965 band->vht_cap.cap |= IEEE80211_VHT_CAP_MU_BEAMFORMER_CAPABLE;
5966
5967 if ((txbf_bfe_cap || txbf_bfr_cap) && (txstreams > 1)) {
5968 band->vht_cap.cap |=
5969 (2 << IEEE80211_VHT_CAP_BEAMFORMEE_STS_SHIFT);
5970 band->vht_cap.cap |= ((txstreams - 1) <<
5971 IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_SHIFT);
5972 band->vht_cap.cap |=
5973 IEEE80211_VHT_CAP_VHT_LINK_ADAPTATION_VHT_MRQ_MFB;
5974 }
18d6c535
AS		 5975}
5976
b48d8916 5977static int brcmf_setup_wiphybands(struct wiphy *wiphy)
5b435de0 5978{
b48d8916 5979 struct brcmf_cfg80211_info *cfg = wiphy_priv(wiphy);
ac24be6f 5980 struct brcmf_if *ifp = netdev_priv(cfg_to_ndev(cfg));
18d6c535
AS		 5981 u32 nmode = 0;
5982 u32 vhtmode = 0;
b48d8916 5983 u32 bw_cap[2] = { WLC_BW_20MHZ_BIT, WLC_BW_20MHZ_BIT };
4aca7a18
DK		 5984 u32 rxchain;
5985 u32 nchain;
b48d8916 5986 int err;
d48200ba 5987 s32 i;
2375d970 5988 struct ieee80211_supported_band *band;
7bf65aa9
HM		 5989 u32 txstreams = 0;
5990 u32 txbf_bfe_cap = 0;
5991 u32 txbf_bfr_cap = 0;
5b435de0 5992
18d6c535 5993 (void)brcmf_fil_iovar_int_get(ifp, "vhtmode", &vhtmode);
d48200ba
HM		 5994 err = brcmf_fil_iovar_int_get(ifp, "nmode", &nmode);
5995 if (err) {
5996 brcmf_err("nmode error (%d)\n", err);
5997 } else {
2375d970 5998 brcmf_get_bwcap(ifp, bw_cap);
d48200ba 5999 }
18d6c535 6000 brcmf_dbg(INFO, "nmode=%d, vhtmode=%d, bw_cap=(%d, %d)\n",
57fbcce3
JB		 6001 nmode, vhtmode, bw_cap[NL80211_BAND_2GHZ],
6002 bw_cap[NL80211_BAND_5GHZ]);
d48200ba 6003
4aca7a18
DK		 6004 err = brcmf_fil_iovar_int_get(ifp, "rxchain", &rxchain);
6005 if (err) {
6006 brcmf_err("rxchain error (%d)\n", err);
6007 nchain = 1;
6008 } else {
6009 for (nchain = 0; rxchain; nchain++)
6010 rxchain = rxchain & (rxchain - 1);
6011 }
6012 brcmf_dbg(INFO, "nchain=%d\n", nchain);
6013
b48d8916 6014 err = brcmf_construct_chaninfo(cfg, bw_cap);
d48200ba 6015 if (err) {
b48d8916 6016 brcmf_err("brcmf_construct_chaninfo failed (%d)\n", err);
d48200ba
HM		 6017 return err;
6018 }
6019
7bf65aa9
HM		 6020 if (vhtmode) {
6021 (void)brcmf_fil_iovar_int_get(ifp, "txstreams", &txstreams);
6022 (void)brcmf_fil_iovar_int_get(ifp, "txbf_bfe_cap",
6023 &txbf_bfe_cap);
6024 (void)brcmf_fil_iovar_int_get(ifp, "txbf_bfr_cap",
6025 &txbf_bfr_cap);
6026 }
6027
b48d8916
AS		 6028 wiphy = cfg_to_wiphy(cfg);
6029 for (i = 0; i < ARRAY_SIZE(wiphy->bands); i++) {
6030 band = wiphy->bands[i];
6031 if (band == NULL)
2375d970 6032 continue;
d48200ba 6033
18d6c535
AS		 6034 if (nmode)
6035 brcmf_update_ht_cap(band, bw_cap, nchain);
6036 if (vhtmode)
7bf65aa9
HM		 6037 brcmf_update_vht_cap(band, bw_cap, nchain, txstreams,
6038 txbf_bfe_cap, txbf_bfr_cap);
d48200ba
HM		 6039 }
6040
b48d8916 6041 return 0;
5b435de0
AS		 6042}
6043
aa70b4fa
AS		 6044static const struct ieee80211_txrx_stypes
6045brcmf_txrx_stypes[NUM_NL80211_IFTYPES] = {
6046 [NL80211_IFTYPE_STATION] = {
6047 .tx = 0xffff,
6048 .rx = BIT(IEEE80211_STYPE_ACTION >> 4) |
6049 BIT(IEEE80211_STYPE_PROBE_REQ >> 4)
6050 },
6051 [NL80211_IFTYPE_P2P_CLIENT] = {
6052 .tx = 0xffff,
6053 .rx = BIT(IEEE80211_STYPE_ACTION >> 4) |
6054 BIT(IEEE80211_STYPE_PROBE_REQ >> 4)
6055 },
6056 [NL80211_IFTYPE_P2P_GO] = {
6057 .tx = 0xffff,
6058 .rx = BIT(IEEE80211_STYPE_ASSOC_REQ >> 4) |
6059 BIT(IEEE80211_STYPE_REASSOC_REQ >> 4) |
6060 BIT(IEEE80211_STYPE_PROBE_REQ >> 4) |
6061 BIT(IEEE80211_STYPE_DISASSOC >> 4) |
6062 BIT(IEEE80211_STYPE_AUTH >> 4) |
6063 BIT(IEEE80211_STYPE_DEAUTH >> 4) |
6064 BIT(IEEE80211_STYPE_ACTION >> 4)
6065 },
6066 [NL80211_IFTYPE_P2P_DEVICE] = {
6067 .tx = 0xffff,
6068 .rx = BIT(IEEE80211_STYPE_ACTION >> 4) |
6069 BIT(IEEE80211_STYPE_PROBE_REQ >> 4)
6070 }
6071};
6072
0882dda3
AS		 6073/**
6074 * brcmf_setup_ifmodes() - determine interface modes and combinations.
6075 *
6076 * @wiphy: wiphy object.
6077 * @ifp: interface object needed for feat module api.
6078 *
6079 * The interface modes and combinations are determined dynamically here
6080 * based on firmware functionality.
6081 *
6082 * no p2p and no mbss:
6083 *
6084 * #STA <= 1, #AP <= 1, channels = 1, 2 total
6085 *
6086 * no p2p and mbss:
6087 *
6088 * #STA <= 1, #AP <= 1, channels = 1, 2 total
6089 * #AP <= 4, matching BI, channels = 1, 4 total
6090 *
6091 * p2p, no mchan, and mbss:
6092 *
6093 * #STA <= 1, #P2P-DEV <= 1, #{P2P-CL, P2P-GO} <= 1, channels = 1, 3 total
6094 * #STA <= 1, #P2P-DEV <= 1, #AP <= 1, #P2P-CL <= 1, channels = 1, 4 total
6095 * #AP <= 4, matching BI, channels = 1, 4 total
6096 *
6097 * p2p, mchan, and mbss:
6098 *
6099 * #STA <= 1, #P2P-DEV <= 1, #{P2P-CL, P2P-GO} <= 1, channels = 2, 3 total
6100 * #STA <= 1, #P2P-DEV <= 1, #AP <= 1, #P2P-CL <= 1, channels = 1, 4 total
6101 * #AP <= 4, matching BI, channels = 1, 4 total
6102 */
2e5f66fe
PF		 6103static int brcmf_setup_ifmodes(struct wiphy *wiphy, struct brcmf_if *ifp)
6104{
6105 struct ieee80211_iface_combination *combo = NULL;
0882dda3
AS		 6106 struct ieee80211_iface_limit *c0_limits = NULL;
6107 struct ieee80211_iface_limit *p2p_limits = NULL;
6108 struct ieee80211_iface_limit *mbss_limits = NULL;
6109 bool mbss, p2p;
6110 int i, c, n_combos;
6111
6112 mbss = brcmf_feat_is_enabled(ifp, BRCMF_FEAT_MBSS);
6113 p2p = brcmf_feat_is_enabled(ifp, BRCMF_FEAT_P2P);
2e5f66fe 6114
0882dda3
AS		 6115 n_combos = 1 + !!p2p + !!mbss;
6116 combo = kcalloc(n_combos, sizeof(*combo), GFP_KERNEL);
2e5f66fe
PF		 6117 if (!combo)
6118 goto err;
6119
0882dda3
AS		 6120 c0_limits = kcalloc(p2p ? 3 : 2, sizeof(*c0_limits), GFP_KERNEL);
6121 if (!c0_limits)
2e5f66fe
PF		 6122 goto err;
6123
0882dda3
AS		 6124 if (p2p) {
6125 p2p_limits = kcalloc(4, sizeof(*p2p_limits), GFP_KERNEL);
6126 if (!p2p_limits)
6127 goto err;
6128 }
6129
6130 if (mbss) {
6131 mbss_limits = kcalloc(1, sizeof(*mbss_limits), GFP_KERNEL);
6132 if (!mbss_limits)
6133 goto err;
6134 }
6135
2e5f66fe
PF		 6136 wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) |
6137 BIT(NL80211_IFTYPE_ADHOC) |
6138 BIT(NL80211_IFTYPE_AP);
6139
0882dda3
AS		 6140 c = 0;
6141 i = 0;
6142 combo[c].num_different_channels = 1;
6143 c0_limits[i].max = 1;
6144 c0_limits[i++].types = BIT(NL80211_IFTYPE_STATION);
6145 if (p2p) {
6146 if (brcmf_feat_is_enabled(ifp, BRCMF_FEAT_MCHAN))
6147 combo[c].num_different_channels = 2;
2e5f66fe
PF		 6148 wiphy->interface_modes |= BIT(NL80211_IFTYPE_P2P_CLIENT) |
6149 BIT(NL80211_IFTYPE_P2P_GO) |
6150 BIT(NL80211_IFTYPE_P2P_DEVICE);
0882dda3
AS		 6151 c0_limits[i].max = 1;
6152 c0_limits[i++].types = BIT(NL80211_IFTYPE_P2P_DEVICE);
6153 c0_limits[i].max = 1;
6154 c0_limits[i++].types = BIT(NL80211_IFTYPE_P2P_CLIENT) |
6155 BIT(NL80211_IFTYPE_P2P_GO);
6156 } else {
6157 c0_limits[i].max = 1;
6158 c0_limits[i++].types = BIT(NL80211_IFTYPE_AP);
6159 }
6160 combo[c].max_interfaces = i;
6161 combo[c].n_limits = i;
6162 combo[c].limits = c0_limits;
6163
6164 if (p2p) {
6165 c++;
6166 i = 0;
6167 combo[c].num_different_channels = 1;
6168 p2p_limits[i].max = 1;
6169 p2p_limits[i++].types = BIT(NL80211_IFTYPE_STATION);
6170 p2p_limits[i].max = 1;
6171 p2p_limits[i++].types = BIT(NL80211_IFTYPE_AP);
6172 p2p_limits[i].max = 1;
6173 p2p_limits[i++].types = BIT(NL80211_IFTYPE_P2P_CLIENT);
6174 p2p_limits[i].max = 1;
6175 p2p_limits[i++].types = BIT(NL80211_IFTYPE_P2P_DEVICE);
6176 combo[c].max_interfaces = i;
6177 combo[c].n_limits = i;
6178 combo[c].limits = p2p_limits;
6179 }
6180
6181 if (mbss) {
6182 c++;
6183 combo[c].beacon_int_infra_match = true;
6184 combo[c].num_different_channels = 1;
6185 mbss_limits[0].max = 4;
6186 mbss_limits[0].types = BIT(NL80211_IFTYPE_AP);
6187 combo[c].max_interfaces = 4;
6188 combo[c].n_limits = 1;
6189 combo[c].limits = mbss_limits;
6190 }
6191 wiphy->n_iface_combinations = n_combos;
2e5f66fe 6192 wiphy->iface_combinations = combo;
2e5f66fe
PF		 6193 return 0;
6194
6195err:
0882dda3
AS		 6196 kfree(c0_limits);
6197 kfree(p2p_limits);
6198 kfree(mbss_limits);
2e5f66fe
PF		 6199 kfree(combo);
6200 return -ENOMEM;
6201}
6202
aa70b4fa
AS		 6203static void brcmf_wiphy_pno_params(struct wiphy *wiphy)
6204{
6205 /* scheduled scan settings */
6206 wiphy->max_sched_scan_ssids = BRCMF_PNO_MAX_PFN_COUNT;
6207 wiphy->max_match_sets = BRCMF_PNO_MAX_PFN_COUNT;
6208 wiphy->max_sched_scan_ie_len = BRCMF_SCAN_IE_LEN_MAX;
6209 wiphy->flags |= WIPHY_FLAG_SUPPORTS_SCHED_SCAN;
6210}
6211
4eb3af7c 6212#ifdef CONFIG_PM
3021ad9a 6213static struct wiphy_wowlan_support brcmf_wowlan_support = {
4eb3af7c 6214 .flags = WIPHY_WOWLAN_MAGIC_PKT | WIPHY_WOWLAN_DISCONNECT,
b9a82f89
HM		 6215 .n_patterns = BRCMF_WOWL_MAXPATTERNS,
6216 .pattern_max_len = BRCMF_WOWL_MAXPATTERNSIZE,
6217 .pattern_min_len = 1,
6218 .max_pkt_offset = 1500,
4eb3af7c
HM		 6219};
6220#endif
6221
3021ad9a 6222static void brcmf_wiphy_wowl_params(struct wiphy *wiphy, struct brcmf_if *ifp)
4eb3af7c
HM		 6223{
6224#ifdef CONFIG_PM
3021ad9a 6225 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy);
3021ad9a
HM		 6226
6227 if (brcmf_feat_is_enabled(ifp, BRCMF_FEAT_PNO)) {
5c22fb85
HM		 6228 if (brcmf_feat_is_enabled(ifp, BRCMF_FEAT_WOWL_ND)) {
6229 brcmf_wowlan_support.flags |= WIPHY_WOWLAN_NET_DETECT;
6230 init_waitqueue_head(&cfg->wowl.nd_data_wait);
3021ad9a
HM		 6231 }
6232 }
5c22fb85
HM		 6233 if (brcmf_feat_is_enabled(ifp, BRCMF_FEAT_WOWL_GTK)) {
6234 brcmf_wowlan_support.flags |= WIPHY_WOWLAN_SUPPORTS_GTK_REKEY;
6235 brcmf_wowlan_support.flags |= WIPHY_WOWLAN_GTK_REKEY_FAILURE;
6236 }
6237
4eb3af7c
HM		 6238 wiphy->wowlan = &brcmf_wowlan_support;
6239#endif
6240}
6241
b48d8916 6242static int brcmf_setup_wiphy(struct wiphy *wiphy, struct brcmf_if *ifp)
aa70b4fa 6243{
e3faa866 6244 struct brcmf_pub *drvr = ifp->drvr;
50f32e2d 6245 const struct ieee80211_iface_combination *combo;
58de92d2 6246 struct ieee80211_supported_band *band;
50f32e2d 6247 u16 max_interfaces = 0;
58de92d2
AS		 6248 __le32 bandlist[3];
6249 u32 n_bands;
6250 int err, i;
6251
aa70b4fa
AS		 6252 wiphy->max_scan_ssids = WL_NUM_SCAN_MAX;
6253 wiphy->max_scan_ie_len = BRCMF_SCAN_IE_LEN_MAX;
6c404f34 6254 wiphy->max_num_pmkids = BRCMF_MAXPMKID;
2e5f66fe
PF		 6255
6256 err = brcmf_setup_ifmodes(wiphy, ifp);
6257 if (err)
6258 return err;
6259
50f32e2d
RM		 6260 for (i = 0, combo = wiphy->iface_combinations;
6261 i < wiphy->n_iface_combinations; i++, combo++) {
6262 max_interfaces = max(max_interfaces, combo->max_interfaces);
6263 }
6264
6265 for (i = 0; i < max_interfaces && i < ARRAY_SIZE(drvr->addresses);
6266 i++) {
e3faa866
RM		 6267 u8 *addr = drvr->addresses[i].addr;
6268
6269 memcpy(addr, drvr->mac, ETH_ALEN);
6270 if (i) {
6271 addr[0] |= BIT(1);
6272 addr[ETH_ALEN - 1] ^= i;
6273 }
6274 }
6275 wiphy->addresses = drvr->addresses;
6276 wiphy->n_addresses = i;
6277
aa70b4fa 6278 wiphy->signal_type = CFG80211_SIGNAL_TYPE_MBM;
240d61a9
HM		 6279 wiphy->cipher_suites = brcmf_cipher_suites;
6280 wiphy->n_cipher_suites = ARRAY_SIZE(brcmf_cipher_suites);
6281 if (!brcmf_feat_is_enabled(ifp, BRCMF_FEAT_MFP))
6282 wiphy->n_cipher_suites--;
aa70b4fa
AS		 6283 wiphy->flags |= WIPHY_FLAG_PS_ON_BY_DEFAULT |
6284 WIPHY_FLAG_OFFCHAN_TX |
a7b82d47
HM		 6285 WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL;
6286 if (brcmf_feat_is_enabled(ifp, BRCMF_FEAT_TDLS))
6287 wiphy->flags |= WIPHY_FLAG_SUPPORTS_TDLS;
7d34b056 6288 if (!ifp->drvr->settings->roamoff)
aa70b4fa
AS		 6289 wiphy->flags |= WIPHY_FLAG_SUPPORTS_FW_ROAM;
6290 wiphy->mgmt_stypes = brcmf_txrx_stypes;
6291 wiphy->max_remain_on_channel_duration = 5000;
7a7a87dc
AS		 6292 if (brcmf_feat_is_enabled(ifp, BRCMF_FEAT_PNO))
6293 brcmf_wiphy_pno_params(wiphy);
aa70b4fa
AS		 6294
6295 /* vendor commands/events support */
6296 wiphy->vendor_commands = brcmf_vendor_cmds;
6297 wiphy->n_vendor_commands = BRCMF_VNDR_CMDS_LAST - 1;
6298
4eb3af7c 6299 if (brcmf_feat_is_enabled(ifp, BRCMF_FEAT_WOWL))
3021ad9a 6300 brcmf_wiphy_wowl_params(wiphy, ifp);
58de92d2
AS		 6301 err = brcmf_fil_cmd_data_get(ifp, BRCMF_C_GET_BANDLIST, &bandlist,
6302 sizeof(bandlist));
6303 if (err) {
6304 brcmf_err("could not obtain band info: err=%d\n", err);
6305 return err;
6306 }
6307 /* first entry in bandlist is number of bands */
6308 n_bands = le32_to_cpu(bandlist[0]);
6309 for (i = 1; i <= n_bands && i < ARRAY_SIZE(bandlist); i++) {
6310 if (bandlist[i] == cpu_to_le32(WLC_BAND_2G)) {
6311 band = kmemdup(&__wl_band_2ghz, sizeof(__wl_band_2ghz),
6312 GFP_KERNEL);
6313 if (!band)
6314 return -ENOMEM;
6315
6316 band->channels = kmemdup(&__wl_2ghz_channels,
6317 sizeof(__wl_2ghz_channels),
6318 GFP_KERNEL);
6319 if (!band->channels) {
6320 kfree(band);
6321 return -ENOMEM;
6322 }
6323
6324 band->n_channels = ARRAY_SIZE(__wl_2ghz_channels);
57fbcce3 6325 wiphy->bands[NL80211_BAND_2GHZ] = band;
58de92d2
AS		 6326 }
6327 if (bandlist[i] == cpu_to_le32(WLC_BAND_5G)) {
6328 band = kmemdup(&__wl_band_5ghz, sizeof(__wl_band_5ghz),
6329 GFP_KERNEL);
6330 if (!band)
6331 return -ENOMEM;
6332
6333 band->channels = kmemdup(&__wl_5ghz_channels,
6334 sizeof(__wl_5ghz_channels),
6335 GFP_KERNEL);
6336 if (!band->channels) {
6337 kfree(band);
6338 return -ENOMEM;
6339 }
6340
6341 band->n_channels = ARRAY_SIZE(__wl_5ghz_channels);
57fbcce3 6342 wiphy->bands[NL80211_BAND_5GHZ] = band;
58de92d2
AS		 6343 }
6344 }
6345 err = brcmf_setup_wiphybands(wiphy);
6346 return err;
5b435de0
AS		 6347}
6348
27a68fe3 6349static s32 brcmf_config_dongle(struct brcmf_cfg80211_info *cfg)
5b435de0
AS		 6350{
6351 struct net_device *ndev;
6352 struct wireless_dev *wdev;
40a23296 6353 struct brcmf_if *ifp;
5b435de0
AS		 6354 s32 power_mode;
6355 s32 err = 0;
6356
27a68fe3 6357 if (cfg->dongle_up)
5b435de0
AS		 6358 return err;
6359
27a68fe3 6360 ndev = cfg_to_ndev(cfg);
5b435de0 6361 wdev = ndev->ieee80211_ptr;
40a23296
HM		 6362 ifp = netdev_priv(ndev);
6363
6364 /* make sure RF is ready for work */
6365 brcmf_fil_cmd_int_set(ifp, BRCMF_C_UP, 0);
5b435de0 6366
1678ba8e 6367 brcmf_dongle_scantime(ifp);
5b435de0 6368
27a68fe3 6369 power_mode = cfg->pwr_save ? PM_FAST : PM_OFF;
40a23296 6370 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_PM, power_mode);
5b435de0
AS		 6371 if (err)
6372 goto default_conf_out;
647c9ae0
AS		 6373 brcmf_dbg(INFO, "power save set to %s\n",
6374 (power_mode ? "enabled" : "disabled"));
5b435de0 6375
1119e23e 6376 err = brcmf_dongle_roam(ifp);
5b435de0
AS		 6377 if (err)
6378 goto default_conf_out;
5dd161ff
FL		 6379 err = brcmf_cfg80211_change_iface(wdev->wiphy, ndev, wdev->iftype,
6380 NULL, NULL);
40a23296 6381 if (err)
5b435de0 6382 goto default_conf_out;
5b435de0 6383
52f22fb2 6384 brcmf_configure_arp_nd_offload(ifp, true);
b3657453 6385
27a68fe3 6386 cfg->dongle_up = true;
40a23296 6387default_conf_out:
5b435de0
AS		 6388
6389 return err;
6390
6391}
6392
bdf5ff51 6393static s32 __brcmf_cfg80211_up(struct brcmf_if *ifp)
5b435de0 6394{
c1179033 6395 set_bit(BRCMF_VIF_STATUS_READY, &ifp->vif->sme_state);
5b435de0 6396
bdf5ff51 6397 return brcmf_config_dongle(ifp->drvr->config);
5b435de0
AS		 6398}
6399
bdf5ff51 6400static s32 __brcmf_cfg80211_down(struct brcmf_if *ifp)
5b435de0 6401{
bdf5ff51 6402 struct brcmf_cfg80211_info *cfg = ifp->drvr->config;
c1179033 6403
5b435de0
AS		 6404 /*
6405 * While going down, if associated with AP disassociate
6406 * from AP to save power
6407 */
903e0eee 6408 if (check_vif_up(ifp->vif)) {
9b7a0ddc 6409 brcmf_link_down(ifp->vif, WLAN_REASON_UNSPECIFIED);
5b435de0
AS		 6410
6411 /* Make sure WPA_Supplicant receives all the event
6412 generated due to DISASSOC call to the fw to keep
6413 the state fw and WPA_Supplicant state consistent
6414 */
6415 brcmf_delay(500);
6416 }
6417
27a68fe3 6418 brcmf_abort_scanning(cfg);
c1179033 6419 clear_bit(BRCMF_VIF_STATUS_READY, &ifp->vif->sme_state);
5b435de0 6420
5b435de0
AS		 6421 return 0;
6422}
6423
bdf5ff51 6424s32 brcmf_cfg80211_up(struct net_device *ndev)
5b435de0 6425{
bdf5ff51
AS		 6426 struct brcmf_if *ifp = netdev_priv(ndev);
6427 struct brcmf_cfg80211_info *cfg = ifp->drvr->config;
5b435de0
AS		 6428 s32 err = 0;
6429
27a68fe3 6430 mutex_lock(&cfg->usr_sync);
bdf5ff51 6431 err = __brcmf_cfg80211_up(ifp);
27a68fe3 6432 mutex_unlock(&cfg->usr_sync);
5b435de0
AS		 6433
6434 return err;
6435}
6436
bdf5ff51 6437s32 brcmf_cfg80211_down(struct net_device *ndev)
5b435de0 6438{
bdf5ff51
AS		 6439 struct brcmf_if *ifp = netdev_priv(ndev);
6440 struct brcmf_cfg80211_info *cfg = ifp->drvr->config;
5b435de0
AS		 6441 s32 err = 0;
6442
27a68fe3 6443 mutex_lock(&cfg->usr_sync);
bdf5ff51 6444 err = __brcmf_cfg80211_down(ifp);
27a68fe3 6445 mutex_unlock(&cfg->usr_sync);
5b435de0
AS		 6446
6447 return err;
6448}
6449
a7965fbb
AS		 6450enum nl80211_iftype brcmf_cfg80211_get_iftype(struct brcmf_if *ifp)
6451{
6452 struct wireless_dev *wdev = &ifp->vif->wdev;
6453
6454 return wdev->iftype;
6455}
6456
bfe81975
HM		 6457bool brcmf_get_vif_state_any(struct brcmf_cfg80211_info *cfg,
6458 unsigned long state)
9f440b7b
AS		 6459{
6460 struct brcmf_cfg80211_vif *vif;
9f440b7b
AS		 6461
6462 list_for_each_entry(vif, &cfg->vif_list, list) {
6463 if (test_bit(state, &vif->sme_state))
e843bb19 6464 return true;
9f440b7b 6465 }
e843bb19 6466 return false;
9f440b7b 6467}
d3c0b633
AS		 6468
6469static inline bool vif_event_equals(struct brcmf_cfg80211_vif_event *event,
6470 u8 action)
6471{
6472 u8 evt_action;
6473
6474 mutex_lock(&event->vif_event_lock);
6475 evt_action = event->action;
6476 mutex_unlock(&event->vif_event_lock);
6477 return evt_action == action;
6478}
6479
6480void brcmf_cfg80211_arm_vif_event(struct brcmf_cfg80211_info *cfg,
6481 struct brcmf_cfg80211_vif *vif)
6482{
6483 struct brcmf_cfg80211_vif_event *event = &cfg->vif_event;
6484
6485 mutex_lock(&event->vif_event_lock);
6486 event->vif = vif;
6487 event->action = 0;
6488 mutex_unlock(&event->vif_event_lock);
6489}
6490
6491bool brcmf_cfg80211_vif_event_armed(struct brcmf_cfg80211_info *cfg)
6492{
6493 struct brcmf_cfg80211_vif_event *event = &cfg->vif_event;
6494 bool armed;
6495
6496 mutex_lock(&event->vif_event_lock);
6497 armed = event->vif != NULL;
6498 mutex_unlock(&event->vif_event_lock);
6499
6500 return armed;
6501}
a9eb0c4b
AS		 6502
6503int brcmf_cfg80211_wait_vif_event(struct brcmf_cfg80211_info *cfg,
6504 u8 action, ulong timeout)
d3c0b633
AS		 6505{
6506 struct brcmf_cfg80211_vif_event *event = &cfg->vif_event;
6507
6508 return wait_event_timeout(event->vif_wq,
6509 vif_event_equals(event, action), timeout);
6510}
6511
73345fd2
HM		 6512static s32 brcmf_translate_country_code(struct brcmf_pub *drvr, char alpha2[2],
6513 struct brcmf_fil_country_le *ccreq)
6514{
4d792895
HM		 6515 struct brcmfmac_pd_cc *country_codes;
6516 struct brcmfmac_pd_cc_entry *cc;
73345fd2
HM		 6517 s32 found_index;
6518 int i;
6519
6520 country_codes = drvr->settings->country_codes;
6521 if (!country_codes) {
6522 brcmf_dbg(TRACE, "No country codes configured for device\n");
6523 return -EINVAL;
6524 }
6525
6526 if ((alpha2[0] == ccreq->country_abbrev[0]) &&
6527 (alpha2[1] == ccreq->country_abbrev[1])) {
6528 brcmf_dbg(TRACE, "Country code already set\n");
6529 return -EAGAIN;
6530 }
6531
6532 found_index = -1;
6533 for (i = 0; i < country_codes->table_size; i++) {
6534 cc = &country_codes->table[i];
6535 if ((cc->iso3166[0] == '\0') && (found_index == -1))
6536 found_index = i;
6537 if ((cc->iso3166[0] == alpha2[0]) &&
6538 (cc->iso3166[1] == alpha2[1])) {
6539 found_index = i;
6540 break;
6541 }
6542 }
6543 if (found_index == -1) {
6544 brcmf_dbg(TRACE, "No country code match found\n");
6545 return -EINVAL;
6546 }
6547 memset(ccreq, 0, sizeof(*ccreq));
6548 ccreq->rev = cpu_to_le32(country_codes->table[found_index].rev);
6549 memcpy(ccreq->ccode, country_codes->table[found_index].cc,
6550 BRCMF_COUNTRY_BUF_SZ);
6551 ccreq->country_abbrev[0] = alpha2[0];
6552 ccreq->country_abbrev[1] = alpha2[1];
6553 ccreq->country_abbrev[2] = 0;
6554
6555 return 0;
6556}
6557
63db1a49
AS		 6558static void brcmf_cfg80211_reg_notifier(struct wiphy *wiphy,
6559 struct regulatory_request *req)
6560{
6561 struct brcmf_cfg80211_info *cfg = wiphy_priv(wiphy);
6562 struct brcmf_if *ifp = netdev_priv(cfg_to_ndev(cfg));
6563 struct brcmf_fil_country_le ccreq;
73345fd2 6564 s32 err;
63db1a49
AS		 6565 int i;
6566
63db1a49
AS		 6567 /* ignore non-ISO3166 country codes */
6568 for (i = 0; i < sizeof(req->alpha2); i++)
6569 if (req->alpha2[i] < 'A' || req->alpha2[i] > 'Z') {
73345fd2
HM		 6570 brcmf_err("not a ISO3166 code (0x%02x 0x%02x)\n",
6571 req->alpha2[0], req->alpha2[1]);
63db1a49
AS		 6572 return;
6573 }
73345fd2
HM		 6574
6575 brcmf_dbg(TRACE, "Enter: initiator=%d, alpha=%c%c\n", req->initiator,
6576 req->alpha2[0], req->alpha2[1]);
6577
6578 err = brcmf_fil_iovar_data_get(ifp, "country", &ccreq, sizeof(ccreq));
6579 if (err) {
6580 brcmf_err("Country code iovar returned err = %d\n", err);
6581 return;
6582 }
6583
6584 err = brcmf_translate_country_code(ifp->drvr, req->alpha2, &ccreq);
6585 if (err)
6586 return;
6587
6588 err = brcmf_fil_iovar_data_set(ifp, "country", &ccreq, sizeof(ccreq));
6589 if (err) {
6590 brcmf_err("Firmware rejected country setting\n");
8afe0ece
AS		 6591 return;
6592 }
6593 brcmf_setup_wiphybands(wiphy);
63db1a49
AS		 6594}
6595
b48d8916
AS		 6596static void brcmf_free_wiphy(struct wiphy *wiphy)
6597{
0882dda3
AS		 6598 int i;
6599
58de92d2
AS		 6600 if (!wiphy)
6601 return;
6602
0882dda3
AS		 6603 if (wiphy->iface_combinations) {
6604 for (i = 0; i < wiphy->n_iface_combinations; i++)
6605 kfree(wiphy->iface_combinations[i].limits);
6606 }
b48d8916 6607 kfree(wiphy->iface_combinations);
57fbcce3
JB		 6608 if (wiphy->bands[NL80211_BAND_2GHZ]) {
6609 kfree(wiphy->bands[NL80211_BAND_2GHZ]->channels);
6610 kfree(wiphy->bands[NL80211_BAND_2GHZ]);
b48d8916 6611 }
57fbcce3
JB		 6612 if (wiphy->bands[NL80211_BAND_5GHZ]) {
6613 kfree(wiphy->bands[NL80211_BAND_5GHZ]->channels);
6614 kfree(wiphy->bands[NL80211_BAND_5GHZ]);
b48d8916
AS		 6615 }
6616 wiphy_free(wiphy);
6617}
6618
ccfd1e81 6619struct brcmf_cfg80211_info *brcmf_cfg80211_attach(struct brcmf_pub *drvr,
ae7c03f6
HM		 6620 struct device *busdev,
6621 bool p2pdev_forced)
ccfd1e81 6622{
46f3b6ee 6623 struct net_device *ndev = brcmf_get_ifp(drvr, 0)->ndev;
ccfd1e81
AS		 6624 struct brcmf_cfg80211_info *cfg;
6625 struct wiphy *wiphy;
5c22fb85 6626 struct cfg80211_ops *ops;
ccfd1e81
AS		 6627 struct brcmf_cfg80211_vif *vif;
6628 struct brcmf_if *ifp;
6629 s32 err = 0;
6630 s32 io_type;
b48d8916 6631 u16 *cap = NULL;
ccfd1e81
AS		 6632
6633 if (!ndev) {
6634 brcmf_err("ndev is invalid\n");
6635 return NULL;
6636 }
6637
5c22fb85
HM		 6638 ops = kzalloc(sizeof(*ops), GFP_KERNEL);
6639 if (!ops)
6640 return NULL;
6641
6642 memcpy(ops, &brcmf_cfg80211_ops, sizeof(*ops));
ccfd1e81 6643 ifp = netdev_priv(ndev);
5c22fb85
HM		 6644#ifdef CONFIG_PM
6645 if (brcmf_feat_is_enabled(ifp, BRCMF_FEAT_WOWL_GTK))
6646 ops->set_rekey_data = brcmf_cfg80211_set_rekey_data;
6647#endif
6648 wiphy = wiphy_new(ops, sizeof(struct brcmf_cfg80211_info));
b48d8916
AS		 6649 if (!wiphy) {
6650 brcmf_err("Could not allocate wiphy device\n");
ccfd1e81 6651 return NULL;
b48d8916 6652 }
6896f4fb 6653 memcpy(wiphy->perm_addr, drvr->mac, ETH_ALEN);
b48d8916 6654 set_wiphy_dev(wiphy, busdev);
ccfd1e81
AS		 6655
6656 cfg = wiphy_priv(wiphy);
6657 cfg->wiphy = wiphy;
5c22fb85 6658 cfg->ops = ops;
ccfd1e81
AS		 6659 cfg->pub = drvr;
6660 init_vif_event(&cfg->vif_event);
6661 INIT_LIST_HEAD(&cfg->vif_list);
6662
6663 vif = brcmf_alloc_vif(cfg, NL80211_IFTYPE_STATION, false);
b48d8916
AS		 6664 if (IS_ERR(vif))
6665 goto wiphy_out;
ccfd1e81
AS		 6666
6667 vif->ifp = ifp;
6668 vif->wdev.netdev = ndev;
6669 ndev->ieee80211_ptr = &vif->wdev;
6670 SET_NETDEV_DEV(ndev, wiphy_dev(cfg->wiphy));
6671
6672 err = wl_init_priv(cfg);
6673 if (err) {
6674 brcmf_err("Failed to init iwm_priv (%d)\n", err);
b48d8916
AS		 6675 brcmf_free_vif(vif);
6676 goto wiphy_out;
ccfd1e81
AS		 6677 }
6678 ifp->vif = vif;
6679
b48d8916
AS		 6680 /* determine d11 io type before wiphy setup */
6681 err = brcmf_fil_cmd_int_get(ifp, BRCMF_C_GET_VERSION, &io_type);
ccfd1e81 6682 if (err) {
b48d8916
AS		 6683 brcmf_err("Failed to get D11 version (%d)\n", err);
6684 goto priv_out;
ccfd1e81 6685 }
b48d8916
AS		 6686 cfg->d11inf.io_type = (u8)io_type;
6687 brcmu_d11_attach(&cfg->d11inf);
6688
6689 err = brcmf_setup_wiphy(wiphy, ifp);
6690 if (err < 0)
6691 goto priv_out;
6692
6693 brcmf_dbg(INFO, "Registering custom regulatory\n");
63db1a49 6694 wiphy->reg_notifier = brcmf_cfg80211_reg_notifier;
b48d8916
AS		 6695 wiphy->regulatory_flags |= REGULATORY_CUSTOM_REG;
6696 wiphy_apply_custom_regulatory(wiphy, &brcmf_regdom);
6697
6698 /* firmware defaults to 40MHz disabled in 2G band. We signal
6699 * cfg80211 here that we do and have it decide we can enable
6700 * it. But first check if device does support 2G operation.
6701 */
57fbcce3
JB		 6702 if (wiphy->bands[NL80211_BAND_2GHZ]) {
6703 cap = &wiphy->bands[NL80211_BAND_2GHZ]->ht_cap.cap;
b48d8916
AS		 6704 *cap |= IEEE80211_HT_CAP_SUP_WIDTH_20_40;
6705 }
6706 err = wiphy_register(wiphy);
6707 if (err < 0) {
6708 brcmf_err("Could not register wiphy device (%d)\n", err);
6709 goto priv_out;
ccfd1e81
AS		 6710 }
6711
6712 /* If cfg80211 didn't disable 40MHz HT CAP in wiphy_register(),
6713 * setup 40MHz in 2GHz band and enable OBSS scanning.
6714 */
b48d8916
AS		 6715 if (cap && (*cap & IEEE80211_HT_CAP_SUP_WIDTH_20_40)) {
6716 err = brcmf_enable_bw40_2g(cfg);
ccfd1e81
AS		 6717 if (!err)
6718 err = brcmf_fil_iovar_int_set(ifp, "obss_coex",
6719 BRCMF_OBSS_COEX_AUTO);
b48d8916
AS		 6720 else
6721 *cap &= ~IEEE80211_HT_CAP_SUP_WIDTH_20_40;
ccfd1e81 6722 }
2b76acdb
HM		 6723 /* p2p might require that "if-events" get processed by fweh. So
6724 * activate the already registered event handlers now and activate
6725 * the rest when initialization has completed. drvr->config needs to
6726 * be assigned before activating events.
6727 */
6728 drvr->config = cfg;
6729 err = brcmf_fweh_activate_events(ifp);
6730 if (err) {
6731 brcmf_err("FWEH activation failed (%d)\n", err);
6732 goto wiphy_unreg_out;
6733 }
ccfd1e81 6734
ae7c03f6 6735 err = brcmf_p2p_attach(cfg, p2pdev_forced);
ccfd1e81 6736 if (err) {
b48d8916
AS		 6737 brcmf_err("P2P initilisation failed (%d)\n", err);
6738 goto wiphy_unreg_out;
6739 }
6740 err = brcmf_btcoex_attach(cfg);
6741 if (err) {
6742 brcmf_err("BT-coex initialisation failed (%d)\n", err);
6743 brcmf_p2p_detach(&cfg->p2p);
6744 goto wiphy_unreg_out;
ccfd1e81
AS		 6745 }
6746
a7b82d47
HM		 6747 if (brcmf_feat_is_enabled(ifp, BRCMF_FEAT_TDLS)) {
6748 err = brcmf_fil_iovar_int_set(ifp, "tdls_enable", 1);
6749 if (err) {
6750 brcmf_dbg(INFO, "TDLS not enabled (%d)\n", err);
6751 wiphy->flags &= ~WIPHY_FLAG_SUPPORTS_TDLS;
6752 } else {
6753 brcmf_fweh_register(cfg->pub, BRCMF_E_TDLS_PEER_EVENT,
6754 brcmf_notify_tdls_peer_event);
6755 }
ccfd1e81 6756 }
ccfd1e81 6757
2b76acdb
HM		 6758 /* (re-) activate FWEH event handling */
6759 err = brcmf_fweh_activate_events(ifp);
6760 if (err) {
6761 brcmf_err("FWEH activation failed (%d)\n", err);
6762 goto wiphy_unreg_out;
6763 }
6764
48ed16e8
HM		 6765 /* Fill in some of the advertised nl80211 supported features */
6766 if (brcmf_feat_is_enabled(ifp, BRCMF_FEAT_SCAN_RANDOM_MAC)) {
6767 wiphy->features |= NL80211_FEATURE_SCHED_SCAN_RANDOM_MAC_ADDR;
6768#ifdef CONFIG_PM
6ea09153
FL		 6769 if (wiphy->wowlan &&
6770 wiphy->wowlan->flags & WIPHY_WOWLAN_NET_DETECT)
48ed16e8
HM		 6771 wiphy->features |= NL80211_FEATURE_ND_RANDOM_MAC_ADDR;
6772#endif
6773 }
6774
ccfd1e81
AS		 6775 return cfg;
6776
b48d8916
AS		 6777wiphy_unreg_out:
6778 wiphy_unregister(cfg->wiphy);
6779priv_out:
ccfd1e81 6780 wl_deinit_priv(cfg);
ccfd1e81 6781 brcmf_free_vif(vif);
2b5d348e 6782 ifp->vif = NULL;
b48d8916
AS		 6783wiphy_out:
6784 brcmf_free_wiphy(wiphy);
5c22fb85 6785 kfree(ops);
ccfd1e81
AS		 6786 return NULL;
6787}
6788
6789void brcmf_cfg80211_detach(struct brcmf_cfg80211_info *cfg)
6790{
6791 if (!cfg)
6792 return;
6793
ccfd1e81 6794 brcmf_btcoex_detach(cfg);
f7a40873 6795 wiphy_unregister(cfg->wiphy);
5c22fb85 6796 kfree(cfg->ops);
ccfd1e81 6797 wl_deinit_priv(cfg);
b48d8916 6798 brcmf_free_wiphy(cfg->wiphy);
ccfd1e81 6799}
Linux kernel - Deliverables
This page took 0.864488 seconds and 5 git commands to generate.