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