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