]> git.proxmox.com Git - mirror_ubuntu-hirsute-kernel.git/blame - drivers/net/wireless/broadcom/brcm80211/brcmfmac/cfg80211.c
projects / mirror_ubuntu-hirsute-kernel.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
brcmfmac: Disable runtime pm for USB.
[mirror_ubuntu-hirsute-kernel.git] / drivers / net / wireless / broadcom / brcm80211 / brcmfmac / cfg80211.c
CommitLineData
5b435de0
AS		 1/*
2 * Copyright (c) 2010 Broadcom Corporation
3 *
4 * Permission to use, copy, modify, and/or distribute this software for any
5 * purpose with or without fee is hereby granted, provided that the above
6 * copyright notice and this permission notice appear in all copies.
7 *
8 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
9 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
10 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
11 * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
12 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
13 * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
14 * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
15 */
16
17/* Toplevel file. Relies on dhd_linux.c to send commands to the dongle. */
18
19#include <linux/kernel.h>
5b435de0 20#include <linux/etherdevice.h>
68ca395f 21#include <linux/module.h>
1bacb048 22#include <linux/vmalloc.h>
5b435de0 23#include <net/cfg80211.h>
cbaa177d 24#include <net/netlink.h>
5b435de0
AS		 25
26#include <brcmu_utils.h>
27#include <defs.h>
28#include <brcmu_wifi.h>
122d3d04 29#include "core.h"
a8e8ed34 30#include "debug.h"
40c1c249 31#include "tracepoint.h"
7a5c1f64 32#include "fwil_types.h"
9f440b7b 33#include "p2p.h"
61730d4d 34#include "btcoex.h"
bfe81975 35#include "cfg80211.h"
c08437b4 36#include "feature.h"
81f5dcb8 37#include "fwil.h"
8851cce0 38#include "proto.h"
1bacb048 39#include "vendor.h"
d14f78b9 40#include "bus.h"
6b89dcb3 41#include "common.h"
5b435de0 42
e5806072
AS		 43#define BRCMF_SCAN_IE_LEN_MAX 2048
44#define BRCMF_PNO_VERSION 2
45#define BRCMF_PNO_TIME 30
46#define BRCMF_PNO_REPEAT 4
47#define BRCMF_PNO_FREQ_EXPO_MAX 3
48#define BRCMF_PNO_MAX_PFN_COUNT 16
49#define BRCMF_PNO_ENABLE_ADAPTSCAN_BIT 6
50#define BRCMF_PNO_HIDDEN_BIT 2
51#define BRCMF_PNO_WPA_AUTH_ANY 0xFFFFFFFF
52#define BRCMF_PNO_SCAN_COMPLETE 1
53#define BRCMF_PNO_SCAN_INCOMPLETE 0
54
1a873342
HM		 55#define WPA_OUI "\x00\x50\xF2" /* WPA OUI */
56#define WPA_OUI_TYPE 1
57#define RSN_OUI "\x00\x0F\xAC" /* RSN OUI */
58#define WME_OUI_TYPE 2
89286dc9 59#define WPS_OUI_TYPE 4
1a873342
HM		 60
61#define VS_IE_FIXED_HDR_LEN 6
62#define WPA_IE_VERSION_LEN 2
63#define WPA_IE_MIN_OUI_LEN 4
64#define WPA_IE_SUITE_COUNT_LEN 2
65
66#define WPA_CIPHER_NONE 0 /* None */
67#define WPA_CIPHER_WEP_40 1 /* WEP (40-bit) */
68#define WPA_CIPHER_TKIP 2 /* TKIP: default for WPA */
69#define WPA_CIPHER_AES_CCM 4 /* AES (CCM) */
70#define WPA_CIPHER_WEP_104 5 /* WEP (104-bit) */
71
72#define RSN_AKM_NONE 0 /* None (IBSS) */
73#define RSN_AKM_UNSPECIFIED 1 /* Over 802.1x */
74#define RSN_AKM_PSK 2 /* Pre-shared Key */
75#define RSN_CAP_LEN 2 /* Length of RSN capabilities */
76#define RSN_CAP_PTK_REPLAY_CNTR_MASK 0x000C
77
78#define VNDR_IE_CMD_LEN 4 /* length of the set command
79 * string :"add", "del" (+ NUL)
80 */
81#define VNDR_IE_COUNT_OFFSET 4
82#define VNDR_IE_PKTFLAG_OFFSET 8
83#define VNDR_IE_VSIE_OFFSET 12
84#define VNDR_IE_HDR_SIZE 12
9f440b7b 85#define VNDR_IE_PARSE_LIMIT 5
1a873342
HM		 86
87#define DOT11_MGMT_HDR_LEN 24 /* d11 management header len */
88#define DOT11_BCN_PRB_FIXED_LEN 12 /* beacon/probe fixed length */
04012895 89
89286dc9
HM		 90#define BRCMF_SCAN_JOIN_ACTIVE_DWELL_TIME_MS 320
91#define BRCMF_SCAN_JOIN_PASSIVE_DWELL_TIME_MS 400
92#define BRCMF_SCAN_JOIN_PROBE_INTERVAL_MS 20
93
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);
92121e69 4254 brcmf_net_setcarrier(ifp, true);
1a873342
HM		 4255
4256exit:
a44aa400 4257 if ((err) && (!mbss)) {
f96aa07e 4258 brcmf_set_mpc(ifp, 1);
b3657453
HM		 4259 brcmf_configure_arp_offload(ifp, true);
4260 }
1a873342
HM		 4261 return err;
4262}
4263
4264static int brcmf_cfg80211_stop_ap(struct wiphy *wiphy, struct net_device *ndev)
4265{
c1179033 4266 struct brcmf_if *ifp = netdev_priv(ndev);
5c33a942 4267 s32 err;
426d0a56 4268 struct brcmf_fil_bss_enable_le bss_enable;
5c33a942 4269 struct brcmf_join_params join_params;
1a873342 4270
d96b801f 4271 brcmf_dbg(TRACE, "Enter\n");
1a873342 4272
426d0a56 4273 if (ifp->vif->wdev.iftype == NL80211_IFTYPE_AP) {
1a873342
HM		 4274 /* Due to most likely deauths outstanding we sleep */
4275 /* first to make sure they get processed by fw. */
4276 msleep(400);
5c33a942 4277
a44aa400
HM		 4278 if (ifp->vif->mbss) {
4279 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_DOWN, 1);
4280 return err;
4281 }
4282
5c33a942
HM		 4283 memset(&join_params, 0, sizeof(join_params));
4284 err = brcmf_fil_cmd_data_set(ifp, BRCMF_C_SET_SSID,
4285 &join_params, sizeof(join_params));
4286 if (err < 0)
4287 brcmf_err("SET SSID error (%d)\n", err);
a44aa400 4288 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_DOWN, 1);
5c33a942 4289 if (err < 0)
a44aa400 4290 brcmf_err("BRCMF_C_DOWN error %d\n", err);
5c33a942
HM		 4291 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_AP, 0);
4292 if (err < 0)
4293 brcmf_err("setting AP mode failed %d\n", err);
4294 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_INFRA, 0);
4295 if (err < 0)
4296 brcmf_err("setting INFRA mode failed %d\n", err);
a44aa400
HM		 4297 if (brcmf_feat_is_enabled(ifp, BRCMF_FEAT_MBSS))
4298 brcmf_fil_iovar_int_set(ifp, "mbss", 0);
98027769
AS		 4299 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_REGULATORY,
4300 ifp->vif->is_11d);
4301 if (err < 0)
4302 brcmf_err("restoring REGULATORY setting failed %d\n",
4303 err);
a44aa400
HM		 4304 /* Bring device back up so it can be used again */
4305 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_UP, 1);
4306 if (err < 0)
4307 brcmf_err("BRCMF_C_UP error %d\n", err);
426d0a56
HM		 4308 } else {
4309 bss_enable.bsscfg_idx = cpu_to_le32(ifp->bssidx);
4310 bss_enable.enable = cpu_to_le32(0);
4311 err = brcmf_fil_iovar_data_set(ifp, "bss", &bss_enable,
4312 sizeof(bss_enable));
4313 if (err < 0)
4314 brcmf_err("bss_enable config failed %d\n", err);
1a873342 4315 }
f96aa07e 4316 brcmf_set_mpc(ifp, 1);
b3657453 4317 brcmf_configure_arp_offload(ifp, true);
426d0a56 4318 clear_bit(BRCMF_VIF_STATUS_AP_CREATED, &ifp->vif->sme_state);
92121e69 4319 brcmf_net_setcarrier(ifp, false);
426d0a56 4320
1a873342
HM		 4321 return err;
4322}
4323
a0f07959
HM		 4324static s32
4325brcmf_cfg80211_change_beacon(struct wiphy *wiphy, struct net_device *ndev,
4326 struct cfg80211_beacon_data *info)
4327{
a0f07959
HM		 4328 struct brcmf_if *ifp = netdev_priv(ndev);
4329 s32 err;
4330
4331 brcmf_dbg(TRACE, "Enter\n");
4332
a0f07959
HM		 4333 err = brcmf_config_ap_mgmt_ie(ifp->vif, info);
4334
4335 return err;
4336}
4337
1a873342
HM		 4338static int
4339brcmf_cfg80211_del_station(struct wiphy *wiphy, struct net_device *ndev,
89c771e5 4340 struct station_del_parameters *params)
1a873342 4341{
a0f07959 4342 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy);
1a873342 4343 struct brcmf_scb_val_le scbval;
0abb5f21 4344 struct brcmf_if *ifp = netdev_priv(ndev);
1a873342
HM		 4345 s32 err;
4346
89c771e5 4347 if (!params->mac)
1a873342
HM		 4348 return -EFAULT;
4349
89c771e5 4350 brcmf_dbg(TRACE, "Enter %pM\n", params->mac);
1a873342 4351
a0f07959
HM		 4352 if (ifp->vif == cfg->p2p.bss_idx[P2PAPI_BSSCFG_DEVICE].vif)
4353 ifp = cfg->p2p.bss_idx[P2PAPI_BSSCFG_PRIMARY].vif->ifp;
ce81e317 4354 if (!check_vif_up(ifp->vif))
1a873342
HM		 4355 return -EIO;
4356
89c771e5 4357 memcpy(&scbval.ea, params->mac, ETH_ALEN);
ba8b6ae6 4358 scbval.val = cpu_to_le32(params->reason_code);
0abb5f21 4359 err = brcmf_fil_cmd_data_set(ifp, BRCMF_C_SCB_DEAUTHENTICATE_FOR_REASON,
81f5dcb8 4360 &scbval, sizeof(scbval));
1a873342 4361 if (err)
57d6e91a 4362 brcmf_err("SCB_DEAUTHENTICATE_FOR_REASON failed %d\n", err);
7ab6acd0 4363
d96b801f 4364 brcmf_dbg(TRACE, "Exit\n");
1a873342
HM		 4365 return err;
4366}
4367
6b89dcb3
HM		 4368static int
4369brcmf_cfg80211_change_station(struct wiphy *wiphy, struct net_device *ndev,
4370 const u8 *mac, struct station_parameters *params)
4371{
4372 struct brcmf_if *ifp = netdev_priv(ndev);
4373 s32 err;
4374
4375 brcmf_dbg(TRACE, "Enter, MAC %pM, mask 0x%04x set 0x%04x\n", mac,
4376 params->sta_flags_mask, params->sta_flags_set);
4377
4378 /* Ignore all 00 MAC */
4379 if (is_zero_ether_addr(mac))
4380 return 0;
4381
4382 if (!(params->sta_flags_mask & BIT(NL80211_STA_FLAG_AUTHORIZED)))
4383 return 0;
4384
4385 if (params->sta_flags_set & BIT(NL80211_STA_FLAG_AUTHORIZED))
4386 err = brcmf_fil_cmd_data_set(ifp, BRCMF_C_SET_SCB_AUTHORIZE,
4387 (void *)mac, ETH_ALEN);
4388 else
4389 err = brcmf_fil_cmd_data_set(ifp, BRCMF_C_SET_SCB_DEAUTHORIZE,
4390 (void *)mac, ETH_ALEN);
4391 if (err < 0)
4392 brcmf_err("Setting SCB (de-)authorize failed, %d\n", err);
4393
4394 return err;
4395}
0de8aace
HM		 4396
4397static void
4398brcmf_cfg80211_mgmt_frame_register(struct wiphy *wiphy,
4399 struct wireless_dev *wdev,
4400 u16 frame_type, bool reg)
4401{
7fa2e352 4402 struct brcmf_cfg80211_vif *vif;
0de8aace
HM		 4403 u16 mgmt_type;
4404
4405 brcmf_dbg(TRACE, "Enter, frame_type %04x, reg=%d\n", frame_type, reg);
4406
4407 mgmt_type = (frame_type & IEEE80211_FCTL_STYPE) >> 4;
7fa2e352 4408 vif = container_of(wdev, struct brcmf_cfg80211_vif, wdev);
0de8aace
HM		 4409 if (reg)
4410 vif->mgmt_rx_reg |= BIT(mgmt_type);
4411 else
318a64ce 4412 vif->mgmt_rx_reg &= ~BIT(mgmt_type);
0de8aace
HM		 4413}
4414
4415
4416static int
4417brcmf_cfg80211_mgmt_tx(struct wiphy *wiphy, struct wireless_dev *wdev,
b176e629 4418 struct cfg80211_mgmt_tx_params *params, u64 *cookie)
0de8aace
HM		 4419{
4420 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy);
b176e629
AO		 4421 struct ieee80211_channel *chan = params->chan;
4422 const u8 *buf = params->buf;
4423 size_t len = params->len;
0de8aace
HM		 4424 const struct ieee80211_mgmt *mgmt;
4425 struct brcmf_cfg80211_vif *vif;
4426 s32 err = 0;
4427 s32 ie_offset;
4428 s32 ie_len;
18e2f61d
HM		 4429 struct brcmf_fil_action_frame_le *action_frame;
4430 struct brcmf_fil_af_params_le *af_params;
4431 bool ack;
4432 s32 chan_nr;
c2ff8cad 4433 u32 freq;
0de8aace
HM		 4434
4435 brcmf_dbg(TRACE, "Enter\n");
4436
4437 *cookie = 0;
4438
4439 mgmt = (const struct ieee80211_mgmt *)buf;
4440
a0f07959
HM		 4441 if (!ieee80211_is_mgmt(mgmt->frame_control)) {
4442 brcmf_err("Driver only allows MGMT packet type\n");
4443 return -EPERM;
4444 }
0de8aace 4445
c2ff8cad
AQ		 4446 vif = container_of(wdev, struct brcmf_cfg80211_vif, wdev);
4447
a0f07959
HM		 4448 if (ieee80211_is_probe_resp(mgmt->frame_control)) {
4449 /* Right now the only reason to get a probe response */
4450 /* is for p2p listen response or for p2p GO from */
4451 /* wpa_supplicant. Unfortunately the probe is send */
4452 /* on primary ndev, while dongle wants it on the p2p */
4453 /* vif. Since this is only reason for a probe */
4454 /* response to be sent, the vif is taken from cfg. */
4455 /* If ever desired to send proberesp for non p2p */
4456 /* response then data should be checked for */
4457 /* "DIRECT-". Note in future supplicant will take */
4458 /* dedicated p2p wdev to do this and then this 'hack'*/
4459 /* is not needed anymore. */
4460 ie_offset = DOT11_MGMT_HDR_LEN +
4461 DOT11_BCN_PRB_FIXED_LEN;
4462 ie_len = len - ie_offset;
a0f07959 4463 if (vif == cfg->p2p.bss_idx[P2PAPI_BSSCFG_PRIMARY].vif)
0de8aace 4464 vif = cfg->p2p.bss_idx[P2PAPI_BSSCFG_DEVICE].vif;
a0f07959
HM		 4465 err = brcmf_vif_set_mgmt_ie(vif,
4466 BRCMF_VNDR_IE_PRBRSP_FLAG,
4467 &buf[ie_offset],
4468 ie_len);
4469 cfg80211_mgmt_tx_status(wdev, *cookie, buf, len, true,
4470 GFP_KERNEL);
18e2f61d
HM		 4471 } else if (ieee80211_is_action(mgmt->frame_control)) {
4472 af_params = kzalloc(sizeof(*af_params), GFP_KERNEL);
4473 if (af_params == NULL) {
4474 brcmf_err("unable to allocate frame\n");
4475 err = -ENOMEM;
4476 goto exit;
4477 }
4478 action_frame = &af_params->action_frame;
4479 /* Add the packet Id */
4480 action_frame->packet_id = cpu_to_le32(*cookie);
4481 /* Add BSSID */
4482 memcpy(&action_frame->da[0], &mgmt->da[0], ETH_ALEN);
4483 memcpy(&af_params->bssid[0], &mgmt->bssid[0], ETH_ALEN);
4484 /* Add the length exepted for 802.11 header */
4485 action_frame->len = cpu_to_le16(len - DOT11_MGMT_HDR_LEN);
c2ff8cad
AQ		 4486 /* Add the channel. Use the one specified as parameter if any or
4487 * the current one (got from the firmware) otherwise
4488 */
4489 if (chan)
4490 freq = chan->center_freq;
4491 else
4492 brcmf_fil_cmd_int_get(vif->ifp, BRCMF_C_GET_CHANNEL,
4493 &freq);
4494 chan_nr = ieee80211_frequency_to_channel(freq);
18e2f61d
HM		 4495 af_params->channel = cpu_to_le32(chan_nr);
4496
4497 memcpy(action_frame->data, &buf[DOT11_MGMT_HDR_LEN],
4498 le16_to_cpu(action_frame->len));
4499
4500 brcmf_dbg(TRACE, "Action frame, cookie=%lld, len=%d, freq=%d\n",
86a9c4a2 4501 *cookie, le16_to_cpu(action_frame->len), freq);
18e2f61d 4502
7fa2e352 4503 ack = brcmf_p2p_send_action_frame(cfg, cfg_to_ndev(cfg),
18e2f61d
HM		 4504 af_params);
4505
4506 cfg80211_mgmt_tx_status(wdev, *cookie, buf, len, ack,
4507 GFP_KERNEL);
4508 kfree(af_params);
a0f07959
HM		 4509 } else {
4510 brcmf_dbg(TRACE, "Unhandled, fc=%04x!!\n", mgmt->frame_control);
4511 brcmf_dbg_hex_dump(true, buf, len, "payload, len=%Zu\n", len);
0de8aace 4512 }
a0f07959 4513
18e2f61d 4514exit:
0de8aace
HM		 4515 return err;
4516}
4517
4518
4519static int
4520brcmf_cfg80211_cancel_remain_on_channel(struct wiphy *wiphy,
4521 struct wireless_dev *wdev,
4522 u64 cookie)
4523{
4524 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy);
4525 struct brcmf_cfg80211_vif *vif;
4526 int err = 0;
4527
4528 brcmf_dbg(TRACE, "Enter p2p listen cancel\n");
4529
4530 vif = cfg->p2p.bss_idx[P2PAPI_BSSCFG_DEVICE].vif;
4531 if (vif == NULL) {
4532 brcmf_err("No p2p device available for probe response\n");
4533 err = -ENODEV;
4534 goto exit;
4535 }
4536 brcmf_p2p_cancel_remain_on_channel(vif->ifp);
4537exit:
4538 return err;
4539}
4540
61730d4d
PH		 4541static int brcmf_cfg80211_crit_proto_start(struct wiphy *wiphy,
4542 struct wireless_dev *wdev,
4543 enum nl80211_crit_proto_id proto,
4544 u16 duration)
4545{
4546 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy);
4547 struct brcmf_cfg80211_vif *vif;
4548
4549 vif = container_of(wdev, struct brcmf_cfg80211_vif, wdev);
4550
4551 /* only DHCP support for now */
4552 if (proto != NL80211_CRIT_PROTO_DHCP)
4553 return -EINVAL;
4554
4555 /* suppress and abort scanning */
4556 set_bit(BRCMF_SCAN_STATUS_SUPPRESS, &cfg->scan_status);
4557 brcmf_abort_scanning(cfg);
4558
4559 return brcmf_btcoex_set_mode(vif, BRCMF_BTCOEX_DISABLED, duration);
4560}
4561
4562static void brcmf_cfg80211_crit_proto_stop(struct wiphy *wiphy,
4563 struct wireless_dev *wdev)
4564{
4565 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy);
4566 struct brcmf_cfg80211_vif *vif;
4567
4568 vif = container_of(wdev, struct brcmf_cfg80211_vif, wdev);
4569
4570 brcmf_btcoex_set_mode(vif, BRCMF_BTCOEX_ENABLED, 0);
4571 clear_bit(BRCMF_SCAN_STATUS_SUPPRESS, &cfg->scan_status);
4572}
4573
70b7d94b
HM		 4574static s32
4575brcmf_notify_tdls_peer_event(struct brcmf_if *ifp,
4576 const struct brcmf_event_msg *e, void *data)
4577{
4578 switch (e->reason) {
4579 case BRCMF_E_REASON_TDLS_PEER_DISCOVERED:
4580 brcmf_dbg(TRACE, "TDLS Peer Discovered\n");
4581 break;
4582 case BRCMF_E_REASON_TDLS_PEER_CONNECTED:
4583 brcmf_dbg(TRACE, "TDLS Peer Connected\n");
4584 brcmf_proto_add_tdls_peer(ifp->drvr, ifp->ifidx, (u8 *)e->addr);
4585 break;
4586 case BRCMF_E_REASON_TDLS_PEER_DISCONNECTED:
4587 brcmf_dbg(TRACE, "TDLS Peer Disconnected\n");
4588 brcmf_proto_delete_peer(ifp->drvr, ifp->ifidx, (u8 *)e->addr);
4589 break;
4590 }
4591
4592 return 0;
4593}
4594
89c2f382
AS		 4595static int brcmf_convert_nl80211_tdls_oper(enum nl80211_tdls_operation oper)
4596{
4597 int ret;
4598
4599 switch (oper) {
4600 case NL80211_TDLS_DISCOVERY_REQ:
4601 ret = BRCMF_TDLS_MANUAL_EP_DISCOVERY;
4602 break;
4603 case NL80211_TDLS_SETUP:
4604 ret = BRCMF_TDLS_MANUAL_EP_CREATE;
4605 break;
4606 case NL80211_TDLS_TEARDOWN:
4607 ret = BRCMF_TDLS_MANUAL_EP_DELETE;
4608 break;
4609 default:
4610 brcmf_err("unsupported operation: %d\n", oper);
4611 ret = -EOPNOTSUPP;
4612 }
4613 return ret;
4614}
4615
4616static int brcmf_cfg80211_tdls_oper(struct wiphy *wiphy,
3b3a0162 4617 struct net_device *ndev, const u8 *peer,
89c2f382
AS		 4618 enum nl80211_tdls_operation oper)
4619{
4620 struct brcmf_if *ifp;
4621 struct brcmf_tdls_iovar_le info;
4622 int ret = 0;
4623
4624 ret = brcmf_convert_nl80211_tdls_oper(oper);
4625 if (ret < 0)
4626 return ret;
4627
4628 ifp = netdev_priv(ndev);
4629 memset(&info, 0, sizeof(info));
4630 info.mode = (u8)ret;
4631 if (peer)
4632 memcpy(info.ea, peer, ETH_ALEN);
4633
4634 ret = brcmf_fil_iovar_data_set(ifp, "tdls_endpoint",
4635 &info, sizeof(info));
4636 if (ret < 0)
4637 brcmf_err("tdls_endpoint iovar failed: ret=%d\n", ret);
4638
4639 return ret;
4640}
4641
5b435de0 4642static struct cfg80211_ops wl_cfg80211_ops = {
9f440b7b
AS		 4643 .add_virtual_intf = brcmf_cfg80211_add_iface,
4644 .del_virtual_intf = brcmf_cfg80211_del_iface,
5b435de0
AS		 4645 .change_virtual_intf = brcmf_cfg80211_change_iface,
4646 .scan = brcmf_cfg80211_scan,
4647 .set_wiphy_params = brcmf_cfg80211_set_wiphy_params,
4648 .join_ibss = brcmf_cfg80211_join_ibss,
4649 .leave_ibss = brcmf_cfg80211_leave_ibss,
4650 .get_station = brcmf_cfg80211_get_station,
bf2a7e04 4651 .dump_station = brcmf_cfg80211_dump_station,
5b435de0
AS		 4652 .set_tx_power = brcmf_cfg80211_set_tx_power,
4653 .get_tx_power = brcmf_cfg80211_get_tx_power,
4654 .add_key = brcmf_cfg80211_add_key,
4655 .del_key = brcmf_cfg80211_del_key,
4656 .get_key = brcmf_cfg80211_get_key,
4657 .set_default_key = brcmf_cfg80211_config_default_key,
4658 .set_default_mgmt_key = brcmf_cfg80211_config_default_mgmt_key,
4659 .set_power_mgmt = brcmf_cfg80211_set_power_mgmt,
5b435de0
AS		 4660 .connect = brcmf_cfg80211_connect,
4661 .disconnect = brcmf_cfg80211_disconnect,
4662 .suspend = brcmf_cfg80211_suspend,
4663 .resume = brcmf_cfg80211_resume,
4664 .set_pmksa = brcmf_cfg80211_set_pmksa,
4665 .del_pmksa = brcmf_cfg80211_del_pmksa,
cbaa177d 4666 .flush_pmksa = brcmf_cfg80211_flush_pmksa,
1a873342
HM		 4667 .start_ap = brcmf_cfg80211_start_ap,
4668 .stop_ap = brcmf_cfg80211_stop_ap,
a0f07959 4669 .change_beacon = brcmf_cfg80211_change_beacon,
1a873342 4670 .del_station = brcmf_cfg80211_del_station,
6b89dcb3 4671 .change_station = brcmf_cfg80211_change_station,
e5806072
AS		 4672 .sched_scan_start = brcmf_cfg80211_sched_scan_start,
4673 .sched_scan_stop = brcmf_cfg80211_sched_scan_stop,
0de8aace
HM		 4674 .mgmt_frame_register = brcmf_cfg80211_mgmt_frame_register,
4675 .mgmt_tx = brcmf_cfg80211_mgmt_tx,
4676 .remain_on_channel = brcmf_p2p_remain_on_channel,
4677 .cancel_remain_on_channel = brcmf_cfg80211_cancel_remain_on_channel,
27f10e38
AS		 4678 .start_p2p_device = brcmf_p2p_start_device,
4679 .stop_p2p_device = brcmf_p2p_stop_device,
61730d4d
PH		 4680 .crit_proto_start = brcmf_cfg80211_crit_proto_start,
4681 .crit_proto_stop = brcmf_cfg80211_crit_proto_stop,
89c2f382 4682 .tdls_oper = brcmf_cfg80211_tdls_oper,
5b435de0
AS		 4683};
4684
3eacf866 4685struct brcmf_cfg80211_vif *brcmf_alloc_vif(struct brcmf_cfg80211_info *cfg,
9f440b7b
AS		 4686 enum nl80211_iftype type,
4687 bool pm_block)
3eacf866 4688{
a44aa400 4689 struct brcmf_cfg80211_vif *vif_walk;
3eacf866 4690 struct brcmf_cfg80211_vif *vif;
a44aa400 4691 bool mbss;
5b435de0 4692
33a6b157 4693 brcmf_dbg(TRACE, "allocating virtual interface (size=%zu)\n",
9f440b7b 4694 sizeof(*vif));
3eacf866
AS		 4695 vif = kzalloc(sizeof(*vif), GFP_KERNEL);
4696 if (!vif)
4697 return ERR_PTR(-ENOMEM);
4698
4699 vif->wdev.wiphy = cfg->wiphy;
9f440b7b 4700 vif->wdev.iftype = type;
5b435de0 4701
3eacf866
AS		 4702 vif->pm_block = pm_block;
4703 vif->roam_off = -1;
4704
6ac4f4ed
AS		 4705 brcmf_init_prof(&vif->profile);
4706
a44aa400
HM		 4707 if (type == NL80211_IFTYPE_AP) {
4708 mbss = false;
4709 list_for_each_entry(vif_walk, &cfg->vif_list, list) {
4710 if (vif_walk->wdev.iftype == NL80211_IFTYPE_AP) {
4711 mbss = true;
4712 break;
4713 }
4714 }
4715 vif->mbss = mbss;
4716 }
4717
3eacf866 4718 list_add_tail(&vif->list, &cfg->vif_list);
3eacf866 4719 return vif;
5b435de0
AS		 4720}
4721
427dec5f 4722void brcmf_free_vif(struct brcmf_cfg80211_vif *vif)
5b435de0 4723{
3eacf866 4724 list_del(&vif->list);
3eacf866 4725 kfree(vif);
5b435de0
AS		 4726}
4727
9df4d542
AS		 4728void brcmf_cfg80211_free_netdev(struct net_device *ndev)
4729{
4730 struct brcmf_cfg80211_vif *vif;
4731 struct brcmf_if *ifp;
4732
4733 ifp = netdev_priv(ndev);
4734 vif = ifp->vif;
4735
95ef1239
AS		 4736 if (vif)
4737 brcmf_free_vif(vif);
9df4d542
AS		 4738 free_netdev(ndev);
4739}
4740
903e0eee 4741static bool brcmf_is_linkup(const struct brcmf_event_msg *e)
5b435de0 4742{
5c36b99a
AS		 4743 u32 event = e->event_code;
4744 u32 status = e->status;
5b435de0
AS		 4745
4746 if (event == BRCMF_E_SET_SSID && status == BRCMF_E_STATUS_SUCCESS) {
16886735 4747 brcmf_dbg(CONN, "Processing set ssid\n");
5b435de0
AS		 4748 return true;
4749 }
4750
4751 return false;
4752}
4753
903e0eee 4754static bool brcmf_is_linkdown(const struct brcmf_event_msg *e)
5b435de0 4755{
5c36b99a
AS		 4756 u32 event = e->event_code;
4757 u16 flags = e->flags;
5b435de0 4758
68ca395f
HM		 4759 if ((event == BRCMF_E_DEAUTH) || (event == BRCMF_E_DEAUTH_IND) ||
4760 (event == BRCMF_E_DISASSOC_IND) ||
4761 ((event == BRCMF_E_LINK) && (!(flags & BRCMF_EVENT_MSG_LINK)))) {
16886735 4762 brcmf_dbg(CONN, "Processing link down\n");
5b435de0
AS		 4763 return true;
4764 }
4765 return false;
4766}
4767
27a68fe3 4768static bool brcmf_is_nonetwork(struct brcmf_cfg80211_info *cfg,
5b435de0
AS		 4769 const struct brcmf_event_msg *e)
4770{
5c36b99a
AS		 4771 u32 event = e->event_code;
4772 u32 status = e->status;
5b435de0
AS		 4773
4774 if (event == BRCMF_E_LINK && status == BRCMF_E_STATUS_NO_NETWORKS) {
16886735
AS		 4775 brcmf_dbg(CONN, "Processing Link %s & no network found\n",
4776 e->flags & BRCMF_EVENT_MSG_LINK ? "up" : "down");
5b435de0
AS		 4777 return true;
4778 }
4779
4780 if (event == BRCMF_E_SET_SSID && status != BRCMF_E_STATUS_SUCCESS) {
16886735 4781 brcmf_dbg(CONN, "Processing connecting & no network found\n");
5b435de0
AS		 4782 return true;
4783 }
4784
4785 return false;
4786}
4787
27a68fe3 4788static void brcmf_clear_assoc_ies(struct brcmf_cfg80211_info *cfg)
5b435de0 4789{
27a68fe3 4790 struct brcmf_cfg80211_connect_info *conn_info = cfg_to_conn(cfg);
5b435de0
AS		 4791
4792 kfree(conn_info->req_ie);
4793 conn_info->req_ie = NULL;
4794 conn_info->req_ie_len = 0;
4795 kfree(conn_info->resp_ie);
4796 conn_info->resp_ie = NULL;
4797 conn_info->resp_ie_len = 0;
4798}
4799
89286dc9
HM		 4800static s32 brcmf_get_assoc_ies(struct brcmf_cfg80211_info *cfg,
4801 struct brcmf_if *ifp)
5b435de0 4802{
c4e382d2 4803 struct brcmf_cfg80211_assoc_ielen_le *assoc_info;
27a68fe3 4804 struct brcmf_cfg80211_connect_info *conn_info = cfg_to_conn(cfg);
5b435de0
AS		 4805 u32 req_len;
4806 u32 resp_len;
4807 s32 err = 0;
4808
27a68fe3 4809 brcmf_clear_assoc_ies(cfg);
5b435de0 4810
ac24be6f
AS		 4811 err = brcmf_fil_iovar_data_get(ifp, "assoc_info",
4812 cfg->extra_buf, WL_ASSOC_INFO_MAX);
5b435de0 4813 if (err) {
57d6e91a 4814 brcmf_err("could not get assoc info (%d)\n", err);
5b435de0
AS		 4815 return err;
4816 }
c4e382d2 4817 assoc_info =
27a68fe3 4818 (struct brcmf_cfg80211_assoc_ielen_le *)cfg->extra_buf;
c4e382d2
AS		 4819 req_len = le32_to_cpu(assoc_info->req_len);
4820 resp_len = le32_to_cpu(assoc_info->resp_len);
5b435de0 4821 if (req_len) {
ac24be6f 4822 err = brcmf_fil_iovar_data_get(ifp, "assoc_req_ies",
81f5dcb8
HM		 4823 cfg->extra_buf,
4824 WL_ASSOC_INFO_MAX);
5b435de0 4825 if (err) {
57d6e91a 4826 brcmf_err("could not get assoc req (%d)\n", err);
5b435de0
AS		 4827 return err;
4828 }
4829 conn_info->req_ie_len = req_len;
4830 conn_info->req_ie =
27a68fe3 4831 kmemdup(cfg->extra_buf, conn_info->req_ie_len,
5b435de0
AS		 4832 GFP_KERNEL);
4833 } else {
4834 conn_info->req_ie_len = 0;
4835 conn_info->req_ie = NULL;
4836 }
4837 if (resp_len) {
ac24be6f 4838 err = brcmf_fil_iovar_data_get(ifp, "assoc_resp_ies",
81f5dcb8
HM		 4839 cfg->extra_buf,
4840 WL_ASSOC_INFO_MAX);
5b435de0 4841 if (err) {
57d6e91a 4842 brcmf_err("could not get assoc resp (%d)\n", err);
5b435de0
AS		 4843 return err;
4844 }
4845 conn_info->resp_ie_len = resp_len;
4846 conn_info->resp_ie =
27a68fe3 4847 kmemdup(cfg->extra_buf, conn_info->resp_ie_len,
5b435de0
AS		 4848 GFP_KERNEL);
4849 } else {
4850 conn_info->resp_ie_len = 0;
4851 conn_info->resp_ie = NULL;
4852 }
16886735
AS		 4853 brcmf_dbg(CONN, "req len (%d) resp len (%d)\n",
4854 conn_info->req_ie_len, conn_info->resp_ie_len);
5b435de0
AS		 4855
4856 return err;
4857}
4858
4859static s32
27a68fe3 4860brcmf_bss_roaming_done(struct brcmf_cfg80211_info *cfg,
5b435de0
AS		 4861 struct net_device *ndev,
4862 const struct brcmf_event_msg *e)
4863{
c1179033
AS		 4864 struct brcmf_if *ifp = netdev_priv(ndev);
4865 struct brcmf_cfg80211_profile *profile = &ifp->vif->profile;
27a68fe3
AS		 4866 struct brcmf_cfg80211_connect_info *conn_info = cfg_to_conn(cfg);
4867 struct wiphy *wiphy = cfg_to_wiphy(cfg);
a180b83b 4868 struct ieee80211_channel *notify_channel = NULL;
5b435de0 4869 struct ieee80211_supported_band *band;
a180b83b 4870 struct brcmf_bss_info_le *bi;
83cf17aa 4871 struct brcmu_chan ch;
5b435de0
AS		 4872 u32 freq;
4873 s32 err = 0;
a180b83b 4874 u8 *buf;
5b435de0 4875
d96b801f 4876 brcmf_dbg(TRACE, "Enter\n");
5b435de0 4877
89286dc9 4878 brcmf_get_assoc_ies(cfg, ifp);
6c8c4f72 4879 memcpy(profile->bssid, e->addr, ETH_ALEN);
89286dc9 4880 brcmf_update_bss_info(cfg, ifp);
5b435de0 4881
a180b83b
FL		 4882 buf = kzalloc(WL_BSS_INFO_MAX, GFP_KERNEL);
4883 if (buf == NULL) {
4884 err = -ENOMEM;
4885 goto done;
4886 }
4887
4888 /* data sent to dongle has to be little endian */
4889 *(__le32 *)buf = cpu_to_le32(WL_BSS_INFO_MAX);
c1179033 4890 err = brcmf_fil_cmd_data_get(ifp, BRCMF_C_GET_BSS_INFO,
ac24be6f 4891 buf, WL_BSS_INFO_MAX);
a180b83b
FL		 4892
4893 if (err)
4894 goto done;
5b435de0 4895
a180b83b 4896 bi = (struct brcmf_bss_info_le *)(buf + 4);
83cf17aa
FL		 4897 ch.chspec = le16_to_cpu(bi->chanspec);
4898 cfg->d11inf.decchspec(&ch);
5b435de0 4899
83cf17aa 4900 if (ch.band == BRCMU_CHAN_BAND_2G)
5b435de0
AS		 4901 band = wiphy->bands[IEEE80211_BAND_2GHZ];
4902 else
4903 band = wiphy->bands[IEEE80211_BAND_5GHZ];
4904
83cf17aa 4905 freq = ieee80211_channel_to_frequency(ch.chnum, band->band);
5b435de0
AS		 4906 notify_channel = ieee80211_get_channel(wiphy, freq);
4907
a180b83b
FL		 4908done:
4909 kfree(buf);
06bb123e 4910 cfg80211_roamed(ndev, notify_channel, (u8 *)profile->bssid,
5b435de0
AS		 4911 conn_info->req_ie, conn_info->req_ie_len,
4912 conn_info->resp_ie, conn_info->resp_ie_len, GFP_KERNEL);
16886735 4913 brcmf_dbg(CONN, "Report roaming result\n");
5b435de0 4914
c1179033 4915 set_bit(BRCMF_VIF_STATUS_CONNECTED, &ifp->vif->sme_state);
d96b801f 4916 brcmf_dbg(TRACE, "Exit\n");
5b435de0
AS		 4917 return err;
4918}
4919
4920static s32
27a68fe3 4921brcmf_bss_connect_done(struct brcmf_cfg80211_info *cfg,
5b435de0
AS		 4922 struct net_device *ndev, const struct brcmf_event_msg *e,
4923 bool completed)
4924{
c1179033
AS		 4925 struct brcmf_if *ifp = netdev_priv(ndev);
4926 struct brcmf_cfg80211_profile *profile = &ifp->vif->profile;
27a68fe3 4927 struct brcmf_cfg80211_connect_info *conn_info = cfg_to_conn(cfg);
5b435de0 4928
d96b801f 4929 brcmf_dbg(TRACE, "Enter\n");
5b435de0 4930
c1179033
AS		 4931 if (test_and_clear_bit(BRCMF_VIF_STATUS_CONNECTING,
4932 &ifp->vif->sme_state)) {
5b435de0 4933 if (completed) {
89286dc9 4934 brcmf_get_assoc_ies(cfg, ifp);
6c8c4f72 4935 memcpy(profile->bssid, e->addr, ETH_ALEN);
89286dc9
HM		 4936 brcmf_update_bss_info(cfg, ifp);
4937 set_bit(BRCMF_VIF_STATUS_CONNECTED,
4938 &ifp->vif->sme_state);
5b435de0
AS		 4939 }
4940 cfg80211_connect_result(ndev,
06bb123e 4941 (u8 *)profile->bssid,
5b435de0
AS		 4942 conn_info->req_ie,
4943 conn_info->req_ie_len,
4944 conn_info->resp_ie,
4945 conn_info->resp_ie_len,
4946 completed ? WLAN_STATUS_SUCCESS :
4947 WLAN_STATUS_AUTH_TIMEOUT,
4948 GFP_KERNEL);
16886735
AS		 4949 brcmf_dbg(CONN, "Report connect result - connection %s\n",
4950 completed ? "succeeded" : "failed");
5b435de0 4951 }
d96b801f 4952 brcmf_dbg(TRACE, "Exit\n");
12f32370 4953 return 0;
5b435de0
AS		 4954}
4955
4956static s32
27a68fe3 4957brcmf_notify_connect_status_ap(struct brcmf_cfg80211_info *cfg,
1a873342
HM		 4958 struct net_device *ndev,
4959 const struct brcmf_event_msg *e, void *data)
4960{
a44aa400 4961 struct brcmf_if *ifp = netdev_priv(ndev);
7ee29602 4962 static int generation;
5c36b99a
AS		 4963 u32 event = e->event_code;
4964 u32 reason = e->reason;
1a873342
HM		 4965 struct station_info sinfo;
4966
16886735 4967 brcmf_dbg(CONN, "event %d, reason %d\n", event, reason);
5f4f9f11
AS		 4968 if (event == BRCMF_E_LINK && reason == BRCMF_E_REASON_LINK_BSSCFG_DIS &&
4969 ndev != cfg_to_ndev(cfg)) {
4970 brcmf_dbg(CONN, "AP mode link down\n");
4971 complete(&cfg->vif_disabled);
a44aa400 4972 if (ifp->vif->mbss)
ee6e3a34 4973 brcmf_remove_interface(ifp);
5f4f9f11
AS		 4974 return 0;
4975 }
1a873342 4976
1a873342 4977 if (((event == BRCMF_E_ASSOC_IND) || (event == BRCMF_E_REASSOC_IND)) &&
7ee29602
HM		 4978 (reason == BRCMF_E_STATUS_SUCCESS)) {
4979 memset(&sinfo, 0, sizeof(sinfo));
1a873342 4980 if (!data) {
57d6e91a 4981 brcmf_err("No IEs present in ASSOC/REASSOC_IND");
1a873342
HM		 4982 return -EINVAL;
4983 }
4984 sinfo.assoc_req_ies = data;
7ee29602 4985 sinfo.assoc_req_ies_len = e->datalen;
1a873342
HM		 4986 generation++;
4987 sinfo.generation = generation;
7ee29602 4988 cfg80211_new_sta(ndev, e->addr, &sinfo, GFP_KERNEL);
1a873342
HM		 4989 } else if ((event == BRCMF_E_DISASSOC_IND) ||
4990 (event == BRCMF_E_DEAUTH_IND) ||
4991 (event == BRCMF_E_DEAUTH)) {
7ee29602 4992 cfg80211_del_sta(ndev, e->addr, GFP_KERNEL);
1a873342 4993 }
7ee29602 4994 return 0;
1a873342
HM		 4995}
4996
5b435de0 4997static s32
1993732e 4998brcmf_notify_connect_status(struct brcmf_if *ifp,
5b435de0
AS		 4999 const struct brcmf_event_msg *e, void *data)
5000{
1993732e
AS		 5001 struct brcmf_cfg80211_info *cfg = ifp->drvr->config;
5002 struct net_device *ndev = ifp->ndev;
c1179033 5003 struct brcmf_cfg80211_profile *profile = &ifp->vif->profile;
fe94f3a4 5004 struct ieee80211_channel *chan;
5b435de0
AS		 5005 s32 err = 0;
5006
8851cce0
HM		 5007 if ((e->event_code == BRCMF_E_DEAUTH) ||
5008 (e->event_code == BRCMF_E_DEAUTH_IND) ||
5009 (e->event_code == BRCMF_E_DISASSOC_IND) ||
5010 ((e->event_code == BRCMF_E_LINK) && (!e->flags))) {
5011 brcmf_proto_delete_peer(ifp->drvr, ifp->ifidx, (u8 *)e->addr);
5012 }
5013
967fe2c8 5014 if (brcmf_is_apmode(ifp->vif)) {
27a68fe3 5015 err = brcmf_notify_connect_status_ap(cfg, ndev, e, data);
903e0eee 5016 } else if (brcmf_is_linkup(e)) {
16886735 5017 brcmf_dbg(CONN, "Linkup\n");
128ce3b6 5018 if (brcmf_is_ibssmode(ifp->vif)) {
fe94f3a4 5019 chan = ieee80211_get_channel(cfg->wiphy, cfg->channel);
6c8c4f72 5020 memcpy(profile->bssid, e->addr, ETH_ALEN);
27a68fe3 5021 wl_inform_ibss(cfg, ndev, e->addr);
fe94f3a4 5022 cfg80211_ibss_joined(ndev, e->addr, chan, GFP_KERNEL);
c1179033
AS		 5023 clear_bit(BRCMF_VIF_STATUS_CONNECTING,
5024 &ifp->vif->sme_state);
5025 set_bit(BRCMF_VIF_STATUS_CONNECTED,
5026 &ifp->vif->sme_state);
5b435de0 5027 } else
27a68fe3 5028 brcmf_bss_connect_done(cfg, ndev, e, true);
92121e69 5029 brcmf_net_setcarrier(ifp, true);
903e0eee 5030 } else if (brcmf_is_linkdown(e)) {
16886735 5031 brcmf_dbg(CONN, "Linkdown\n");
128ce3b6 5032 if (!brcmf_is_ibssmode(ifp->vif)) {
27a68fe3 5033 brcmf_bss_connect_done(cfg, ndev, e, false);
5b435de0 5034 }
9b7a0ddc 5035 brcmf_link_down(ifp->vif, brcmf_map_fw_linkdown_reason(e));
6ac4f4ed 5036 brcmf_init_prof(ndev_to_prof(ndev));
5f4f9f11
AS		 5037 if (ndev != cfg_to_ndev(cfg))
5038 complete(&cfg->vif_disabled);
92121e69 5039 brcmf_net_setcarrier(ifp, false);
27a68fe3 5040 } else if (brcmf_is_nonetwork(cfg, e)) {
128ce3b6 5041 if (brcmf_is_ibssmode(ifp->vif))
c1179033
AS		 5042 clear_bit(BRCMF_VIF_STATUS_CONNECTING,
5043 &ifp->vif->sme_state);
5b435de0 5044 else
27a68fe3 5045 brcmf_bss_connect_done(cfg, ndev, e, false);
5b435de0
AS		 5046 }
5047
5048 return err;
5049}
5050
5051static s32
1993732e 5052brcmf_notify_roaming_status(struct brcmf_if *ifp,
5b435de0
AS		 5053 const struct brcmf_event_msg *e, void *data)
5054{
1993732e 5055 struct brcmf_cfg80211_info *cfg = ifp->drvr->config;
5c36b99a
AS		 5056 u32 event = e->event_code;
5057 u32 status = e->status;
5b435de0
AS		 5058
5059 if (event == BRCMF_E_ROAM && status == BRCMF_E_STATUS_SUCCESS) {
c1179033 5060 if (test_bit(BRCMF_VIF_STATUS_CONNECTED, &ifp->vif->sme_state))
1993732e 5061 brcmf_bss_roaming_done(cfg, ifp->ndev, e);
5b435de0 5062 else
1993732e 5063 brcmf_bss_connect_done(cfg, ifp->ndev, e, true);
5b435de0
AS		 5064 }
5065
12f32370 5066 return 0;
5b435de0
AS		 5067}
5068
5069static s32
1993732e 5070brcmf_notify_mic_status(struct brcmf_if *ifp,
5b435de0
AS		 5071 const struct brcmf_event_msg *e, void *data)
5072{
5c36b99a 5073 u16 flags = e->flags;
5b435de0
AS		 5074 enum nl80211_key_type key_type;
5075
5076 if (flags & BRCMF_EVENT_MSG_GROUP)
5077 key_type = NL80211_KEYTYPE_GROUP;
5078 else
5079 key_type = NL80211_KEYTYPE_PAIRWISE;
5080
1993732e 5081 cfg80211_michael_mic_failure(ifp->ndev, (u8 *)&e->addr, key_type, -1,
5b435de0
AS		 5082 NULL, GFP_KERNEL);
5083
5084 return 0;
5085}
5086
d3c0b633
AS		 5087static s32 brcmf_notify_vif_event(struct brcmf_if *ifp,
5088 const struct brcmf_event_msg *e, void *data)
5089{
5090 struct brcmf_cfg80211_info *cfg = ifp->drvr->config;
5091 struct brcmf_if_event *ifevent = (struct brcmf_if_event *)data;
5092 struct brcmf_cfg80211_vif_event *event = &cfg->vif_event;
5093 struct brcmf_cfg80211_vif *vif;
5094
5095 brcmf_dbg(TRACE, "Enter: action %u flags %u ifidx %u bsscfg %u\n",
5096 ifevent->action, ifevent->flags, ifevent->ifidx,
5097 ifevent->bssidx);
5098
d3c0b633
AS		 5099 mutex_lock(&event->vif_event_lock);
5100 event->action = ifevent->action;
5101 vif = event->vif;
5102
5103 switch (ifevent->action) {
5104 case BRCMF_E_IF_ADD:
5105 /* waiting process may have timed out */
dc4a787c
WY		 5106 if (!cfg->vif_event.vif) {
5107 mutex_unlock(&event->vif_event_lock);
d3c0b633 5108 return -EBADF;
dc4a787c 5109 }
d3c0b633
AS		 5110
5111 ifp->vif = vif;
5112 vif->ifp = ifp;
01b8e7db
AS		 5113 if (ifp->ndev) {
5114 vif->wdev.netdev = ifp->ndev;
5115 ifp->ndev->ieee80211_ptr = &vif->wdev;
5116 SET_NETDEV_DEV(ifp->ndev, wiphy_dev(cfg->wiphy));
5117 }
d3c0b633
AS		 5118 mutex_unlock(&event->vif_event_lock);
5119 wake_up(&event->vif_wq);
4b3a89de 5120 return 0;
d3c0b633
AS		 5121
5122 case BRCMF_E_IF_DEL:
d3c0b633
AS		 5123 mutex_unlock(&event->vif_event_lock);
5124 /* event may not be upon user request */
5125 if (brcmf_cfg80211_vif_event_armed(cfg))
5126 wake_up(&event->vif_wq);
5127 return 0;
5128
7a5c1f64
HM		 5129 case BRCMF_E_IF_CHANGE:
5130 mutex_unlock(&event->vif_event_lock);
5131 wake_up(&event->vif_wq);
5132 return 0;
5133
d3c0b633
AS		 5134 default:
5135 mutex_unlock(&event->vif_event_lock);
5136 break;
5137 }
5138 return -EINVAL;
5139}
5140
5b435de0
AS		 5141static void brcmf_init_conf(struct brcmf_cfg80211_conf *conf)
5142{
5b435de0
AS		 5143 conf->frag_threshold = (u32)-1;
5144 conf->rts_threshold = (u32)-1;
5145 conf->retry_short = (u32)-1;
5146 conf->retry_long = (u32)-1;
5147 conf->tx_power = -1;
5148}
5149
5c36b99a 5150static void brcmf_register_event_handlers(struct brcmf_cfg80211_info *cfg)
5b435de0 5151{
5c36b99a
AS		 5152 brcmf_fweh_register(cfg->pub, BRCMF_E_LINK,
5153 brcmf_notify_connect_status);
5154 brcmf_fweh_register(cfg->pub, BRCMF_E_DEAUTH_IND,
5155 brcmf_notify_connect_status);
5156 brcmf_fweh_register(cfg->pub, BRCMF_E_DEAUTH,
5157 brcmf_notify_connect_status);
5158 brcmf_fweh_register(cfg->pub, BRCMF_E_DISASSOC_IND,
5159 brcmf_notify_connect_status);
5160 brcmf_fweh_register(cfg->pub, BRCMF_E_ASSOC_IND,
5161 brcmf_notify_connect_status);
5162 brcmf_fweh_register(cfg->pub, BRCMF_E_REASSOC_IND,
5163 brcmf_notify_connect_status);
5164 brcmf_fweh_register(cfg->pub, BRCMF_E_ROAM,
5165 brcmf_notify_roaming_status);
5166 brcmf_fweh_register(cfg->pub, BRCMF_E_MIC_ERROR,
5167 brcmf_notify_mic_status);
5168 brcmf_fweh_register(cfg->pub, BRCMF_E_SET_SSID,
5169 brcmf_notify_connect_status);
5170 brcmf_fweh_register(cfg->pub, BRCMF_E_PFN_NET_FOUND,
5171 brcmf_notify_sched_scan_results);
d3c0b633
AS		 5172 brcmf_fweh_register(cfg->pub, BRCMF_E_IF,
5173 brcmf_notify_vif_event);
0de8aace 5174 brcmf_fweh_register(cfg->pub, BRCMF_E_P2P_PROBEREQ_MSG,
6eda4e2c 5175 brcmf_p2p_notify_rx_mgmt_p2p_probereq);
0de8aace
HM		 5176 brcmf_fweh_register(cfg->pub, BRCMF_E_P2P_DISC_LISTEN_COMPLETE,
5177 brcmf_p2p_notify_listen_complete);
e6da3400
HM		 5178 brcmf_fweh_register(cfg->pub, BRCMF_E_ACTION_FRAME_RX,
5179 brcmf_p2p_notify_action_frame_rx);
18e2f61d
HM		 5180 brcmf_fweh_register(cfg->pub, BRCMF_E_ACTION_FRAME_COMPLETE,
5181 brcmf_p2p_notify_action_tx_complete);
6eda4e2c
HM		 5182 brcmf_fweh_register(cfg->pub, BRCMF_E_ACTION_FRAME_OFF_CHAN_COMPLETE,
5183 brcmf_p2p_notify_action_tx_complete);
5b435de0
AS		 5184}
5185
27a68fe3
AS		 5186static void brcmf_deinit_priv_mem(struct brcmf_cfg80211_info *cfg)
5187{
27a68fe3
AS		 5188 kfree(cfg->conf);
5189 cfg->conf = NULL;
27a68fe3
AS		 5190 kfree(cfg->escan_ioctl_buf);
5191 cfg->escan_ioctl_buf = NULL;
27a68fe3
AS		 5192 kfree(cfg->extra_buf);
5193 cfg->extra_buf = NULL;
27a68fe3
AS		 5194 kfree(cfg->pmk_list);
5195 cfg->pmk_list = NULL;
27a68fe3
AS		 5196}
5197
5198static s32 brcmf_init_priv_mem(struct brcmf_cfg80211_info *cfg)
5199{
27a68fe3
AS		 5200 cfg->conf = kzalloc(sizeof(*cfg->conf), GFP_KERNEL);
5201 if (!cfg->conf)
5b435de0 5202 goto init_priv_mem_out;
27a68fe3
AS		 5203 cfg->escan_ioctl_buf = kzalloc(BRCMF_DCMD_MEDLEN, GFP_KERNEL);
5204 if (!cfg->escan_ioctl_buf)
e756af5b 5205 goto init_priv_mem_out;
27a68fe3
AS		 5206 cfg->extra_buf = kzalloc(WL_EXTRA_BUF_MAX, GFP_KERNEL);
5207 if (!cfg->extra_buf)
5b435de0 5208 goto init_priv_mem_out;
27a68fe3
AS		 5209 cfg->pmk_list = kzalloc(sizeof(*cfg->pmk_list), GFP_KERNEL);
5210 if (!cfg->pmk_list)
5b435de0
AS		 5211 goto init_priv_mem_out;
5212
5213 return 0;
5214
5215init_priv_mem_out:
27a68fe3 5216 brcmf_deinit_priv_mem(cfg);
5b435de0
AS		 5217
5218 return -ENOMEM;
5219}
5220
27a68fe3 5221static s32 wl_init_priv(struct brcmf_cfg80211_info *cfg)
5b435de0
AS		 5222{
5223 s32 err = 0;
5224
27a68fe3
AS		 5225 cfg->scan_request = NULL;
5226 cfg->pwr_save = true;
68ca395f
HM		 5227 cfg->active_scan = true; /* we do active scan per default */
5228 cfg->dongle_up = false; /* dongle is not up yet */
27a68fe3 5229 err = brcmf_init_priv_mem(cfg);
5b435de0
AS		 5230 if (err)
5231 return err;
5c36b99a 5232 brcmf_register_event_handlers(cfg);
27a68fe3 5233 mutex_init(&cfg->usr_sync);
27a68fe3
AS		 5234 brcmf_init_escan(cfg);
5235 brcmf_init_conf(cfg->conf);
5f4f9f11 5236 init_completion(&cfg->vif_disabled);
5b435de0
AS		 5237 return err;
5238}
5239
27a68fe3 5240static void wl_deinit_priv(struct brcmf_cfg80211_info *cfg)
5b435de0 5241{
27a68fe3 5242 cfg->dongle_up = false; /* dongle down */
27a68fe3
AS		 5243 brcmf_abort_scanning(cfg);
5244 brcmf_deinit_priv_mem(cfg);
5b435de0
AS		 5245}
5246
d3c0b633
AS		 5247static void init_vif_event(struct brcmf_cfg80211_vif_event *event)
5248{
5249 init_waitqueue_head(&event->vif_wq);
d3c0b633
AS		 5250 mutex_init(&event->vif_event_lock);
5251}
5252
5b435de0 5253static s32
68ca395f 5254brcmf_dongle_roam(struct brcmf_if *ifp, u32 bcn_timeout)
5b435de0 5255{
5b435de0 5256 s32 err = 0;
f588bc0c
AS		 5257 __le32 roamtrigger[2];
5258 __le32 roam_delta[2];
5b435de0
AS		 5259
5260 /*
5261 * Setup timeout if Beacons are lost and roam is
5262 * off to report link down
5263 */
68ca395f 5264 if (brcmf_roamoff) {
ac24be6f 5265 err = brcmf_fil_iovar_int_set(ifp, "bcn_timeout", bcn_timeout);
5b435de0 5266 if (err) {
57d6e91a 5267 brcmf_err("bcn_timeout error (%d)\n", err);
5b435de0
AS		 5268 goto dongle_rom_out;
5269 }
5270 }
5271
5272 /*
5273 * Enable/Disable built-in roaming to allow supplicant
5274 * to take care of roaming
5275 */
68ca395f
HM		 5276 brcmf_dbg(INFO, "Internal Roaming = %s\n",
5277 brcmf_roamoff ? "Off" : "On");
5278 err = brcmf_fil_iovar_int_set(ifp, "roam_off", !!(brcmf_roamoff));
5b435de0 5279 if (err) {
57d6e91a 5280 brcmf_err("roam_off error (%d)\n", err);
5b435de0
AS		 5281 goto dongle_rom_out;
5282 }
5283
f588bc0c
AS		 5284 roamtrigger[0] = cpu_to_le32(WL_ROAM_TRIGGER_LEVEL);
5285 roamtrigger[1] = cpu_to_le32(BRCM_BAND_ALL);
ac24be6f 5286 err = brcmf_fil_cmd_data_set(ifp, BRCMF_C_SET_ROAM_TRIGGER,
81f5dcb8 5287 (void *)roamtrigger, sizeof(roamtrigger));
5b435de0 5288 if (err) {
57d6e91a 5289 brcmf_err("WLC_SET_ROAM_TRIGGER error (%d)\n", err);
5b435de0
AS		 5290 goto dongle_rom_out;
5291 }
5292
f588bc0c
AS		 5293 roam_delta[0] = cpu_to_le32(WL_ROAM_DELTA);
5294 roam_delta[1] = cpu_to_le32(BRCM_BAND_ALL);
ac24be6f 5295 err = brcmf_fil_cmd_data_set(ifp, BRCMF_C_SET_ROAM_DELTA,
81f5dcb8 5296 (void *)roam_delta, sizeof(roam_delta));
5b435de0 5297 if (err) {
57d6e91a 5298 brcmf_err("WLC_SET_ROAM_DELTA error (%d)\n", err);
5b435de0
AS		 5299 goto dongle_rom_out;
5300 }
5301
5302dongle_rom_out:
5303 return err;
5304}
5305
5306static s32
40a23296 5307brcmf_dongle_scantime(struct brcmf_if *ifp, s32 scan_assoc_time,
c68cdc0f 5308 s32 scan_unassoc_time, s32 scan_passive_time)
5b435de0
AS		 5309{
5310 s32 err = 0;
5311
ac24be6f 5312 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_SCAN_CHANNEL_TIME,
81f5dcb8 5313 scan_assoc_time);
5b435de0
AS		 5314 if (err) {
5315 if (err == -EOPNOTSUPP)
647c9ae0 5316 brcmf_dbg(INFO, "Scan assoc time is not supported\n");
5b435de0 5317 else
57d6e91a 5318 brcmf_err("Scan assoc time error (%d)\n", err);
5b435de0
AS		 5319 goto dongle_scantime_out;
5320 }
ac24be6f 5321 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_SCAN_UNASSOC_TIME,
81f5dcb8 5322 scan_unassoc_time);
5b435de0
AS		 5323 if (err) {
5324 if (err == -EOPNOTSUPP)
647c9ae0 5325 brcmf_dbg(INFO, "Scan unassoc time is not supported\n");
5b435de0 5326 else
57d6e91a 5327 brcmf_err("Scan unassoc time error (%d)\n", err);
5b435de0
AS		 5328 goto dongle_scantime_out;
5329 }
5330
ac24be6f 5331 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_SCAN_PASSIVE_TIME,
81f5dcb8 5332 scan_passive_time);
5b435de0
AS		 5333 if (err) {
5334 if (err == -EOPNOTSUPP)
647c9ae0 5335 brcmf_dbg(INFO, "Scan passive time is not supported\n");
5b435de0 5336 else
57d6e91a 5337 brcmf_err("Scan passive time error (%d)\n", err);
5b435de0
AS		 5338 goto dongle_scantime_out;
5339 }
5340
5341dongle_scantime_out:
5342 return err;
5343}
5344
b48d8916
AS		 5345static void brcmf_update_bw40_channel_flag(struct ieee80211_channel *channel,
5346 struct brcmu_chan *ch)
5347{
5348 u32 ht40_flag;
d48200ba 5349
b48d8916
AS		 5350 ht40_flag = channel->flags & IEEE80211_CHAN_NO_HT40;
5351 if (ch->sb == BRCMU_CHAN_SB_U) {
5352 if (ht40_flag == IEEE80211_CHAN_NO_HT40)
5353 channel->flags &= ~IEEE80211_CHAN_NO_HT40;
5354 channel->flags |= IEEE80211_CHAN_NO_HT40PLUS;
5355 } else {
5356 /* It should be one of
5357 * IEEE80211_CHAN_NO_HT40 or
5358 * IEEE80211_CHAN_NO_HT40PLUS
5359 */
5360 channel->flags &= ~IEEE80211_CHAN_NO_HT40;
5361 if (ht40_flag == IEEE80211_CHAN_NO_HT40)
5362 channel->flags |= IEEE80211_CHAN_NO_HT40MINUS;
5363 }
5364}
5365
5366static int brcmf_construct_chaninfo(struct brcmf_cfg80211_info *cfg,
5367 u32 bw_cap[])
d48200ba
HM		 5368{
5369 struct brcmf_if *ifp = netdev_priv(cfg_to_ndev(cfg));
b48d8916
AS		 5370 struct ieee80211_supported_band *band;
5371 struct ieee80211_channel *channel;
5372 struct wiphy *wiphy;
d48200ba 5373 struct brcmf_chanspec_list *list;
83cf17aa 5374 struct brcmu_chan ch;
b48d8916 5375 int err;
d48200ba
HM		 5376 u8 *pbuf;
5377 u32 i, j;
5378 u32 total;
b48d8916 5379 u32 chaninfo;
d48200ba 5380 u32 index;
d48200ba
HM		 5381
5382 pbuf = kzalloc(BRCMF_DCMD_MEDLEN, GFP_KERNEL);
5383
5384 if (pbuf == NULL)
5385 return -ENOMEM;
5386
5387 list = (struct brcmf_chanspec_list *)pbuf;
5388
5389 err = brcmf_fil_iovar_data_get(ifp, "chanspecs", pbuf,
5390 BRCMF_DCMD_MEDLEN);
5391 if (err) {
5392 brcmf_err("get chanspecs error (%d)\n", err);
b48d8916 5393 goto fail_pbuf;
d48200ba
HM		 5394 }
5395
b48d8916 5396 wiphy = cfg_to_wiphy(cfg);
58de92d2
AS		 5397 band = wiphy->bands[IEEE80211_BAND_2GHZ];
5398 if (band)
5399 for (i = 0; i < band->n_channels; i++)
5400 band->channels[i].flags = IEEE80211_CHAN_DISABLED;
5401 band = wiphy->bands[IEEE80211_BAND_5GHZ];
5402 if (band)
5403 for (i = 0; i < band->n_channels; i++)
5404 band->channels[i].flags = IEEE80211_CHAN_DISABLED;
d48200ba
HM		 5405
5406 total = le32_to_cpu(list->count);
5407 for (i = 0; i < total; i++) {
83cf17aa
FL		 5408 ch.chspec = (u16)le32_to_cpu(list->element[i]);
5409 cfg->d11inf.decchspec(&ch);
d48200ba 5410
83cf17aa 5411 if (ch.band == BRCMU_CHAN_BAND_2G) {
b48d8916 5412 band = wiphy->bands[IEEE80211_BAND_2GHZ];
83cf17aa 5413 } else if (ch.band == BRCMU_CHAN_BAND_5G) {
b48d8916 5414 band = wiphy->bands[IEEE80211_BAND_5GHZ];
d48200ba 5415 } else {
2375d970 5416 brcmf_err("Invalid channel Spec. 0x%x.\n", ch.chspec);
d48200ba
HM		 5417 continue;
5418 }
58de92d2
AS		 5419 if (!band)
5420 continue;
b48d8916 5421 if (!(bw_cap[band->band] & WLC_BW_40MHZ_BIT) &&
2375d970 5422 ch.bw == BRCMU_CHAN_BW_40)
d48200ba 5423 continue;
b48d8916 5424 if (!(bw_cap[band->band] & WLC_BW_80MHZ_BIT) &&
ee942ecc
AS		 5425 ch.bw == BRCMU_CHAN_BW_80)
5426 continue;
b48d8916
AS		 5427
5428 channel = band->channels;
5429 index = band->n_channels;
5430 for (j = 0; j < band->n_channels; j++) {
5431 if (channel[j].hw_value == ch.chnum) {
5432 index = j;
d48200ba
HM		 5433 break;
5434 }
5435 }
b48d8916
AS		 5436 channel[index].center_freq =
5437 ieee80211_channel_to_frequency(ch.chnum, band->band);
5438 channel[index].hw_value = ch.chnum;
5439
5440 /* assuming the chanspecs order is HT20,
5441 * HT40 upper, HT40 lower, and VHT80.
5442 */
5443 if (ch.bw == BRCMU_CHAN_BW_80) {
5444 channel[index].flags &= ~IEEE80211_CHAN_NO_80MHZ;
5445 } else if (ch.bw == BRCMU_CHAN_BW_40) {
5446 brcmf_update_bw40_channel_flag(&channel[index], &ch);
5447 } else {
58de92d2
AS		 5448 /* enable the channel and disable other bandwidths
5449 * for now as mentioned order assure they are enabled
5450 * for subsequent chanspecs.
ee942ecc 5451 */
b48d8916
AS		 5452 channel[index].flags = IEEE80211_CHAN_NO_HT40 |
5453 IEEE80211_CHAN_NO_80MHZ;
5454 ch.bw = BRCMU_CHAN_BW_20;
5455 cfg->d11inf.encchspec(&ch);
5456 chaninfo = ch.chspec;
5457 err = brcmf_fil_bsscfg_int_get(ifp, "per_chan_info",
5458 &chaninfo);
5459 if (!err) {
5460 if (chaninfo & WL_CHAN_RADAR)
5461 channel[index].flags |=
5462 (IEEE80211_CHAN_RADAR |
5463 IEEE80211_CHAN_NO_IR);
5464 if (chaninfo & WL_CHAN_PASSIVE)
5465 channel[index].flags |=
5466 IEEE80211_CHAN_NO_IR;
d48200ba 5467 }
d48200ba
HM		 5468 }
5469 }
b48d8916 5470
b48d8916 5471fail_pbuf:
d48200ba
HM		 5472 kfree(pbuf);
5473 return err;
5474}
5475
b48d8916 5476static int brcmf_enable_bw40_2g(struct brcmf_cfg80211_info *cfg)
aa70b4fa 5477{
b48d8916
AS		 5478 struct brcmf_if *ifp = netdev_priv(cfg_to_ndev(cfg));
5479 struct ieee80211_supported_band *band;
aa70b4fa 5480 struct brcmf_fil_bwcap_le band_bwcap;
b48d8916
AS		 5481 struct brcmf_chanspec_list *list;
5482 u8 *pbuf;
aa70b4fa
AS		 5483 u32 val;
5484 int err;
b48d8916
AS		 5485 struct brcmu_chan ch;
5486 u32 num_chan;
5487 int i, j;
aa70b4fa
AS		 5488
5489 /* verify support for bw_cap command */
5490 val = WLC_BAND_5G;
5491 err = brcmf_fil_iovar_int_get(ifp, "bw_cap", &val);
5492
5493 if (!err) {
5494 /* only set 2G bandwidth using bw_cap command */
5495 band_bwcap.band = cpu_to_le32(WLC_BAND_2G);
5496 band_bwcap.bw_cap = cpu_to_le32(WLC_BW_CAP_40MHZ);
5497 err = brcmf_fil_iovar_data_set(ifp, "bw_cap", &band_bwcap,
5498 sizeof(band_bwcap));
5499 } else {
5500 brcmf_dbg(INFO, "fallback to mimo_bw_cap\n");
5501 val = WLC_N_BW_40ALL;
5502 err = brcmf_fil_iovar_int_set(ifp, "mimo_bw_cap", val);
5503 }
b48d8916
AS		 5504
5505 if (!err) {
5506 /* update channel info in 2G band */
5507 pbuf = kzalloc(BRCMF_DCMD_MEDLEN, GFP_KERNEL);
5508
5509 if (pbuf == NULL)
5510 return -ENOMEM;
5511
5512 ch.band = BRCMU_CHAN_BAND_2G;
5513 ch.bw = BRCMU_CHAN_BW_40;
fac7d2a3 5514 ch.sb = BRCMU_CHAN_SB_NONE;
b48d8916
AS		 5515 ch.chnum = 0;
5516 cfg->d11inf.encchspec(&ch);
5517
5518 /* pass encoded chanspec in query */
5519 *(__le16 *)pbuf = cpu_to_le16(ch.chspec);
5520
5521 err = brcmf_fil_iovar_data_get(ifp, "chanspecs", pbuf,
5522 BRCMF_DCMD_MEDLEN);
5523 if (err) {
5524 brcmf_err("get chanspecs error (%d)\n", err);
5525 kfree(pbuf);
5526 return err;
5527 }
5528
5529 band = cfg_to_wiphy(cfg)->bands[IEEE80211_BAND_2GHZ];
5530 list = (struct brcmf_chanspec_list *)pbuf;
5531 num_chan = le32_to_cpu(list->count);
5532 for (i = 0; i < num_chan; i++) {
5533 ch.chspec = (u16)le32_to_cpu(list->element[i]);
5534 cfg->d11inf.decchspec(&ch);
5535 if (WARN_ON(ch.band != BRCMU_CHAN_BAND_2G))
5536 continue;
5537 if (WARN_ON(ch.bw != BRCMU_CHAN_BW_40))
5538 continue;
5539 for (j = 0; j < band->n_channels; j++) {
5540 if (band->channels[j].hw_value == ch.chnum)
5541 break;
5542 }
5543 if (WARN_ON(j == band->n_channels))
5544 continue;
5545
5546 brcmf_update_bw40_channel_flag(&band->channels[j], &ch);
5547 }
fac7d2a3 5548 kfree(pbuf);
b48d8916 5549 }
aa70b4fa
AS		 5550 return err;
5551}
5552
2375d970
AS		 5553static void brcmf_get_bwcap(struct brcmf_if *ifp, u32 bw_cap[])
5554{
5555 u32 band, mimo_bwcap;
5556 int err;
5557
5558 band = WLC_BAND_2G;
5559 err = brcmf_fil_iovar_int_get(ifp, "bw_cap", &band);
5560 if (!err) {
5561 bw_cap[IEEE80211_BAND_2GHZ] = band;
5562 band = WLC_BAND_5G;
5563 err = brcmf_fil_iovar_int_get(ifp, "bw_cap", &band);
5564 if (!err) {
5565 bw_cap[IEEE80211_BAND_5GHZ] = band;
5566 return;
5567 }
5568 WARN_ON(1);
5569 return;
5570 }
5571 brcmf_dbg(INFO, "fallback to mimo_bw_cap info\n");
5572 mimo_bwcap = 0;
5573 err = brcmf_fil_iovar_int_get(ifp, "mimo_bw_cap", &mimo_bwcap);
5574 if (err)
5575 /* assume 20MHz if firmware does not give a clue */
5576 mimo_bwcap = WLC_N_BW_20ALL;
5577
5578 switch (mimo_bwcap) {
5579 case WLC_N_BW_40ALL:
5580 bw_cap[IEEE80211_BAND_2GHZ] |= WLC_BW_40MHZ_BIT;
5581 /* fall-thru */
5582 case WLC_N_BW_20IN2G_40IN5G:
5583 bw_cap[IEEE80211_BAND_5GHZ] |= WLC_BW_40MHZ_BIT;
5584 /* fall-thru */
5585 case WLC_N_BW_20ALL:
5586 bw_cap[IEEE80211_BAND_2GHZ] |= WLC_BW_20MHZ_BIT;
5587 bw_cap[IEEE80211_BAND_5GHZ] |= WLC_BW_20MHZ_BIT;
5588 break;
5589 default:
5590 brcmf_err("invalid mimo_bw_cap value\n");
5591 }
5592}
d48200ba 5593
18d6c535
AS		 5594static void brcmf_update_ht_cap(struct ieee80211_supported_band *band,
5595 u32 bw_cap[2], u32 nchain)
5596{
5597 band->ht_cap.ht_supported = true;
5598 if (bw_cap[band->band] & WLC_BW_40MHZ_BIT) {
5599 band->ht_cap.cap |= IEEE80211_HT_CAP_SGI_40;
5600 band->ht_cap.cap |= IEEE80211_HT_CAP_SUP_WIDTH_20_40;
5601 }
5602 band->ht_cap.cap |= IEEE80211_HT_CAP_SGI_20;
5603 band->ht_cap.cap |= IEEE80211_HT_CAP_DSSSCCK40;
5604 band->ht_cap.ampdu_factor = IEEE80211_HT_MAX_AMPDU_64K;
5605 band->ht_cap.ampdu_density = IEEE80211_HT_MPDU_DENSITY_16;
5606 memset(band->ht_cap.mcs.rx_mask, 0xff, nchain);
5607 band->ht_cap.mcs.tx_params = IEEE80211_HT_MCS_TX_DEFINED;
5608}
5609
5610static __le16 brcmf_get_mcs_map(u32 nchain, enum ieee80211_vht_mcs_support supp)
5611{
5612 u16 mcs_map;
5613 int i;
5614
5615 for (i = 0, mcs_map = 0xFFFF; i < nchain; i++)
5616 mcs_map = (mcs_map << 2) | supp;
5617
5618 return cpu_to_le16(mcs_map);
5619}
5620
5621static void brcmf_update_vht_cap(struct ieee80211_supported_band *band,
5622 u32 bw_cap[2], u32 nchain)
5623{
5624 __le16 mcs_map;
5625
5626 /* not allowed in 2.4G band */
5627 if (band->band == IEEE80211_BAND_2GHZ)
5628 return;
5629
5630 band->vht_cap.vht_supported = true;
5631 /* 80MHz is mandatory */
5632 band->vht_cap.cap |= IEEE80211_VHT_CAP_SHORT_GI_80;
5633 if (bw_cap[band->band] & WLC_BW_160MHZ_BIT) {
5634 band->vht_cap.cap |= IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160MHZ;
5635 band->vht_cap.cap |= IEEE80211_VHT_CAP_SHORT_GI_160;
5636 }
5637 /* all support 256-QAM */
5638 mcs_map = brcmf_get_mcs_map(nchain, IEEE80211_VHT_MCS_SUPPORT_0_9);
5639 band->vht_cap.vht_mcs.rx_mcs_map = mcs_map;
5640 band->vht_cap.vht_mcs.tx_mcs_map = mcs_map;
5641}
5642
b48d8916 5643static int brcmf_setup_wiphybands(struct wiphy *wiphy)
5b435de0 5644{
b48d8916 5645 struct brcmf_cfg80211_info *cfg = wiphy_priv(wiphy);
ac24be6f 5646 struct brcmf_if *ifp = netdev_priv(cfg_to_ndev(cfg));
18d6c535
AS		 5647 u32 nmode = 0;
5648 u32 vhtmode = 0;
b48d8916 5649 u32 bw_cap[2] = { WLC_BW_20MHZ_BIT, WLC_BW_20MHZ_BIT };
4aca7a18
DK		 5650 u32 rxchain;
5651 u32 nchain;
b48d8916 5652 int err;
d48200ba 5653 s32 i;
2375d970 5654 struct ieee80211_supported_band *band;
5b435de0 5655
18d6c535 5656 (void)brcmf_fil_iovar_int_get(ifp, "vhtmode", &vhtmode);
d48200ba
HM		 5657 err = brcmf_fil_iovar_int_get(ifp, "nmode", &nmode);
5658 if (err) {
5659 brcmf_err("nmode error (%d)\n", err);
5660 } else {
2375d970 5661 brcmf_get_bwcap(ifp, bw_cap);
d48200ba 5662 }
18d6c535
AS		 5663 brcmf_dbg(INFO, "nmode=%d, vhtmode=%d, bw_cap=(%d, %d)\n",
5664 nmode, vhtmode, bw_cap[IEEE80211_BAND_2GHZ],
5665 bw_cap[IEEE80211_BAND_5GHZ]);
d48200ba 5666
4aca7a18
DK		 5667 err = brcmf_fil_iovar_int_get(ifp, "rxchain", &rxchain);
5668 if (err) {
5669 brcmf_err("rxchain error (%d)\n", err);
5670 nchain = 1;
5671 } else {
5672 for (nchain = 0; rxchain; nchain++)
5673 rxchain = rxchain & (rxchain - 1);
5674 }
5675 brcmf_dbg(INFO, "nchain=%d\n", nchain);
5676
b48d8916 5677 err = brcmf_construct_chaninfo(cfg, bw_cap);
d48200ba 5678 if (err) {
b48d8916 5679 brcmf_err("brcmf_construct_chaninfo failed (%d)\n", err);
d48200ba
HM		 5680 return err;
5681 }
5682
b48d8916
AS		 5683 wiphy = cfg_to_wiphy(cfg);
5684 for (i = 0; i < ARRAY_SIZE(wiphy->bands); i++) {
5685 band = wiphy->bands[i];
5686 if (band == NULL)
2375d970 5687 continue;
d48200ba 5688
18d6c535
AS		 5689 if (nmode)
5690 brcmf_update_ht_cap(band, bw_cap, nchain);
5691 if (vhtmode)
5692 brcmf_update_vht_cap(band, bw_cap, nchain);
d48200ba
HM		 5693 }
5694
b48d8916 5695 return 0;
5b435de0
AS		 5696}
5697
aa70b4fa
AS		 5698static const struct ieee80211_txrx_stypes
5699brcmf_txrx_stypes[NUM_NL80211_IFTYPES] = {
5700 [NL80211_IFTYPE_STATION] = {
5701 .tx = 0xffff,
5702 .rx = BIT(IEEE80211_STYPE_ACTION >> 4) |
5703 BIT(IEEE80211_STYPE_PROBE_REQ >> 4)
5704 },
5705 [NL80211_IFTYPE_P2P_CLIENT] = {
5706 .tx = 0xffff,
5707 .rx = BIT(IEEE80211_STYPE_ACTION >> 4) |
5708 BIT(IEEE80211_STYPE_PROBE_REQ >> 4)
5709 },
5710 [NL80211_IFTYPE_P2P_GO] = {
5711 .tx = 0xffff,
5712 .rx = BIT(IEEE80211_STYPE_ASSOC_REQ >> 4) |
5713 BIT(IEEE80211_STYPE_REASSOC_REQ >> 4) |
5714 BIT(IEEE80211_STYPE_PROBE_REQ >> 4) |
5715 BIT(IEEE80211_STYPE_DISASSOC >> 4) |
5716 BIT(IEEE80211_STYPE_AUTH >> 4) |
5717 BIT(IEEE80211_STYPE_DEAUTH >> 4) |
5718 BIT(IEEE80211_STYPE_ACTION >> 4)
5719 },
5720 [NL80211_IFTYPE_P2P_DEVICE] = {
5721 .tx = 0xffff,
5722 .rx = BIT(IEEE80211_STYPE_ACTION >> 4) |
5723 BIT(IEEE80211_STYPE_PROBE_REQ >> 4)
5724 }
5725};
5726
0882dda3
AS		 5727/**
5728 * brcmf_setup_ifmodes() - determine interface modes and combinations.
5729 *
5730 * @wiphy: wiphy object.
5731 * @ifp: interface object needed for feat module api.
5732 *
5733 * The interface modes and combinations are determined dynamically here
5734 * based on firmware functionality.
5735 *
5736 * no p2p and no mbss:
5737 *
5738 * #STA <= 1, #AP <= 1, channels = 1, 2 total
5739 *
5740 * no p2p and mbss:
5741 *
5742 * #STA <= 1, #AP <= 1, channels = 1, 2 total
5743 * #AP <= 4, matching BI, channels = 1, 4 total
5744 *
5745 * p2p, no mchan, and mbss:
5746 *
5747 * #STA <= 1, #P2P-DEV <= 1, #{P2P-CL, P2P-GO} <= 1, channels = 1, 3 total
5748 * #STA <= 1, #P2P-DEV <= 1, #AP <= 1, #P2P-CL <= 1, channels = 1, 4 total
5749 * #AP <= 4, matching BI, channels = 1, 4 total
5750 *
5751 * p2p, mchan, and mbss:
5752 *
5753 * #STA <= 1, #P2P-DEV <= 1, #{P2P-CL, P2P-GO} <= 1, channels = 2, 3 total
5754 * #STA <= 1, #P2P-DEV <= 1, #AP <= 1, #P2P-CL <= 1, channels = 1, 4 total
5755 * #AP <= 4, matching BI, channels = 1, 4 total
5756 */
2e5f66fe
PF		 5757static int brcmf_setup_ifmodes(struct wiphy *wiphy, struct brcmf_if *ifp)
5758{
5759 struct ieee80211_iface_combination *combo = NULL;
0882dda3
AS		 5760 struct ieee80211_iface_limit *c0_limits = NULL;
5761 struct ieee80211_iface_limit *p2p_limits = NULL;
5762 struct ieee80211_iface_limit *mbss_limits = NULL;
5763 bool mbss, p2p;
5764 int i, c, n_combos;
5765
5766 mbss = brcmf_feat_is_enabled(ifp, BRCMF_FEAT_MBSS);
5767 p2p = brcmf_feat_is_enabled(ifp, BRCMF_FEAT_P2P);
2e5f66fe 5768
0882dda3
AS		 5769 n_combos = 1 + !!p2p + !!mbss;
5770 combo = kcalloc(n_combos, sizeof(*combo), GFP_KERNEL);
2e5f66fe
PF		 5771 if (!combo)
5772 goto err;
5773
0882dda3
AS		 5774 c0_limits = kcalloc(p2p ? 3 : 2, sizeof(*c0_limits), GFP_KERNEL);
5775 if (!c0_limits)
2e5f66fe
PF		 5776 goto err;
5777
0882dda3
AS		 5778 if (p2p) {
5779 p2p_limits = kcalloc(4, sizeof(*p2p_limits), GFP_KERNEL);
5780 if (!p2p_limits)
5781 goto err;
5782 }
5783
5784 if (mbss) {
5785 mbss_limits = kcalloc(1, sizeof(*mbss_limits), GFP_KERNEL);
5786 if (!mbss_limits)
5787 goto err;
5788 }
5789
2e5f66fe
PF		 5790 wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) |
5791 BIT(NL80211_IFTYPE_ADHOC) |
5792 BIT(NL80211_IFTYPE_AP);
5793
0882dda3
AS		 5794 c = 0;
5795 i = 0;
5796 combo[c].num_different_channels = 1;
5797 c0_limits[i].max = 1;
5798 c0_limits[i++].types = BIT(NL80211_IFTYPE_STATION);
5799 if (p2p) {
5800 if (brcmf_feat_is_enabled(ifp, BRCMF_FEAT_MCHAN))
5801 combo[c].num_different_channels = 2;
2e5f66fe
PF		 5802 wiphy->interface_modes |= BIT(NL80211_IFTYPE_P2P_CLIENT) |
5803 BIT(NL80211_IFTYPE_P2P_GO) |
5804 BIT(NL80211_IFTYPE_P2P_DEVICE);
0882dda3
AS		 5805 c0_limits[i].max = 1;
5806 c0_limits[i++].types = BIT(NL80211_IFTYPE_P2P_DEVICE);
5807 c0_limits[i].max = 1;
5808 c0_limits[i++].types = BIT(NL80211_IFTYPE_P2P_CLIENT) |
5809 BIT(NL80211_IFTYPE_P2P_GO);
5810 } else {
5811 c0_limits[i].max = 1;
5812 c0_limits[i++].types = BIT(NL80211_IFTYPE_AP);
5813 }
5814 combo[c].max_interfaces = i;
5815 combo[c].n_limits = i;
5816 combo[c].limits = c0_limits;
5817
5818 if (p2p) {
5819 c++;
5820 i = 0;
5821 combo[c].num_different_channels = 1;
5822 p2p_limits[i].max = 1;
5823 p2p_limits[i++].types = BIT(NL80211_IFTYPE_STATION);
5824 p2p_limits[i].max = 1;
5825 p2p_limits[i++].types = BIT(NL80211_IFTYPE_AP);
5826 p2p_limits[i].max = 1;
5827 p2p_limits[i++].types = BIT(NL80211_IFTYPE_P2P_CLIENT);
5828 p2p_limits[i].max = 1;
5829 p2p_limits[i++].types = BIT(NL80211_IFTYPE_P2P_DEVICE);
5830 combo[c].max_interfaces = i;
5831 combo[c].n_limits = i;
5832 combo[c].limits = p2p_limits;
5833 }
5834
5835 if (mbss) {
5836 c++;
5837 combo[c].beacon_int_infra_match = true;
5838 combo[c].num_different_channels = 1;
5839 mbss_limits[0].max = 4;
5840 mbss_limits[0].types = BIT(NL80211_IFTYPE_AP);
5841 combo[c].max_interfaces = 4;
5842 combo[c].n_limits = 1;
5843 combo[c].limits = mbss_limits;
5844 }
5845 wiphy->n_iface_combinations = n_combos;
2e5f66fe 5846 wiphy->iface_combinations = combo;
2e5f66fe
PF		 5847 return 0;
5848
5849err:
0882dda3
AS		 5850 kfree(c0_limits);
5851 kfree(p2p_limits);
5852 kfree(mbss_limits);
2e5f66fe
PF		 5853 kfree(combo);
5854 return -ENOMEM;
5855}
5856
aa70b4fa
AS		 5857static void brcmf_wiphy_pno_params(struct wiphy *wiphy)
5858{
5859 /* scheduled scan settings */
5860 wiphy->max_sched_scan_ssids = BRCMF_PNO_MAX_PFN_COUNT;
5861 wiphy->max_match_sets = BRCMF_PNO_MAX_PFN_COUNT;
5862 wiphy->max_sched_scan_ie_len = BRCMF_SCAN_IE_LEN_MAX;
5863 wiphy->flags |= WIPHY_FLAG_SUPPORTS_SCHED_SCAN;
5864}
5865
4eb3af7c
HM		 5866#ifdef CONFIG_PM
5867static const struct wiphy_wowlan_support brcmf_wowlan_support = {
5868 .flags = WIPHY_WOWLAN_MAGIC_PKT | WIPHY_WOWLAN_DISCONNECT,
b9a82f89
HM		 5869 .n_patterns = BRCMF_WOWL_MAXPATTERNS,
5870 .pattern_max_len = BRCMF_WOWL_MAXPATTERNSIZE,
5871 .pattern_min_len = 1,
5872 .max_pkt_offset = 1500,
4eb3af7c
HM		 5873};
5874#endif
5875
5876static void brcmf_wiphy_wowl_params(struct wiphy *wiphy)
5877{
5878#ifdef CONFIG_PM
5879 /* wowl settings */
5880 wiphy->wowlan = &brcmf_wowlan_support;
5881#endif
5882}
5883
b48d8916 5884static int brcmf_setup_wiphy(struct wiphy *wiphy, struct brcmf_if *ifp)
aa70b4fa 5885{
e3faa866 5886 struct brcmf_pub *drvr = ifp->drvr;
50f32e2d 5887 const struct ieee80211_iface_combination *combo;
58de92d2 5888 struct ieee80211_supported_band *band;
50f32e2d 5889 u16 max_interfaces = 0;
58de92d2
AS		 5890 __le32 bandlist[3];
5891 u32 n_bands;
5892 int err, i;
5893
aa70b4fa
AS		 5894 wiphy->max_scan_ssids = WL_NUM_SCAN_MAX;
5895 wiphy->max_scan_ie_len = BRCMF_SCAN_IE_LEN_MAX;
5896 wiphy->max_num_pmkids = WL_NUM_PMKIDS_MAX;
2e5f66fe
PF		 5897
5898 err = brcmf_setup_ifmodes(wiphy, ifp);
5899 if (err)
5900 return err;
5901
50f32e2d
RM		 5902 for (i = 0, combo = wiphy->iface_combinations;
5903 i < wiphy->n_iface_combinations; i++, combo++) {
5904 max_interfaces = max(max_interfaces, combo->max_interfaces);
5905 }
5906
5907 for (i = 0; i < max_interfaces && i < ARRAY_SIZE(drvr->addresses);
5908 i++) {
e3faa866
RM		 5909 u8 *addr = drvr->addresses[i].addr;
5910
5911 memcpy(addr, drvr->mac, ETH_ALEN);
5912 if (i) {
5913 addr[0] |= BIT(1);
5914 addr[ETH_ALEN - 1] ^= i;
5915 }
5916 }
5917 wiphy->addresses = drvr->addresses;
5918 wiphy->n_addresses = i;
5919
aa70b4fa
AS		 5920 wiphy->signal_type = CFG80211_SIGNAL_TYPE_MBM;
5921 wiphy->cipher_suites = __wl_cipher_suites;
5922 wiphy->n_cipher_suites = ARRAY_SIZE(__wl_cipher_suites);
5923 wiphy->flags |= WIPHY_FLAG_PS_ON_BY_DEFAULT |
5924 WIPHY_FLAG_OFFCHAN_TX |
5925 WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL |
5926 WIPHY_FLAG_SUPPORTS_TDLS;
5927 if (!brcmf_roamoff)
5928 wiphy->flags |= WIPHY_FLAG_SUPPORTS_FW_ROAM;
5929 wiphy->mgmt_stypes = brcmf_txrx_stypes;
5930 wiphy->max_remain_on_channel_duration = 5000;
7a7a87dc
AS		 5931 if (brcmf_feat_is_enabled(ifp, BRCMF_FEAT_PNO))
5932 brcmf_wiphy_pno_params(wiphy);
aa70b4fa
AS		 5933
5934 /* vendor commands/events support */
5935 wiphy->vendor_commands = brcmf_vendor_cmds;
5936 wiphy->n_vendor_commands = BRCMF_VNDR_CMDS_LAST - 1;
5937
4eb3af7c
HM		 5938 if (brcmf_feat_is_enabled(ifp, BRCMF_FEAT_WOWL))
5939 brcmf_wiphy_wowl_params(wiphy);
5940
58de92d2
AS		 5941 err = brcmf_fil_cmd_data_get(ifp, BRCMF_C_GET_BANDLIST, &bandlist,
5942 sizeof(bandlist));
5943 if (err) {
5944 brcmf_err("could not obtain band info: err=%d\n", err);
5945 return err;
5946 }
5947 /* first entry in bandlist is number of bands */
5948 n_bands = le32_to_cpu(bandlist[0]);
5949 for (i = 1; i <= n_bands && i < ARRAY_SIZE(bandlist); i++) {
5950 if (bandlist[i] == cpu_to_le32(WLC_BAND_2G)) {
5951 band = kmemdup(&__wl_band_2ghz, sizeof(__wl_band_2ghz),
5952 GFP_KERNEL);
5953 if (!band)
5954 return -ENOMEM;
5955
5956 band->channels = kmemdup(&__wl_2ghz_channels,
5957 sizeof(__wl_2ghz_channels),
5958 GFP_KERNEL);
5959 if (!band->channels) {
5960 kfree(band);
5961 return -ENOMEM;
5962 }
5963
5964 band->n_channels = ARRAY_SIZE(__wl_2ghz_channels);
5965 wiphy->bands[IEEE80211_BAND_2GHZ] = band;
5966 }
5967 if (bandlist[i] == cpu_to_le32(WLC_BAND_5G)) {
5968 band = kmemdup(&__wl_band_5ghz, sizeof(__wl_band_5ghz),
5969 GFP_KERNEL);
5970 if (!band)
5971 return -ENOMEM;
5972
5973 band->channels = kmemdup(&__wl_5ghz_channels,
5974 sizeof(__wl_5ghz_channels),
5975 GFP_KERNEL);
5976 if (!band->channels) {
5977 kfree(band);
5978 return -ENOMEM;
5979 }
5980
5981 band->n_channels = ARRAY_SIZE(__wl_5ghz_channels);
5982 wiphy->bands[IEEE80211_BAND_5GHZ] = band;
5983 }
5984 }
5985 err = brcmf_setup_wiphybands(wiphy);
5986 return err;
5b435de0
AS		 5987}
5988
27a68fe3 5989static s32 brcmf_config_dongle(struct brcmf_cfg80211_info *cfg)
5b435de0
AS		 5990{
5991 struct net_device *ndev;
5992 struct wireless_dev *wdev;
40a23296 5993 struct brcmf_if *ifp;
5b435de0
AS		 5994 s32 power_mode;
5995 s32 err = 0;
5996
27a68fe3 5997 if (cfg->dongle_up)
5b435de0
AS		 5998 return err;
5999
27a68fe3 6000 ndev = cfg_to_ndev(cfg);
5b435de0 6001 wdev = ndev->ieee80211_ptr;
40a23296
HM		 6002 ifp = netdev_priv(ndev);
6003
6004 /* make sure RF is ready for work */
6005 brcmf_fil_cmd_int_set(ifp, BRCMF_C_UP, 0);
5b435de0 6006
40a23296
HM		 6007 brcmf_dongle_scantime(ifp, WL_SCAN_CHANNEL_TIME,
6008 WL_SCAN_UNASSOC_TIME, WL_SCAN_PASSIVE_TIME);
5b435de0 6009
27a68fe3 6010 power_mode = cfg->pwr_save ? PM_FAST : PM_OFF;
40a23296 6011 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_PM, power_mode);
5b435de0
AS		 6012 if (err)
6013 goto default_conf_out;
647c9ae0
AS		 6014 brcmf_dbg(INFO, "power save set to %s\n",
6015 (power_mode ? "enabled" : "disabled"));
5b435de0 6016
68ca395f 6017 err = brcmf_dongle_roam(ifp, WL_BEACON_TIMEOUT);
5b435de0
AS		 6018 if (err)
6019 goto default_conf_out;
5dd161ff
FL		 6020 err = brcmf_cfg80211_change_iface(wdev->wiphy, ndev, wdev->iftype,
6021 NULL, NULL);
40a23296 6022 if (err)
5b435de0 6023 goto default_conf_out;
5b435de0 6024
b3657453
HM		 6025 brcmf_configure_arp_offload(ifp, true);
6026
27a68fe3 6027 cfg->dongle_up = true;
40a23296 6028default_conf_out:
5b435de0
AS		 6029
6030 return err;
6031
6032}
6033
bdf5ff51 6034static s32 __brcmf_cfg80211_up(struct brcmf_if *ifp)
5b435de0 6035{
c1179033 6036 set_bit(BRCMF_VIF_STATUS_READY, &ifp->vif->sme_state);
5b435de0 6037
bdf5ff51 6038 return brcmf_config_dongle(ifp->drvr->config);
5b435de0
AS		 6039}
6040
bdf5ff51 6041static s32 __brcmf_cfg80211_down(struct brcmf_if *ifp)
5b435de0 6042{
bdf5ff51 6043 struct brcmf_cfg80211_info *cfg = ifp->drvr->config;
c1179033 6044
5b435de0
AS		 6045 /*
6046 * While going down, if associated with AP disassociate
6047 * from AP to save power
6048 */
903e0eee 6049 if (check_vif_up(ifp->vif)) {
9b7a0ddc 6050 brcmf_link_down(ifp->vif, WLAN_REASON_UNSPECIFIED);
5b435de0
AS		 6051
6052 /* Make sure WPA_Supplicant receives all the event
6053 generated due to DISASSOC call to the fw to keep
6054 the state fw and WPA_Supplicant state consistent
6055 */
6056 brcmf_delay(500);
6057 }
6058
27a68fe3 6059 brcmf_abort_scanning(cfg);
c1179033 6060 clear_bit(BRCMF_VIF_STATUS_READY, &ifp->vif->sme_state);
5b435de0 6061
5b435de0
AS		 6062 return 0;
6063}
6064
bdf5ff51 6065s32 brcmf_cfg80211_up(struct net_device *ndev)
5b435de0 6066{
bdf5ff51
AS		 6067 struct brcmf_if *ifp = netdev_priv(ndev);
6068 struct brcmf_cfg80211_info *cfg = ifp->drvr->config;
5b435de0
AS		 6069 s32 err = 0;
6070
27a68fe3 6071 mutex_lock(&cfg->usr_sync);
bdf5ff51 6072 err = __brcmf_cfg80211_up(ifp);
27a68fe3 6073 mutex_unlock(&cfg->usr_sync);
5b435de0
AS		 6074
6075 return err;
6076}
6077
bdf5ff51 6078s32 brcmf_cfg80211_down(struct net_device *ndev)
5b435de0 6079{
bdf5ff51
AS		 6080 struct brcmf_if *ifp = netdev_priv(ndev);
6081 struct brcmf_cfg80211_info *cfg = ifp->drvr->config;
5b435de0
AS		 6082 s32 err = 0;
6083
27a68fe3 6084 mutex_lock(&cfg->usr_sync);
bdf5ff51 6085 err = __brcmf_cfg80211_down(ifp);
27a68fe3 6086 mutex_unlock(&cfg->usr_sync);
5b435de0
AS		 6087
6088 return err;
6089}
6090
a7965fbb
AS		 6091enum nl80211_iftype brcmf_cfg80211_get_iftype(struct brcmf_if *ifp)
6092{
6093 struct wireless_dev *wdev = &ifp->vif->wdev;
6094
6095 return wdev->iftype;
6096}
6097
bfe81975
HM		 6098bool brcmf_get_vif_state_any(struct brcmf_cfg80211_info *cfg,
6099 unsigned long state)
9f440b7b
AS		 6100{
6101 struct brcmf_cfg80211_vif *vif;
9f440b7b
AS		 6102
6103 list_for_each_entry(vif, &cfg->vif_list, list) {
6104 if (test_bit(state, &vif->sme_state))
e843bb19 6105 return true;
9f440b7b 6106 }
e843bb19 6107 return false;
9f440b7b 6108}
d3c0b633
AS		 6109
6110static inline bool vif_event_equals(struct brcmf_cfg80211_vif_event *event,
6111 u8 action)
6112{
6113 u8 evt_action;
6114
6115 mutex_lock(&event->vif_event_lock);
6116 evt_action = event->action;
6117 mutex_unlock(&event->vif_event_lock);
6118 return evt_action == action;
6119}
6120
6121void brcmf_cfg80211_arm_vif_event(struct brcmf_cfg80211_info *cfg,
6122 struct brcmf_cfg80211_vif *vif)
6123{
6124 struct brcmf_cfg80211_vif_event *event = &cfg->vif_event;
6125
6126 mutex_lock(&event->vif_event_lock);
6127 event->vif = vif;
6128 event->action = 0;
6129 mutex_unlock(&event->vif_event_lock);
6130}
6131
6132bool brcmf_cfg80211_vif_event_armed(struct brcmf_cfg80211_info *cfg)
6133{
6134 struct brcmf_cfg80211_vif_event *event = &cfg->vif_event;
6135 bool armed;
6136
6137 mutex_lock(&event->vif_event_lock);
6138 armed = event->vif != NULL;
6139 mutex_unlock(&event->vif_event_lock);
6140
6141 return armed;
6142}
6143int brcmf_cfg80211_wait_vif_event_timeout(struct brcmf_cfg80211_info *cfg,
6144 u8 action, ulong timeout)
6145{
6146 struct brcmf_cfg80211_vif_event *event = &cfg->vif_event;
6147
6148 return wait_event_timeout(event->vif_wq,
6149 vif_event_equals(event, action), timeout);
6150}
6151
63db1a49
AS		 6152static void brcmf_cfg80211_reg_notifier(struct wiphy *wiphy,
6153 struct regulatory_request *req)
6154{
6155 struct brcmf_cfg80211_info *cfg = wiphy_priv(wiphy);
6156 struct brcmf_if *ifp = netdev_priv(cfg_to_ndev(cfg));
6157 struct brcmf_fil_country_le ccreq;
6158 int i;
6159
6160 brcmf_dbg(TRACE, "enter: initiator=%d, alpha=%c%c\n", req->initiator,
6161 req->alpha2[0], req->alpha2[1]);
6162
6163 /* ignore non-ISO3166 country codes */
6164 for (i = 0; i < sizeof(req->alpha2); i++)
6165 if (req->alpha2[i] < 'A' || req->alpha2[i] > 'Z') {
6166 brcmf_err("not a ISO3166 code\n");
6167 return;
6168 }
6169 memset(&ccreq, 0, sizeof(ccreq));
6170 ccreq.rev = cpu_to_le32(-1);
6171 memcpy(ccreq.ccode, req->alpha2, sizeof(req->alpha2));
8afe0ece
AS		 6172 if (brcmf_fil_iovar_data_set(ifp, "country", &ccreq, sizeof(ccreq))) {
6173 brcmf_err("firmware rejected country setting\n");
6174 return;
6175 }
6176 brcmf_setup_wiphybands(wiphy);
63db1a49
AS		 6177}
6178
b48d8916
AS		 6179static void brcmf_free_wiphy(struct wiphy *wiphy)
6180{
0882dda3
AS		 6181 int i;
6182
58de92d2
AS		 6183 if (!wiphy)
6184 return;
6185
0882dda3
AS		 6186 if (wiphy->iface_combinations) {
6187 for (i = 0; i < wiphy->n_iface_combinations; i++)
6188 kfree(wiphy->iface_combinations[i].limits);
6189 }
b48d8916
AS		 6190 kfree(wiphy->iface_combinations);
6191 if (wiphy->bands[IEEE80211_BAND_2GHZ]) {
6192 kfree(wiphy->bands[IEEE80211_BAND_2GHZ]->channels);
6193 kfree(wiphy->bands[IEEE80211_BAND_2GHZ]);
6194 }
6195 if (wiphy->bands[IEEE80211_BAND_5GHZ]) {
6196 kfree(wiphy->bands[IEEE80211_BAND_5GHZ]->channels);
6197 kfree(wiphy->bands[IEEE80211_BAND_5GHZ]);
6198 }
6199 wiphy_free(wiphy);
6200}
6201
ccfd1e81 6202struct brcmf_cfg80211_info *brcmf_cfg80211_attach(struct brcmf_pub *drvr,
ae7c03f6
HM		 6203 struct device *busdev,
6204 bool p2pdev_forced)
ccfd1e81 6205{
46f3b6ee 6206 struct net_device *ndev = brcmf_get_ifp(drvr, 0)->ndev;
ccfd1e81
AS		 6207 struct brcmf_cfg80211_info *cfg;
6208 struct wiphy *wiphy;
6209 struct brcmf_cfg80211_vif *vif;
6210 struct brcmf_if *ifp;
6211 s32 err = 0;
6212 s32 io_type;
b48d8916 6213 u16 *cap = NULL;
ccfd1e81
AS		 6214
6215 if (!ndev) {
6216 brcmf_err("ndev is invalid\n");
6217 return NULL;
6218 }
6219
6220 ifp = netdev_priv(ndev);
b48d8916
AS		 6221 wiphy = wiphy_new(&wl_cfg80211_ops, sizeof(struct brcmf_cfg80211_info));
6222 if (!wiphy) {
6223 brcmf_err("Could not allocate wiphy device\n");
ccfd1e81 6224 return NULL;
b48d8916 6225 }
6896f4fb 6226 memcpy(wiphy->perm_addr, drvr->mac, ETH_ALEN);
b48d8916 6227 set_wiphy_dev(wiphy, busdev);
ccfd1e81
AS		 6228
6229 cfg = wiphy_priv(wiphy);
6230 cfg->wiphy = wiphy;
6231 cfg->pub = drvr;
6232 init_vif_event(&cfg->vif_event);
6233 INIT_LIST_HEAD(&cfg->vif_list);
6234
6235 vif = brcmf_alloc_vif(cfg, NL80211_IFTYPE_STATION, false);
b48d8916
AS		 6236 if (IS_ERR(vif))
6237 goto wiphy_out;
ccfd1e81
AS		 6238
6239 vif->ifp = ifp;
6240 vif->wdev.netdev = ndev;
6241 ndev->ieee80211_ptr = &vif->wdev;
6242 SET_NETDEV_DEV(ndev, wiphy_dev(cfg->wiphy));
6243
6244 err = wl_init_priv(cfg);
6245 if (err) {
6246 brcmf_err("Failed to init iwm_priv (%d)\n", err);
b48d8916
AS		 6247 brcmf_free_vif(vif);
6248 goto wiphy_out;
ccfd1e81
AS		 6249 }
6250 ifp->vif = vif;
6251
b48d8916
AS		 6252 /* determine d11 io type before wiphy setup */
6253 err = brcmf_fil_cmd_int_get(ifp, BRCMF_C_GET_VERSION, &io_type);
ccfd1e81 6254 if (err) {
b48d8916
AS		 6255 brcmf_err("Failed to get D11 version (%d)\n", err);
6256 goto priv_out;
ccfd1e81 6257 }
b48d8916
AS		 6258 cfg->d11inf.io_type = (u8)io_type;
6259 brcmu_d11_attach(&cfg->d11inf);
6260
6261 err = brcmf_setup_wiphy(wiphy, ifp);
6262 if (err < 0)
6263 goto priv_out;
6264
6265 brcmf_dbg(INFO, "Registering custom regulatory\n");
63db1a49 6266 wiphy->reg_notifier = brcmf_cfg80211_reg_notifier;
b48d8916
AS		 6267 wiphy->regulatory_flags |= REGULATORY_CUSTOM_REG;
6268 wiphy_apply_custom_regulatory(wiphy, &brcmf_regdom);
6269
6270 /* firmware defaults to 40MHz disabled in 2G band. We signal
6271 * cfg80211 here that we do and have it decide we can enable
6272 * it. But first check if device does support 2G operation.
6273 */
6274 if (wiphy->bands[IEEE80211_BAND_2GHZ]) {
6275 cap = &wiphy->bands[IEEE80211_BAND_2GHZ]->ht_cap.cap;
6276 *cap |= IEEE80211_HT_CAP_SUP_WIDTH_20_40;
6277 }
6278 err = wiphy_register(wiphy);
6279 if (err < 0) {
6280 brcmf_err("Could not register wiphy device (%d)\n", err);
6281 goto priv_out;
ccfd1e81
AS		 6282 }
6283
6284 /* If cfg80211 didn't disable 40MHz HT CAP in wiphy_register(),
6285 * setup 40MHz in 2GHz band and enable OBSS scanning.
6286 */
b48d8916
AS		 6287 if (cap && (*cap & IEEE80211_HT_CAP_SUP_WIDTH_20_40)) {
6288 err = brcmf_enable_bw40_2g(cfg);
ccfd1e81
AS		 6289 if (!err)
6290 err = brcmf_fil_iovar_int_set(ifp, "obss_coex",
6291 BRCMF_OBSS_COEX_AUTO);
b48d8916
AS		 6292 else
6293 *cap &= ~IEEE80211_HT_CAP_SUP_WIDTH_20_40;
ccfd1e81 6294 }
2b76acdb
HM		 6295 /* p2p might require that "if-events" get processed by fweh. So
6296 * activate the already registered event handlers now and activate
6297 * the rest when initialization has completed. drvr->config needs to
6298 * be assigned before activating events.
6299 */
6300 drvr->config = cfg;
6301 err = brcmf_fweh_activate_events(ifp);
6302 if (err) {
6303 brcmf_err("FWEH activation failed (%d)\n", err);
6304 goto wiphy_unreg_out;
6305 }
ccfd1e81 6306
ae7c03f6 6307 err = brcmf_p2p_attach(cfg, p2pdev_forced);
ccfd1e81 6308 if (err) {
b48d8916
AS		 6309 brcmf_err("P2P initilisation failed (%d)\n", err);
6310 goto wiphy_unreg_out;
6311 }
6312 err = brcmf_btcoex_attach(cfg);
6313 if (err) {
6314 brcmf_err("BT-coex initialisation failed (%d)\n", err);
6315 brcmf_p2p_detach(&cfg->p2p);
6316 goto wiphy_unreg_out;
ccfd1e81
AS		 6317 }
6318
b48d8916 6319 err = brcmf_fil_iovar_int_set(ifp, "tdls_enable", 1);
ccfd1e81 6320 if (err) {
b48d8916
AS		 6321 brcmf_dbg(INFO, "TDLS not enabled (%d)\n", err);
6322 wiphy->flags &= ~WIPHY_FLAG_SUPPORTS_TDLS;
70b7d94b
HM		 6323 } else {
6324 brcmf_fweh_register(cfg->pub, BRCMF_E_TDLS_PEER_EVENT,
6325 brcmf_notify_tdls_peer_event);
ccfd1e81 6326 }
ccfd1e81 6327
2b76acdb
HM		 6328 /* (re-) activate FWEH event handling */
6329 err = brcmf_fweh_activate_events(ifp);
6330 if (err) {
6331 brcmf_err("FWEH activation failed (%d)\n", err);
6332 goto wiphy_unreg_out;
6333 }
6334
ccfd1e81
AS		 6335 return cfg;
6336
b48d8916
AS		 6337wiphy_unreg_out:
6338 wiphy_unregister(cfg->wiphy);
6339priv_out:
ccfd1e81 6340 wl_deinit_priv(cfg);
ccfd1e81 6341 brcmf_free_vif(vif);
2b5d348e 6342 ifp->vif = NULL;
b48d8916
AS		 6343wiphy_out:
6344 brcmf_free_wiphy(wiphy);
ccfd1e81
AS		 6345 return NULL;
6346}
6347
6348void brcmf_cfg80211_detach(struct brcmf_cfg80211_info *cfg)
6349{
6350 if (!cfg)
6351 return;
6352
ccfd1e81 6353 brcmf_btcoex_detach(cfg);
f7a40873 6354 wiphy_unregister(cfg->wiphy);
ccfd1e81 6355 wl_deinit_priv(cfg);
b48d8916 6356 brcmf_free_wiphy(cfg->wiphy);
ccfd1e81 6357}
Ubuntu Hirsute Linux kernel mirror