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