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