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