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