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