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