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