projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
brcmfmac: Add length checks on firmware events
[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
3021ad9a
HM		 98#define BRCMF_ND_INFO_TIMEOUT msecs_to_jiffies(2000)
99
5b435de0
AS		 100#define BRCMF_ASSOC_PARAMS_FIXED_SIZE \
101 (sizeof(struct brcmf_assoc_params_le) - sizeof(u16))
102
ce81e317 103static bool check_vif_up(struct brcmf_cfg80211_vif *vif)
5b435de0 104{
c1179033 105 if (!test_bit(BRCMF_VIF_STATUS_READY, &vif->sme_state)) {
647c9ae0
AS		 106 brcmf_dbg(INFO, "device is not ready : status (%lu)\n",
107 vif->sme_state);
5b435de0
AS		 108 return false;
109 }
110 return true;
111}
112
5b435de0
AS		 113#define RATE_TO_BASE100KBPS(rate) (((rate) * 10) / 2)
114#define RATETAB_ENT(_rateid, _flags) \
115 { \
116 .bitrate = RATE_TO_BASE100KBPS(_rateid), \
117 .hw_value = (_rateid), \
118 .flags = (_flags), \
119 }
120
121static struct ieee80211_rate __wl_rates[] = {
122 RATETAB_ENT(BRCM_RATE_1M, 0),
123 RATETAB_ENT(BRCM_RATE_2M, IEEE80211_RATE_SHORT_PREAMBLE),
124 RATETAB_ENT(BRCM_RATE_5M5, IEEE80211_RATE_SHORT_PREAMBLE),
125 RATETAB_ENT(BRCM_RATE_11M, IEEE80211_RATE_SHORT_PREAMBLE),
126 RATETAB_ENT(BRCM_RATE_6M, 0),
127 RATETAB_ENT(BRCM_RATE_9M, 0),
128 RATETAB_ENT(BRCM_RATE_12M, 0),
129 RATETAB_ENT(BRCM_RATE_18M, 0),
130 RATETAB_ENT(BRCM_RATE_24M, 0),
131 RATETAB_ENT(BRCM_RATE_36M, 0),
132 RATETAB_ENT(BRCM_RATE_48M, 0),
133 RATETAB_ENT(BRCM_RATE_54M, 0),
134};
135
5b435de0 136#define wl_g_rates (__wl_rates + 0)
58de92d2
AS		 137#define wl_g_rates_size ARRAY_SIZE(__wl_rates)
138#define wl_a_rates (__wl_rates + 4)
139#define wl_a_rates_size (wl_g_rates_size - 4)
140
141#define CHAN2G(_channel, _freq) { \
142 .band = IEEE80211_BAND_2GHZ, \
143 .center_freq = (_freq), \
144 .hw_value = (_channel), \
145 .flags = IEEE80211_CHAN_DISABLED, \
146 .max_antenna_gain = 0, \
147 .max_power = 30, \
148}
149
150#define CHAN5G(_channel) { \
151 .band = IEEE80211_BAND_5GHZ, \
152 .center_freq = 5000 + (5 * (_channel)), \
153 .hw_value = (_channel), \
154 .flags = IEEE80211_CHAN_DISABLED, \
155 .max_antenna_gain = 0, \
156 .max_power = 30, \
157}
158
159static struct ieee80211_channel __wl_2ghz_channels[] = {
160 CHAN2G(1, 2412), CHAN2G(2, 2417), CHAN2G(3, 2422), CHAN2G(4, 2427),
161 CHAN2G(5, 2432), CHAN2G(6, 2437), CHAN2G(7, 2442), CHAN2G(8, 2447),
162 CHAN2G(9, 2452), CHAN2G(10, 2457), CHAN2G(11, 2462), CHAN2G(12, 2467),
163 CHAN2G(13, 2472), CHAN2G(14, 2484)
164};
165
166static struct ieee80211_channel __wl_5ghz_channels[] = {
167 CHAN5G(34), CHAN5G(36), CHAN5G(38), CHAN5G(40), CHAN5G(42),
168 CHAN5G(44), CHAN5G(46), CHAN5G(48), CHAN5G(52), CHAN5G(56),
169 CHAN5G(60), CHAN5G(64), CHAN5G(100), CHAN5G(104), CHAN5G(108),
170 CHAN5G(112), CHAN5G(116), CHAN5G(120), CHAN5G(124), CHAN5G(128),
171 CHAN5G(132), CHAN5G(136), CHAN5G(140), CHAN5G(144), CHAN5G(149),
172 CHAN5G(153), CHAN5G(157), CHAN5G(161), CHAN5G(165)
173};
5b435de0 174
b48d8916 175/* Band templates duplicated per wiphy. The channel info
58de92d2 176 * above is added to the band during setup.
b48d8916
AS		 177 */
178static const struct ieee80211_supported_band __wl_band_2ghz = {
5b435de0 179 .band = IEEE80211_BAND_2GHZ,
5b435de0
AS		 180 .bitrates = wl_g_rates,
181 .n_bitrates = wl_g_rates_size,
182};
183
58de92d2 184static const struct ieee80211_supported_band __wl_band_5ghz = {
5b435de0 185 .band = IEEE80211_BAND_5GHZ,
5b435de0
AS		 186 .bitrates = wl_a_rates,
187 .n_bitrates = wl_a_rates_size,
188};
189
d48200ba
HM		 190/* This is to override regulatory domains defined in cfg80211 module (reg.c)
191 * By default world regulatory domain defined in reg.c puts the flags
8fe02e16
LR		 192 * NL80211_RRF_NO_IR for 5GHz channels (for * 36..48 and 149..165).
193 * With respect to these flags, wpa_supplicant doesn't * start p2p
194 * operations on 5GHz channels. All the changes in world regulatory
d48200ba
HM		 195 * domain are to be done here.
196 */
197static const struct ieee80211_regdomain brcmf_regdom = {
198 .n_reg_rules = 4,
199 .alpha2 = "99",
200 .reg_rules = {
201 /* IEEE 802.11b/g, channels 1..11 */
202 REG_RULE(2412-10, 2472+10, 40, 6, 20, 0),
203 /* If any */
204 /* IEEE 802.11 channel 14 - Only JP enables
205 * this and for 802.11b only
206 */
207 REG_RULE(2484-10, 2484+10, 20, 6, 20, 0),
208 /* IEEE 802.11a, channel 36..64 */
c555ecde 209 REG_RULE(5150-10, 5350+10, 80, 6, 20, 0),
d48200ba 210 /* IEEE 802.11a, channel 100..165 */
c555ecde 211 REG_RULE(5470-10, 5850+10, 80, 6, 20, 0), }
5b435de0
AS		 212};
213
214static const u32 __wl_cipher_suites[] = {
215 WLAN_CIPHER_SUITE_WEP40,
216 WLAN_CIPHER_SUITE_WEP104,
217 WLAN_CIPHER_SUITE_TKIP,
218 WLAN_CIPHER_SUITE_CCMP,
219 WLAN_CIPHER_SUITE_AES_CMAC,
220};
221
1a873342
HM		 222/* Vendor specific ie. id = 221, oui and type defines exact ie */
223struct brcmf_vs_tlv {
224 u8 id;
225 u8 len;
226 u8 oui[3];
227 u8 oui_type;
228};
229
230struct parsed_vndr_ie_info {
231 u8 *ie_ptr;
232 u32 ie_len; /* total length including id & length field */
233 struct brcmf_vs_tlv vndrie;
234};
235
236struct parsed_vndr_ies {
237 u32 count;
9f440b7b 238 struct parsed_vndr_ie_info ie_info[VNDR_IE_PARSE_LIMIT];
1a873342
HM		 239};
240
5a394eba
AS		 241static u16 chandef_to_chanspec(struct brcmu_d11inf *d11inf,
242 struct cfg80211_chan_def *ch)
600a897d
AS		 243{
244 struct brcmu_chan ch_inf;
245 s32 primary_offset;
246
247 brcmf_dbg(TRACE, "chandef: control %d center %d width %d\n",
248 ch->chan->center_freq, ch->center_freq1, ch->width);
249 ch_inf.chnum = ieee80211_frequency_to_channel(ch->center_freq1);
36e8072e 250 primary_offset = ch->chan->center_freq - ch->center_freq1;
600a897d
AS		 251 switch (ch->width) {
252 case NL80211_CHAN_WIDTH_20:
0cd75b19 253 case NL80211_CHAN_WIDTH_20_NOHT:
600a897d
AS		 254 ch_inf.bw = BRCMU_CHAN_BW_20;
255 WARN_ON(primary_offset != 0);
256 break;
257 case NL80211_CHAN_WIDTH_40:
258 ch_inf.bw = BRCMU_CHAN_BW_40;
36e8072e 259 if (primary_offset > 0)
600a897d
AS		 260 ch_inf.sb = BRCMU_CHAN_SB_U;
261 else
262 ch_inf.sb = BRCMU_CHAN_SB_L;
263 break;
264 case NL80211_CHAN_WIDTH_80:
265 ch_inf.bw = BRCMU_CHAN_BW_80;
36e8072e
RM		 266 if (primary_offset == -30)
267 ch_inf.sb = BRCMU_CHAN_SB_LL;
268 else if (primary_offset == -10)
269 ch_inf.sb = BRCMU_CHAN_SB_LU;
270 else if (primary_offset == 10)
271 ch_inf.sb = BRCMU_CHAN_SB_UL;
272 else
273 ch_inf.sb = BRCMU_CHAN_SB_UU;
600a897d 274 break;
0cd75b19
AS		 275 case NL80211_CHAN_WIDTH_80P80:
276 case NL80211_CHAN_WIDTH_160:
277 case NL80211_CHAN_WIDTH_5:
278 case NL80211_CHAN_WIDTH_10:
600a897d
AS		 279 default:
280 WARN_ON_ONCE(1);
281 }
282 switch (ch->chan->band) {
283 case IEEE80211_BAND_2GHZ:
284 ch_inf.band = BRCMU_CHAN_BAND_2G;
285 break;
286 case IEEE80211_BAND_5GHZ:
287 ch_inf.band = BRCMU_CHAN_BAND_5G;
288 break;
0cd75b19 289 case IEEE80211_BAND_60GHZ:
600a897d
AS		 290 default:
291 WARN_ON_ONCE(1);
292 }
293 d11inf->encchspec(&ch_inf);
294
295 return ch_inf.chspec;
296}
297
83cf17aa
FL		 298u16 channel_to_chanspec(struct brcmu_d11inf *d11inf,
299 struct ieee80211_channel *ch)
6e186166 300{
83cf17aa 301 struct brcmu_chan ch_inf;
6e186166 302
83cf17aa
FL		 303 ch_inf.chnum = ieee80211_frequency_to_channel(ch->center_freq);
304 ch_inf.bw = BRCMU_CHAN_BW_20;
305 d11inf->encchspec(&ch_inf);
6e186166 306
83cf17aa 307 return ch_inf.chspec;
6e186166
AS		 308}
309
89286dc9
HM		 310/* Traverse a string of 1-byte tag/1-byte length/variable-length value
311 * triples, returning a pointer to the substring whose first element
312 * matches tag
313 */
4b5800fe
JB		 314const struct brcmf_tlv *
315brcmf_parse_tlvs(const void *buf, int buflen, uint key)
89286dc9 316{
4b5800fe
JB		 317 const struct brcmf_tlv *elt = buf;
318 int totlen = buflen;
89286dc9
HM		 319
320 /* find tagged parameter */
321 while (totlen >= TLV_HDR_LEN) {
322 int len = elt->len;
323
324 /* validate remaining totlen */
325 if ((elt->id == key) && (totlen >= (len + TLV_HDR_LEN)))
326 return elt;
327
328 elt = (struct brcmf_tlv *)((u8 *)elt + (len + TLV_HDR_LEN));
329 totlen -= (len + TLV_HDR_LEN);
330 }
331
332 return NULL;
333}
334
335/* Is any of the tlvs the expected entry? If
336 * not update the tlvs buffer pointer/length.
337 */
338static bool
4b5800fe
JB		 339brcmf_tlv_has_ie(const u8 *ie, const u8 **tlvs, u32 *tlvs_len,
340 const u8 *oui, u32 oui_len, u8 type)
89286dc9
HM		 341{
342 /* If the contents match the OUI and the type */
343 if (ie[TLV_LEN_OFF] >= oui_len + 1 &&
344 !memcmp(&ie[TLV_BODY_OFF], oui, oui_len) &&
345 type == ie[TLV_BODY_OFF + oui_len]) {
346 return true;
347 }
348
349 if (tlvs == NULL)
350 return false;
351 /* point to the next ie */
352 ie += ie[TLV_LEN_OFF] + TLV_HDR_LEN;
353 /* calculate the length of the rest of the buffer */
354 *tlvs_len -= (int)(ie - *tlvs);
355 /* update the pointer to the start of the buffer */
356 *tlvs = ie;
357
358 return false;
359}
360
361static struct brcmf_vs_tlv *
4b5800fe 362brcmf_find_wpaie(const u8 *parse, u32 len)
89286dc9 363{
4b5800fe 364 const struct brcmf_tlv *ie;
89286dc9
HM		 365
366 while ((ie = brcmf_parse_tlvs(parse, len, WLAN_EID_VENDOR_SPECIFIC))) {
4b5800fe 367 if (brcmf_tlv_has_ie((const u8 *)ie, &parse, &len,
89286dc9
HM		 368 WPA_OUI, TLV_OUI_LEN, WPA_OUI_TYPE))
369 return (struct brcmf_vs_tlv *)ie;
370 }
371 return NULL;
372}
373
374static struct brcmf_vs_tlv *
4b5800fe 375brcmf_find_wpsie(const u8 *parse, u32 len)
89286dc9 376{
4b5800fe 377 const struct brcmf_tlv *ie;
89286dc9
HM		 378
379 while ((ie = brcmf_parse_tlvs(parse, len, WLAN_EID_VENDOR_SPECIFIC))) {
380 if (brcmf_tlv_has_ie((u8 *)ie, &parse, &len,
381 WPA_OUI, TLV_OUI_LEN, WPS_OUI_TYPE))
382 return (struct brcmf_vs_tlv *)ie;
383 }
384 return NULL;
385}
386
39504a2d
AS		 387static int brcmf_vif_change_validate(struct brcmf_cfg80211_info *cfg,
388 struct brcmf_cfg80211_vif *vif,
389 enum nl80211_iftype new_type)
390{
391 int iftype_num[NUM_NL80211_IFTYPES];
392 struct brcmf_cfg80211_vif *pos;
353c46ac
AS		 393 bool check_combos = false;
394 int ret = 0;
39504a2d
AS		 395
396 memset(&iftype_num[0], 0, sizeof(iftype_num));
397 list_for_each_entry(pos, &cfg->vif_list, list)
353c46ac 398 if (pos == vif) {
39504a2d 399 iftype_num[new_type]++;
353c46ac
AS		 400 } else {
401 /* concurrent interfaces so need check combinations */
402 check_combos = true;
39504a2d 403 iftype_num[pos->wdev.iftype]++;
353c46ac
AS		 404 }
405
406 if (check_combos)
407 ret = cfg80211_check_combinations(cfg->wiphy, 1, 0, iftype_num);
39504a2d 408
353c46ac 409 return ret;
39504a2d
AS		 410}
411
412static int brcmf_vif_add_validate(struct brcmf_cfg80211_info *cfg,
413 enum nl80211_iftype new_type)
414{
415 int iftype_num[NUM_NL80211_IFTYPES];
416 struct brcmf_cfg80211_vif *pos;
417
418 memset(&iftype_num[0], 0, sizeof(iftype_num));
419 list_for_each_entry(pos, &cfg->vif_list, list)
420 iftype_num[pos->wdev.iftype]++;
421
422 iftype_num[new_type]++;
423 return cfg80211_check_combinations(cfg->wiphy, 1, 0, iftype_num);
424}
89286dc9 425
5b435de0
AS		 426static void convert_key_from_CPU(struct brcmf_wsec_key *key,
427 struct brcmf_wsec_key_le *key_le)
428{
429 key_le->index = cpu_to_le32(key->index);
430 key_le->len = cpu_to_le32(key->len);
431 key_le->algo = cpu_to_le32(key->algo);
432 key_le->flags = cpu_to_le32(key->flags);
433 key_le->rxiv.hi = cpu_to_le32(key->rxiv.hi);
434 key_le->rxiv.lo = cpu_to_le16(key->rxiv.lo);
435 key_le->iv_initialized = cpu_to_le32(key->iv_initialized);
436 memcpy(key_le->data, key->data, sizeof(key->data));
437 memcpy(key_le->ea, key->ea, sizeof(key->ea));
438}
439
f09d0c02 440static int
118eb304 441send_key_to_dongle(struct brcmf_if *ifp, struct brcmf_wsec_key *key)
5b435de0
AS		 442{
443 int err;
444 struct brcmf_wsec_key_le key_le;
445
446 convert_key_from_CPU(key, &key_le);
f09d0c02 447
118eb304 448 brcmf_netdev_wait_pend8021x(ifp);
81f5dcb8 449
118eb304 450 err = brcmf_fil_bsscfg_data_set(ifp, "wsec_key", &key_le,
81f5dcb8 451 sizeof(key_le));
f09d0c02 452
5b435de0 453 if (err)
57d6e91a 454 brcmf_err("wsec_key error (%d)\n", err);
5b435de0
AS		 455 return err;
456}
457
b3657453
HM		 458static s32
459brcmf_configure_arp_offload(struct brcmf_if *ifp, bool enable)
460{
461 s32 err;
462 u32 mode;
463
464 if (enable)
465 mode = BRCMF_ARP_OL_AGENT | BRCMF_ARP_OL_PEER_AUTO_REPLY;
466 else
467 mode = 0;
468
469 /* Try to set and enable ARP offload feature, this may fail, then it */
470 /* is simply not supported and err 0 will be returned */
471 err = brcmf_fil_iovar_int_set(ifp, "arp_ol", mode);
472 if (err) {
473 brcmf_dbg(TRACE, "failed to set ARP offload mode to 0x%x, err = %d\n",
474 mode, err);
475 err = 0;
476 } else {
477 err = brcmf_fil_iovar_int_set(ifp, "arpoe", enable);
478 if (err) {
479 brcmf_dbg(TRACE, "failed to configure (%d) ARP offload err = %d\n",
480 enable, err);
481 err = 0;
482 } else
483 brcmf_dbg(TRACE, "successfully configured (%d) ARP offload to 0x%x\n",
484 enable, mode);
485 }
486
487 return err;
488}
489
8851cce0
HM		 490static void
491brcmf_cfg80211_update_proto_addr_mode(struct wireless_dev *wdev)
492{
8f2b4597
AS		 493 struct brcmf_cfg80211_vif *vif;
494 struct brcmf_if *ifp;
495
496 vif = container_of(wdev, struct brcmf_cfg80211_vif, wdev);
497 ifp = vif->ifp;
8851cce0
HM		 498
499 if ((wdev->iftype == NL80211_IFTYPE_ADHOC) ||
500 (wdev->iftype == NL80211_IFTYPE_AP) ||
501 (wdev->iftype == NL80211_IFTYPE_P2P_GO))
502 brcmf_proto_configure_addr_mode(ifp->drvr, ifp->ifidx,
503 ADDR_DIRECT);
504 else
505 brcmf_proto_configure_addr_mode(ifp->drvr, ifp->ifidx,
506 ADDR_INDIRECT);
507}
508
a44aa400
HM		 509static int brcmf_cfg80211_request_ap_if(struct brcmf_if *ifp)
510{
511 struct brcmf_mbss_ssid_le mbss_ssid_le;
512 int bsscfgidx;
513 int err;
514
515 memset(&mbss_ssid_le, 0, sizeof(mbss_ssid_le));
516 bsscfgidx = brcmf_get_next_free_bsscfgidx(ifp->drvr);
517 if (bsscfgidx < 0)
518 return bsscfgidx;
519
520 mbss_ssid_le.bsscfgidx = cpu_to_le32(bsscfgidx);
521 mbss_ssid_le.SSID_len = cpu_to_le32(5);
522 sprintf(mbss_ssid_le.SSID, "ssid%d" , bsscfgidx);
523
524 err = brcmf_fil_bsscfg_data_set(ifp, "bsscfg:ssid", &mbss_ssid_le,
525 sizeof(mbss_ssid_le));
526 if (err < 0)
527 brcmf_err("setting ssid failed %d\n", err);
528
529 return err;
530}
531
532/**
533 * brcmf_ap_add_vif() - create a new AP virtual interface for multiple BSS
534 *
535 * @wiphy: wiphy device of new interface.
536 * @name: name of the new interface.
537 * @flags: not used.
538 * @params: contains mac address for AP device.
539 */
540static
541struct wireless_dev *brcmf_ap_add_vif(struct wiphy *wiphy, const char *name,
542 u32 *flags, struct vif_params *params)
543{
544 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy);
545 struct brcmf_if *ifp = netdev_priv(cfg_to_ndev(cfg));
546 struct brcmf_cfg80211_vif *vif;
547 int err;
548
549 if (brcmf_cfg80211_vif_event_armed(cfg))
550 return ERR_PTR(-EBUSY);
551
552 brcmf_dbg(INFO, "Adding vif \"%s\"\n", name);
553
554 vif = brcmf_alloc_vif(cfg, NL80211_IFTYPE_AP, false);
555 if (IS_ERR(vif))
556 return (struct wireless_dev *)vif;
557
558 brcmf_cfg80211_arm_vif_event(cfg, vif);
559
560 err = brcmf_cfg80211_request_ap_if(ifp);
561 if (err) {
562 brcmf_cfg80211_arm_vif_event(cfg, NULL);
563 goto fail;
564 }
565
566 /* wait for firmware event */
a9eb0c4b
AS		 567 err = brcmf_cfg80211_wait_vif_event(cfg, BRCMF_E_IF_ADD,
568 BRCMF_VIF_EVENT_TIMEOUT);
a44aa400
HM		 569 brcmf_cfg80211_arm_vif_event(cfg, NULL);
570 if (!err) {
571 brcmf_err("timeout occurred\n");
572 err = -EIO;
573 goto fail;
574 }
575
576 /* interface created in firmware */
577 ifp = vif->ifp;
578 if (!ifp) {
579 brcmf_err("no if pointer provided\n");
580 err = -ENOENT;
581 goto fail;
582 }
583
584 strncpy(ifp->ndev->name, name, sizeof(ifp->ndev->name) - 1);
585 err = brcmf_net_attach(ifp, true);
586 if (err) {
587 brcmf_err("Registering netdevice failed\n");
588 goto fail;
589 }
590
591 return &ifp->vif->wdev;
592
593fail:
594 brcmf_free_vif(vif);
595 return ERR_PTR(err);
596}
597
967fe2c8
AS		 598static bool brcmf_is_apmode(struct brcmf_cfg80211_vif *vif)
599{
600 enum nl80211_iftype iftype;
601
602 iftype = vif->wdev.iftype;
603 return iftype == NL80211_IFTYPE_AP || iftype == NL80211_IFTYPE_P2P_GO;
604}
605
606static bool brcmf_is_ibssmode(struct brcmf_cfg80211_vif *vif)
607{
608 return vif->wdev.iftype == NL80211_IFTYPE_ADHOC;
609}
610
9f440b7b
AS		 611static struct wireless_dev *brcmf_cfg80211_add_iface(struct wiphy *wiphy,
612 const char *name,
6bab2e19 613 unsigned char name_assign_type,
9f440b7b
AS		 614 enum nl80211_iftype type,
615 u32 *flags,
616 struct vif_params *params)
617{
8851cce0 618 struct wireless_dev *wdev;
39504a2d 619 int err;
8851cce0 620
9f440b7b 621 brcmf_dbg(TRACE, "enter: %s type %d\n", name, type);
39504a2d
AS		 622 err = brcmf_vif_add_validate(wiphy_to_cfg(wiphy), type);
623 if (err) {
624 brcmf_err("iface validation failed: err=%d\n", err);
625 return ERR_PTR(err);
626 }
9f440b7b
AS		 627 switch (type) {
628 case NL80211_IFTYPE_ADHOC:
629 case NL80211_IFTYPE_STATION:
9f440b7b
AS		 630 case NL80211_IFTYPE_AP_VLAN:
631 case NL80211_IFTYPE_WDS:
632 case NL80211_IFTYPE_MONITOR:
633 case NL80211_IFTYPE_MESH_POINT:
634 return ERR_PTR(-EOPNOTSUPP);
a44aa400
HM		 635 case NL80211_IFTYPE_AP:
636 wdev = brcmf_ap_add_vif(wiphy, name, flags, params);
637 if (!IS_ERR(wdev))
638 brcmf_cfg80211_update_proto_addr_mode(wdev);
639 return wdev;
9f440b7b
AS		 640 case NL80211_IFTYPE_P2P_CLIENT:
641 case NL80211_IFTYPE_P2P_GO:
27f10e38 642 case NL80211_IFTYPE_P2P_DEVICE:
6bab2e19 643 wdev = brcmf_p2p_add_vif(wiphy, name, name_assign_type, type, flags, params);
8851cce0
HM		 644 if (!IS_ERR(wdev))
645 brcmf_cfg80211_update_proto_addr_mode(wdev);
646 return wdev;
9f440b7b 647 case NL80211_IFTYPE_UNSPECIFIED:
9f440b7b
AS		 648 default:
649 return ERR_PTR(-EINVAL);
650 }
651}
652
5e787f75
DK		 653static void brcmf_scan_config_mpc(struct brcmf_if *ifp, int mpc)
654{
c08437b4 655 if (brcmf_feat_is_quirk_enabled(ifp, BRCMF_FEAT_QUIRK_NEED_MPC))
5e787f75
DK		 656 brcmf_set_mpc(ifp, mpc);
657}
658
f96aa07e 659void brcmf_set_mpc(struct brcmf_if *ifp, int mpc)
5f4f9f11 660{
5f4f9f11
AS		 661 s32 err = 0;
662
663 if (check_vif_up(ifp->vif)) {
664 err = brcmf_fil_iovar_int_set(ifp, "mpc", mpc);
665 if (err) {
666 brcmf_err("fail to set mpc\n");
667 return;
668 }
669 brcmf_dbg(INFO, "MPC : %d\n", mpc);
670 }
671}
672
a0f472ac
AS		 673s32 brcmf_notify_escan_complete(struct brcmf_cfg80211_info *cfg,
674 struct brcmf_if *ifp, bool aborted,
675 bool fw_abort)
5f4f9f11
AS		 676{
677 struct brcmf_scan_params_le params_le;
678 struct cfg80211_scan_request *scan_request;
679 s32 err = 0;
680
681 brcmf_dbg(SCAN, "Enter\n");
682
683 /* clear scan request, because the FW abort can cause a second call */
684 /* to this functon and might cause a double cfg80211_scan_done */
685 scan_request = cfg->scan_request;
686 cfg->scan_request = NULL;
687
688 if (timer_pending(&cfg->escan_timeout))
689 del_timer_sync(&cfg->escan_timeout);
690
691 if (fw_abort) {
692 /* Do a scan abort to stop the driver's scan engine */
693 brcmf_dbg(SCAN, "ABORT scan in firmware\n");
694 memset(&params_le, 0, sizeof(params_le));
93803b33 695 eth_broadcast_addr(params_le.bssid);
5f4f9f11
AS		 696 params_le.bss_type = DOT11_BSSTYPE_ANY;
697 params_le.scan_type = 0;
698 params_le.channel_num = cpu_to_le32(1);
699 params_le.nprobes = cpu_to_le32(1);
700 params_le.active_time = cpu_to_le32(-1);
701 params_le.passive_time = cpu_to_le32(-1);
702 params_le.home_time = cpu_to_le32(-1);
703 /* Scan is aborted by setting channel_list[0] to -1 */
704 params_le.channel_list[0] = cpu_to_le16(-1);
705 /* E-Scan (or anyother type) can be aborted by SCAN */
f96aa07e 706 err = brcmf_fil_cmd_data_set(ifp, BRCMF_C_SCAN,
5f4f9f11
AS		 707 &params_le, sizeof(params_le));
708 if (err)
709 brcmf_err("Scan abort failed\n");
710 }
0f0fe990 711
5e787f75 712 brcmf_scan_config_mpc(ifp, 1);
0f0fe990 713
5f4f9f11
AS		 714 /*
715 * e-scan can be initiated by scheduled scan
716 * which takes precedence.
717 */
718 if (cfg->sched_escan) {
719 brcmf_dbg(SCAN, "scheduled scan completed\n");
720 cfg->sched_escan = false;
721 if (!aborted)
722 cfg80211_sched_scan_results(cfg_to_wiphy(cfg));
5f4f9f11
AS		 723 } else if (scan_request) {
724 brcmf_dbg(SCAN, "ESCAN Completed scan: %s\n",
725 aborted ? "Aborted" : "Done");
726 cfg80211_scan_done(scan_request, aborted);
5f4f9f11 727 }
6eda4e2c
HM		 728 if (!test_and_clear_bit(BRCMF_SCAN_STATUS_BUSY, &cfg->scan_status))
729 brcmf_dbg(SCAN, "Scan complete, probably P2P scan\n");
5f4f9f11
AS		 730
731 return err;
732}
733
9f440b7b
AS		 734static
735int brcmf_cfg80211_del_iface(struct wiphy *wiphy, struct wireless_dev *wdev)
736{
5f4f9f11
AS		 737 struct brcmf_cfg80211_info *cfg = wiphy_priv(wiphy);
738 struct net_device *ndev = wdev->netdev;
739
740 /* vif event pending in firmware */
741 if (brcmf_cfg80211_vif_event_armed(cfg))
742 return -EBUSY;
743
744 if (ndev) {
745 if (test_bit(BRCMF_SCAN_STATUS_BUSY, &cfg->scan_status) &&
a0f472ac
AS		 746 cfg->escan_info.ifp == netdev_priv(ndev))
747 brcmf_notify_escan_complete(cfg, netdev_priv(ndev),
748 true, true);
5f4f9f11
AS		 749
750 brcmf_fil_iovar_int_set(netdev_priv(ndev), "mpc", 1);
751 }
752
9f440b7b
AS		 753 switch (wdev->iftype) {
754 case NL80211_IFTYPE_ADHOC:
755 case NL80211_IFTYPE_STATION:
756 case NL80211_IFTYPE_AP:
757 case NL80211_IFTYPE_AP_VLAN:
758 case NL80211_IFTYPE_WDS:
759 case NL80211_IFTYPE_MONITOR:
760 case NL80211_IFTYPE_MESH_POINT:
761 return -EOPNOTSUPP;
762 case NL80211_IFTYPE_P2P_CLIENT:
763 case NL80211_IFTYPE_P2P_GO:
27f10e38 764 case NL80211_IFTYPE_P2P_DEVICE:
9f440b7b
AS		 765 return brcmf_p2p_del_vif(wiphy, wdev);
766 case NL80211_IFTYPE_UNSPECIFIED:
9f440b7b
AS		 767 default:
768 return -EINVAL;
769 }
770 return -EOPNOTSUPP;
771}
772
5b435de0
AS		 773static s32
774brcmf_cfg80211_change_iface(struct wiphy *wiphy, struct net_device *ndev,
775 enum nl80211_iftype type, u32 *flags,
776 struct vif_params *params)
777{
7a5c1f64 778 struct brcmf_cfg80211_info *cfg = wiphy_priv(wiphy);
c1179033 779 struct brcmf_if *ifp = netdev_priv(ndev);
128ce3b6 780 struct brcmf_cfg80211_vif *vif = ifp->vif;
5b435de0 781 s32 infra = 0;
1a873342 782 s32 ap = 0;
5b435de0
AS		 783 s32 err = 0;
784
37a869ec
HM		 785 brcmf_dbg(TRACE, "Enter, bsscfgidx=%d, type=%d\n", ifp->bsscfgidx,
786 type);
178e9ef9
HM		 787
788 /* WAR: There are a number of p2p interface related problems which
789 * need to be handled initially (before doing the validate).
790 * wpa_supplicant tends to do iface changes on p2p device/client/go
791 * which are not always possible/allowed. However we need to return
792 * OK otherwise the wpa_supplicant wont start. The situation differs
793 * on configuration and setup (p2pon=1 module param). The first check
794 * is to see if the request is a change to station for p2p iface.
795 */
796 if ((type == NL80211_IFTYPE_STATION) &&
797 ((vif->wdev.iftype == NL80211_IFTYPE_P2P_CLIENT) ||
798 (vif->wdev.iftype == NL80211_IFTYPE_P2P_GO) ||
799 (vif->wdev.iftype == NL80211_IFTYPE_P2P_DEVICE))) {
800 brcmf_dbg(TRACE, "Ignoring cmd for p2p if\n");
801 /* Now depending on whether module param p2pon=1 was used the
802 * response needs to be either 0 or EOPNOTSUPP. The reason is
803 * that if p2pon=1 is used, but a newer supplicant is used then
804 * we should return an error, as this combination wont work.
805 * In other situations 0 is returned and supplicant will start
806 * normally. It will give a trace in cfg80211, but it is the
807 * only way to get it working. Unfortunately this will result
808 * in situation where we wont support new supplicant in
809 * combination with module param p2pon=1, but that is the way
810 * it is. If the user tries this then unloading of driver might
811 * fail/lock.
812 */
813 if (cfg->p2p.p2pdev_dynamically)
814 return -EOPNOTSUPP;
815 else
816 return 0;
817 }
39504a2d
AS		 818 err = brcmf_vif_change_validate(wiphy_to_cfg(wiphy), vif, type);
819 if (err) {
820 brcmf_err("iface validation failed: err=%d\n", err);
821 return err;
822 }
5b435de0
AS		 823 switch (type) {
824 case NL80211_IFTYPE_MONITOR:
825 case NL80211_IFTYPE_WDS:
57d6e91a
AS		 826 brcmf_err("type (%d) : currently we do not support this type\n",
827 type);
5b435de0
AS		 828 return -EOPNOTSUPP;
829 case NL80211_IFTYPE_ADHOC:
5b435de0
AS		 830 infra = 0;
831 break;
832 case NL80211_IFTYPE_STATION:
5b435de0
AS		 833 infra = 1;
834 break;
1a873342 835 case NL80211_IFTYPE_AP:
7a5c1f64 836 case NL80211_IFTYPE_P2P_GO:
1a873342
HM		 837 ap = 1;
838 break;
5b435de0
AS		 839 default:
840 err = -EINVAL;
841 goto done;
842 }
843
1a873342 844 if (ap) {
7a5c1f64
HM		 845 if (type == NL80211_IFTYPE_P2P_GO) {
846 brcmf_dbg(INFO, "IF Type = P2P GO\n");
847 err = brcmf_p2p_ifchange(cfg, BRCMF_FIL_P2P_IF_GO);
848 }
849 if (!err) {
7a5c1f64
HM		 850 brcmf_dbg(INFO, "IF Type = AP\n");
851 }
5b435de0 852 } else {
128ce3b6 853 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_INFRA, infra);
1a873342 854 if (err) {
57d6e91a 855 brcmf_err("WLC_SET_INFRA error (%d)\n", err);
1a873342
HM		 856 err = -EAGAIN;
857 goto done;
858 }
967fe2c8 859 brcmf_dbg(INFO, "IF Type = %s\n", brcmf_is_ibssmode(vif) ?
647c9ae0 860 "Adhoc" : "Infra");
5b435de0 861 }
1a873342 862 ndev->ieee80211_ptr->iftype = type;
5b435de0 863
8851cce0
HM		 864 brcmf_cfg80211_update_proto_addr_mode(&vif->wdev);
865
5b435de0 866done:
d96b801f 867 brcmf_dbg(TRACE, "Exit\n");
5b435de0
AS		 868
869 return err;
870}
871
83cf17aa
FL		 872static void brcmf_escan_prep(struct brcmf_cfg80211_info *cfg,
873 struct brcmf_scan_params_le *params_le,
e756af5b
HM		 874 struct cfg80211_scan_request *request)
875{
876 u32 n_ssids;
877 u32 n_channels;
878 s32 i;
879 s32 offset;
029591f3 880 u16 chanspec;
e756af5b 881 char *ptr;
029591f3 882 struct brcmf_ssid_le ssid_le;
e756af5b 883
93803b33 884 eth_broadcast_addr(params_le->bssid);
e756af5b
HM		 885 params_le->bss_type = DOT11_BSSTYPE_ANY;
886 params_le->scan_type = 0;
887 params_le->channel_num = 0;
888 params_le->nprobes = cpu_to_le32(-1);
889 params_le->active_time = cpu_to_le32(-1);
890 params_le->passive_time = cpu_to_le32(-1);
891 params_le->home_time = cpu_to_le32(-1);
892 memset(&params_le->ssid_le, 0, sizeof(params_le->ssid_le));
893
894 /* if request is null exit so it will be all channel broadcast scan */
895 if (!request)
896 return;
897
898 n_ssids = request->n_ssids;
899 n_channels = request->n_channels;
900 /* Copy channel array if applicable */
4e8a008e
AS		 901 brcmf_dbg(SCAN, "### List of channelspecs to scan ### %d\n",
902 n_channels);
e756af5b
HM		 903 if (n_channels > 0) {
904 for (i = 0; i < n_channels; i++) {
83cf17aa
FL		 905 chanspec = channel_to_chanspec(&cfg->d11inf,
906 request->channels[i]);
4e8a008e
AS		 907 brcmf_dbg(SCAN, "Chan : %d, Channel spec: %x\n",
908 request->channels[i]->hw_value, chanspec);
029591f3 909 params_le->channel_list[i] = cpu_to_le16(chanspec);
e756af5b
HM		 910 }
911 } else {
4e8a008e 912 brcmf_dbg(SCAN, "Scanning all channels\n");
e756af5b
HM		 913 }
914 /* Copy ssid array if applicable */
4e8a008e 915 brcmf_dbg(SCAN, "### List of SSIDs to scan ### %d\n", n_ssids);
e756af5b
HM		 916 if (n_ssids > 0) {
917 offset = offsetof(struct brcmf_scan_params_le, channel_list) +
918 n_channels * sizeof(u16);
919 offset = roundup(offset, sizeof(u32));
920 ptr = (char *)params_le + offset;
921 for (i = 0; i < n_ssids; i++) {
029591f3
AS		 922 memset(&ssid_le, 0, sizeof(ssid_le));
923 ssid_le.SSID_len =
924 cpu_to_le32(request->ssids[i].ssid_len);
925 memcpy(ssid_le.SSID, request->ssids[i].ssid,
926 request->ssids[i].ssid_len);
927 if (!ssid_le.SSID_len)
4e8a008e 928 brcmf_dbg(SCAN, "%d: Broadcast scan\n", i);
e756af5b 929 else
4e8a008e
AS		 930 brcmf_dbg(SCAN, "%d: scan for %s size =%d\n",
931 i, ssid_le.SSID, ssid_le.SSID_len);
029591f3
AS		 932 memcpy(ptr, &ssid_le, sizeof(ssid_le));
933 ptr += sizeof(ssid_le);
e756af5b
HM		 934 }
935 } else {
4e8a008e 936 brcmf_dbg(SCAN, "Broadcast scan %p\n", request->ssids);
e756af5b 937 if ((request->ssids) && request->ssids->ssid_len) {
4e8a008e
AS		 938 brcmf_dbg(SCAN, "SSID %s len=%d\n",
939 params_le->ssid_le.SSID,
940 request->ssids->ssid_len);
e756af5b
HM		 941 params_le->ssid_le.SSID_len =
942 cpu_to_le32(request->ssids->ssid_len);
943 memcpy(&params_le->ssid_le.SSID, request->ssids->ssid,
944 request->ssids->ssid_len);
945 }
946 }
947 /* Adding mask to channel numbers */
948 params_le->channel_num =
949 cpu_to_le32((n_ssids << BRCMF_SCAN_PARAMS_NSSID_SHIFT) |
950 (n_channels & BRCMF_SCAN_PARAMS_COUNT_MASK));
951}
952
e756af5b 953static s32
a0f472ac 954brcmf_run_escan(struct brcmf_cfg80211_info *cfg, struct brcmf_if *ifp,
c4958106 955 struct cfg80211_scan_request *request)
e756af5b
HM		 956{
957 s32 params_size = BRCMF_SCAN_PARAMS_FIXED_SIZE +
958 offsetof(struct brcmf_escan_params_le, params_le);
959 struct brcmf_escan_params_le *params;
960 s32 err = 0;
961
4e8a008e 962 brcmf_dbg(SCAN, "E-SCAN START\n");
e756af5b
HM		 963
964 if (request != NULL) {
965 /* Allocate space for populating ssids in struct */
966 params_size += sizeof(u32) * ((request->n_channels + 1) / 2);
967
968 /* Allocate space for populating ssids in struct */
e9a6ca82 969 params_size += sizeof(struct brcmf_ssid_le) * request->n_ssids;
e756af5b
HM		 970 }
971
972 params = kzalloc(params_size, GFP_KERNEL);
973 if (!params) {
974 err = -ENOMEM;
975 goto exit;
976 }
977 BUG_ON(params_size + sizeof("escan") >= BRCMF_DCMD_MEDLEN);
83cf17aa 978 brcmf_escan_prep(cfg, &params->params_le, request);
e756af5b 979 params->version = cpu_to_le32(BRCMF_ESCAN_REQ_VERSION);
c4958106 980 params->action = cpu_to_le16(WL_ESCAN_ACTION_START);
e756af5b
HM		 981 params->sync_id = cpu_to_le16(0x1234);
982
a0f472ac 983 err = brcmf_fil_iovar_data_set(ifp, "escan", params, params_size);
e756af5b
HM		 984 if (err) {
985 if (err == -EBUSY)
647c9ae0 986 brcmf_dbg(INFO, "system busy : escan canceled\n");
e756af5b 987 else
57d6e91a 988 brcmf_err("error (%d)\n", err);
e756af5b
HM		 989 }
990
991 kfree(params);
992exit:
993 return err;
994}
995
996static s32
27a68fe3 997brcmf_do_escan(struct brcmf_cfg80211_info *cfg, struct wiphy *wiphy,
a0f472ac 998 struct brcmf_if *ifp, struct cfg80211_scan_request *request)
e756af5b
HM		 999{
1000 s32 err;
81f5dcb8 1001 u32 passive_scan;
e756af5b 1002 struct brcmf_scan_results *results;
9f440b7b 1003 struct escan_info *escan = &cfg->escan_info;
e756af5b 1004
4e8a008e 1005 brcmf_dbg(SCAN, "Enter\n");
a0f472ac 1006 escan->ifp = ifp;
9f440b7b
AS		 1007 escan->wiphy = wiphy;
1008 escan->escan_state = WL_ESCAN_STATE_SCANNING;
81f5dcb8 1009 passive_scan = cfg->active_scan ? 0 : 1;
f96aa07e 1010 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_PASSIVE_SCAN,
81f5dcb8 1011 passive_scan);
e756af5b 1012 if (err) {
57d6e91a 1013 brcmf_err("error (%d)\n", err);
e756af5b
HM		 1014 return err;
1015 }
5e787f75 1016 brcmf_scan_config_mpc(ifp, 0);
27a68fe3 1017 results = (struct brcmf_scan_results *)cfg->escan_info.escan_buf;
e756af5b
HM		 1018 results->version = 0;
1019 results->count = 0;
1020 results->buflen = WL_ESCAN_RESULTS_FIXED_SIZE;
1021
c4958106 1022 err = escan->run(cfg, ifp, request);
e756af5b 1023 if (err)
5e787f75 1024 brcmf_scan_config_mpc(ifp, 1);
e756af5b
HM		 1025 return err;
1026}
1027
1028static s32
a0f472ac 1029brcmf_cfg80211_escan(struct wiphy *wiphy, struct brcmf_cfg80211_vif *vif,
e756af5b
HM		 1030 struct cfg80211_scan_request *request,
1031 struct cfg80211_ssid *this_ssid)
1032{
a0f472ac
AS		 1033 struct brcmf_if *ifp = vif->ifp;
1034 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy);
e756af5b 1035 struct cfg80211_ssid *ssids;
81f5dcb8 1036 u32 passive_scan;
e756af5b
HM		 1037 bool escan_req;
1038 bool spec_scan;
1039 s32 err;
675f5d82 1040 struct brcmf_ssid_le ssid_le;
e756af5b
HM		 1041 u32 SSID_len;
1042
4e8a008e 1043 brcmf_dbg(SCAN, "START ESCAN\n");
e756af5b 1044
c1179033 1045 if (test_bit(BRCMF_SCAN_STATUS_BUSY, &cfg->scan_status)) {
57d6e91a 1046 brcmf_err("Scanning already: status (%lu)\n", cfg->scan_status);
e756af5b
HM		 1047 return -EAGAIN;
1048 }
c1179033 1049 if (test_bit(BRCMF_SCAN_STATUS_ABORT, &cfg->scan_status)) {
57d6e91a
AS		 1050 brcmf_err("Scanning being aborted: status (%lu)\n",
1051 cfg->scan_status);
e756af5b
HM		 1052 return -EAGAIN;
1053 }
1687eee2
AS		 1054 if (test_bit(BRCMF_SCAN_STATUS_SUPPRESS, &cfg->scan_status)) {
1055 brcmf_err("Scanning suppressed: status (%lu)\n",
1056 cfg->scan_status);
1057 return -EAGAIN;
1058 }
c1179033 1059 if (test_bit(BRCMF_VIF_STATUS_CONNECTING, &ifp->vif->sme_state)) {
57d6e91a 1060 brcmf_err("Connecting: status (%lu)\n", ifp->vif->sme_state);
e756af5b
HM		 1061 return -EAGAIN;
1062 }
1063
0f8ffe17 1064 /* If scan req comes for p2p0, send it over primary I/F */
a0f472ac
AS		 1065 if (vif == cfg->p2p.bss_idx[P2PAPI_BSSCFG_DEVICE].vif)
1066 vif = cfg->p2p.bss_idx[P2PAPI_BSSCFG_PRIMARY].vif;
0f8ffe17 1067
e756af5b
HM		 1068 escan_req = false;
1069 if (request) {
1070 /* scan bss */
1071 ssids = request->ssids;
1072 escan_req = true;
1073 } else {
1074 /* scan in ibss */
1075 /* we don't do escan in ibss */
1076 ssids = this_ssid;
1077 }
1078
27a68fe3 1079 cfg->scan_request = request;
c1179033 1080 set_bit(BRCMF_SCAN_STATUS_BUSY, &cfg->scan_status);
e756af5b 1081 if (escan_req) {
9f440b7b 1082 cfg->escan_info.run = brcmf_run_escan;
a0f472ac 1083 err = brcmf_p2p_scan_prep(wiphy, request, vif);
9f440b7b
AS		 1084 if (err)
1085 goto scan_out;
1086
a0f472ac 1087 err = brcmf_do_escan(cfg, wiphy, vif->ifp, request);
2cb941c0 1088 if (err)
e756af5b
HM		 1089 goto scan_out;
1090 } else {
4e8a008e
AS		 1091 brcmf_dbg(SCAN, "ssid \"%s\", ssid_len (%d)\n",
1092 ssids->ssid, ssids->ssid_len);
675f5d82
HM		 1093 memset(&ssid_le, 0, sizeof(ssid_le));
1094 SSID_len = min_t(u8, sizeof(ssid_le.SSID), ssids->ssid_len);
1095 ssid_le.SSID_len = cpu_to_le32(0);
e756af5b
HM		 1096 spec_scan = false;
1097 if (SSID_len) {
675f5d82
HM		 1098 memcpy(ssid_le.SSID, ssids->ssid, SSID_len);
1099 ssid_le.SSID_len = cpu_to_le32(SSID_len);
e756af5b
HM		 1100 spec_scan = true;
1101 } else
4e8a008e 1102 brcmf_dbg(SCAN, "Broadcast scan\n");
e756af5b 1103
81f5dcb8 1104 passive_scan = cfg->active_scan ? 0 : 1;
c1179033 1105 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_PASSIVE_SCAN,
81f5dcb8 1106 passive_scan);
e756af5b 1107 if (err) {
57d6e91a 1108 brcmf_err("WLC_SET_PASSIVE_SCAN error (%d)\n", err);
e756af5b
HM		 1109 goto scan_out;
1110 }
5e787f75 1111 brcmf_scan_config_mpc(ifp, 0);
675f5d82
HM		 1112 err = brcmf_fil_cmd_data_set(ifp, BRCMF_C_SCAN, &ssid_le,
1113 sizeof(ssid_le));
e756af5b
HM		 1114 if (err) {
1115 if (err == -EBUSY)
647c9ae0 1116 brcmf_dbg(INFO, "BUSY: scan for \"%s\" canceled\n",
675f5d82 1117 ssid_le.SSID);
e756af5b 1118 else
57d6e91a 1119 brcmf_err("WLC_SCAN error (%d)\n", err);
e756af5b 1120
5e787f75 1121 brcmf_scan_config_mpc(ifp, 1);
e756af5b
HM		 1122 goto scan_out;
1123 }
1124 }
1125
661fa95d
HM		 1126 /* Arm scan timeout timer */
1127 mod_timer(&cfg->escan_timeout, jiffies +
d5367334 1128 BRCMF_ESCAN_TIMER_INTERVAL_MS * HZ / 1000);
661fa95d 1129
e756af5b
HM		 1130 return 0;
1131
1132scan_out:
c1179033 1133 clear_bit(BRCMF_SCAN_STATUS_BUSY, &cfg->scan_status);
27a68fe3 1134 cfg->scan_request = NULL;
e756af5b
HM		 1135 return err;
1136}
1137
5b435de0 1138static s32
0abb5f21 1139brcmf_cfg80211_scan(struct wiphy *wiphy, struct cfg80211_scan_request *request)
5b435de0 1140{
a0f472ac 1141 struct brcmf_cfg80211_vif *vif;
5b435de0
AS		 1142 s32 err = 0;
1143
d96b801f 1144 brcmf_dbg(TRACE, "Enter\n");
a0f472ac
AS		 1145 vif = container_of(request->wdev, struct brcmf_cfg80211_vif, wdev);
1146 if (!check_vif_up(vif))
5b435de0
AS		 1147 return -EIO;
1148
a0f472ac 1149 err = brcmf_cfg80211_escan(wiphy, vif, request, NULL);
e756af5b 1150
5b435de0 1151 if (err)
57d6e91a 1152 brcmf_err("scan error (%d)\n", err);
5b435de0 1153
d96b801f 1154 brcmf_dbg(TRACE, "Exit\n");
5b435de0
AS		 1155 return err;
1156}
1157
1158static s32 brcmf_set_rts(struct net_device *ndev, u32 rts_threshold)
1159{
1160 s32 err = 0;
1161
ac24be6f
AS		 1162 err = brcmf_fil_iovar_int_set(netdev_priv(ndev), "rtsthresh",
1163 rts_threshold);
5b435de0 1164 if (err)
57d6e91a 1165 brcmf_err("Error (%d)\n", err);
5b435de0
AS		 1166
1167 return err;
1168}
1169
1170static s32 brcmf_set_frag(struct net_device *ndev, u32 frag_threshold)
1171{
1172 s32 err = 0;
1173
ac24be6f
AS		 1174 err = brcmf_fil_iovar_int_set(netdev_priv(ndev), "fragthresh",
1175 frag_threshold);
5b435de0 1176 if (err)
57d6e91a 1177 brcmf_err("Error (%d)\n", err);
5b435de0
AS		 1178
1179 return err;
1180}
1181
1182static s32 brcmf_set_retry(struct net_device *ndev, u32 retry, bool l)
1183{
1184 s32 err = 0;
b87e2c48 1185 u32 cmd = (l ? BRCMF_C_SET_LRL : BRCMF_C_SET_SRL);
5b435de0 1186
ac24be6f 1187 err = brcmf_fil_cmd_int_set(netdev_priv(ndev), cmd, retry);
5b435de0 1188 if (err) {
57d6e91a 1189 brcmf_err("cmd (%d) , error (%d)\n", cmd, err);
5b435de0
AS		 1190 return err;
1191 }
1192 return err;
1193}
1194
1195static s32 brcmf_cfg80211_set_wiphy_params(struct wiphy *wiphy, u32 changed)
1196{
27a68fe3
AS		 1197 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy);
1198 struct net_device *ndev = cfg_to_ndev(cfg);
0abb5f21 1199 struct brcmf_if *ifp = netdev_priv(ndev);
5b435de0
AS		 1200 s32 err = 0;
1201
d96b801f 1202 brcmf_dbg(TRACE, "Enter\n");
ce81e317 1203 if (!check_vif_up(ifp->vif))
5b435de0
AS		 1204 return -EIO;
1205
1206 if (changed & WIPHY_PARAM_RTS_THRESHOLD &&
27a68fe3
AS		 1207 (cfg->conf->rts_threshold != wiphy->rts_threshold)) {
1208 cfg->conf->rts_threshold = wiphy->rts_threshold;
1209 err = brcmf_set_rts(ndev, cfg->conf->rts_threshold);
5b435de0
AS		 1210 if (!err)
1211 goto done;
1212 }
1213 if (changed & WIPHY_PARAM_FRAG_THRESHOLD &&
27a68fe3
AS		 1214 (cfg->conf->frag_threshold != wiphy->frag_threshold)) {
1215 cfg->conf->frag_threshold = wiphy->frag_threshold;
1216 err = brcmf_set_frag(ndev, cfg->conf->frag_threshold);
5b435de0
AS		 1217 if (!err)
1218 goto done;
1219 }
1220 if (changed & WIPHY_PARAM_RETRY_LONG
27a68fe3
AS		 1221 && (cfg->conf->retry_long != wiphy->retry_long)) {
1222 cfg->conf->retry_long = wiphy->retry_long;
1223 err = brcmf_set_retry(ndev, cfg->conf->retry_long, true);
5b435de0
AS		 1224 if (!err)
1225 goto done;
1226 }
1227 if (changed & WIPHY_PARAM_RETRY_SHORT
27a68fe3
AS		 1228 && (cfg->conf->retry_short != wiphy->retry_short)) {
1229 cfg->conf->retry_short = wiphy->retry_short;
1230 err = brcmf_set_retry(ndev, cfg->conf->retry_short, false);
5b435de0
AS		 1231 if (!err)
1232 goto done;
1233 }
1234
1235done:
d96b801f 1236 brcmf_dbg(TRACE, "Exit\n");
5b435de0
AS		 1237 return err;
1238}
1239
5b435de0
AS		 1240static void brcmf_init_prof(struct brcmf_cfg80211_profile *prof)
1241{
1242 memset(prof, 0, sizeof(*prof));
1243}
1244
9b7a0ddc
AS		 1245static u16 brcmf_map_fw_linkdown_reason(const struct brcmf_event_msg *e)
1246{
1247 u16 reason;
1248
1249 switch (e->event_code) {
1250 case BRCMF_E_DEAUTH:
1251 case BRCMF_E_DEAUTH_IND:
1252 case BRCMF_E_DISASSOC_IND:
1253 reason = e->reason;
1254 break;
1255 case BRCMF_E_LINK:
1256 default:
1257 reason = 0;
1258 break;
1259 }
1260 return reason;
1261}
1262
1263static void brcmf_link_down(struct brcmf_cfg80211_vif *vif, u16 reason)
5b435de0 1264{
61730d4d 1265 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(vif->wdev.wiphy);
5b435de0
AS		 1266 s32 err = 0;
1267
d96b801f 1268 brcmf_dbg(TRACE, "Enter\n");
5b435de0 1269
b0a79088 1270 if (test_and_clear_bit(BRCMF_VIF_STATUS_CONNECTED, &vif->sme_state)) {
647c9ae0 1271 brcmf_dbg(INFO, "Call WLC_DISASSOC to stop excess roaming\n ");
903e0eee 1272 err = brcmf_fil_cmd_data_set(vif->ifp,
ac24be6f 1273 BRCMF_C_DISASSOC, NULL, 0);
a538ae31 1274 if (err) {
57d6e91a 1275 brcmf_err("WLC_DISASSOC failed (%d)\n", err);
a538ae31 1276 }
b0a79088
HM		 1277 if ((vif->wdev.iftype == NL80211_IFTYPE_STATION) ||
1278 (vif->wdev.iftype == NL80211_IFTYPE_P2P_CLIENT))
1279 cfg80211_disconnected(vif->wdev.netdev, reason, NULL, 0,
1280 true, GFP_KERNEL);
5b435de0 1281 }
903e0eee 1282 clear_bit(BRCMF_VIF_STATUS_CONNECTING, &vif->sme_state);
61730d4d
PH		 1283 clear_bit(BRCMF_SCAN_STATUS_SUPPRESS, &cfg->scan_status);
1284 brcmf_btcoex_set_mode(vif, BRCMF_BTCOEX_ENABLED, 0);
d96b801f 1285 brcmf_dbg(TRACE, "Exit\n");
5b435de0
AS		 1286}
1287
1288static s32
1289brcmf_cfg80211_join_ibss(struct wiphy *wiphy, struct net_device *ndev,
1290 struct cfg80211_ibss_params *params)
1291{
27a68fe3 1292 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy);
0abb5f21
AS		 1293 struct brcmf_if *ifp = netdev_priv(ndev);
1294 struct brcmf_cfg80211_profile *profile = &ifp->vif->profile;
5b435de0
AS		 1295 struct brcmf_join_params join_params;
1296 size_t join_params_size = 0;
1297 s32 err = 0;
1298 s32 wsec = 0;
1299 s32 bcnprd;
1701261d 1300 u16 chanspec;
e9a6ca82 1301 u32 ssid_len;
5b435de0 1302
d96b801f 1303 brcmf_dbg(TRACE, "Enter\n");
ce81e317 1304 if (!check_vif_up(ifp->vif))
5b435de0
AS		 1305 return -EIO;
1306
1307 if (params->ssid)
16886735 1308 brcmf_dbg(CONN, "SSID: %s\n", params->ssid);
5b435de0 1309 else {
16886735 1310 brcmf_dbg(CONN, "SSID: NULL, Not supported\n");
5b435de0
AS		 1311 return -EOPNOTSUPP;
1312 }
1313
c1179033 1314 set_bit(BRCMF_VIF_STATUS_CONNECTING, &ifp->vif->sme_state);
5b435de0
AS		 1315
1316 if (params->bssid)
16886735 1317 brcmf_dbg(CONN, "BSSID: %pM\n", params->bssid);
5b435de0 1318 else
16886735 1319 brcmf_dbg(CONN, "No BSSID specified\n");
5b435de0 1320
683b6d3b 1321 if (params->chandef.chan)
16886735
AS		 1322 brcmf_dbg(CONN, "channel: %d\n",
1323 params->chandef.chan->center_freq);
5b435de0 1324 else
16886735 1325 brcmf_dbg(CONN, "no channel specified\n");
5b435de0
AS		 1326
1327 if (params->channel_fixed)
16886735 1328 brcmf_dbg(CONN, "fixed channel required\n");
5b435de0 1329 else
16886735 1330 brcmf_dbg(CONN, "no fixed channel required\n");
5b435de0
AS		 1331
1332 if (params->ie && params->ie_len)
16886735 1333 brcmf_dbg(CONN, "ie len: %d\n", params->ie_len);
5b435de0 1334 else
16886735 1335 brcmf_dbg(CONN, "no ie specified\n");
5b435de0
AS		 1336
1337 if (params->beacon_interval)
16886735
AS		 1338 brcmf_dbg(CONN, "beacon interval: %d\n",
1339 params->beacon_interval);
5b435de0 1340 else
16886735 1341 brcmf_dbg(CONN, "no beacon interval specified\n");
5b435de0
AS		 1342
1343 if (params->basic_rates)
16886735 1344 brcmf_dbg(CONN, "basic rates: %08X\n", params->basic_rates);
5b435de0 1345 else
16886735 1346 brcmf_dbg(CONN, "no basic rates specified\n");
5b435de0
AS		 1347
1348 if (params->privacy)
16886735 1349 brcmf_dbg(CONN, "privacy required\n");
5b435de0 1350 else
16886735 1351 brcmf_dbg(CONN, "no privacy required\n");
5b435de0
AS		 1352
1353 /* Configure Privacy for starter */
1354 if (params->privacy)
1355 wsec |= WEP_ENABLED;
1356
c1179033 1357 err = brcmf_fil_iovar_int_set(ifp, "wsec", wsec);
5b435de0 1358 if (err) {
57d6e91a 1359 brcmf_err("wsec failed (%d)\n", err);
5b435de0
AS		 1360 goto done;
1361 }
1362
1363 /* Configure Beacon Interval for starter */
1364 if (params->beacon_interval)
1365 bcnprd = params->beacon_interval;
1366 else
1367 bcnprd = 100;
1368
b87e2c48 1369 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_BCNPRD, bcnprd);
5b435de0 1370 if (err) {
57d6e91a 1371 brcmf_err("WLC_SET_BCNPRD failed (%d)\n", err);
5b435de0
AS		 1372 goto done;
1373 }
1374
1375 /* Configure required join parameter */
1376 memset(&join_params, 0, sizeof(struct brcmf_join_params));
1377
1378 /* SSID */
e9a6ca82
HM		 1379 ssid_len = min_t(u32, params->ssid_len, IEEE80211_MAX_SSID_LEN);
1380 memcpy(join_params.ssid_le.SSID, params->ssid, ssid_len);
1381 join_params.ssid_le.SSID_len = cpu_to_le32(ssid_len);
5b435de0 1382 join_params_size = sizeof(join_params.ssid_le);
5b435de0
AS		 1383
1384 /* BSSID */
1385 if (params->bssid) {
1386 memcpy(join_params.params_le.bssid, params->bssid, ETH_ALEN);
e9a6ca82 1387 join_params_size += BRCMF_ASSOC_PARAMS_FIXED_SIZE;
6c8c4f72 1388 memcpy(profile->bssid, params->bssid, ETH_ALEN);
5b435de0 1389 } else {
93803b33
JP		 1390 eth_broadcast_addr(join_params.params_le.bssid);
1391 eth_zero_addr(profile->bssid);
5b435de0
AS		 1392 }
1393
5b435de0 1394 /* Channel */
683b6d3b 1395 if (params->chandef.chan) {
5b435de0
AS		 1396 u32 target_channel;
1397
27a68fe3 1398 cfg->channel =
5b435de0 1399 ieee80211_frequency_to_channel(
683b6d3b 1400 params->chandef.chan->center_freq);
5b435de0
AS		 1401 if (params->channel_fixed) {
1402 /* adding chanspec */
600a897d
AS		 1403 chanspec = chandef_to_chanspec(&cfg->d11inf,
1404 &params->chandef);
1701261d
HM		 1405 join_params.params_le.chanspec_list[0] =
1406 cpu_to_le16(chanspec);
1407 join_params.params_le.chanspec_num = cpu_to_le32(1);
1408 join_params_size += sizeof(join_params.params_le);
5b435de0
AS		 1409 }
1410
1411 /* set channel for starter */
27a68fe3 1412 target_channel = cfg->channel;
b87e2c48 1413 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_CHANNEL,
81f5dcb8 1414 target_channel);
5b435de0 1415 if (err) {
57d6e91a 1416 brcmf_err("WLC_SET_CHANNEL failed (%d)\n", err);
5b435de0
AS		 1417 goto done;
1418 }
1419 } else
27a68fe3 1420 cfg->channel = 0;
5b435de0 1421
27a68fe3 1422 cfg->ibss_starter = false;
5b435de0
AS		 1423
1424
c1179033 1425 err = brcmf_fil_cmd_data_set(ifp, BRCMF_C_SET_SSID,
81f5dcb8 1426 &join_params, join_params_size);
5b435de0 1427 if (err) {
57d6e91a 1428 brcmf_err("WLC_SET_SSID failed (%d)\n", err);
5b435de0
AS		 1429 goto done;
1430 }
1431
1432done:
1433 if (err)
c1179033 1434 clear_bit(BRCMF_VIF_STATUS_CONNECTING, &ifp->vif->sme_state);
d96b801f 1435 brcmf_dbg(TRACE, "Exit\n");
5b435de0
AS		 1436 return err;
1437}
1438
1439static s32
1440brcmf_cfg80211_leave_ibss(struct wiphy *wiphy, struct net_device *ndev)
1441{
0abb5f21 1442 struct brcmf_if *ifp = netdev_priv(ndev);
5b435de0 1443
d96b801f 1444 brcmf_dbg(TRACE, "Enter\n");
6a98d64a
HM		 1445 if (!check_vif_up(ifp->vif)) {
1446 /* When driver is being unloaded, it can end up here. If an
1447 * error is returned then later on a debug trace in the wireless
1448 * core module will be printed. To avoid this 0 is returned.
1449 */
1450 return 0;
1451 }
5b435de0 1452
9b7a0ddc 1453 brcmf_link_down(ifp->vif, WLAN_REASON_DEAUTH_LEAVING);
42e0ed0d 1454 brcmf_net_setcarrier(ifp, false);
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;
d5367334 3023 if (bi_length > BRCMF_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 }
d5367334
HM		 3036 memcpy(&cfg->escan_info.escan_buf[list->buflen], bss_info_le,
3037 bi_length);
e756af5b
HM		 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
5419f7f1
HM		 3070/* PFN result doesn't have all the info which are required by the supplicant
3071 * (For e.g IEs) Do a target Escan so that sched scan results are reported
3072 * via wl_inform_single_bss in the required format. Escan does require the
3073 * scan request in the form of cfg80211_scan_request. For timebeing, create
3074 * cfg80211_scan_request one out of the received PNO event.
3075 */
3021ad9a 3076static s32
5419f7f1
HM		 3077brcmf_notify_sched_scan_results(struct brcmf_if *ifp,
3078 const struct brcmf_event_msg *e, void *data)
3021ad9a
HM		 3079{
3080 struct brcmf_cfg80211_info *cfg = ifp->drvr->config;
5419f7f1
HM		 3081 struct brcmf_pno_net_info_le *netinfo, *netinfo_start;
3082 struct cfg80211_scan_request *request = NULL;
3083 struct cfg80211_ssid *ssid = NULL;
3084 struct ieee80211_channel *channel = NULL;
3085 struct wiphy *wiphy = cfg_to_wiphy(cfg);
3086 int err = 0;
3087 int channel_req = 0;
3088 int band = 0;
3021ad9a 3089 struct brcmf_pno_scanresults_le *pfn_result;
5419f7f1
HM		 3090 u32 result_count;
3091 u32 status;
3021ad9a
HM		 3092
3093 brcmf_dbg(SCAN, "Enter\n");
3094
0aedbcaf
HM		 3095 if (e->datalen < (sizeof(*pfn_result) + sizeof(*netinfo))) {
3096 brcmf_dbg(SCAN, "Event data to small. Ignore\n");
3097 return 0;
3098 }
3099
3021ad9a 3100 if (e->event_code == BRCMF_E_PFN_NET_LOST) {
5419f7f1 3101 brcmf_dbg(SCAN, "PFN NET LOST event. Do Nothing\n");
3021ad9a
HM		 3102 return 0;
3103 }
3104
5419f7f1
HM		 3105 pfn_result = (struct brcmf_pno_scanresults_le *)data;
3106 result_count = le32_to_cpu(pfn_result->count);
3107 status = le32_to_cpu(pfn_result->status);
3021ad9a 3108
5419f7f1
HM		 3109 /* PFN event is limited to fit 512 bytes so we may get
3110 * multiple NET_FOUND events. For now place a warning here.
3111 */
3112 WARN_ON(status != BRCMF_PNO_SCAN_COMPLETE);
3113 brcmf_dbg(SCAN, "PFN NET FOUND event. count: %d\n", result_count);
3114 if (result_count > 0) {
3115 int i;
3021ad9a 3116
5419f7f1
HM		 3117 request = kzalloc(sizeof(*request), GFP_KERNEL);
3118 ssid = kcalloc(result_count, sizeof(*ssid), GFP_KERNEL);
3119 channel = kcalloc(result_count, sizeof(*channel), GFP_KERNEL);
3120 if (!request || !ssid || !channel) {
3121 err = -ENOMEM;
3122 goto out_err;
3123 }
3021ad9a 3124
5419f7f1
HM		 3125 request->wiphy = wiphy;
3126 data += sizeof(struct brcmf_pno_scanresults_le);
3127 netinfo_start = (struct brcmf_pno_net_info_le *)data;
3021ad9a 3128
5419f7f1
HM		 3129 for (i = 0; i < result_count; i++) {
3130 netinfo = &netinfo_start[i];
3131 if (!netinfo) {
3132 brcmf_err("Invalid netinfo ptr. index: %d\n",
3133 i);
3134 err = -EINVAL;
3135 goto out_err;
3136 }
aeb64225 3137
5419f7f1
HM		 3138 brcmf_dbg(SCAN, "SSID:%s Channel:%d\n",
3139 netinfo->SSID, netinfo->channel);
3140 memcpy(ssid[i].ssid, netinfo->SSID, netinfo->SSID_len);
3141 ssid[i].ssid_len = netinfo->SSID_len;
3142 request->n_ssids++;
aeb64225 3143
5419f7f1
HM		 3144 channel_req = netinfo->channel;
3145 if (channel_req <= CH_MAX_2G_CHANNEL)
3146 band = NL80211_BAND_2GHZ;
3147 else
3148 band = NL80211_BAND_5GHZ;
3149 channel[i].center_freq =
3150 ieee80211_channel_to_frequency(channel_req,
3151 band);
3152 channel[i].band = band;
3153 channel[i].flags |= IEEE80211_CHAN_NO_HT40;
3154 request->channels[i] = &channel[i];
3155 request->n_channels++;
3156 }
aeb64225 3157
5419f7f1
HM		 3158 /* assign parsed ssid array */
3159 if (request->n_ssids)
3160 request->ssids = &ssid[0];
aeb64225 3161
5419f7f1
HM		 3162 if (test_bit(BRCMF_SCAN_STATUS_BUSY, &cfg->scan_status)) {
3163 /* Abort any on-going scan */
3164 brcmf_abort_scanning(cfg);
aeb64225 3165 }
5419f7f1
HM		 3166
3167 set_bit(BRCMF_SCAN_STATUS_BUSY, &cfg->scan_status);
3168 cfg->escan_info.run = brcmf_run_escan;
3169 err = brcmf_do_escan(cfg, wiphy, ifp, request);
3170 if (err) {
3171 clear_bit(BRCMF_SCAN_STATUS_BUSY, &cfg->scan_status);
3172 goto out_err;
3021ad9a 3173 }
5419f7f1
HM		 3174 cfg->sched_escan = true;
3175 cfg->scan_request = request;
aeb64225 3176 } else {
5419f7f1
HM		 3177 brcmf_err("FALSE PNO Event. (pfn_count == 0)\n");
3178 goto out_err;
aeb64225 3179 }
aeb64225 3180
5419f7f1
HM		 3181 kfree(ssid);
3182 kfree(channel);
3183 kfree(request);
3184 return 0;
aeb64225 3185
5419f7f1
HM		 3186out_err:
3187 kfree(ssid);
3188 kfree(channel);
3189 kfree(request);
3190 cfg80211_sched_scan_stopped(wiphy);
3191 return err;
aeb64225
HM		 3192}
3193
5419f7f1 3194static int brcmf_dev_pno_clean(struct net_device *ndev)
5b435de0 3195{
5419f7f1 3196 int ret;
4eb3af7c 3197
5419f7f1
HM		 3198 /* Disable pfn */
3199 ret = brcmf_fil_iovar_int_set(netdev_priv(ndev), "pfn", 0);
3200 if (ret == 0) {
3201 /* clear pfn */
3202 ret = brcmf_fil_iovar_data_set(netdev_priv(ndev), "pfnclear",
3203 NULL, 0);
3204 }
3205 if (ret < 0)
3206 brcmf_err("failed code %d\n", ret);
5b435de0 3207
5419f7f1
HM		 3208 return ret;
3209}
3210
3211static int brcmf_dev_pno_config(struct brcmf_if *ifp,
3212 struct cfg80211_sched_scan_request *request)
3213{
3214 struct brcmf_pno_param_le pfn_param;
3215 struct brcmf_pno_macaddr_le pfn_mac;
3216 s32 err;
3217 u8 *mac_mask;
3218 int i;
3219
3220 memset(&pfn_param, 0, sizeof(pfn_param));
3221 pfn_param.version = cpu_to_le32(BRCMF_PNO_VERSION);
3222
3223 /* set extra pno params */
3224 pfn_param.flags = cpu_to_le16(1 << BRCMF_PNO_ENABLE_ADAPTSCAN_BIT);
3225 pfn_param.repeat = BRCMF_PNO_REPEAT;
3226 pfn_param.exp = BRCMF_PNO_FREQ_EXPO_MAX;
3227
3228 /* set up pno scan fr */
3229 pfn_param.scan_freq = cpu_to_le32(BRCMF_PNO_TIME);
3230
3231 err = brcmf_fil_iovar_data_set(ifp, "pfn_set", &pfn_param,
3232 sizeof(pfn_param));
3233 if (err) {
3234 brcmf_err("pfn_set failed, err=%d\n", err);
3235 return err;
3236 }
3237
3238 /* Find out if mac randomization should be turned on */
3239 if (!(request->flags & NL80211_SCAN_FLAG_RANDOM_ADDR))
3240 return 0;
3241
3242 pfn_mac.version = BRCMF_PFN_MACADDR_CFG_VER;
3243 pfn_mac.flags = BRCMF_PFN_MAC_OUI_ONLY | BRCMF_PFN_SET_MAC_UNASSOC;
3244
3245 memcpy(pfn_mac.mac, request->mac_addr, ETH_ALEN);
3246 mac_mask = request->mac_addr_mask;
3247 for (i = 0; i < ETH_ALEN; i++) {
3248 pfn_mac.mac[i] &= mac_mask[i];
3249 pfn_mac.mac[i] |= get_random_int() & ~(mac_mask[i]);
3250 }
3251 /* Clear multi bit */
3252 pfn_mac.mac[0] &= 0xFE;
3253 /* Set locally administered */
3254 pfn_mac.mac[0] |= 0x02;
3255
3256 err = brcmf_fil_iovar_data_set(ifp, "pfn_macaddr", &pfn_mac,
3257 sizeof(pfn_mac));
3258 if (err)
3259 brcmf_err("pfn_macaddr failed, err=%d\n", err);
3260
3261 return err;
3262}
3263
3264static int
3265brcmf_cfg80211_sched_scan_start(struct wiphy *wiphy,
3266 struct net_device *ndev,
3267 struct cfg80211_sched_scan_request *request)
3268{
3269 struct brcmf_if *ifp = netdev_priv(ndev);
3270 struct brcmf_cfg80211_info *cfg = wiphy_priv(wiphy);
3271 struct brcmf_pno_net_param_le pfn;
3272 int i;
3273 int ret = 0;
3274
3275 brcmf_dbg(SCAN, "Enter n_match_sets:%d n_ssids:%d\n",
3276 request->n_match_sets, request->n_ssids);
3277 if (test_bit(BRCMF_SCAN_STATUS_BUSY, &cfg->scan_status)) {
3278 brcmf_err("Scanning already: status (%lu)\n", cfg->scan_status);
3279 return -EAGAIN;
3280 }
3281 if (test_bit(BRCMF_SCAN_STATUS_SUPPRESS, &cfg->scan_status)) {
3282 brcmf_err("Scanning suppressed: status (%lu)\n",
3283 cfg->scan_status);
3284 return -EAGAIN;
3285 }
3286
3287 if (!request->n_ssids || !request->n_match_sets) {
3288 brcmf_dbg(SCAN, "Invalid sched scan req!! n_ssids:%d\n",
3289 request->n_ssids);
3290 return -EINVAL;
3291 }
3292
3293 if (request->n_ssids > 0) {
3294 for (i = 0; i < request->n_ssids; i++) {
3295 /* Active scan req for ssids */
3296 brcmf_dbg(SCAN, ">>> Active scan req for ssid (%s)\n",
3297 request->ssids[i].ssid);
3298
3299 /* match_set ssids is a supert set of n_ssid list,
3300 * so we need not add these set separately.
3301 */
3302 }
3303 }
3304
3305 if (request->n_match_sets > 0) {
3306 /* clean up everything */
3307 ret = brcmf_dev_pno_clean(ndev);
3308 if (ret < 0) {
3309 brcmf_err("failed error=%d\n", ret);
3310 return ret;
3311 }
3312
3313 /* configure pno */
3314 if (brcmf_dev_pno_config(ifp, request))
3315 return -EINVAL;
3316
3317 /* configure each match set */
3318 for (i = 0; i < request->n_match_sets; i++) {
3319 struct cfg80211_ssid *ssid;
3320 u32 ssid_len;
3321
3322 ssid = &request->match_sets[i].ssid;
3323 ssid_len = ssid->ssid_len;
3324
3325 if (!ssid_len) {
3326 brcmf_err("skip broadcast ssid\n");
3327 continue;
3328 }
3329 pfn.auth = cpu_to_le32(WLAN_AUTH_OPEN);
3330 pfn.wpa_auth = cpu_to_le32(BRCMF_PNO_WPA_AUTH_ANY);
3331 pfn.wsec = cpu_to_le32(0);
3332 pfn.infra = cpu_to_le32(1);
3333 pfn.flags = cpu_to_le32(1 << BRCMF_PNO_HIDDEN_BIT);
3334 pfn.ssid.SSID_len = cpu_to_le32(ssid_len);
3335 memcpy(pfn.ssid.SSID, ssid->ssid, ssid_len);
3336 ret = brcmf_fil_iovar_data_set(ifp, "pfn_add", &pfn,
3337 sizeof(pfn));
3338 brcmf_dbg(SCAN, ">>> PNO filter %s for ssid (%s)\n",
3339 ret == 0 ? "set" : "failed", ssid->ssid);
3340 }
3341 /* Enable the PNO */
3342 if (brcmf_fil_iovar_int_set(ifp, "pfn", 1) < 0) {
3343 brcmf_err("PNO enable failed!! ret=%d\n", ret);
3344 return -EINVAL;
3345 }
3346 } else {
3347 return -EINVAL;
3348 }
3349
3350 return 0;
3351}
3352
3353static int brcmf_cfg80211_sched_scan_stop(struct wiphy *wiphy,
3354 struct net_device *ndev)
3355{
3356 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy);
3357
3358 brcmf_dbg(SCAN, "enter\n");
3359 brcmf_dev_pno_clean(ndev);
3360 if (cfg->sched_escan)
3361 brcmf_notify_escan_complete(cfg, netdev_priv(ndev), true, true);
3362 return 0;
3363}
3364
3365static __always_inline void brcmf_delay(u32 ms)
3366{
3367 if (ms < 1000 / HZ) {
3368 cond_resched();
3369 mdelay(ms);
3370 } else {
3371 msleep(ms);
3372 }
3373}
3374
3375static s32 brcmf_config_wowl_pattern(struct brcmf_if *ifp, u8 cmd[4],
3376 u8 *pattern, u32 patternsize, u8 *mask,
3377 u32 packet_offset)
3378{
3379 struct brcmf_fil_wowl_pattern_le *filter;
3380 u32 masksize;
3381 u32 patternoffset;
3382 u8 *buf;
3383 u32 bufsize;
3384 s32 ret;
3385
3386 masksize = (patternsize + 7) / 8;
3387 patternoffset = sizeof(*filter) - sizeof(filter->cmd) + masksize;
3388
3389 bufsize = sizeof(*filter) + patternsize + masksize;
3390 buf = kzalloc(bufsize, GFP_KERNEL);
3391 if (!buf)
3392 return -ENOMEM;
3393 filter = (struct brcmf_fil_wowl_pattern_le *)buf;
3394
3395 memcpy(filter->cmd, cmd, 4);
3396 filter->masksize = cpu_to_le32(masksize);
3397 filter->offset = cpu_to_le32(packet_offset);
3398 filter->patternoffset = cpu_to_le32(patternoffset);
3399 filter->patternsize = cpu_to_le32(patternsize);
3400 filter->type = cpu_to_le32(BRCMF_WOWL_PATTERN_TYPE_BITMAP);
3401
3402 if ((mask) && (masksize))
3403 memcpy(buf + sizeof(*filter), mask, masksize);
3404 if ((pattern) && (patternsize))
3405 memcpy(buf + sizeof(*filter) + masksize, pattern, patternsize);
3406
3407 ret = brcmf_fil_iovar_data_set(ifp, "wowl_pattern", buf, bufsize);
3408
3409 kfree(buf);
3410 return ret;
3411}
3412
3413static s32
3414brcmf_wowl_nd_results(struct brcmf_if *ifp, const struct brcmf_event_msg *e,
3415 void *data)
3416{
3417 struct brcmf_cfg80211_info *cfg = ifp->drvr->config;
3418 struct brcmf_pno_scanresults_le *pfn_result;
3419 struct brcmf_pno_net_info_le *netinfo;
3420
3421 brcmf_dbg(SCAN, "Enter\n");
3422
0aedbcaf
HM		 3423 if (e->datalen < (sizeof(*pfn_result) + sizeof(*netinfo))) {
3424 brcmf_dbg(SCAN, "Event data to small. Ignore\n");
3425 return 0;
3426 }
3427
5419f7f1
HM		 3428 pfn_result = (struct brcmf_pno_scanresults_le *)data;
3429
3430 if (e->event_code == BRCMF_E_PFN_NET_LOST) {
3431 brcmf_dbg(SCAN, "PFN NET LOST event. Ignore\n");
3432 return 0;
3433 }
3434
3435 if (le32_to_cpu(pfn_result->count) < 1) {
3436 brcmf_err("Invalid result count, expected 1 (%d)\n",
3437 le32_to_cpu(pfn_result->count));
3438 return -EINVAL;
3439 }
3440
3441 data += sizeof(struct brcmf_pno_scanresults_le);
3442 netinfo = (struct brcmf_pno_net_info_le *)data;
3443 memcpy(cfg->wowl.nd->ssid.ssid, netinfo->SSID, netinfo->SSID_len);
3444 cfg->wowl.nd->ssid.ssid_len = netinfo->SSID_len;
3445 cfg->wowl.nd->n_channels = 1;
3446 cfg->wowl.nd->channels[0] =
3447 ieee80211_channel_to_frequency(netinfo->channel,
3448 netinfo->channel <= CH_MAX_2G_CHANNEL ?
3449 NL80211_BAND_2GHZ : NL80211_BAND_5GHZ);
3450 cfg->wowl.nd_info->n_matches = 1;
3451 cfg->wowl.nd_info->matches[0] = cfg->wowl.nd;
3452
3453 /* Inform (the resume task) that the net detect information was recvd */
3454 cfg->wowl.nd_data_completed = true;
3455 wake_up(&cfg->wowl.nd_data_wait);
3456
3457 return 0;
3458}
3459
3460#ifdef CONFIG_PM
3461
3462static void brcmf_report_wowl_wakeind(struct wiphy *wiphy, struct brcmf_if *ifp)
3463{
3464 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy);
3465 struct brcmf_wowl_wakeind_le wake_ind_le;
3466 struct cfg80211_wowlan_wakeup wakeup_data;
3467 struct cfg80211_wowlan_wakeup *wakeup;
3468 u32 wakeind;
3469 s32 err;
3470 int timeout;
3471
3472 err = brcmf_fil_iovar_data_get(ifp, "wowl_wakeind", &wake_ind_le,
3473 sizeof(wake_ind_le));
3474 if (err) {
3475 brcmf_err("Get wowl_wakeind failed, err = %d\n", err);
3476 return;
3477 }
3478
3479 wakeind = le32_to_cpu(wake_ind_le.ucode_wakeind);
3480 if (wakeind & (BRCMF_WOWL_MAGIC | BRCMF_WOWL_DIS | BRCMF_WOWL_BCN |
3481 BRCMF_WOWL_RETR | BRCMF_WOWL_NET |
3482 BRCMF_WOWL_PFN_FOUND)) {
3483 wakeup = &wakeup_data;
3484 memset(&wakeup_data, 0, sizeof(wakeup_data));
3485 wakeup_data.pattern_idx = -1;
3486
3487 if (wakeind & BRCMF_WOWL_MAGIC) {
3488 brcmf_dbg(INFO, "WOWL Wake indicator: BRCMF_WOWL_MAGIC\n");
3489 wakeup_data.magic_pkt = true;
3490 }
3491 if (wakeind & BRCMF_WOWL_DIS) {
3492 brcmf_dbg(INFO, "WOWL Wake indicator: BRCMF_WOWL_DIS\n");
3493 wakeup_data.disconnect = true;
3494 }
3495 if (wakeind & BRCMF_WOWL_BCN) {
3496 brcmf_dbg(INFO, "WOWL Wake indicator: BRCMF_WOWL_BCN\n");
3497 wakeup_data.disconnect = true;
3498 }
3499 if (wakeind & BRCMF_WOWL_RETR) {
3500 brcmf_dbg(INFO, "WOWL Wake indicator: BRCMF_WOWL_RETR\n");
3501 wakeup_data.disconnect = true;
3502 }
3503 if (wakeind & BRCMF_WOWL_NET) {
3504 brcmf_dbg(INFO, "WOWL Wake indicator: BRCMF_WOWL_NET\n");
3505 /* For now always map to pattern 0, no API to get
3506 * correct information available at the moment.
3507 */
3508 wakeup_data.pattern_idx = 0;
3509 }
3510 if (wakeind & BRCMF_WOWL_PFN_FOUND) {
3511 brcmf_dbg(INFO, "WOWL Wake indicator: BRCMF_WOWL_PFN_FOUND\n");
3512 timeout = wait_event_timeout(cfg->wowl.nd_data_wait,
3513 cfg->wowl.nd_data_completed,
3514 BRCMF_ND_INFO_TIMEOUT);
3515 if (!timeout)
3516 brcmf_err("No result for wowl net detect\n");
3517 else
3518 wakeup_data.net_detect = cfg->wowl.nd_info;
3519 }
3520 } else {
3521 wakeup = NULL;
3522 }
3523 cfg80211_report_wowlan_wakeup(&ifp->vif->wdev, wakeup, GFP_KERNEL);
3524}
3525
3526#else
3527
3528static void brcmf_report_wowl_wakeind(struct wiphy *wiphy, struct brcmf_if *ifp)
3529{
3530}
3531
3532#endif /* CONFIG_PM */
3533
3534static s32 brcmf_cfg80211_resume(struct wiphy *wiphy)
3535{
3536 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy);
3537 struct net_device *ndev = cfg_to_ndev(cfg);
3538 struct brcmf_if *ifp = netdev_priv(ndev);
3539
3540 brcmf_dbg(TRACE, "Enter\n");
3541
3542 if (cfg->wowl.active) {
3543 brcmf_report_wowl_wakeind(wiphy, ifp);
3544 brcmf_fil_iovar_int_set(ifp, "wowl_clear", 0);
3545 brcmf_config_wowl_pattern(ifp, "clr", NULL, 0, NULL, 0);
3546 brcmf_configure_arp_offload(ifp, true);
4eb3af7c 3547 brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_PM,
3021ad9a
HM		 3548 cfg->wowl.pre_pmmode);
3549 cfg->wowl.active = false;
3550 if (cfg->wowl.nd_enabled) {
3551 brcmf_cfg80211_sched_scan_stop(cfg->wiphy, ifp->ndev);
3552 brcmf_fweh_unregister(cfg->pub, BRCMF_E_PFN_NET_FOUND);
3553 brcmf_fweh_register(cfg->pub, BRCMF_E_PFN_NET_FOUND,
3554 brcmf_notify_sched_scan_results);
3555 cfg->wowl.nd_enabled = false;
3556 }
4eb3af7c 3557 }
5b435de0
AS		 3558 return 0;
3559}
3560
4eb3af7c
HM		 3561static void brcmf_configure_wowl(struct brcmf_cfg80211_info *cfg,
3562 struct brcmf_if *ifp,
3563 struct cfg80211_wowlan *wowl)
3564{
3565 u32 wowl_config;
b9a82f89 3566 u32 i;
4eb3af7c
HM		 3567
3568 brcmf_dbg(TRACE, "Suspend, wowl config.\n");
3569
b9a82f89 3570 brcmf_configure_arp_offload(ifp, false);
3021ad9a 3571 brcmf_fil_cmd_int_get(ifp, BRCMF_C_GET_PM, &cfg->wowl.pre_pmmode);
4eb3af7c
HM		 3572 brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_PM, PM_MAX);
3573
3574 wowl_config = 0;
3575 if (wowl->disconnect)
b9a82f89 3576 wowl_config = BRCMF_WOWL_DIS | BRCMF_WOWL_BCN | BRCMF_WOWL_RETR;
4eb3af7c 3577 if (wowl->magic_pkt)
b9a82f89
HM		 3578 wowl_config |= BRCMF_WOWL_MAGIC;
3579 if ((wowl->patterns) && (wowl->n_patterns)) {
3580 wowl_config |= BRCMF_WOWL_NET;
3581 for (i = 0; i < wowl->n_patterns; i++) {
3582 brcmf_config_wowl_pattern(ifp, "add",
3583 (u8 *)wowl->patterns[i].pattern,
3584 wowl->patterns[i].pattern_len,
3585 (u8 *)wowl->patterns[i].mask,
3586 wowl->patterns[i].pkt_offset);
3587 }
3588 }
3021ad9a
HM		 3589 if (wowl->nd_config) {
3590 brcmf_cfg80211_sched_scan_start(cfg->wiphy, ifp->ndev,
3591 wowl->nd_config);
3592 wowl_config |= BRCMF_WOWL_PFN_FOUND;
3593
3594 cfg->wowl.nd_data_completed = false;
3595 cfg->wowl.nd_enabled = true;
3596 /* Now reroute the event for PFN to the wowl function. */
3597 brcmf_fweh_unregister(cfg->pub, BRCMF_E_PFN_NET_FOUND);
3598 brcmf_fweh_register(cfg->pub, BRCMF_E_PFN_NET_FOUND,
3599 brcmf_wowl_nd_results);
3600 }
3601 if (!test_bit(BRCMF_VIF_STATUS_CONNECTED, &ifp->vif->sme_state))
3602 wowl_config |= BRCMF_WOWL_UNASSOC;
3603
aeb64225 3604 brcmf_fil_iovar_data_set(ifp, "wowl_wakeind", "clear", strlen("clear"));
4eb3af7c
HM		 3605 brcmf_fil_iovar_int_set(ifp, "wowl", wowl_config);
3606 brcmf_fil_iovar_int_set(ifp, "wowl_activate", 1);
3607 brcmf_bus_wowl_config(cfg->pub->bus_if, true);
3021ad9a 3608 cfg->wowl.active = true;
4eb3af7c
HM		 3609}
3610
5b435de0 3611static s32 brcmf_cfg80211_suspend(struct wiphy *wiphy,
4eb3af7c 3612 struct cfg80211_wowlan *wowl)
5b435de0 3613{
27a68fe3
AS		 3614 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy);
3615 struct net_device *ndev = cfg_to_ndev(cfg);
4eb3af7c 3616 struct brcmf_if *ifp = netdev_priv(ndev);
7d641072 3617 struct brcmf_cfg80211_vif *vif;
5b435de0 3618
d96b801f 3619 brcmf_dbg(TRACE, "Enter\n");
5b435de0 3620
4eb3af7c 3621 /* if the primary net_device is not READY there is nothing
7d641072 3622 * we can do but pray resume goes smoothly.
5b435de0 3623 */
4eb3af7c 3624 if (!check_vif_up(ifp->vif))
7d641072 3625 goto exit;
5b435de0 3626
3021ad9a
HM		 3627 /* Stop scheduled scan */
3628 if (brcmf_feat_is_enabled(ifp, BRCMF_FEAT_PNO))
3629 brcmf_cfg80211_sched_scan_stop(wiphy, ndev);
3630
7d641072
AS		 3631 /* end any scanning */
3632 if (test_bit(BRCMF_SCAN_STATUS_BUSY, &cfg->scan_status))
27a68fe3 3633 brcmf_abort_scanning(cfg);
5b435de0 3634
4eb3af7c
HM		 3635 if (wowl == NULL) {
3636 brcmf_bus_wowl_config(cfg->pub->bus_if, false);
3637 list_for_each_entry(vif, &cfg->vif_list, list) {
3638 if (!test_bit(BRCMF_VIF_STATUS_READY, &vif->sme_state))
3639 continue;
3640 /* While going to suspend if associated with AP
3641 * disassociate from AP to save power while system is
3642 * in suspended state
3643 */
9b7a0ddc 3644 brcmf_link_down(vif, WLAN_REASON_UNSPECIFIED);
4eb3af7c
HM		 3645 /* Make sure WPA_Supplicant receives all the event
3646 * generated due to DISASSOC call to the fw to keep
5419f7f1
HM		 3647 * the state fw and WPA_Supplicant state consistent
3648 */
3649 brcmf_delay(500);
e5806072 3650 }
5419f7f1
HM		 3651 /* Configure MPC */
3652 brcmf_set_mpc(ifp, 1);
e5806072 3653
e5806072 3654 } else {
5419f7f1
HM		 3655 /* Configure WOWL paramaters */
3656 brcmf_configure_wowl(cfg, ifp, wowl);
e5806072
AS		 3657 }
3658
5419f7f1
HM		 3659exit:
3660 brcmf_dbg(TRACE, "Exit\n");
3661 /* clear any scanning activity */
3662 cfg->scan_status = 0;
e5806072 3663 return 0;
e5806072
AS		 3664}
3665
5419f7f1
HM		 3666static __used s32
3667brcmf_update_pmklist(struct brcmf_cfg80211_info *cfg, struct brcmf_if *ifp)
e5806072 3668{
5419f7f1 3669 struct brcmf_pmk_list_le *pmk_list;
48ed16e8 3670 int i;
5419f7f1
HM		 3671 u32 npmk;
3672 s32 err;
e5806072 3673
5419f7f1
HM		 3674 pmk_list = &cfg->pmk_list;
3675 npmk = le32_to_cpu(pmk_list->npmk);
48ed16e8 3676
5419f7f1
HM		 3677 brcmf_dbg(CONN, "No of elements %d\n", npmk);
3678 for (i = 0; i < npmk; i++)
3679 brcmf_dbg(CONN, "PMK[%d]: %pM\n", i, &pmk_list->pmk[i].bssid);
48ed16e8 3680
5419f7f1
HM		 3681 err = brcmf_fil_iovar_data_set(ifp, "pmkid_info", pmk_list,
3682 sizeof(*pmk_list));
48ed16e8
HM		 3683
3684 return err;
e5806072
AS		 3685}
3686
5419f7f1
HM		 3687static s32
3688brcmf_cfg80211_set_pmksa(struct wiphy *wiphy, struct net_device *ndev,
3689 struct cfg80211_pmksa *pmksa)
e5806072 3690{
5419f7f1 3691 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy);
c1179033 3692 struct brcmf_if *ifp = netdev_priv(ndev);
5419f7f1
HM		 3693 struct brcmf_pmksa *pmk = &cfg->pmk_list.pmk[0];
3694 s32 err;
3695 u32 npmk, i;
e5806072 3696
5419f7f1
HM		 3697 brcmf_dbg(TRACE, "Enter\n");
3698 if (!check_vif_up(ifp->vif))
3699 return -EIO;
e5806072 3700
5419f7f1
HM		 3701 npmk = le32_to_cpu(cfg->pmk_list.npmk);
3702 for (i = 0; i < npmk; i++)
3703 if (!memcmp(pmksa->bssid, pmk[i].bssid, ETH_ALEN))
3704 break;
3705 if (i < BRCMF_MAXPMKID) {
3706 memcpy(pmk[i].bssid, pmksa->bssid, ETH_ALEN);
3707 memcpy(pmk[i].pmkid, pmksa->pmkid, WLAN_PMKID_LEN);
3708 if (i == npmk) {
3709 npmk++;
3710 cfg->pmk_list.npmk = cpu_to_le32(npmk);
3711 }
3712 } else {
3713 brcmf_err("Too many PMKSA entries cached %d\n", npmk);
e5806072
AS		 3714 return -EINVAL;
3715 }
3716
5419f7f1
HM		 3717 brcmf_dbg(CONN, "set_pmksa - PMK bssid: %pM =\n", pmk[npmk].bssid);
3718 for (i = 0; i < WLAN_PMKID_LEN; i += 4)
3719 brcmf_dbg(CONN, "%02x %02x %02x %02x\n", pmk[npmk].pmkid[i],
3720 pmk[npmk].pmkid[i + 1], pmk[npmk].pmkid[i + 2],
3721 pmk[npmk].pmkid[i + 3]);
e5806072 3722
5419f7f1 3723 err = brcmf_update_pmklist(cfg, ifp);
e5806072 3724
5419f7f1
HM		 3725 brcmf_dbg(TRACE, "Exit\n");
3726 return err;
3727}
e5806072 3728
5419f7f1
HM		 3729static s32
3730brcmf_cfg80211_del_pmksa(struct wiphy *wiphy, struct net_device *ndev,
3731 struct cfg80211_pmksa *pmksa)
3732{
3733 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy);
3734 struct brcmf_if *ifp = netdev_priv(ndev);
3735 struct brcmf_pmksa *pmk = &cfg->pmk_list.pmk[0];
3736 s32 err;
3737 u32 npmk, i;
e5806072 3738
5419f7f1
HM		 3739 brcmf_dbg(TRACE, "Enter\n");
3740 if (!check_vif_up(ifp->vif))
3741 return -EIO;
e5806072 3742
5419f7f1 3743 brcmf_dbg(CONN, "del_pmksa - PMK bssid = %pM\n", &pmksa->bssid);
e5806072 3744
5419f7f1
HM		 3745 npmk = le32_to_cpu(cfg->pmk_list.npmk);
3746 for (i = 0; i < npmk; i++)
3747 if (!memcmp(&pmksa->bssid, &pmk[i].bssid, ETH_ALEN))
3748 break;
3749
3750 if ((npmk > 0) && (i < npmk)) {
3751 for (; i < (npmk - 1); i++) {
3752 memcpy(&pmk[i].bssid, &pmk[i + 1].bssid, ETH_ALEN);
3753 memcpy(&pmk[i].pmkid, &pmk[i + 1].pmkid,
3754 WLAN_PMKID_LEN);
e5806072 3755 }
5419f7f1
HM		 3756 memset(&pmk[i], 0, sizeof(*pmk));
3757 cfg->pmk_list.npmk = cpu_to_le32(npmk - 1);
e5806072 3758 } else {
5419f7f1 3759 brcmf_err("Cache entry not found\n");
e5806072
AS		 3760 return -EINVAL;
3761 }
3762
5419f7f1
HM		 3763 err = brcmf_update_pmklist(cfg, ifp);
3764
3765 brcmf_dbg(TRACE, "Exit\n");
3766 return err;
3767
e5806072
AS		 3768}
3769
5419f7f1
HM		 3770static s32
3771brcmf_cfg80211_flush_pmksa(struct wiphy *wiphy, struct net_device *ndev)
e5806072 3772{
27a68fe3 3773 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy);
5419f7f1
HM		 3774 struct brcmf_if *ifp = netdev_priv(ndev);
3775 s32 err;
3776
3777 brcmf_dbg(TRACE, "Enter\n");
3778 if (!check_vif_up(ifp->vif))
3779 return -EIO;
3780
3781 memset(&cfg->pmk_list, 0, sizeof(cfg->pmk_list));
3782 err = brcmf_update_pmklist(cfg, ifp);
3783
3784 brcmf_dbg(TRACE, "Exit\n");
3785 return err;
e5806072 3786
e5806072 3787}
e5806072 3788
1f170110 3789static s32 brcmf_configure_opensecurity(struct brcmf_if *ifp)
1a873342
HM		 3790{
3791 s32 err;
3792
3793 /* set auth */
ac24be6f 3794 err = brcmf_fil_bsscfg_int_set(ifp, "auth", 0);
1a873342 3795 if (err < 0) {
57d6e91a 3796 brcmf_err("auth error %d\n", err);
1a873342
HM		 3797 return err;
3798 }
3799 /* set wsec */
ac24be6f 3800 err = brcmf_fil_bsscfg_int_set(ifp, "wsec", 0);
1a873342 3801 if (err < 0) {
57d6e91a 3802 brcmf_err("wsec error %d\n", err);
1a873342
HM		 3803 return err;
3804 }
3805 /* set upper-layer auth */
ac24be6f 3806 err = brcmf_fil_bsscfg_int_set(ifp, "wpa_auth", WPA_AUTH_NONE);
1a873342 3807 if (err < 0) {
57d6e91a 3808 brcmf_err("wpa_auth error %d\n", err);
1a873342
HM		 3809 return err;
3810 }
3811
3812 return 0;
3813}
3814
3815static bool brcmf_valid_wpa_oui(u8 *oui, bool is_rsn_ie)
3816{
3817 if (is_rsn_ie)
3818 return (memcmp(oui, RSN_OUI, TLV_OUI_LEN) == 0);
3819
3820 return (memcmp(oui, WPA_OUI, TLV_OUI_LEN) == 0);
3821}
3822
3823static s32
a44aa400 3824brcmf_configure_wpaie(struct brcmf_if *ifp,
4b5800fe
JB		 3825 const struct brcmf_vs_tlv *wpa_ie,
3826 bool is_rsn_ie)
1a873342
HM		 3827{
3828 u32 auth = 0; /* d11 open authentication */
3829 u16 count;
3830 s32 err = 0;
3831 s32 len = 0;
3832 u32 i;
3833 u32 wsec;
3834 u32 pval = 0;
3835 u32 gval = 0;
3836 u32 wpa_auth = 0;
3837 u32 offset;
3838 u8 *data;
3839 u16 rsn_cap;
3840 u32 wme_bss_disable;
3841
d96b801f 3842 brcmf_dbg(TRACE, "Enter\n");
1a873342
HM		 3843 if (wpa_ie == NULL)
3844 goto exit;
3845
3846 len = wpa_ie->len + TLV_HDR_LEN;
3847 data = (u8 *)wpa_ie;
619c5a9a 3848 offset = TLV_HDR_LEN;
1a873342
HM		 3849 if (!is_rsn_ie)
3850 offset += VS_IE_FIXED_HDR_LEN;
619c5a9a
HM		 3851 else
3852 offset += WPA_IE_VERSION_LEN;
1a873342
HM		 3853
3854 /* check for multicast cipher suite */
3855 if (offset + WPA_IE_MIN_OUI_LEN > len) {
3856 err = -EINVAL;
57d6e91a 3857 brcmf_err("no multicast cipher suite\n");
1a873342
HM		 3858 goto exit;
3859 }
3860
3861 if (!brcmf_valid_wpa_oui(&data[offset], is_rsn_ie)) {
3862 err = -EINVAL;
57d6e91a 3863 brcmf_err("ivalid OUI\n");
1a873342
HM		 3864 goto exit;
3865 }
3866 offset += TLV_OUI_LEN;
3867
3868 /* pick up multicast cipher */
3869 switch (data[offset]) {
3870 case WPA_CIPHER_NONE:
3871 gval = 0;
3872 break;
3873 case WPA_CIPHER_WEP_40:
3874 case WPA_CIPHER_WEP_104:
3875 gval = WEP_ENABLED;
3876 break;
3877 case WPA_CIPHER_TKIP:
3878 gval = TKIP_ENABLED;
3879 break;
3880 case WPA_CIPHER_AES_CCM:
3881 gval = AES_ENABLED;
3882 break;
3883 default:
3884 err = -EINVAL;
57d6e91a 3885 brcmf_err("Invalid multi cast cipher info\n");
1a873342
HM		 3886 goto exit;
3887 }
3888
3889 offset++;
3890 /* walk thru unicast cipher list and pick up what we recognize */
3891 count = data[offset] + (data[offset + 1] << 8);
3892 offset += WPA_IE_SUITE_COUNT_LEN;
3893 /* Check for unicast suite(s) */
3894 if (offset + (WPA_IE_MIN_OUI_LEN * count) > len) {
3895 err = -EINVAL;
57d6e91a 3896 brcmf_err("no unicast cipher suite\n");
1a873342
HM		 3897 goto exit;
3898 }
3899 for (i = 0; i < count; i++) {
3900 if (!brcmf_valid_wpa_oui(&data[offset], is_rsn_ie)) {
3901 err = -EINVAL;
57d6e91a 3902 brcmf_err("ivalid OUI\n");
1a873342
HM		 3903 goto exit;
3904 }
3905 offset += TLV_OUI_LEN;
3906 switch (data[offset]) {
3907 case WPA_CIPHER_NONE:
3908 break;
3909 case WPA_CIPHER_WEP_40:
3910 case WPA_CIPHER_WEP_104:
3911 pval |= WEP_ENABLED;
3912 break;
3913 case WPA_CIPHER_TKIP:
3914 pval |= TKIP_ENABLED;
3915 break;
3916 case WPA_CIPHER_AES_CCM:
3917 pval |= AES_ENABLED;
3918 break;
3919 default:
57d6e91a 3920 brcmf_err("Ivalid unicast security info\n");
1a873342
HM		 3921 }
3922 offset++;
3923 }
3924 /* walk thru auth management suite list and pick up what we recognize */
3925 count = data[offset] + (data[offset + 1] << 8);
3926 offset += WPA_IE_SUITE_COUNT_LEN;
3927 /* Check for auth key management suite(s) */
3928 if (offset + (WPA_IE_MIN_OUI_LEN * count) > len) {
3929 err = -EINVAL;
57d6e91a 3930 brcmf_err("no auth key mgmt suite\n");
1a873342
HM		 3931 goto exit;
3932 }
3933 for (i = 0; i < count; i++) {
3934 if (!brcmf_valid_wpa_oui(&data[offset], is_rsn_ie)) {
3935 err = -EINVAL;
57d6e91a 3936 brcmf_err("ivalid OUI\n");
1a873342
HM		 3937 goto exit;
3938 }
3939 offset += TLV_OUI_LEN;
3940 switch (data[offset]) {
3941 case RSN_AKM_NONE:
d96b801f 3942 brcmf_dbg(TRACE, "RSN_AKM_NONE\n");
1a873342
HM		 3943 wpa_auth |= WPA_AUTH_NONE;
3944 break;
3945 case RSN_AKM_UNSPECIFIED:
d96b801f 3946 brcmf_dbg(TRACE, "RSN_AKM_UNSPECIFIED\n");
1a873342
HM		 3947 is_rsn_ie ? (wpa_auth |= WPA2_AUTH_UNSPECIFIED) :
3948 (wpa_auth |= WPA_AUTH_UNSPECIFIED);
3949 break;
3950 case RSN_AKM_PSK:
d96b801f 3951 brcmf_dbg(TRACE, "RSN_AKM_PSK\n");
1a873342
HM		 3952 is_rsn_ie ? (wpa_auth |= WPA2_AUTH_PSK) :
3953 (wpa_auth |= WPA_AUTH_PSK);
3954 break;
3955 default:
57d6e91a 3956 brcmf_err("Ivalid key mgmt info\n");
1a873342
HM		 3957 }
3958 offset++;
3959 }
3960
3961 if (is_rsn_ie) {
3962 wme_bss_disable = 1;
3963 if ((offset + RSN_CAP_LEN) <= len) {
3964 rsn_cap = data[offset] + (data[offset + 1] << 8);
3965 if (rsn_cap & RSN_CAP_PTK_REPLAY_CNTR_MASK)
3966 wme_bss_disable = 0;
3967 }
3968 /* set wme_bss_disable to sync RSN Capabilities */
ac24be6f 3969 err = brcmf_fil_bsscfg_int_set(ifp, "wme_bss_disable",
81f5dcb8 3970 wme_bss_disable);
1a873342 3971 if (err < 0) {
57d6e91a 3972 brcmf_err("wme_bss_disable error %d\n", err);
1a873342
HM		 3973 goto exit;
3974 }
3975 }
3976 /* FOR WPS , set SES_OW_ENABLED */
3977 wsec = (pval | gval | SES_OW_ENABLED);
3978
3979 /* set auth */
ac24be6f 3980 err = brcmf_fil_bsscfg_int_set(ifp, "auth", auth);
1a873342 3981 if (err < 0) {
57d6e91a 3982 brcmf_err("auth error %d\n", err);
1a873342
HM		 3983 goto exit;
3984 }
3985 /* set wsec */
ac24be6f 3986 err = brcmf_fil_bsscfg_int_set(ifp, "wsec", wsec);
1a873342 3987 if (err < 0) {
57d6e91a 3988 brcmf_err("wsec error %d\n", err);
1a873342
HM		 3989 goto exit;
3990 }
3991 /* set upper-layer auth */
ac24be6f 3992 err = brcmf_fil_bsscfg_int_set(ifp, "wpa_auth", wpa_auth);
1a873342 3993 if (err < 0) {
57d6e91a 3994 brcmf_err("wpa_auth error %d\n", err);
1a873342
HM		 3995 goto exit;
3996 }
3997
3998exit:
3999 return err;
4000}
4001
4002static s32
3082b9be 4003brcmf_parse_vndr_ies(const u8 *vndr_ie_buf, u32 vndr_ie_len,
1a873342
HM		 4004 struct parsed_vndr_ies *vndr_ies)
4005{
1a873342
HM		 4006 struct brcmf_vs_tlv *vndrie;
4007 struct brcmf_tlv *ie;
4008 struct parsed_vndr_ie_info *parsed_info;
4009 s32 remaining_len;
4010
4011 remaining_len = (s32)vndr_ie_len;
4012 memset(vndr_ies, 0, sizeof(*vndr_ies));
4013
4014 ie = (struct brcmf_tlv *)vndr_ie_buf;
4015 while (ie) {
4016 if (ie->id != WLAN_EID_VENDOR_SPECIFIC)
4017 goto next;
4018 vndrie = (struct brcmf_vs_tlv *)ie;
4019 /* len should be bigger than OUI length + one */
4020 if (vndrie->len < (VS_IE_FIXED_HDR_LEN - TLV_HDR_LEN + 1)) {
57d6e91a
AS		 4021 brcmf_err("invalid vndr ie. length is too small %d\n",
4022 vndrie->len);
1a873342
HM		 4023 goto next;
4024 }
4025 /* if wpa or wme ie, do not add ie */
4026 if (!memcmp(vndrie->oui, (u8 *)WPA_OUI, TLV_OUI_LEN) &&
4027 ((vndrie->oui_type == WPA_OUI_TYPE) ||
4028 (vndrie->oui_type == WME_OUI_TYPE))) {
d96b801f 4029 brcmf_dbg(TRACE, "Found WPA/WME oui. Do not add it\n");
1a873342
HM		 4030 goto next;
4031 }
4032
4033 parsed_info = &vndr_ies->ie_info[vndr_ies->count];
4034
4035 /* save vndr ie information */
4036 parsed_info->ie_ptr = (char *)vndrie;
4037 parsed_info->ie_len = vndrie->len + TLV_HDR_LEN;
4038 memcpy(&parsed_info->vndrie, vndrie, sizeof(*vndrie));
4039
4040 vndr_ies->count++;
4041
d96b801f
AS		 4042 brcmf_dbg(TRACE, "** OUI %02x %02x %02x, type 0x%02x\n",
4043 parsed_info->vndrie.oui[0],
4044 parsed_info->vndrie.oui[1],
4045 parsed_info->vndrie.oui[2],
4046 parsed_info->vndrie.oui_type);
1a873342 4047
9f440b7b 4048 if (vndr_ies->count >= VNDR_IE_PARSE_LIMIT)
1a873342
HM		 4049 break;
4050next:
b41fc3d7
HM		 4051 remaining_len -= (ie->len + TLV_HDR_LEN);
4052 if (remaining_len <= TLV_HDR_LEN)
1a873342
HM		 4053 ie = NULL;
4054 else
b41fc3d7
HM		 4055 ie = (struct brcmf_tlv *)(((u8 *)ie) + ie->len +
4056 TLV_HDR_LEN);
1a873342 4057 }
12f32370 4058 return 0;
1a873342
HM		 4059}
4060
4061static u32
4062brcmf_vndr_ie(u8 *iebuf, s32 pktflag, u8 *ie_ptr, u32 ie_len, s8 *add_del_cmd)
4063{
4064
1a873342
HM		 4065 strncpy(iebuf, add_del_cmd, VNDR_IE_CMD_LEN - 1);
4066 iebuf[VNDR_IE_CMD_LEN - 1] = '\0';
4067
362126cd 4068 put_unaligned_le32(1, &iebuf[VNDR_IE_COUNT_OFFSET]);
1a873342 4069
362126cd 4070 put_unaligned_le32(pktflag, &iebuf[VNDR_IE_PKTFLAG_OFFSET]);
1a873342
HM		 4071
4072 memcpy(&iebuf[VNDR_IE_VSIE_OFFSET], ie_ptr, ie_len);
4073
4074 return ie_len + VNDR_IE_HDR_SIZE;
4075}
4076
1332e26e
AS		 4077s32 brcmf_vif_set_mgmt_ie(struct brcmf_cfg80211_vif *vif, s32 pktflag,
4078 const u8 *vndr_ie_buf, u32 vndr_ie_len)
1a873342 4079{
1332e26e
AS		 4080 struct brcmf_if *ifp;
4081 struct vif_saved_ie *saved_ie;
1a873342
HM		 4082 s32 err = 0;
4083 u8 *iovar_ie_buf;
4084 u8 *curr_ie_buf;
4085 u8 *mgmt_ie_buf = NULL;
3e4f319d 4086 int mgmt_ie_buf_len;
81118d16 4087 u32 *mgmt_ie_len;
1a873342
HM		 4088 u32 del_add_ie_buf_len = 0;
4089 u32 total_ie_buf_len = 0;
4090 u32 parsed_ie_buf_len = 0;
4091 struct parsed_vndr_ies old_vndr_ies;
4092 struct parsed_vndr_ies new_vndr_ies;
4093 struct parsed_vndr_ie_info *vndrie_info;
4094 s32 i;
4095 u8 *ptr;
3e4f319d 4096 int remained_buf_len;
1a873342 4097
1332e26e
AS		 4098 if (!vif)
4099 return -ENODEV;
4100 ifp = vif->ifp;
4101 saved_ie = &vif->saved_ie;
4102
37a869ec
HM		 4103 brcmf_dbg(TRACE, "bsscfgidx %d, pktflag : 0x%02X\n", ifp->bsscfgidx,
4104 pktflag);
1a873342
HM		 4105 iovar_ie_buf = kzalloc(WL_EXTRA_BUF_MAX, GFP_KERNEL);
4106 if (!iovar_ie_buf)
4107 return -ENOMEM;
4108 curr_ie_buf = iovar_ie_buf;
89286dc9
HM		 4109 switch (pktflag) {
4110 case BRCMF_VNDR_IE_PRBREQ_FLAG:
4111 mgmt_ie_buf = saved_ie->probe_req_ie;
4112 mgmt_ie_len = &saved_ie->probe_req_ie_len;
4113 mgmt_ie_buf_len = sizeof(saved_ie->probe_req_ie);
4114 break;
4115 case BRCMF_VNDR_IE_PRBRSP_FLAG:
4116 mgmt_ie_buf = saved_ie->probe_res_ie;
4117 mgmt_ie_len = &saved_ie->probe_res_ie_len;
4118 mgmt_ie_buf_len = sizeof(saved_ie->probe_res_ie);
4119 break;
4120 case BRCMF_VNDR_IE_BEACON_FLAG:
4121 mgmt_ie_buf = saved_ie->beacon_ie;
4122 mgmt_ie_len = &saved_ie->beacon_ie_len;
4123 mgmt_ie_buf_len = sizeof(saved_ie->beacon_ie);
4124 break;
4125 case BRCMF_VNDR_IE_ASSOCREQ_FLAG:
4126 mgmt_ie_buf = saved_ie->assoc_req_ie;
4127 mgmt_ie_len = &saved_ie->assoc_req_ie_len;
4128 mgmt_ie_buf_len = sizeof(saved_ie->assoc_req_ie);
4129 break;
4130 default:
4131 err = -EPERM;
4132 brcmf_err("not suitable type\n");
4133 goto exit;
1a873342
HM		 4134 }
4135
4136 if (vndr_ie_len > mgmt_ie_buf_len) {
4137 err = -ENOMEM;
57d6e91a 4138 brcmf_err("extra IE size too big\n");
1a873342
HM		 4139 goto exit;
4140 }
4141
4142 /* parse and save new vndr_ie in curr_ie_buff before comparing it */
4143 if (vndr_ie_buf && vndr_ie_len && curr_ie_buf) {
4144 ptr = curr_ie_buf;
4145 brcmf_parse_vndr_ies(vndr_ie_buf, vndr_ie_len, &new_vndr_ies);
4146 for (i = 0; i < new_vndr_ies.count; i++) {
4147 vndrie_info = &new_vndr_ies.ie_info[i];
4148 memcpy(ptr + parsed_ie_buf_len, vndrie_info->ie_ptr,
4149 vndrie_info->ie_len);
4150 parsed_ie_buf_len += vndrie_info->ie_len;
4151 }
4152 }
4153
b41fc3d7 4154 if (mgmt_ie_buf && *mgmt_ie_len) {
1a873342
HM		 4155 if (parsed_ie_buf_len && (parsed_ie_buf_len == *mgmt_ie_len) &&
4156 (memcmp(mgmt_ie_buf, curr_ie_buf,
4157 parsed_ie_buf_len) == 0)) {
d96b801f 4158 brcmf_dbg(TRACE, "Previous mgmt IE equals to current IE\n");
1a873342
HM		 4159 goto exit;
4160 }
4161
4162 /* parse old vndr_ie */
4163 brcmf_parse_vndr_ies(mgmt_ie_buf, *mgmt_ie_len, &old_vndr_ies);
4164
4165 /* make a command to delete old ie */
4166 for (i = 0; i < old_vndr_ies.count; i++) {
4167 vndrie_info = &old_vndr_ies.ie_info[i];
4168
d96b801f
AS		 4169 brcmf_dbg(TRACE, "DEL ID : %d, Len: %d , OUI:%02x:%02x:%02x\n",
4170 vndrie_info->vndrie.id,
4171 vndrie_info->vndrie.len,
4172 vndrie_info->vndrie.oui[0],
4173 vndrie_info->vndrie.oui[1],
4174 vndrie_info->vndrie.oui[2]);
1a873342
HM		 4175
4176 del_add_ie_buf_len = brcmf_vndr_ie(curr_ie_buf, pktflag,
4177 vndrie_info->ie_ptr,
4178 vndrie_info->ie_len,
4179 "del");
4180 curr_ie_buf += del_add_ie_buf_len;
4181 total_ie_buf_len += del_add_ie_buf_len;
4182 }
4183 }
4184
4185 *mgmt_ie_len = 0;
4186 /* Add if there is any extra IE */
4187 if (mgmt_ie_buf && parsed_ie_buf_len) {
4188 ptr = mgmt_ie_buf;
4189
4190 remained_buf_len = mgmt_ie_buf_len;
4191
4192 /* make a command to add new ie */
4193 for (i = 0; i < new_vndr_ies.count; i++) {
4194 vndrie_info = &new_vndr_ies.ie_info[i];
4195
b41fc3d7
HM		 4196 /* verify remained buf size before copy data */
4197 if (remained_buf_len < (vndrie_info->vndrie.len +
4198 VNDR_IE_VSIE_OFFSET)) {
57d6e91a
AS		 4199 brcmf_err("no space in mgmt_ie_buf: len left %d",
4200 remained_buf_len);
b41fc3d7
HM		 4201 break;
4202 }
4203 remained_buf_len -= (vndrie_info->ie_len +
4204 VNDR_IE_VSIE_OFFSET);
4205
d96b801f
AS		 4206 brcmf_dbg(TRACE, "ADDED ID : %d, Len: %d, OUI:%02x:%02x:%02x\n",
4207 vndrie_info->vndrie.id,
4208 vndrie_info->vndrie.len,
4209 vndrie_info->vndrie.oui[0],
4210 vndrie_info->vndrie.oui[1],
4211 vndrie_info->vndrie.oui[2]);
1a873342
HM		 4212
4213 del_add_ie_buf_len = brcmf_vndr_ie(curr_ie_buf, pktflag,
4214 vndrie_info->ie_ptr,
4215 vndrie_info->ie_len,
4216 "add");
1a873342
HM		 4217
4218 /* save the parsed IE in wl struct */
4219 memcpy(ptr + (*mgmt_ie_len), vndrie_info->ie_ptr,
4220 vndrie_info->ie_len);
4221 *mgmt_ie_len += vndrie_info->ie_len;
4222
4223 curr_ie_buf += del_add_ie_buf_len;
4224 total_ie_buf_len += del_add_ie_buf_len;
4225 }
4226 }
4227 if (total_ie_buf_len) {
c1179033 4228 err = brcmf_fil_bsscfg_data_set(ifp, "vndr_ie", iovar_ie_buf,
81f5dcb8 4229 total_ie_buf_len);
1a873342 4230 if (err)
57d6e91a 4231 brcmf_err("vndr ie set error : %d\n", err);
1a873342
HM		 4232 }
4233
4234exit:
4235 kfree(iovar_ie_buf);
4236 return err;
4237}
4238
5f4f9f11
AS		 4239s32 brcmf_vif_clear_mgmt_ies(struct brcmf_cfg80211_vif *vif)
4240{
4241 s32 pktflags[] = {
4242 BRCMF_VNDR_IE_PRBREQ_FLAG,
4243 BRCMF_VNDR_IE_PRBRSP_FLAG,
4244 BRCMF_VNDR_IE_BEACON_FLAG
4245 };
4246 int i;
4247
4248 for (i = 0; i < ARRAY_SIZE(pktflags); i++)
4249 brcmf_vif_set_mgmt_ie(vif, pktflags[i], NULL, 0);
4250
4251 memset(&vif->saved_ie, 0, sizeof(vif->saved_ie));
4252 return 0;
4253}
4254
a0f07959
HM		 4255static s32
4256brcmf_config_ap_mgmt_ie(struct brcmf_cfg80211_vif *vif,
4257 struct cfg80211_beacon_data *beacon)
4258{
4259 s32 err;
4260
4261 /* Set Beacon IEs to FW */
4262 err = brcmf_vif_set_mgmt_ie(vif, BRCMF_VNDR_IE_BEACON_FLAG,
4263 beacon->tail, beacon->tail_len);
4264 if (err) {
4265 brcmf_err("Set Beacon IE Failed\n");
4266 return err;
4267 }
4268 brcmf_dbg(TRACE, "Applied Vndr IEs for Beacon\n");
4269
4270 /* Set Probe Response IEs to FW */
4271 err = brcmf_vif_set_mgmt_ie(vif, BRCMF_VNDR_IE_PRBRSP_FLAG,
4272 beacon->proberesp_ies,
4273 beacon->proberesp_ies_len);
4274 if (err)
4275 brcmf_err("Set Probe Resp IE Failed\n");
4276 else
4277 brcmf_dbg(TRACE, "Applied Vndr IEs for Probe Resp\n");
4278
4279 return err;
4280}
4281
1a873342
HM		 4282static s32
4283brcmf_cfg80211_start_ap(struct wiphy *wiphy, struct net_device *ndev,
4284 struct cfg80211_ap_settings *settings)
4285{
4286 s32 ie_offset;
1c9d30cf 4287 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy);
ac24be6f 4288 struct brcmf_if *ifp = netdev_priv(ndev);
4b5800fe 4289 const struct brcmf_tlv *ssid_ie;
98027769 4290 const struct brcmf_tlv *country_ie;
1a873342 4291 struct brcmf_ssid_le ssid_le;
1a873342 4292 s32 err = -EPERM;
4b5800fe
JB		 4293 const struct brcmf_tlv *rsn_ie;
4294 const struct brcmf_vs_tlv *wpa_ie;
1a873342 4295 struct brcmf_join_params join_params;
a0f07959
HM		 4296 enum nl80211_iftype dev_role;
4297 struct brcmf_fil_bss_enable_le bss_enable;
06c01585 4298 u16 chanspec;
a44aa400 4299 bool mbss;
98027769 4300 int is_11d;
1a873342 4301
06c01585
AS		 4302 brcmf_dbg(TRACE, "ctrlchn=%d, center=%d, bw=%d, beacon_interval=%d, dtim_period=%d,\n",
4303 settings->chandef.chan->hw_value,
4304 settings->chandef.center_freq1, settings->chandef.width,
a9a56878 4305 settings->beacon_interval, settings->dtim_period);
d96b801f
AS		 4306 brcmf_dbg(TRACE, "ssid=%s(%zu), auth_type=%d, inactivity_timeout=%d\n",
4307 settings->ssid, settings->ssid_len, settings->auth_type,
4308 settings->inactivity_timeout);
426d0a56 4309 dev_role = ifp->vif->wdev.iftype;
a44aa400 4310 mbss = ifp->vif->mbss;
1a873342 4311
98027769
AS		 4312 /* store current 11d setting */
4313 brcmf_fil_cmd_int_get(ifp, BRCMF_C_GET_REGULATORY, &ifp->vif->is_11d);
4314 country_ie = brcmf_parse_tlvs((u8 *)settings->beacon.tail,
4315 settings->beacon.tail_len,
4316 WLAN_EID_COUNTRY);
4317 is_11d = country_ie ? 1 : 0;
4318
1a873342
HM		 4319 memset(&ssid_le, 0, sizeof(ssid_le));
4320 if (settings->ssid == NULL || settings->ssid_len == 0) {
4321 ie_offset = DOT11_MGMT_HDR_LEN + DOT11_BCN_PRB_FIXED_LEN;
4322 ssid_ie = brcmf_parse_tlvs(
4323 (u8 *)&settings->beacon.head[ie_offset],
4324 settings->beacon.head_len - ie_offset,
4325 WLAN_EID_SSID);
4326 if (!ssid_ie)
4327 return -EINVAL;
4328
4329 memcpy(ssid_le.SSID, ssid_ie->data, ssid_ie->len);
4330 ssid_le.SSID_len = cpu_to_le32(ssid_ie->len);
d96b801f 4331 brcmf_dbg(TRACE, "SSID is (%s) in Head\n", ssid_le.SSID);
1a873342
HM		 4332 } else {
4333 memcpy(ssid_le.SSID, settings->ssid, settings->ssid_len);
4334 ssid_le.SSID_len = cpu_to_le32((u32)settings->ssid_len);
4335 }
4336
a44aa400
HM		 4337 if (!mbss) {
4338 brcmf_set_mpc(ifp, 0);
4339 brcmf_configure_arp_offload(ifp, false);
4340 }
1a873342
HM		 4341
4342 /* find the RSN_IE */
4343 rsn_ie = brcmf_parse_tlvs((u8 *)settings->beacon.tail,
4344 settings->beacon.tail_len, WLAN_EID_RSN);
4345
4346 /* find the WPA_IE */
4347 wpa_ie = brcmf_find_wpaie((u8 *)settings->beacon.tail,
4348 settings->beacon.tail_len);
4349
1a873342 4350 if ((wpa_ie != NULL || rsn_ie != NULL)) {
d96b801f 4351 brcmf_dbg(TRACE, "WPA(2) IE is found\n");
1a873342
HM		 4352 if (wpa_ie != NULL) {
4353 /* WPA IE */
a44aa400 4354 err = brcmf_configure_wpaie(ifp, wpa_ie, false);
1a873342
HM		 4355 if (err < 0)
4356 goto exit;
1a873342 4357 } else {
a44aa400
HM		 4358 struct brcmf_vs_tlv *tmp_ie;
4359
4360 tmp_ie = (struct brcmf_vs_tlv *)rsn_ie;
4361
1a873342 4362 /* RSN IE */
a44aa400 4363 err = brcmf_configure_wpaie(ifp, tmp_ie, true);
1a873342
HM		 4364 if (err < 0)
4365 goto exit;
1a873342 4366 }
1a873342 4367 } else {
d96b801f 4368 brcmf_dbg(TRACE, "No WPA(2) IEs found\n");
1f170110 4369 brcmf_configure_opensecurity(ifp);
1a873342 4370 }
1a873342 4371
a0f07959 4372 brcmf_config_ap_mgmt_ie(ifp->vif, &settings->beacon);
1a873342 4373
a44aa400
HM		 4374 if (!mbss) {
4375 chanspec = chandef_to_chanspec(&cfg->d11inf,
4376 &settings->chandef);
4377 err = brcmf_fil_iovar_int_set(ifp, "chanspec", chanspec);
1a873342 4378 if (err < 0) {
a44aa400
HM		 4379 brcmf_err("Set Channel failed: chspec=%d, %d\n",
4380 chanspec, err);
1a873342
HM		 4381 goto exit;
4382 }
a44aa400 4383
98027769
AS		 4384 if (is_11d != ifp->vif->is_11d) {
4385 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_REGULATORY,
4386 is_11d);
4387 if (err < 0) {
4388 brcmf_err("Regulatory Set Error, %d\n", err);
4389 goto exit;
4390 }
4391 }
a44aa400
HM		 4392 if (settings->beacon_interval) {
4393 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_BCNPRD,
4394 settings->beacon_interval);
4395 if (err < 0) {
4396 brcmf_err("Beacon Interval Set Error, %d\n",
4397 err);
4398 goto exit;
4399 }
4400 }
4401 if (settings->dtim_period) {
4402 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_DTIMPRD,
4403 settings->dtim_period);
4404 if (err < 0) {
4405 brcmf_err("DTIM Interval Set Error, %d\n", err);
4406 goto exit;
4407 }
1a873342 4408 }
a0f07959 4409
8abffd81
HM		 4410 if ((dev_role == NL80211_IFTYPE_AP) &&
4411 ((ifp->ifidx == 0) ||
4412 !brcmf_feat_is_enabled(ifp, BRCMF_FEAT_RSDB))) {
a44aa400
HM		 4413 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_DOWN, 1);
4414 if (err < 0) {
4415 brcmf_err("BRCMF_C_DOWN error %d\n", err);
4416 goto exit;
4417 }
4418 brcmf_fil_iovar_int_set(ifp, "apsta", 0);
4419 }
4420
4421 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_INFRA, 1);
a0f07959 4422 if (err < 0) {
a44aa400 4423 brcmf_err("SET INFRA error %d\n", err);
a0f07959
HM		 4424 goto exit;
4425 }
98027769
AS		 4426 } else if (WARN_ON(is_11d != ifp->vif->is_11d)) {
4427 /* Multiple-BSS should use same 11d configuration */
4428 err = -EINVAL;
4429 goto exit;
1a873342 4430 }
a0f07959 4431 if (dev_role == NL80211_IFTYPE_AP) {
a44aa400
HM		 4432 if ((brcmf_feat_is_enabled(ifp, BRCMF_FEAT_MBSS)) && (!mbss))
4433 brcmf_fil_iovar_int_set(ifp, "mbss", 1);
4434
a0f07959
HM		 4435 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_AP, 1);
4436 if (err < 0) {
4437 brcmf_err("setting AP mode failed %d\n", err);
4438 goto exit;
4439 }
4440 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_UP, 1);
4441 if (err < 0) {
4442 brcmf_err("BRCMF_C_UP error (%d)\n", err);
4443 goto exit;
4444 }
118eb304
HM		 4445 /* On DOWN the firmware removes the WEP keys, reconfigure
4446 * them if they were set.
4447 */
4448 brcmf_cfg80211_reconfigure_wep(ifp);
a0f07959
HM		 4449
4450 memset(&join_params, 0, sizeof(join_params));
4451 /* join parameters starts with ssid */
4452 memcpy(&join_params.ssid_le, &ssid_le, sizeof(ssid_le));
4453 /* create softap */
4454 err = brcmf_fil_cmd_data_set(ifp, BRCMF_C_SET_SSID,
4455 &join_params, sizeof(join_params));
4456 if (err < 0) {
4457 brcmf_err("SET SSID error (%d)\n", err);
4458 goto exit;
4459 }
4460 brcmf_dbg(TRACE, "AP mode configuration complete\n");
4461 } else {
4462 err = brcmf_fil_bsscfg_data_set(ifp, "ssid", &ssid_le,
4463 sizeof(ssid_le));
4464 if (err < 0) {
4465 brcmf_err("setting ssid failed %d\n", err);
4466 goto exit;
4467 }
37a869ec 4468 bss_enable.bsscfgidx = cpu_to_le32(ifp->bsscfgidx);
a0f07959
HM		 4469 bss_enable.enable = cpu_to_le32(1);
4470 err = brcmf_fil_iovar_data_set(ifp, "bss", &bss_enable,
4471 sizeof(bss_enable));
4472 if (err < 0) {
4473 brcmf_err("bss_enable config failed %d\n", err);
4474 goto exit;
4475 }
4476
4477 brcmf_dbg(TRACE, "GO mode configuration complete\n");
4478 }
c1179033 4479 set_bit(BRCMF_VIF_STATUS_AP_CREATED, &ifp->vif->sme_state);
92121e69 4480 brcmf_net_setcarrier(ifp, true);
1a873342
HM		 4481
4482exit:
a44aa400 4483 if ((err) && (!mbss)) {
f96aa07e 4484 brcmf_set_mpc(ifp, 1);
b3657453
HM		 4485 brcmf_configure_arp_offload(ifp, true);
4486 }
1a873342
HM		 4487 return err;
4488}
4489
4490static int brcmf_cfg80211_stop_ap(struct wiphy *wiphy, struct net_device *ndev)
4491{
c1179033 4492 struct brcmf_if *ifp = netdev_priv(ndev);
5c33a942 4493 s32 err;
426d0a56 4494 struct brcmf_fil_bss_enable_le bss_enable;
5c33a942 4495 struct brcmf_join_params join_params;
1a873342 4496
d96b801f 4497 brcmf_dbg(TRACE, "Enter\n");
1a873342 4498
426d0a56 4499 if (ifp->vif->wdev.iftype == NL80211_IFTYPE_AP) {
1a873342
HM		 4500 /* Due to most likely deauths outstanding we sleep */
4501 /* first to make sure they get processed by fw. */
4502 msleep(400);
5c33a942 4503
a44aa400
HM		 4504 if (ifp->vif->mbss) {
4505 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_DOWN, 1);
4506 return err;
4507 }
4508
5c33a942
HM		 4509 memset(&join_params, 0, sizeof(join_params));
4510 err = brcmf_fil_cmd_data_set(ifp, BRCMF_C_SET_SSID,
4511 &join_params, sizeof(join_params));
4512 if (err < 0)
4513 brcmf_err("SET SSID error (%d)\n", err);
a44aa400 4514 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_DOWN, 1);
5c33a942 4515 if (err < 0)
a44aa400 4516 brcmf_err("BRCMF_C_DOWN error %d\n", err);
5c33a942
HM		 4517 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_AP, 0);
4518 if (err < 0)
4519 brcmf_err("setting AP mode failed %d\n", err);
4520 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_INFRA, 0);
4521 if (err < 0)
4522 brcmf_err("setting INFRA mode failed %d\n", err);
a44aa400
HM		 4523 if (brcmf_feat_is_enabled(ifp, BRCMF_FEAT_MBSS))
4524 brcmf_fil_iovar_int_set(ifp, "mbss", 0);
98027769
AS		 4525 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_REGULATORY,
4526 ifp->vif->is_11d);
4527 if (err < 0)
4528 brcmf_err("restoring REGULATORY setting failed %d\n",
4529 err);
a44aa400
HM		 4530 /* Bring device back up so it can be used again */
4531 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_UP, 1);
4532 if (err < 0)
4533 brcmf_err("BRCMF_C_UP error %d\n", err);
426d0a56 4534 } else {
37a869ec 4535 bss_enable.bsscfgidx = cpu_to_le32(ifp->bsscfgidx);
426d0a56
HM		 4536 bss_enable.enable = cpu_to_le32(0);
4537 err = brcmf_fil_iovar_data_set(ifp, "bss", &bss_enable,
4538 sizeof(bss_enable));
4539 if (err < 0)
4540 brcmf_err("bss_enable config failed %d\n", err);
1a873342 4541 }
f96aa07e 4542 brcmf_set_mpc(ifp, 1);
b3657453 4543 brcmf_configure_arp_offload(ifp, true);
426d0a56 4544 clear_bit(BRCMF_VIF_STATUS_AP_CREATED, &ifp->vif->sme_state);
92121e69 4545 brcmf_net_setcarrier(ifp, false);
426d0a56 4546
1a873342
HM		 4547 return err;
4548}
4549
a0f07959
HM		 4550static s32
4551brcmf_cfg80211_change_beacon(struct wiphy *wiphy, struct net_device *ndev,
4552 struct cfg80211_beacon_data *info)
4553{
a0f07959
HM		 4554 struct brcmf_if *ifp = netdev_priv(ndev);
4555 s32 err;
4556
4557 brcmf_dbg(TRACE, "Enter\n");
4558
a0f07959
HM		 4559 err = brcmf_config_ap_mgmt_ie(ifp->vif, info);
4560
4561 return err;
4562}
4563
1a873342
HM		 4564static int
4565brcmf_cfg80211_del_station(struct wiphy *wiphy, struct net_device *ndev,
89c771e5 4566 struct station_del_parameters *params)
1a873342 4567{
a0f07959 4568 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy);
1a873342 4569 struct brcmf_scb_val_le scbval;
0abb5f21 4570 struct brcmf_if *ifp = netdev_priv(ndev);
1a873342
HM		 4571 s32 err;
4572
89c771e5 4573 if (!params->mac)
1a873342
HM		 4574 return -EFAULT;
4575
89c771e5 4576 brcmf_dbg(TRACE, "Enter %pM\n", params->mac);
1a873342 4577
a0f07959
HM		 4578 if (ifp->vif == cfg->p2p.bss_idx[P2PAPI_BSSCFG_DEVICE].vif)
4579 ifp = cfg->p2p.bss_idx[P2PAPI_BSSCFG_PRIMARY].vif->ifp;
ce81e317 4580 if (!check_vif_up(ifp->vif))
1a873342
HM		 4581 return -EIO;
4582
89c771e5 4583 memcpy(&scbval.ea, params->mac, ETH_ALEN);
ba8b6ae6 4584 scbval.val = cpu_to_le32(params->reason_code);
0abb5f21 4585 err = brcmf_fil_cmd_data_set(ifp, BRCMF_C_SCB_DEAUTHENTICATE_FOR_REASON,
81f5dcb8 4586 &scbval, sizeof(scbval));
1a873342 4587 if (err)
57d6e91a 4588 brcmf_err("SCB_DEAUTHENTICATE_FOR_REASON failed %d\n", err);
7ab6acd0 4589
d96b801f 4590 brcmf_dbg(TRACE, "Exit\n");
1a873342
HM		 4591 return err;
4592}
4593
6b89dcb3
HM		 4594static int
4595brcmf_cfg80211_change_station(struct wiphy *wiphy, struct net_device *ndev,
4596 const u8 *mac, struct station_parameters *params)
4597{
4598 struct brcmf_if *ifp = netdev_priv(ndev);
4599 s32 err;
4600
4601 brcmf_dbg(TRACE, "Enter, MAC %pM, mask 0x%04x set 0x%04x\n", mac,
4602 params->sta_flags_mask, params->sta_flags_set);
4603
4604 /* Ignore all 00 MAC */
4605 if (is_zero_ether_addr(mac))
4606 return 0;
4607
4608 if (!(params->sta_flags_mask & BIT(NL80211_STA_FLAG_AUTHORIZED)))
4609 return 0;
4610
4611 if (params->sta_flags_set & BIT(NL80211_STA_FLAG_AUTHORIZED))
4612 err = brcmf_fil_cmd_data_set(ifp, BRCMF_C_SET_SCB_AUTHORIZE,
4613 (void *)mac, ETH_ALEN);
4614 else
4615 err = brcmf_fil_cmd_data_set(ifp, BRCMF_C_SET_SCB_DEAUTHORIZE,
4616 (void *)mac, ETH_ALEN);
4617 if (err < 0)
4618 brcmf_err("Setting SCB (de-)authorize failed, %d\n", err);
4619
4620 return err;
4621}
0de8aace
HM		 4622
4623static void
4624brcmf_cfg80211_mgmt_frame_register(struct wiphy *wiphy,
4625 struct wireless_dev *wdev,
4626 u16 frame_type, bool reg)
4627{
7fa2e352 4628 struct brcmf_cfg80211_vif *vif;
0de8aace
HM		 4629 u16 mgmt_type;
4630
4631 brcmf_dbg(TRACE, "Enter, frame_type %04x, reg=%d\n", frame_type, reg);
4632
4633 mgmt_type = (frame_type & IEEE80211_FCTL_STYPE) >> 4;
7fa2e352 4634 vif = container_of(wdev, struct brcmf_cfg80211_vif, wdev);
0de8aace
HM		 4635 if (reg)
4636 vif->mgmt_rx_reg |= BIT(mgmt_type);
4637 else
318a64ce 4638 vif->mgmt_rx_reg &= ~BIT(mgmt_type);
0de8aace
HM		 4639}
4640
4641
4642static int
4643brcmf_cfg80211_mgmt_tx(struct wiphy *wiphy, struct wireless_dev *wdev,
b176e629 4644 struct cfg80211_mgmt_tx_params *params, u64 *cookie)
0de8aace
HM		 4645{
4646 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy);
b176e629
AO		 4647 struct ieee80211_channel *chan = params->chan;
4648 const u8 *buf = params->buf;
4649 size_t len = params->len;
0de8aace
HM		 4650 const struct ieee80211_mgmt *mgmt;
4651 struct brcmf_cfg80211_vif *vif;
4652 s32 err = 0;
4653 s32 ie_offset;
4654 s32 ie_len;
18e2f61d
HM		 4655 struct brcmf_fil_action_frame_le *action_frame;
4656 struct brcmf_fil_af_params_le *af_params;
4657 bool ack;
4658 s32 chan_nr;
c2ff8cad 4659 u32 freq;
0de8aace
HM		 4660
4661 brcmf_dbg(TRACE, "Enter\n");
4662
4663 *cookie = 0;
4664
4665 mgmt = (const struct ieee80211_mgmt *)buf;
4666
a0f07959
HM		 4667 if (!ieee80211_is_mgmt(mgmt->frame_control)) {
4668 brcmf_err("Driver only allows MGMT packet type\n");
4669 return -EPERM;
4670 }
0de8aace 4671
c2ff8cad
AQ		 4672 vif = container_of(wdev, struct brcmf_cfg80211_vif, wdev);
4673
a0f07959
HM		 4674 if (ieee80211_is_probe_resp(mgmt->frame_control)) {
4675 /* Right now the only reason to get a probe response */
4676 /* is for p2p listen response or for p2p GO from */
4677 /* wpa_supplicant. Unfortunately the probe is send */
4678 /* on primary ndev, while dongle wants it on the p2p */
4679 /* vif. Since this is only reason for a probe */
4680 /* response to be sent, the vif is taken from cfg. */
4681 /* If ever desired to send proberesp for non p2p */
4682 /* response then data should be checked for */
4683 /* "DIRECT-". Note in future supplicant will take */
4684 /* dedicated p2p wdev to do this and then this 'hack'*/
4685 /* is not needed anymore. */
4686 ie_offset = DOT11_MGMT_HDR_LEN +
4687 DOT11_BCN_PRB_FIXED_LEN;
4688 ie_len = len - ie_offset;
a0f07959 4689 if (vif == cfg->p2p.bss_idx[P2PAPI_BSSCFG_PRIMARY].vif)
0de8aace 4690 vif = cfg->p2p.bss_idx[P2PAPI_BSSCFG_DEVICE].vif;
a0f07959
HM		 4691 err = brcmf_vif_set_mgmt_ie(vif,
4692 BRCMF_VNDR_IE_PRBRSP_FLAG,
4693 &buf[ie_offset],
4694 ie_len);
4695 cfg80211_mgmt_tx_status(wdev, *cookie, buf, len, true,
4696 GFP_KERNEL);
18e2f61d
HM		 4697 } else if (ieee80211_is_action(mgmt->frame_control)) {
4698 af_params = kzalloc(sizeof(*af_params), GFP_KERNEL);
4699 if (af_params == NULL) {
4700 brcmf_err("unable to allocate frame\n");
4701 err = -ENOMEM;
4702 goto exit;
4703 }
4704 action_frame = &af_params->action_frame;
4705 /* Add the packet Id */
4706 action_frame->packet_id = cpu_to_le32(*cookie);
4707 /* Add BSSID */
4708 memcpy(&action_frame->da[0], &mgmt->da[0], ETH_ALEN);
4709 memcpy(&af_params->bssid[0], &mgmt->bssid[0], ETH_ALEN);
4710 /* Add the length exepted for 802.11 header */
4711 action_frame->len = cpu_to_le16(len - DOT11_MGMT_HDR_LEN);
c2ff8cad
AQ		 4712 /* Add the channel. Use the one specified as parameter if any or
4713 * the current one (got from the firmware) otherwise
4714 */
4715 if (chan)
4716 freq = chan->center_freq;
4717 else
4718 brcmf_fil_cmd_int_get(vif->ifp, BRCMF_C_GET_CHANNEL,
4719 &freq);
4720 chan_nr = ieee80211_frequency_to_channel(freq);
18e2f61d
HM		 4721 af_params->channel = cpu_to_le32(chan_nr);
4722
4723 memcpy(action_frame->data, &buf[DOT11_MGMT_HDR_LEN],
4724 le16_to_cpu(action_frame->len));
4725
4726 brcmf_dbg(TRACE, "Action frame, cookie=%lld, len=%d, freq=%d\n",
86a9c4a2 4727 *cookie, le16_to_cpu(action_frame->len), freq);
18e2f61d 4728
7fa2e352 4729 ack = brcmf_p2p_send_action_frame(cfg, cfg_to_ndev(cfg),
18e2f61d
HM		 4730 af_params);
4731
4732 cfg80211_mgmt_tx_status(wdev, *cookie, buf, len, ack,
4733 GFP_KERNEL);
4734 kfree(af_params);
a0f07959
HM		 4735 } else {
4736 brcmf_dbg(TRACE, "Unhandled, fc=%04x!!\n", mgmt->frame_control);
4737 brcmf_dbg_hex_dump(true, buf, len, "payload, len=%Zu\n", len);
0de8aace 4738 }
a0f07959 4739
18e2f61d 4740exit:
0de8aace
HM		 4741 return err;
4742}
4743
4744
4745static int
4746brcmf_cfg80211_cancel_remain_on_channel(struct wiphy *wiphy,
4747 struct wireless_dev *wdev,
4748 u64 cookie)
4749{
4750 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy);
4751 struct brcmf_cfg80211_vif *vif;
4752 int err = 0;
4753
4754 brcmf_dbg(TRACE, "Enter p2p listen cancel\n");
4755
4756 vif = cfg->p2p.bss_idx[P2PAPI_BSSCFG_DEVICE].vif;
4757 if (vif == NULL) {
4758 brcmf_err("No p2p device available for probe response\n");
4759 err = -ENODEV;
4760 goto exit;
4761 }
4762 brcmf_p2p_cancel_remain_on_channel(vif->ifp);
4763exit:
4764 return err;
4765}
4766
61730d4d
PH		 4767static int brcmf_cfg80211_crit_proto_start(struct wiphy *wiphy,
4768 struct wireless_dev *wdev,
4769 enum nl80211_crit_proto_id proto,
4770 u16 duration)
4771{
4772 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy);
4773 struct brcmf_cfg80211_vif *vif;
4774
4775 vif = container_of(wdev, struct brcmf_cfg80211_vif, wdev);
4776
4777 /* only DHCP support for now */
4778 if (proto != NL80211_CRIT_PROTO_DHCP)
4779 return -EINVAL;
4780
4781 /* suppress and abort scanning */
4782 set_bit(BRCMF_SCAN_STATUS_SUPPRESS, &cfg->scan_status);
4783 brcmf_abort_scanning(cfg);
4784
4785 return brcmf_btcoex_set_mode(vif, BRCMF_BTCOEX_DISABLED, duration);
4786}
4787
4788static void brcmf_cfg80211_crit_proto_stop(struct wiphy *wiphy,
4789 struct wireless_dev *wdev)
4790{
4791 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy);
4792 struct brcmf_cfg80211_vif *vif;
4793
4794 vif = container_of(wdev, struct brcmf_cfg80211_vif, wdev);
4795
4796 brcmf_btcoex_set_mode(vif, BRCMF_BTCOEX_ENABLED, 0);
4797 clear_bit(BRCMF_SCAN_STATUS_SUPPRESS, &cfg->scan_status);
4798}
4799
70b7d94b
HM		 4800static s32
4801brcmf_notify_tdls_peer_event(struct brcmf_if *ifp,
4802 const struct brcmf_event_msg *e, void *data)
4803{
4804 switch (e->reason) {
4805 case BRCMF_E_REASON_TDLS_PEER_DISCOVERED:
4806 brcmf_dbg(TRACE, "TDLS Peer Discovered\n");
4807 break;
4808 case BRCMF_E_REASON_TDLS_PEER_CONNECTED:
4809 brcmf_dbg(TRACE, "TDLS Peer Connected\n");
4810 brcmf_proto_add_tdls_peer(ifp->drvr, ifp->ifidx, (u8 *)e->addr);
4811 break;
4812 case BRCMF_E_REASON_TDLS_PEER_DISCONNECTED:
4813 brcmf_dbg(TRACE, "TDLS Peer Disconnected\n");
4814 brcmf_proto_delete_peer(ifp->drvr, ifp->ifidx, (u8 *)e->addr);
4815 break;
4816 }
4817
4818 return 0;
4819}
4820
89c2f382
AS		 4821static int brcmf_convert_nl80211_tdls_oper(enum nl80211_tdls_operation oper)
4822{
4823 int ret;
4824
4825 switch (oper) {
4826 case NL80211_TDLS_DISCOVERY_REQ:
4827 ret = BRCMF_TDLS_MANUAL_EP_DISCOVERY;
4828 break;
4829 case NL80211_TDLS_SETUP:
4830 ret = BRCMF_TDLS_MANUAL_EP_CREATE;
4831 break;
4832 case NL80211_TDLS_TEARDOWN:
4833 ret = BRCMF_TDLS_MANUAL_EP_DELETE;
4834 break;
4835 default:
4836 brcmf_err("unsupported operation: %d\n", oper);
4837 ret = -EOPNOTSUPP;
4838 }
4839 return ret;
4840}
4841
4842static int brcmf_cfg80211_tdls_oper(struct wiphy *wiphy,
3b3a0162 4843 struct net_device *ndev, const u8 *peer,
89c2f382
AS		 4844 enum nl80211_tdls_operation oper)
4845{
4846 struct brcmf_if *ifp;
4847 struct brcmf_tdls_iovar_le info;
4848 int ret = 0;
4849
4850 ret = brcmf_convert_nl80211_tdls_oper(oper);
4851 if (ret < 0)
4852 return ret;
4853
4854 ifp = netdev_priv(ndev);
4855 memset(&info, 0, sizeof(info));
4856 info.mode = (u8)ret;
4857 if (peer)
4858 memcpy(info.ea, peer, ETH_ALEN);
4859
4860 ret = brcmf_fil_iovar_data_set(ifp, "tdls_endpoint",
4861 &info, sizeof(info));
4862 if (ret < 0)
4863 brcmf_err("tdls_endpoint iovar failed: ret=%d\n", ret);
4864
4865 return ret;
4866}
4867
5b435de0 4868static struct cfg80211_ops wl_cfg80211_ops = {
9f440b7b
AS		 4869 .add_virtual_intf = brcmf_cfg80211_add_iface,
4870 .del_virtual_intf = brcmf_cfg80211_del_iface,
5b435de0
AS		 4871 .change_virtual_intf = brcmf_cfg80211_change_iface,
4872 .scan = brcmf_cfg80211_scan,
4873 .set_wiphy_params = brcmf_cfg80211_set_wiphy_params,
4874 .join_ibss = brcmf_cfg80211_join_ibss,
4875 .leave_ibss = brcmf_cfg80211_leave_ibss,
4876 .get_station = brcmf_cfg80211_get_station,
bf2a7e04 4877 .dump_station = brcmf_cfg80211_dump_station,
5b435de0
AS		 4878 .set_tx_power = brcmf_cfg80211_set_tx_power,
4879 .get_tx_power = brcmf_cfg80211_get_tx_power,
4880 .add_key = brcmf_cfg80211_add_key,
4881 .del_key = brcmf_cfg80211_del_key,
4882 .get_key = brcmf_cfg80211_get_key,
4883 .set_default_key = brcmf_cfg80211_config_default_key,
4884 .set_default_mgmt_key = brcmf_cfg80211_config_default_mgmt_key,
4885 .set_power_mgmt = brcmf_cfg80211_set_power_mgmt,
5b435de0
AS		 4886 .connect = brcmf_cfg80211_connect,
4887 .disconnect = brcmf_cfg80211_disconnect,
4888 .suspend = brcmf_cfg80211_suspend,
4889 .resume = brcmf_cfg80211_resume,
4890 .set_pmksa = brcmf_cfg80211_set_pmksa,
4891 .del_pmksa = brcmf_cfg80211_del_pmksa,
cbaa177d 4892 .flush_pmksa = brcmf_cfg80211_flush_pmksa,
1a873342
HM		 4893 .start_ap = brcmf_cfg80211_start_ap,
4894 .stop_ap = brcmf_cfg80211_stop_ap,
a0f07959 4895 .change_beacon = brcmf_cfg80211_change_beacon,
1a873342 4896 .del_station = brcmf_cfg80211_del_station,
6b89dcb3 4897 .change_station = brcmf_cfg80211_change_station,
e5806072
AS		 4898 .sched_scan_start = brcmf_cfg80211_sched_scan_start,
4899 .sched_scan_stop = brcmf_cfg80211_sched_scan_stop,
0de8aace
HM		 4900 .mgmt_frame_register = brcmf_cfg80211_mgmt_frame_register,
4901 .mgmt_tx = brcmf_cfg80211_mgmt_tx,
4902 .remain_on_channel = brcmf_p2p_remain_on_channel,
4903 .cancel_remain_on_channel = brcmf_cfg80211_cancel_remain_on_channel,
27f10e38
AS		 4904 .start_p2p_device = brcmf_p2p_start_device,
4905 .stop_p2p_device = brcmf_p2p_stop_device,
61730d4d
PH		 4906 .crit_proto_start = brcmf_cfg80211_crit_proto_start,
4907 .crit_proto_stop = brcmf_cfg80211_crit_proto_stop,
89c2f382 4908 .tdls_oper = brcmf_cfg80211_tdls_oper,
5b435de0
AS		 4909};
4910
3eacf866 4911struct brcmf_cfg80211_vif *brcmf_alloc_vif(struct brcmf_cfg80211_info *cfg,
9f440b7b
AS		 4912 enum nl80211_iftype type,
4913 bool pm_block)
3eacf866 4914{
a44aa400 4915 struct brcmf_cfg80211_vif *vif_walk;
3eacf866 4916 struct brcmf_cfg80211_vif *vif;
a44aa400 4917 bool mbss;
5b435de0 4918
33a6b157 4919 brcmf_dbg(TRACE, "allocating virtual interface (size=%zu)\n",
9f440b7b 4920 sizeof(*vif));
3eacf866
AS		 4921 vif = kzalloc(sizeof(*vif), GFP_KERNEL);
4922 if (!vif)
4923 return ERR_PTR(-ENOMEM);
4924
4925 vif->wdev.wiphy = cfg->wiphy;
9f440b7b 4926 vif->wdev.iftype = type;
5b435de0 4927
3eacf866 4928 vif->pm_block = pm_block;
3eacf866 4929
6ac4f4ed
AS		 4930 brcmf_init_prof(&vif->profile);
4931
a44aa400
HM		 4932 if (type == NL80211_IFTYPE_AP) {
4933 mbss = false;
4934 list_for_each_entry(vif_walk, &cfg->vif_list, list) {
4935 if (vif_walk->wdev.iftype == NL80211_IFTYPE_AP) {
4936 mbss = true;
4937 break;
4938 }
4939 }
4940 vif->mbss = mbss;
4941 }
4942
3eacf866 4943 list_add_tail(&vif->list, &cfg->vif_list);
3eacf866 4944 return vif;
5b435de0
AS		 4945}
4946
427dec5f 4947void brcmf_free_vif(struct brcmf_cfg80211_vif *vif)
5b435de0 4948{
3eacf866 4949 list_del(&vif->list);
3eacf866 4950 kfree(vif);
5b435de0
AS		 4951}
4952
9df4d542
AS		 4953void brcmf_cfg80211_free_netdev(struct net_device *ndev)
4954{
4955 struct brcmf_cfg80211_vif *vif;
4956 struct brcmf_if *ifp;
4957
4958 ifp = netdev_priv(ndev);
4959 vif = ifp->vif;
4960
95ef1239
AS		 4961 if (vif)
4962 brcmf_free_vif(vif);
9df4d542
AS		 4963 free_netdev(ndev);
4964}
4965
903e0eee 4966static bool brcmf_is_linkup(const struct brcmf_event_msg *e)
5b435de0 4967{
5c36b99a
AS		 4968 u32 event = e->event_code;
4969 u32 status = e->status;
5b435de0
AS		 4970
4971 if (event == BRCMF_E_SET_SSID && status == BRCMF_E_STATUS_SUCCESS) {
16886735 4972 brcmf_dbg(CONN, "Processing set ssid\n");
5b435de0
AS		 4973 return true;
4974 }
4975
4976 return false;
4977}
4978
903e0eee 4979static bool brcmf_is_linkdown(const struct brcmf_event_msg *e)
5b435de0 4980{
5c36b99a
AS		 4981 u32 event = e->event_code;
4982 u16 flags = e->flags;
5b435de0 4983
68ca395f
HM		 4984 if ((event == BRCMF_E_DEAUTH) || (event == BRCMF_E_DEAUTH_IND) ||
4985 (event == BRCMF_E_DISASSOC_IND) ||
4986 ((event == BRCMF_E_LINK) && (!(flags & BRCMF_EVENT_MSG_LINK)))) {
16886735 4987 brcmf_dbg(CONN, "Processing link down\n");
5b435de0
AS		 4988 return true;
4989 }
4990 return false;
4991}
4992
27a68fe3 4993static bool brcmf_is_nonetwork(struct brcmf_cfg80211_info *cfg,
5b435de0
AS		 4994 const struct brcmf_event_msg *e)
4995{
5c36b99a
AS		 4996 u32 event = e->event_code;
4997 u32 status = e->status;
5b435de0
AS		 4998
4999 if (event == BRCMF_E_LINK && status == BRCMF_E_STATUS_NO_NETWORKS) {
16886735
AS		 5000 brcmf_dbg(CONN, "Processing Link %s & no network found\n",
5001 e->flags & BRCMF_EVENT_MSG_LINK ? "up" : "down");
5b435de0
AS		 5002 return true;
5003 }
5004
5005 if (event == BRCMF_E_SET_SSID && status != BRCMF_E_STATUS_SUCCESS) {
16886735 5006 brcmf_dbg(CONN, "Processing connecting & no network found\n");
5b435de0
AS		 5007 return true;
5008 }
5009
5010 return false;
5011}
5012
27a68fe3 5013static void brcmf_clear_assoc_ies(struct brcmf_cfg80211_info *cfg)
5b435de0 5014{
27a68fe3 5015 struct brcmf_cfg80211_connect_info *conn_info = cfg_to_conn(cfg);
5b435de0
AS		 5016
5017 kfree(conn_info->req_ie);
5018 conn_info->req_ie = NULL;
5019 conn_info->req_ie_len = 0;
5020 kfree(conn_info->resp_ie);
5021 conn_info->resp_ie = NULL;
5022 conn_info->resp_ie_len = 0;
5023}
5024
89286dc9
HM		 5025static s32 brcmf_get_assoc_ies(struct brcmf_cfg80211_info *cfg,
5026 struct brcmf_if *ifp)
5b435de0 5027{
c4e382d2 5028 struct brcmf_cfg80211_assoc_ielen_le *assoc_info;
27a68fe3 5029 struct brcmf_cfg80211_connect_info *conn_info = cfg_to_conn(cfg);
5b435de0
AS		 5030 u32 req_len;
5031 u32 resp_len;
5032 s32 err = 0;
5033
27a68fe3 5034 brcmf_clear_assoc_ies(cfg);
5b435de0 5035
ac24be6f
AS		 5036 err = brcmf_fil_iovar_data_get(ifp, "assoc_info",
5037 cfg->extra_buf, WL_ASSOC_INFO_MAX);
5b435de0 5038 if (err) {
57d6e91a 5039 brcmf_err("could not get assoc info (%d)\n", err);
5b435de0
AS		 5040 return err;
5041 }
c4e382d2 5042 assoc_info =
27a68fe3 5043 (struct brcmf_cfg80211_assoc_ielen_le *)cfg->extra_buf;
c4e382d2
AS		 5044 req_len = le32_to_cpu(assoc_info->req_len);
5045 resp_len = le32_to_cpu(assoc_info->resp_len);
5b435de0 5046 if (req_len) {
ac24be6f 5047 err = brcmf_fil_iovar_data_get(ifp, "assoc_req_ies",
81f5dcb8
HM		 5048 cfg->extra_buf,
5049 WL_ASSOC_INFO_MAX);
5b435de0 5050 if (err) {
57d6e91a 5051 brcmf_err("could not get assoc req (%d)\n", err);
5b435de0
AS		 5052 return err;
5053 }
5054 conn_info->req_ie_len = req_len;
5055 conn_info->req_ie =
27a68fe3 5056 kmemdup(cfg->extra_buf, conn_info->req_ie_len,
5b435de0
AS		 5057 GFP_KERNEL);
5058 } else {
5059 conn_info->req_ie_len = 0;
5060 conn_info->req_ie = NULL;
5061 }
5062 if (resp_len) {
ac24be6f 5063 err = brcmf_fil_iovar_data_get(ifp, "assoc_resp_ies",
81f5dcb8
HM		 5064 cfg->extra_buf,
5065 WL_ASSOC_INFO_MAX);
5b435de0 5066 if (err) {
57d6e91a 5067 brcmf_err("could not get assoc resp (%d)\n", err);
5b435de0
AS		 5068 return err;
5069 }
5070 conn_info->resp_ie_len = resp_len;
5071 conn_info->resp_ie =
27a68fe3 5072 kmemdup(cfg->extra_buf, conn_info->resp_ie_len,
5b435de0
AS		 5073 GFP_KERNEL);
5074 } else {
5075 conn_info->resp_ie_len = 0;
5076 conn_info->resp_ie = NULL;
5077 }
16886735
AS		 5078 brcmf_dbg(CONN, "req len (%d) resp len (%d)\n",
5079 conn_info->req_ie_len, conn_info->resp_ie_len);
5b435de0
AS		 5080
5081 return err;
5082}
5083
5084static s32
27a68fe3 5085brcmf_bss_roaming_done(struct brcmf_cfg80211_info *cfg,
5b435de0
AS		 5086 struct net_device *ndev,
5087 const struct brcmf_event_msg *e)
5088{
c1179033
AS		 5089 struct brcmf_if *ifp = netdev_priv(ndev);
5090 struct brcmf_cfg80211_profile *profile = &ifp->vif->profile;
27a68fe3
AS		 5091 struct brcmf_cfg80211_connect_info *conn_info = cfg_to_conn(cfg);
5092 struct wiphy *wiphy = cfg_to_wiphy(cfg);
a180b83b 5093 struct ieee80211_channel *notify_channel = NULL;
5b435de0 5094 struct ieee80211_supported_band *band;
a180b83b 5095 struct brcmf_bss_info_le *bi;
83cf17aa 5096 struct brcmu_chan ch;
5b435de0
AS		 5097 u32 freq;
5098 s32 err = 0;
a180b83b 5099 u8 *buf;
5b435de0 5100
d96b801f 5101 brcmf_dbg(TRACE, "Enter\n");
5b435de0 5102
89286dc9 5103 brcmf_get_assoc_ies(cfg, ifp);
6c8c4f72 5104 memcpy(profile->bssid, e->addr, ETH_ALEN);
89286dc9 5105 brcmf_update_bss_info(cfg, ifp);
5b435de0 5106
a180b83b
FL		 5107 buf = kzalloc(WL_BSS_INFO_MAX, GFP_KERNEL);
5108 if (buf == NULL) {
5109 err = -ENOMEM;
5110 goto done;
5111 }
5112
5113 /* data sent to dongle has to be little endian */
5114 *(__le32 *)buf = cpu_to_le32(WL_BSS_INFO_MAX);
c1179033 5115 err = brcmf_fil_cmd_data_get(ifp, BRCMF_C_GET_BSS_INFO,
ac24be6f 5116 buf, WL_BSS_INFO_MAX);
a180b83b
FL		 5117
5118 if (err)
5119 goto done;
5b435de0 5120
a180b83b 5121 bi = (struct brcmf_bss_info_le *)(buf + 4);
83cf17aa
FL		 5122 ch.chspec = le16_to_cpu(bi->chanspec);
5123 cfg->d11inf.decchspec(&ch);
5b435de0 5124
83cf17aa 5125 if (ch.band == BRCMU_CHAN_BAND_2G)
5b435de0
AS		 5126 band = wiphy->bands[IEEE80211_BAND_2GHZ];
5127 else
5128 band = wiphy->bands[IEEE80211_BAND_5GHZ];
5129
83cf17aa 5130 freq = ieee80211_channel_to_frequency(ch.chnum, band->band);
5b435de0
AS		 5131 notify_channel = ieee80211_get_channel(wiphy, freq);
5132
a180b83b
FL		 5133done:
5134 kfree(buf);
06bb123e 5135 cfg80211_roamed(ndev, notify_channel, (u8 *)profile->bssid,
5b435de0
AS		 5136 conn_info->req_ie, conn_info->req_ie_len,
5137 conn_info->resp_ie, conn_info->resp_ie_len, GFP_KERNEL);
16886735 5138 brcmf_dbg(CONN, "Report roaming result\n");
5b435de0 5139
c1179033 5140 set_bit(BRCMF_VIF_STATUS_CONNECTED, &ifp->vif->sme_state);
d96b801f 5141 brcmf_dbg(TRACE, "Exit\n");
5b435de0
AS		 5142 return err;
5143}
5144
5145static s32
27a68fe3 5146brcmf_bss_connect_done(struct brcmf_cfg80211_info *cfg,
5b435de0
AS		 5147 struct net_device *ndev, const struct brcmf_event_msg *e,
5148 bool completed)
5149{
c1179033
AS		 5150 struct brcmf_if *ifp = netdev_priv(ndev);
5151 struct brcmf_cfg80211_profile *profile = &ifp->vif->profile;
27a68fe3 5152 struct brcmf_cfg80211_connect_info *conn_info = cfg_to_conn(cfg);
5b435de0 5153
d96b801f 5154 brcmf_dbg(TRACE, "Enter\n");
5b435de0 5155
c1179033
AS		 5156 if (test_and_clear_bit(BRCMF_VIF_STATUS_CONNECTING,
5157 &ifp->vif->sme_state)) {
5b435de0 5158 if (completed) {
89286dc9 5159 brcmf_get_assoc_ies(cfg, ifp);
6c8c4f72 5160 memcpy(profile->bssid, e->addr, ETH_ALEN);
89286dc9
HM		 5161 brcmf_update_bss_info(cfg, ifp);
5162 set_bit(BRCMF_VIF_STATUS_CONNECTED,
5163 &ifp->vif->sme_state);
5b435de0
AS		 5164 }
5165 cfg80211_connect_result(ndev,
06bb123e 5166 (u8 *)profile->bssid,
5b435de0
AS		 5167 conn_info->req_ie,
5168 conn_info->req_ie_len,
5169 conn_info->resp_ie,
5170 conn_info->resp_ie_len,
5171 completed ? WLAN_STATUS_SUCCESS :
5172 WLAN_STATUS_AUTH_TIMEOUT,
5173 GFP_KERNEL);
16886735
AS		 5174 brcmf_dbg(CONN, "Report connect result - connection %s\n",
5175 completed ? "succeeded" : "failed");
5b435de0 5176 }
d96b801f 5177 brcmf_dbg(TRACE, "Exit\n");
12f32370 5178 return 0;
5b435de0
AS		 5179}
5180
5181static s32
27a68fe3 5182brcmf_notify_connect_status_ap(struct brcmf_cfg80211_info *cfg,
1a873342
HM		 5183 struct net_device *ndev,
5184 const struct brcmf_event_msg *e, void *data)
5185{
a44aa400 5186 struct brcmf_if *ifp = netdev_priv(ndev);
7ee29602 5187 static int generation;
5c36b99a
AS		 5188 u32 event = e->event_code;
5189 u32 reason = e->reason;
1a873342
HM		 5190 struct station_info sinfo;
5191
16886735 5192 brcmf_dbg(CONN, "event %d, reason %d\n", event, reason);
5f4f9f11
AS		 5193 if (event == BRCMF_E_LINK && reason == BRCMF_E_REASON_LINK_BSSCFG_DIS &&
5194 ndev != cfg_to_ndev(cfg)) {
5195 brcmf_dbg(CONN, "AP mode link down\n");
5196 complete(&cfg->vif_disabled);
a44aa400 5197 if (ifp->vif->mbss)
ee6e3a34 5198 brcmf_remove_interface(ifp);
5f4f9f11
AS		 5199 return 0;
5200 }
1a873342 5201
1a873342 5202 if (((event == BRCMF_E_ASSOC_IND) || (event == BRCMF_E_REASSOC_IND)) &&
7ee29602
HM		 5203 (reason == BRCMF_E_STATUS_SUCCESS)) {
5204 memset(&sinfo, 0, sizeof(sinfo));
1a873342 5205 if (!data) {
57d6e91a 5206 brcmf_err("No IEs present in ASSOC/REASSOC_IND");
1a873342
HM		 5207 return -EINVAL;
5208 }
5209 sinfo.assoc_req_ies = data;
7ee29602 5210 sinfo.assoc_req_ies_len = e->datalen;
1a873342
HM		 5211 generation++;
5212 sinfo.generation = generation;
7ee29602 5213 cfg80211_new_sta(ndev, e->addr, &sinfo, GFP_KERNEL);
1a873342
HM		 5214 } else if ((event == BRCMF_E_DISASSOC_IND) ||
5215 (event == BRCMF_E_DEAUTH_IND) ||
5216 (event == BRCMF_E_DEAUTH)) {
7ee29602 5217 cfg80211_del_sta(ndev, e->addr, GFP_KERNEL);
1a873342 5218 }
7ee29602 5219 return 0;
1a873342
HM		 5220}
5221
5b435de0 5222static s32
1993732e 5223brcmf_notify_connect_status(struct brcmf_if *ifp,
5b435de0
AS		 5224 const struct brcmf_event_msg *e, void *data)
5225{
1993732e
AS		 5226 struct brcmf_cfg80211_info *cfg = ifp->drvr->config;
5227 struct net_device *ndev = ifp->ndev;
c1179033 5228 struct brcmf_cfg80211_profile *profile = &ifp->vif->profile;
fe94f3a4 5229 struct ieee80211_channel *chan;
5b435de0
AS		 5230 s32 err = 0;
5231
8851cce0
HM		 5232 if ((e->event_code == BRCMF_E_DEAUTH) ||
5233 (e->event_code == BRCMF_E_DEAUTH_IND) ||
5234 (e->event_code == BRCMF_E_DISASSOC_IND) ||
5235 ((e->event_code == BRCMF_E_LINK) && (!e->flags))) {
5236 brcmf_proto_delete_peer(ifp->drvr, ifp->ifidx, (u8 *)e->addr);
5237 }
5238
967fe2c8 5239 if (brcmf_is_apmode(ifp->vif)) {
27a68fe3 5240 err = brcmf_notify_connect_status_ap(cfg, ndev, e, data);
903e0eee 5241 } else if (brcmf_is_linkup(e)) {
16886735 5242 brcmf_dbg(CONN, "Linkup\n");
128ce3b6 5243 if (brcmf_is_ibssmode(ifp->vif)) {
b0a79088 5244 brcmf_inform_ibss(cfg, ndev, e->addr);
fe94f3a4 5245 chan = ieee80211_get_channel(cfg->wiphy, cfg->channel);
6c8c4f72 5246 memcpy(profile->bssid, e->addr, ETH_ALEN);
fe94f3a4 5247 cfg80211_ibss_joined(ndev, e->addr, chan, GFP_KERNEL);
c1179033
AS		 5248 clear_bit(BRCMF_VIF_STATUS_CONNECTING,
5249 &ifp->vif->sme_state);
5250 set_bit(BRCMF_VIF_STATUS_CONNECTED,
5251 &ifp->vif->sme_state);
5b435de0 5252 } else
27a68fe3 5253 brcmf_bss_connect_done(cfg, ndev, e, true);
92121e69 5254 brcmf_net_setcarrier(ifp, true);
903e0eee 5255 } else if (brcmf_is_linkdown(e)) {
16886735 5256 brcmf_dbg(CONN, "Linkdown\n");
128ce3b6 5257 if (!brcmf_is_ibssmode(ifp->vif)) {
27a68fe3 5258 brcmf_bss_connect_done(cfg, ndev, e, false);
42e0ed0d
HM		 5259 brcmf_link_down(ifp->vif,
5260 brcmf_map_fw_linkdown_reason(e));
5261 brcmf_init_prof(ndev_to_prof(ndev));
5262 if (ndev != cfg_to_ndev(cfg))
5263 complete(&cfg->vif_disabled);
5264 brcmf_net_setcarrier(ifp, false);
5b435de0 5265 }
27a68fe3 5266 } else if (brcmf_is_nonetwork(cfg, e)) {
128ce3b6 5267 if (brcmf_is_ibssmode(ifp->vif))
c1179033
AS		 5268 clear_bit(BRCMF_VIF_STATUS_CONNECTING,
5269 &ifp->vif->sme_state);
5b435de0 5270 else
27a68fe3 5271 brcmf_bss_connect_done(cfg, ndev, e, false);
5b435de0
AS		 5272 }
5273
5274 return err;
5275}
5276
5277static s32
1993732e 5278brcmf_notify_roaming_status(struct brcmf_if *ifp,
5b435de0
AS		 5279 const struct brcmf_event_msg *e, void *data)
5280{
1993732e 5281 struct brcmf_cfg80211_info *cfg = ifp->drvr->config;
5c36b99a
AS		 5282 u32 event = e->event_code;
5283 u32 status = e->status;
5b435de0
AS		 5284
5285 if (event == BRCMF_E_ROAM && status == BRCMF_E_STATUS_SUCCESS) {
c1179033 5286 if (test_bit(BRCMF_VIF_STATUS_CONNECTED, &ifp->vif->sme_state))
1993732e 5287 brcmf_bss_roaming_done(cfg, ifp->ndev, e);
5b435de0 5288 else
1993732e 5289 brcmf_bss_connect_done(cfg, ifp->ndev, e, true);
5b435de0
AS		 5290 }
5291
12f32370 5292 return 0;
5b435de0
AS		 5293}
5294
5295static s32
1993732e 5296brcmf_notify_mic_status(struct brcmf_if *ifp,
5b435de0
AS		 5297 const struct brcmf_event_msg *e, void *data)
5298{
5c36b99a 5299 u16 flags = e->flags;
5b435de0
AS		 5300 enum nl80211_key_type key_type;
5301
5302 if (flags & BRCMF_EVENT_MSG_GROUP)
5303 key_type = NL80211_KEYTYPE_GROUP;
5304 else
5305 key_type = NL80211_KEYTYPE_PAIRWISE;
5306
1993732e 5307 cfg80211_michael_mic_failure(ifp->ndev, (u8 *)&e->addr, key_type, -1,
5b435de0
AS		 5308 NULL, GFP_KERNEL);
5309
5310 return 0;
5311}
5312
d3c0b633
AS		 5313static s32 brcmf_notify_vif_event(struct brcmf_if *ifp,
5314 const struct brcmf_event_msg *e, void *data)
5315{
5316 struct brcmf_cfg80211_info *cfg = ifp->drvr->config;
5317 struct brcmf_if_event *ifevent = (struct brcmf_if_event *)data;
5318 struct brcmf_cfg80211_vif_event *event = &cfg->vif_event;
5319 struct brcmf_cfg80211_vif *vif;
5320
37a869ec 5321 brcmf_dbg(TRACE, "Enter: action %u flags %u ifidx %u bsscfgidx %u\n",
d3c0b633 5322 ifevent->action, ifevent->flags, ifevent->ifidx,
37a869ec 5323 ifevent->bsscfgidx);
d3c0b633 5324
d3c0b633
AS		 5325 mutex_lock(&event->vif_event_lock);
5326 event->action = ifevent->action;
5327 vif = event->vif;
5328
5329 switch (ifevent->action) {
5330 case BRCMF_E_IF_ADD:
5331 /* waiting process may have timed out */
dc4a787c
WY		 5332 if (!cfg->vif_event.vif) {
5333 mutex_unlock(&event->vif_event_lock);
d3c0b633 5334 return -EBADF;
dc4a787c 5335 }
d3c0b633
AS		 5336
5337 ifp->vif = vif;
5338 vif->ifp = ifp;
01b8e7db
AS		 5339 if (ifp->ndev) {
5340 vif->wdev.netdev = ifp->ndev;
5341 ifp->ndev->ieee80211_ptr = &vif->wdev;
5342 SET_NETDEV_DEV(ifp->ndev, wiphy_dev(cfg->wiphy));
5343 }
d3c0b633
AS		 5344 mutex_unlock(&event->vif_event_lock);
5345 wake_up(&event->vif_wq);
4b3a89de 5346 return 0;
d3c0b633
AS		 5347
5348 case BRCMF_E_IF_DEL:
d3c0b633
AS		 5349 mutex_unlock(&event->vif_event_lock);
5350 /* event may not be upon user request */
5351 if (brcmf_cfg80211_vif_event_armed(cfg))
5352 wake_up(&event->vif_wq);
5353 return 0;
5354
7a5c1f64
HM		 5355 case BRCMF_E_IF_CHANGE:
5356 mutex_unlock(&event->vif_event_lock);
5357 wake_up(&event->vif_wq);
5358 return 0;
5359
d3c0b633
AS		 5360 default:
5361 mutex_unlock(&event->vif_event_lock);
5362 break;
5363 }
5364 return -EINVAL;
5365}
5366
5b435de0
AS		 5367static void brcmf_init_conf(struct brcmf_cfg80211_conf *conf)
5368{
5b435de0
AS		 5369 conf->frag_threshold = (u32)-1;
5370 conf->rts_threshold = (u32)-1;
5371 conf->retry_short = (u32)-1;
5372 conf->retry_long = (u32)-1;
5b435de0
AS		 5373}
5374
5c36b99a 5375static void brcmf_register_event_handlers(struct brcmf_cfg80211_info *cfg)
5b435de0 5376{
5c36b99a
AS		 5377 brcmf_fweh_register(cfg->pub, BRCMF_E_LINK,
5378 brcmf_notify_connect_status);
5379 brcmf_fweh_register(cfg->pub, BRCMF_E_DEAUTH_IND,
5380 brcmf_notify_connect_status);
5381 brcmf_fweh_register(cfg->pub, BRCMF_E_DEAUTH,
5382 brcmf_notify_connect_status);
5383 brcmf_fweh_register(cfg->pub, BRCMF_E_DISASSOC_IND,
5384 brcmf_notify_connect_status);
5385 brcmf_fweh_register(cfg->pub, BRCMF_E_ASSOC_IND,
5386 brcmf_notify_connect_status);
5387 brcmf_fweh_register(cfg->pub, BRCMF_E_REASSOC_IND,
5388 brcmf_notify_connect_status);
5389 brcmf_fweh_register(cfg->pub, BRCMF_E_ROAM,
5390 brcmf_notify_roaming_status);
5391 brcmf_fweh_register(cfg->pub, BRCMF_E_MIC_ERROR,
5392 brcmf_notify_mic_status);
5393 brcmf_fweh_register(cfg->pub, BRCMF_E_SET_SSID,
5394 brcmf_notify_connect_status);
5395 brcmf_fweh_register(cfg->pub, BRCMF_E_PFN_NET_FOUND,
5396 brcmf_notify_sched_scan_results);
d3c0b633
AS		 5397 brcmf_fweh_register(cfg->pub, BRCMF_E_IF,
5398 brcmf_notify_vif_event);
0de8aace 5399 brcmf_fweh_register(cfg->pub, BRCMF_E_P2P_PROBEREQ_MSG,
6eda4e2c 5400 brcmf_p2p_notify_rx_mgmt_p2p_probereq);
0de8aace
HM		 5401 brcmf_fweh_register(cfg->pub, BRCMF_E_P2P_DISC_LISTEN_COMPLETE,
5402 brcmf_p2p_notify_listen_complete);
e6da3400
HM		 5403 brcmf_fweh_register(cfg->pub, BRCMF_E_ACTION_FRAME_RX,
5404 brcmf_p2p_notify_action_frame_rx);
18e2f61d
HM		 5405 brcmf_fweh_register(cfg->pub, BRCMF_E_ACTION_FRAME_COMPLETE,
5406 brcmf_p2p_notify_action_tx_complete);
6eda4e2c
HM		 5407 brcmf_fweh_register(cfg->pub, BRCMF_E_ACTION_FRAME_OFF_CHAN_COMPLETE,
5408 brcmf_p2p_notify_action_tx_complete);
5b435de0
AS		 5409}
5410
27a68fe3
AS		 5411static void brcmf_deinit_priv_mem(struct brcmf_cfg80211_info *cfg)
5412{
27a68fe3
AS		 5413 kfree(cfg->conf);
5414 cfg->conf = NULL;
27a68fe3
AS		 5415 kfree(cfg->extra_buf);
5416 cfg->extra_buf = NULL;
3021ad9a
HM		 5417 kfree(cfg->wowl.nd);
5418 cfg->wowl.nd = NULL;
5419 kfree(cfg->wowl.nd_info);
5420 cfg->wowl.nd_info = NULL;
d5367334
HM		 5421 kfree(cfg->escan_info.escan_buf);
5422 cfg->escan_info.escan_buf = NULL;
27a68fe3
AS		 5423}
5424
5425static s32 brcmf_init_priv_mem(struct brcmf_cfg80211_info *cfg)
5426{
27a68fe3
AS		 5427 cfg->conf = kzalloc(sizeof(*cfg->conf), GFP_KERNEL);
5428 if (!cfg->conf)
5b435de0 5429 goto init_priv_mem_out;
27a68fe3
AS		 5430 cfg->extra_buf = kzalloc(WL_EXTRA_BUF_MAX, GFP_KERNEL);
5431 if (!cfg->extra_buf)
5b435de0 5432 goto init_priv_mem_out;
3021ad9a
HM		 5433 cfg->wowl.nd = kzalloc(sizeof(*cfg->wowl.nd) + sizeof(u32), GFP_KERNEL);
5434 if (!cfg->wowl.nd)
5435 goto init_priv_mem_out;
5436 cfg->wowl.nd_info = kzalloc(sizeof(*cfg->wowl.nd_info) +
5437 sizeof(struct cfg80211_wowlan_nd_match *),
5438 GFP_KERNEL);
5439 if (!cfg->wowl.nd_info)
5440 goto init_priv_mem_out;
d5367334
HM		 5441 cfg->escan_info.escan_buf = kzalloc(BRCMF_ESCAN_BUF_SIZE, GFP_KERNEL);
5442 if (!cfg->escan_info.escan_buf)
5443 goto init_priv_mem_out;
5b435de0
AS		 5444
5445 return 0;
5446
5447init_priv_mem_out:
27a68fe3 5448 brcmf_deinit_priv_mem(cfg);
5b435de0
AS		 5449
5450 return -ENOMEM;
5451}
5452
27a68fe3 5453static s32 wl_init_priv(struct brcmf_cfg80211_info *cfg)
5b435de0
AS		 5454{
5455 s32 err = 0;
5456
27a68fe3
AS		 5457 cfg->scan_request = NULL;
5458 cfg->pwr_save = true;
68ca395f
HM		 5459 cfg->active_scan = true; /* we do active scan per default */
5460 cfg->dongle_up = false; /* dongle is not up yet */
27a68fe3 5461 err = brcmf_init_priv_mem(cfg);
5b435de0
AS		 5462 if (err)
5463 return err;
5c36b99a 5464 brcmf_register_event_handlers(cfg);
27a68fe3 5465 mutex_init(&cfg->usr_sync);
27a68fe3
AS		 5466 brcmf_init_escan(cfg);
5467 brcmf_init_conf(cfg->conf);
5f4f9f11 5468 init_completion(&cfg->vif_disabled);
5b435de0
AS		 5469 return err;
5470}
5471
27a68fe3 5472static void wl_deinit_priv(struct brcmf_cfg80211_info *cfg)
5b435de0 5473{
27a68fe3 5474 cfg->dongle_up = false; /* dongle down */
27a68fe3
AS		 5475 brcmf_abort_scanning(cfg);
5476 brcmf_deinit_priv_mem(cfg);
5b435de0
AS		 5477}
5478
d3c0b633
AS		 5479static void init_vif_event(struct brcmf_cfg80211_vif_event *event)
5480{
5481 init_waitqueue_head(&event->vif_wq);
d3c0b633
AS		 5482 mutex_init(&event->vif_event_lock);
5483}
5484
1119e23e 5485static s32 brcmf_dongle_roam(struct brcmf_if *ifp)
5b435de0 5486{
1119e23e
HM		 5487 s32 err;
5488 u32 bcn_timeout;
f588bc0c
AS		 5489 __le32 roamtrigger[2];
5490 __le32 roam_delta[2];
5b435de0 5491
1119e23e 5492 /* Configure beacon timeout value based upon roaming setting */
7d34b056 5493 if (ifp->drvr->settings->roamoff)
1119e23e
HM		 5494 bcn_timeout = BRCMF_DEFAULT_BCN_TIMEOUT_ROAM_OFF;
5495 else
5496 bcn_timeout = BRCMF_DEFAULT_BCN_TIMEOUT_ROAM_ON;
5497 err = brcmf_fil_iovar_int_set(ifp, "bcn_timeout", bcn_timeout);
5498 if (err) {
5499 brcmf_err("bcn_timeout error (%d)\n", err);
5500 goto roam_setup_done;
5b435de0
AS		 5501 }
5502
1119e23e
HM		 5503 /* Enable/Disable built-in roaming to allow supplicant to take care of
5504 * roaming.
5b435de0 5505 */
68ca395f 5506 brcmf_dbg(INFO, "Internal Roaming = %s\n",
7d34b056
HM		 5507 ifp->drvr->settings->roamoff ? "Off" : "On");
5508 err = brcmf_fil_iovar_int_set(ifp, "roam_off",
5509 ifp->drvr->settings->roamoff);
5b435de0 5510 if (err) {
57d6e91a 5511 brcmf_err("roam_off error (%d)\n", err);
1119e23e 5512 goto roam_setup_done;
5b435de0
AS		 5513 }
5514
f588bc0c
AS		 5515 roamtrigger[0] = cpu_to_le32(WL_ROAM_TRIGGER_LEVEL);
5516 roamtrigger[1] = cpu_to_le32(BRCM_BAND_ALL);
ac24be6f 5517 err = brcmf_fil_cmd_data_set(ifp, BRCMF_C_SET_ROAM_TRIGGER,
81f5dcb8 5518 (void *)roamtrigger, sizeof(roamtrigger));
5b435de0 5519 if (err) {
57d6e91a 5520 brcmf_err("WLC_SET_ROAM_TRIGGER error (%d)\n", err);
1119e23e 5521 goto roam_setup_done;
5b435de0
AS		 5522 }
5523
f588bc0c
AS		 5524 roam_delta[0] = cpu_to_le32(WL_ROAM_DELTA);
5525 roam_delta[1] = cpu_to_le32(BRCM_BAND_ALL);
ac24be6f 5526 err = brcmf_fil_cmd_data_set(ifp, BRCMF_C_SET_ROAM_DELTA,
81f5dcb8 5527 (void *)roam_delta, sizeof(roam_delta));
5b435de0 5528 if (err) {
57d6e91a 5529 brcmf_err("WLC_SET_ROAM_DELTA error (%d)\n", err);
1119e23e 5530 goto roam_setup_done;
5b435de0
AS		 5531 }
5532
1119e23e 5533roam_setup_done:
5b435de0
AS		 5534 return err;
5535}
5536
5537static s32
1678ba8e 5538brcmf_dongle_scantime(struct brcmf_if *ifp)
5b435de0
AS		 5539{
5540 s32 err = 0;
5541
ac24be6f 5542 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_SCAN_CHANNEL_TIME,
1678ba8e 5543 BRCMF_SCAN_CHANNEL_TIME);
5b435de0 5544 if (err) {
1678ba8e 5545 brcmf_err("Scan assoc time error (%d)\n", err);
5b435de0
AS		 5546 goto dongle_scantime_out;
5547 }
ac24be6f 5548 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_SCAN_UNASSOC_TIME,
1678ba8e 5549 BRCMF_SCAN_UNASSOC_TIME);
5b435de0 5550 if (err) {
1678ba8e 5551 brcmf_err("Scan unassoc time error (%d)\n", err);
5b435de0
AS		 5552 goto dongle_scantime_out;
5553 }
5554
ac24be6f 5555 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_SCAN_PASSIVE_TIME,
1678ba8e 5556 BRCMF_SCAN_PASSIVE_TIME);
5b435de0 5557 if (err) {
1678ba8e 5558 brcmf_err("Scan passive time error (%d)\n", err);
5b435de0
AS		 5559 goto dongle_scantime_out;
5560 }
5561
5562dongle_scantime_out:
5563 return err;
5564}
5565
b48d8916
AS		 5566static void brcmf_update_bw40_channel_flag(struct ieee80211_channel *channel,
5567 struct brcmu_chan *ch)
5568{
5569 u32 ht40_flag;
d48200ba 5570
b48d8916
AS		 5571 ht40_flag = channel->flags & IEEE80211_CHAN_NO_HT40;
5572 if (ch->sb == BRCMU_CHAN_SB_U) {
5573 if (ht40_flag == IEEE80211_CHAN_NO_HT40)
5574 channel->flags &= ~IEEE80211_CHAN_NO_HT40;
5575 channel->flags |= IEEE80211_CHAN_NO_HT40PLUS;
5576 } else {
5577 /* It should be one of
5578 * IEEE80211_CHAN_NO_HT40 or
5579 * IEEE80211_CHAN_NO_HT40PLUS
5580 */
5581 channel->flags &= ~IEEE80211_CHAN_NO_HT40;
5582 if (ht40_flag == IEEE80211_CHAN_NO_HT40)
5583 channel->flags |= IEEE80211_CHAN_NO_HT40MINUS;
5584 }
5585}
5586
5587static int brcmf_construct_chaninfo(struct brcmf_cfg80211_info *cfg,
5588 u32 bw_cap[])
d48200ba
HM		 5589{
5590 struct brcmf_if *ifp = netdev_priv(cfg_to_ndev(cfg));
b48d8916
AS		 5591 struct ieee80211_supported_band *band;
5592 struct ieee80211_channel *channel;
5593 struct wiphy *wiphy;
d48200ba 5594 struct brcmf_chanspec_list *list;
83cf17aa 5595 struct brcmu_chan ch;
b48d8916 5596 int err;
d48200ba
HM		 5597 u8 *pbuf;
5598 u32 i, j;
5599 u32 total;
b48d8916 5600 u32 chaninfo;
d48200ba 5601 u32 index;
d48200ba
HM		 5602
5603 pbuf = kzalloc(BRCMF_DCMD_MEDLEN, GFP_KERNEL);
5604
5605 if (pbuf == NULL)
5606 return -ENOMEM;
5607
5608 list = (struct brcmf_chanspec_list *)pbuf;
5609
5610 err = brcmf_fil_iovar_data_get(ifp, "chanspecs", pbuf,
5611 BRCMF_DCMD_MEDLEN);
5612 if (err) {
5613 brcmf_err("get chanspecs error (%d)\n", err);
b48d8916 5614 goto fail_pbuf;
d48200ba
HM		 5615 }
5616
b48d8916 5617 wiphy = cfg_to_wiphy(cfg);
58de92d2
AS		 5618 band = wiphy->bands[IEEE80211_BAND_2GHZ];
5619 if (band)
5620 for (i = 0; i < band->n_channels; i++)
5621 band->channels[i].flags = IEEE80211_CHAN_DISABLED;
5622 band = wiphy->bands[IEEE80211_BAND_5GHZ];
5623 if (band)
5624 for (i = 0; i < band->n_channels; i++)
5625 band->channels[i].flags = IEEE80211_CHAN_DISABLED;
d48200ba
HM		 5626
5627 total = le32_to_cpu(list->count);
5628 for (i = 0; i < total; i++) {
83cf17aa
FL		 5629 ch.chspec = (u16)le32_to_cpu(list->element[i]);
5630 cfg->d11inf.decchspec(&ch);
d48200ba 5631
83cf17aa 5632 if (ch.band == BRCMU_CHAN_BAND_2G) {
b48d8916 5633 band = wiphy->bands[IEEE80211_BAND_2GHZ];
83cf17aa 5634 } else if (ch.band == BRCMU_CHAN_BAND_5G) {
b48d8916 5635 band = wiphy->bands[IEEE80211_BAND_5GHZ];
d48200ba 5636 } else {
2375d970 5637 brcmf_err("Invalid channel Spec. 0x%x.\n", ch.chspec);
d48200ba
HM		 5638 continue;
5639 }
58de92d2
AS		 5640 if (!band)
5641 continue;
b48d8916 5642 if (!(bw_cap[band->band] & WLC_BW_40MHZ_BIT) &&
2375d970 5643 ch.bw == BRCMU_CHAN_BW_40)
d48200ba 5644 continue;
b48d8916 5645 if (!(bw_cap[band->band] & WLC_BW_80MHZ_BIT) &&
ee942ecc
AS		 5646 ch.bw == BRCMU_CHAN_BW_80)
5647 continue;
b48d8916
AS		 5648
5649 channel = band->channels;
5650 index = band->n_channels;
5651 for (j = 0; j < band->n_channels; j++) {
5652 if (channel[j].hw_value == ch.chnum) {
5653 index = j;
d48200ba
HM		 5654 break;
5655 }
5656 }
b48d8916
AS		 5657 channel[index].center_freq =
5658 ieee80211_channel_to_frequency(ch.chnum, band->band);
5659 channel[index].hw_value = ch.chnum;
5660
5661 /* assuming the chanspecs order is HT20,
5662 * HT40 upper, HT40 lower, and VHT80.
5663 */
5664 if (ch.bw == BRCMU_CHAN_BW_80) {
5665 channel[index].flags &= ~IEEE80211_CHAN_NO_80MHZ;
5666 } else if (ch.bw == BRCMU_CHAN_BW_40) {
5667 brcmf_update_bw40_channel_flag(&channel[index], &ch);
5668 } else {
58de92d2
AS		 5669 /* enable the channel and disable other bandwidths
5670 * for now as mentioned order assure they are enabled
5671 * for subsequent chanspecs.
ee942ecc 5672 */
b48d8916
AS		 5673 channel[index].flags = IEEE80211_CHAN_NO_HT40 |
5674 IEEE80211_CHAN_NO_80MHZ;
5675 ch.bw = BRCMU_CHAN_BW_20;
5676 cfg->d11inf.encchspec(&ch);
5677 chaninfo = ch.chspec;
5678 err = brcmf_fil_bsscfg_int_get(ifp, "per_chan_info",
5679 &chaninfo);
5680 if (!err) {
5681 if (chaninfo & WL_CHAN_RADAR)
5682 channel[index].flags |=
5683 (IEEE80211_CHAN_RADAR |
5684 IEEE80211_CHAN_NO_IR);
5685 if (chaninfo & WL_CHAN_PASSIVE)
5686 channel[index].flags |=
5687 IEEE80211_CHAN_NO_IR;
d48200ba 5688 }
d48200ba
HM		 5689 }
5690 }
b48d8916 5691
b48d8916 5692fail_pbuf:
d48200ba
HM		 5693 kfree(pbuf);
5694 return err;
5695}
5696
b48d8916 5697static int brcmf_enable_bw40_2g(struct brcmf_cfg80211_info *cfg)
aa70b4fa 5698{
b48d8916
AS		 5699 struct brcmf_if *ifp = netdev_priv(cfg_to_ndev(cfg));
5700 struct ieee80211_supported_band *band;
aa70b4fa 5701 struct brcmf_fil_bwcap_le band_bwcap;
b48d8916
AS		 5702 struct brcmf_chanspec_list *list;
5703 u8 *pbuf;
aa70b4fa
AS		 5704 u32 val;
5705 int err;
b48d8916
AS		 5706 struct brcmu_chan ch;
5707 u32 num_chan;
5708 int i, j;
aa70b4fa
AS		 5709
5710 /* verify support for bw_cap command */
5711 val = WLC_BAND_5G;
5712 err = brcmf_fil_iovar_int_get(ifp, "bw_cap", &val);
5713
5714 if (!err) {
5715 /* only set 2G bandwidth using bw_cap command */
5716 band_bwcap.band = cpu_to_le32(WLC_BAND_2G);
5717 band_bwcap.bw_cap = cpu_to_le32(WLC_BW_CAP_40MHZ);
5718 err = brcmf_fil_iovar_data_set(ifp, "bw_cap", &band_bwcap,
5719 sizeof(band_bwcap));
5720 } else {
5721 brcmf_dbg(INFO, "fallback to mimo_bw_cap\n");
5722 val = WLC_N_BW_40ALL;
5723 err = brcmf_fil_iovar_int_set(ifp, "mimo_bw_cap", val);
5724 }
b48d8916
AS		 5725
5726 if (!err) {
5727 /* update channel info in 2G band */
5728 pbuf = kzalloc(BRCMF_DCMD_MEDLEN, GFP_KERNEL);
5729
5730 if (pbuf == NULL)
5731 return -ENOMEM;
5732
5733 ch.band = BRCMU_CHAN_BAND_2G;
5734 ch.bw = BRCMU_CHAN_BW_40;
fac7d2a3 5735 ch.sb = BRCMU_CHAN_SB_NONE;
b48d8916
AS		 5736 ch.chnum = 0;
5737 cfg->d11inf.encchspec(&ch);
5738
5739 /* pass encoded chanspec in query */
5740 *(__le16 *)pbuf = cpu_to_le16(ch.chspec);
5741
5742 err = brcmf_fil_iovar_data_get(ifp, "chanspecs", pbuf,
5743 BRCMF_DCMD_MEDLEN);
5744 if (err) {
5745 brcmf_err("get chanspecs error (%d)\n", err);
5746 kfree(pbuf);
5747 return err;
5748 }
5749
5750 band = cfg_to_wiphy(cfg)->bands[IEEE80211_BAND_2GHZ];
5751 list = (struct brcmf_chanspec_list *)pbuf;
5752 num_chan = le32_to_cpu(list->count);
5753 for (i = 0; i < num_chan; i++) {
5754 ch.chspec = (u16)le32_to_cpu(list->element[i]);
5755 cfg->d11inf.decchspec(&ch);
5756 if (WARN_ON(ch.band != BRCMU_CHAN_BAND_2G))
5757 continue;
5758 if (WARN_ON(ch.bw != BRCMU_CHAN_BW_40))
5759 continue;
5760 for (j = 0; j < band->n_channels; j++) {
5761 if (band->channels[j].hw_value == ch.chnum)
5762 break;
5763 }
5764 if (WARN_ON(j == band->n_channels))
5765 continue;
5766
5767 brcmf_update_bw40_channel_flag(&band->channels[j], &ch);
5768 }
fac7d2a3 5769 kfree(pbuf);
b48d8916 5770 }
aa70b4fa
AS		 5771 return err;
5772}
5773
2375d970
AS		 5774static void brcmf_get_bwcap(struct brcmf_if *ifp, u32 bw_cap[])
5775{
5776 u32 band, mimo_bwcap;
5777 int err;
5778
5779 band = WLC_BAND_2G;
5780 err = brcmf_fil_iovar_int_get(ifp, "bw_cap", &band);
5781 if (!err) {
5782 bw_cap[IEEE80211_BAND_2GHZ] = band;
5783 band = WLC_BAND_5G;
5784 err = brcmf_fil_iovar_int_get(ifp, "bw_cap", &band);
5785 if (!err) {
5786 bw_cap[IEEE80211_BAND_5GHZ] = band;
5787 return;
5788 }
5789 WARN_ON(1);
5790 return;
5791 }
5792 brcmf_dbg(INFO, "fallback to mimo_bw_cap info\n");
5793 mimo_bwcap = 0;
5794 err = brcmf_fil_iovar_int_get(ifp, "mimo_bw_cap", &mimo_bwcap);
5795 if (err)
5796 /* assume 20MHz if firmware does not give a clue */
5797 mimo_bwcap = WLC_N_BW_20ALL;
5798
5799 switch (mimo_bwcap) {
5800 case WLC_N_BW_40ALL:
5801 bw_cap[IEEE80211_BAND_2GHZ] |= WLC_BW_40MHZ_BIT;
5802 /* fall-thru */
5803 case WLC_N_BW_20IN2G_40IN5G:
5804 bw_cap[IEEE80211_BAND_5GHZ] |= WLC_BW_40MHZ_BIT;
5805 /* fall-thru */
5806 case WLC_N_BW_20ALL:
5807 bw_cap[IEEE80211_BAND_2GHZ] |= WLC_BW_20MHZ_BIT;
5808 bw_cap[IEEE80211_BAND_5GHZ] |= WLC_BW_20MHZ_BIT;
5809 break;
5810 default:
5811 brcmf_err("invalid mimo_bw_cap value\n");
5812 }
5813}
d48200ba 5814
18d6c535
AS		 5815static void brcmf_update_ht_cap(struct ieee80211_supported_band *band,
5816 u32 bw_cap[2], u32 nchain)
5817{
5818 band->ht_cap.ht_supported = true;
5819 if (bw_cap[band->band] & WLC_BW_40MHZ_BIT) {
5820 band->ht_cap.cap |= IEEE80211_HT_CAP_SGI_40;
5821 band->ht_cap.cap |= IEEE80211_HT_CAP_SUP_WIDTH_20_40;
5822 }
5823 band->ht_cap.cap |= IEEE80211_HT_CAP_SGI_20;
5824 band->ht_cap.cap |= IEEE80211_HT_CAP_DSSSCCK40;
5825 band->ht_cap.ampdu_factor = IEEE80211_HT_MAX_AMPDU_64K;
5826 band->ht_cap.ampdu_density = IEEE80211_HT_MPDU_DENSITY_16;
5827 memset(band->ht_cap.mcs.rx_mask, 0xff, nchain);
5828 band->ht_cap.mcs.tx_params = IEEE80211_HT_MCS_TX_DEFINED;
5829}
5830
5831static __le16 brcmf_get_mcs_map(u32 nchain, enum ieee80211_vht_mcs_support supp)
5832{
5833 u16 mcs_map;
5834 int i;
5835
5836 for (i = 0, mcs_map = 0xFFFF; i < nchain; i++)
5837 mcs_map = (mcs_map << 2) | supp;
5838
5839 return cpu_to_le16(mcs_map);
5840}
5841
5842static void brcmf_update_vht_cap(struct ieee80211_supported_band *band,
7bf65aa9
HM		 5843 u32 bw_cap[2], u32 nchain, u32 txstreams,
5844 u32 txbf_bfe_cap, u32 txbf_bfr_cap)
18d6c535
AS		 5845{
5846 __le16 mcs_map;
5847
5848 /* not allowed in 2.4G band */
5849 if (band->band == IEEE80211_BAND_2GHZ)
5850 return;
5851
5852 band->vht_cap.vht_supported = true;
5853 /* 80MHz is mandatory */
5854 band->vht_cap.cap |= IEEE80211_VHT_CAP_SHORT_GI_80;
5855 if (bw_cap[band->band] & WLC_BW_160MHZ_BIT) {
5856 band->vht_cap.cap |= IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160MHZ;
5857 band->vht_cap.cap |= IEEE80211_VHT_CAP_SHORT_GI_160;
5858 }
5859 /* all support 256-QAM */
5860 mcs_map = brcmf_get_mcs_map(nchain, IEEE80211_VHT_MCS_SUPPORT_0_9);
5861 band->vht_cap.vht_mcs.rx_mcs_map = mcs_map;
5862 band->vht_cap.vht_mcs.tx_mcs_map = mcs_map;
7bf65aa9
HM		 5863
5864 /* Beamforming support information */
5865 if (txbf_bfe_cap & BRCMF_TXBF_SU_BFE_CAP)
5866 band->vht_cap.cap |= IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE;
5867 if (txbf_bfe_cap & BRCMF_TXBF_MU_BFE_CAP)
5868 band->vht_cap.cap |= IEEE80211_VHT_CAP_MU_BEAMFORMEE_CAPABLE;
5869 if (txbf_bfr_cap & BRCMF_TXBF_SU_BFR_CAP)
5870 band->vht_cap.cap |= IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE;
5871 if (txbf_bfr_cap & BRCMF_TXBF_MU_BFR_CAP)
5872 band->vht_cap.cap |= IEEE80211_VHT_CAP_MU_BEAMFORMER_CAPABLE;
5873
5874 if ((txbf_bfe_cap || txbf_bfr_cap) && (txstreams > 1)) {
5875 band->vht_cap.cap |=
5876 (2 << IEEE80211_VHT_CAP_BEAMFORMEE_STS_SHIFT);
5877 band->vht_cap.cap |= ((txstreams - 1) <<
5878 IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_SHIFT);
5879 band->vht_cap.cap |=
5880 IEEE80211_VHT_CAP_VHT_LINK_ADAPTATION_VHT_MRQ_MFB;
5881 }
18d6c535
AS		 5882}
5883
b48d8916 5884static int brcmf_setup_wiphybands(struct wiphy *wiphy)
5b435de0 5885{
b48d8916 5886 struct brcmf_cfg80211_info *cfg = wiphy_priv(wiphy);
ac24be6f 5887 struct brcmf_if *ifp = netdev_priv(cfg_to_ndev(cfg));
18d6c535
AS		 5888 u32 nmode = 0;
5889 u32 vhtmode = 0;
b48d8916 5890 u32 bw_cap[2] = { WLC_BW_20MHZ_BIT, WLC_BW_20MHZ_BIT };
4aca7a18
DK		 5891 u32 rxchain;
5892 u32 nchain;
b48d8916 5893 int err;
d48200ba 5894 s32 i;
2375d970 5895 struct ieee80211_supported_band *band;
7bf65aa9
HM		 5896 u32 txstreams = 0;
5897 u32 txbf_bfe_cap = 0;
5898 u32 txbf_bfr_cap = 0;
5b435de0 5899
18d6c535 5900 (void)brcmf_fil_iovar_int_get(ifp, "vhtmode", &vhtmode);
d48200ba
HM		 5901 err = brcmf_fil_iovar_int_get(ifp, "nmode", &nmode);
5902 if (err) {
5903 brcmf_err("nmode error (%d)\n", err);
5904 } else {
2375d970 5905 brcmf_get_bwcap(ifp, bw_cap);
d48200ba 5906 }
18d6c535
AS		 5907 brcmf_dbg(INFO, "nmode=%d, vhtmode=%d, bw_cap=(%d, %d)\n",
5908 nmode, vhtmode, bw_cap[IEEE80211_BAND_2GHZ],
5909 bw_cap[IEEE80211_BAND_5GHZ]);
d48200ba 5910
4aca7a18
DK		 5911 err = brcmf_fil_iovar_int_get(ifp, "rxchain", &rxchain);
5912 if (err) {
5913 brcmf_err("rxchain error (%d)\n", err);
5914 nchain = 1;
5915 } else {
5916 for (nchain = 0; rxchain; nchain++)
5917 rxchain = rxchain & (rxchain - 1);
5918 }
5919 brcmf_dbg(INFO, "nchain=%d\n", nchain);
5920
b48d8916 5921 err = brcmf_construct_chaninfo(cfg, bw_cap);
d48200ba 5922 if (err) {
b48d8916 5923 brcmf_err("brcmf_construct_chaninfo failed (%d)\n", err);
d48200ba
HM		 5924 return err;
5925 }
5926
7bf65aa9
HM		 5927 if (vhtmode) {
5928 (void)brcmf_fil_iovar_int_get(ifp, "txstreams", &txstreams);
5929 (void)brcmf_fil_iovar_int_get(ifp, "txbf_bfe_cap",
5930 &txbf_bfe_cap);
5931 (void)brcmf_fil_iovar_int_get(ifp, "txbf_bfr_cap",
5932 &txbf_bfr_cap);
5933 }
5934
b48d8916
AS		 5935 wiphy = cfg_to_wiphy(cfg);
5936 for (i = 0; i < ARRAY_SIZE(wiphy->bands); i++) {
5937 band = wiphy->bands[i];
5938 if (band == NULL)
2375d970 5939 continue;
d48200ba 5940
18d6c535
AS		 5941 if (nmode)
5942 brcmf_update_ht_cap(band, bw_cap, nchain);
5943 if (vhtmode)
7bf65aa9
HM		 5944 brcmf_update_vht_cap(band, bw_cap, nchain, txstreams,
5945 txbf_bfe_cap, txbf_bfr_cap);
d48200ba
HM		 5946 }
5947
b48d8916 5948 return 0;
5b435de0
AS		 5949}
5950
aa70b4fa
AS		 5951static const struct ieee80211_txrx_stypes
5952brcmf_txrx_stypes[NUM_NL80211_IFTYPES] = {
5953 [NL80211_IFTYPE_STATION] = {
5954 .tx = 0xffff,
5955 .rx = BIT(IEEE80211_STYPE_ACTION >> 4) |
5956 BIT(IEEE80211_STYPE_PROBE_REQ >> 4)
5957 },
5958 [NL80211_IFTYPE_P2P_CLIENT] = {
5959 .tx = 0xffff,
5960 .rx = BIT(IEEE80211_STYPE_ACTION >> 4) |
5961 BIT(IEEE80211_STYPE_PROBE_REQ >> 4)
5962 },
5963 [NL80211_IFTYPE_P2P_GO] = {
5964 .tx = 0xffff,
5965 .rx = BIT(IEEE80211_STYPE_ASSOC_REQ >> 4) |
5966 BIT(IEEE80211_STYPE_REASSOC_REQ >> 4) |
5967 BIT(IEEE80211_STYPE_PROBE_REQ >> 4) |
5968 BIT(IEEE80211_STYPE_DISASSOC >> 4) |
5969 BIT(IEEE80211_STYPE_AUTH >> 4) |
5970 BIT(IEEE80211_STYPE_DEAUTH >> 4) |
5971 BIT(IEEE80211_STYPE_ACTION >> 4)
5972 },
5973 [NL80211_IFTYPE_P2P_DEVICE] = {
5974 .tx = 0xffff,
5975 .rx = BIT(IEEE80211_STYPE_ACTION >> 4) |
5976 BIT(IEEE80211_STYPE_PROBE_REQ >> 4)
5977 }
5978};
5979
0882dda3
AS		 5980/**
5981 * brcmf_setup_ifmodes() - determine interface modes and combinations.
5982 *
5983 * @wiphy: wiphy object.
5984 * @ifp: interface object needed for feat module api.
5985 *
5986 * The interface modes and combinations are determined dynamically here
5987 * based on firmware functionality.
5988 *
5989 * no p2p and no mbss:
5990 *
5991 * #STA <= 1, #AP <= 1, channels = 1, 2 total
5992 *
5993 * no p2p and mbss:
5994 *
5995 * #STA <= 1, #AP <= 1, channels = 1, 2 total
5996 * #AP <= 4, matching BI, channels = 1, 4 total
5997 *
5998 * p2p, no mchan, and mbss:
5999 *
6000 * #STA <= 1, #P2P-DEV <= 1, #{P2P-CL, P2P-GO} <= 1, channels = 1, 3 total
6001 * #STA <= 1, #P2P-DEV <= 1, #AP <= 1, #P2P-CL <= 1, channels = 1, 4 total
6002 * #AP <= 4, matching BI, channels = 1, 4 total
6003 *
6004 * p2p, mchan, and mbss:
6005 *
6006 * #STA <= 1, #P2P-DEV <= 1, #{P2P-CL, P2P-GO} <= 1, channels = 2, 3 total
6007 * #STA <= 1, #P2P-DEV <= 1, #AP <= 1, #P2P-CL <= 1, channels = 1, 4 total
6008 * #AP <= 4, matching BI, channels = 1, 4 total
6009 */
2e5f66fe
PF		 6010static int brcmf_setup_ifmodes(struct wiphy *wiphy, struct brcmf_if *ifp)
6011{
6012 struct ieee80211_iface_combination *combo = NULL;
0882dda3
AS		 6013 struct ieee80211_iface_limit *c0_limits = NULL;
6014 struct ieee80211_iface_limit *p2p_limits = NULL;
6015 struct ieee80211_iface_limit *mbss_limits = NULL;
6016 bool mbss, p2p;
6017 int i, c, n_combos;
6018
6019 mbss = brcmf_feat_is_enabled(ifp, BRCMF_FEAT_MBSS);
6020 p2p = brcmf_feat_is_enabled(ifp, BRCMF_FEAT_P2P);
2e5f66fe 6021
0882dda3
AS		 6022 n_combos = 1 + !!p2p + !!mbss;
6023 combo = kcalloc(n_combos, sizeof(*combo), GFP_KERNEL);
2e5f66fe
PF		 6024 if (!combo)
6025 goto err;
6026
0882dda3
AS		 6027 c0_limits = kcalloc(p2p ? 3 : 2, sizeof(*c0_limits), GFP_KERNEL);
6028 if (!c0_limits)
2e5f66fe
PF		 6029 goto err;
6030
0882dda3
AS		 6031 if (p2p) {
6032 p2p_limits = kcalloc(4, sizeof(*p2p_limits), GFP_KERNEL);
6033 if (!p2p_limits)
6034 goto err;
6035 }
6036
6037 if (mbss) {
6038 mbss_limits = kcalloc(1, sizeof(*mbss_limits), GFP_KERNEL);
6039 if (!mbss_limits)
6040 goto err;
6041 }
6042
2e5f66fe
PF		 6043 wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) |
6044 BIT(NL80211_IFTYPE_ADHOC) |
6045 BIT(NL80211_IFTYPE_AP);
6046
0882dda3
AS		 6047 c = 0;
6048 i = 0;
6049 combo[c].num_different_channels = 1;
6050 c0_limits[i].max = 1;
6051 c0_limits[i++].types = BIT(NL80211_IFTYPE_STATION);
6052 if (p2p) {
6053 if (brcmf_feat_is_enabled(ifp, BRCMF_FEAT_MCHAN))
6054 combo[c].num_different_channels = 2;
2e5f66fe
PF		 6055 wiphy->interface_modes |= BIT(NL80211_IFTYPE_P2P_CLIENT) |
6056 BIT(NL80211_IFTYPE_P2P_GO) |
6057 BIT(NL80211_IFTYPE_P2P_DEVICE);
0882dda3
AS		 6058 c0_limits[i].max = 1;
6059 c0_limits[i++].types = BIT(NL80211_IFTYPE_P2P_DEVICE);
6060 c0_limits[i].max = 1;
6061 c0_limits[i++].types = BIT(NL80211_IFTYPE_P2P_CLIENT) |
6062 BIT(NL80211_IFTYPE_P2P_GO);
6063 } else {
6064 c0_limits[i].max = 1;
6065 c0_limits[i++].types = BIT(NL80211_IFTYPE_AP);
6066 }
6067 combo[c].max_interfaces = i;
6068 combo[c].n_limits = i;
6069 combo[c].limits = c0_limits;
6070
6071 if (p2p) {
6072 c++;
6073 i = 0;
6074 combo[c].num_different_channels = 1;
6075 p2p_limits[i].max = 1;
6076 p2p_limits[i++].types = BIT(NL80211_IFTYPE_STATION);
6077 p2p_limits[i].max = 1;
6078 p2p_limits[i++].types = BIT(NL80211_IFTYPE_AP);
6079 p2p_limits[i].max = 1;
6080 p2p_limits[i++].types = BIT(NL80211_IFTYPE_P2P_CLIENT);
6081 p2p_limits[i].max = 1;
6082 p2p_limits[i++].types = BIT(NL80211_IFTYPE_P2P_DEVICE);
6083 combo[c].max_interfaces = i;
6084 combo[c].n_limits = i;
6085 combo[c].limits = p2p_limits;
6086 }
6087
6088 if (mbss) {
6089 c++;
6090 combo[c].beacon_int_infra_match = true;
6091 combo[c].num_different_channels = 1;
6092 mbss_limits[0].max = 4;
6093 mbss_limits[0].types = BIT(NL80211_IFTYPE_AP);
6094 combo[c].max_interfaces = 4;
6095 combo[c].n_limits = 1;
6096 combo[c].limits = mbss_limits;
6097 }
6098 wiphy->n_iface_combinations = n_combos;
2e5f66fe 6099 wiphy->iface_combinations = combo;
2e5f66fe
PF		 6100 return 0;
6101
6102err:
0882dda3
AS		 6103 kfree(c0_limits);
6104 kfree(p2p_limits);
6105 kfree(mbss_limits);
2e5f66fe
PF		 6106 kfree(combo);
6107 return -ENOMEM;
6108}
6109
aa70b4fa
AS		 6110static void brcmf_wiphy_pno_params(struct wiphy *wiphy)
6111{
6112 /* scheduled scan settings */
6113 wiphy->max_sched_scan_ssids = BRCMF_PNO_MAX_PFN_COUNT;
6114 wiphy->max_match_sets = BRCMF_PNO_MAX_PFN_COUNT;
6115 wiphy->max_sched_scan_ie_len = BRCMF_SCAN_IE_LEN_MAX;
6116 wiphy->flags |= WIPHY_FLAG_SUPPORTS_SCHED_SCAN;
6117}
6118
4eb3af7c 6119#ifdef CONFIG_PM
3021ad9a 6120static struct wiphy_wowlan_support brcmf_wowlan_support = {
4eb3af7c 6121 .flags = WIPHY_WOWLAN_MAGIC_PKT | WIPHY_WOWLAN_DISCONNECT,
b9a82f89
HM		 6122 .n_patterns = BRCMF_WOWL_MAXPATTERNS,
6123 .pattern_max_len = BRCMF_WOWL_MAXPATTERNSIZE,
6124 .pattern_min_len = 1,
6125 .max_pkt_offset = 1500,
4eb3af7c
HM		 6126};
6127#endif
6128
3021ad9a 6129static void brcmf_wiphy_wowl_params(struct wiphy *wiphy, struct brcmf_if *ifp)
4eb3af7c
HM		 6130{
6131#ifdef CONFIG_PM
3021ad9a
HM		 6132 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy);
6133 s32 err;
6134 u32 wowl_cap;
6135
6136 if (brcmf_feat_is_enabled(ifp, BRCMF_FEAT_PNO)) {
6137 err = brcmf_fil_iovar_int_get(ifp, "wowl_cap", &wowl_cap);
6138 if (!err) {
6139 if (wowl_cap & BRCMF_WOWL_PFN_FOUND) {
6140 brcmf_wowlan_support.flags |=
6141 WIPHY_WOWLAN_NET_DETECT;
6142 init_waitqueue_head(&cfg->wowl.nd_data_wait);
6143 }
6144 }
6145 }
4eb3af7c
HM		 6146 wiphy->wowlan = &brcmf_wowlan_support;
6147#endif
6148}
6149
b48d8916 6150static int brcmf_setup_wiphy(struct wiphy *wiphy, struct brcmf_if *ifp)
aa70b4fa 6151{
e3faa866 6152 struct brcmf_pub *drvr = ifp->drvr;
50f32e2d 6153 const struct ieee80211_iface_combination *combo;
58de92d2 6154 struct ieee80211_supported_band *band;
50f32e2d 6155 u16 max_interfaces = 0;
58de92d2
AS		 6156 __le32 bandlist[3];
6157 u32 n_bands;
6158 int err, i;
6159
aa70b4fa
AS		 6160 wiphy->max_scan_ssids = WL_NUM_SCAN_MAX;
6161 wiphy->max_scan_ie_len = BRCMF_SCAN_IE_LEN_MAX;
6c404f34 6162 wiphy->max_num_pmkids = BRCMF_MAXPMKID;
2e5f66fe
PF		 6163
6164 err = brcmf_setup_ifmodes(wiphy, ifp);
6165 if (err)
6166 return err;
6167
50f32e2d
RM		 6168 for (i = 0, combo = wiphy->iface_combinations;
6169 i < wiphy->n_iface_combinations; i++, combo++) {
6170 max_interfaces = max(max_interfaces, combo->max_interfaces);
6171 }
6172
6173 for (i = 0; i < max_interfaces && i < ARRAY_SIZE(drvr->addresses);
6174 i++) {
e3faa866
RM		 6175 u8 *addr = drvr->addresses[i].addr;
6176
6177 memcpy(addr, drvr->mac, ETH_ALEN);
6178 if (i) {
6179 addr[0] |= BIT(1);
6180 addr[ETH_ALEN - 1] ^= i;
6181 }
6182 }
6183 wiphy->addresses = drvr->addresses;
6184 wiphy->n_addresses = i;
6185
aa70b4fa
AS		 6186 wiphy->signal_type = CFG80211_SIGNAL_TYPE_MBM;
6187 wiphy->cipher_suites = __wl_cipher_suites;
6188 wiphy->n_cipher_suites = ARRAY_SIZE(__wl_cipher_suites);
6189 wiphy->flags |= WIPHY_FLAG_PS_ON_BY_DEFAULT |
6190 WIPHY_FLAG_OFFCHAN_TX |
a7b82d47
HM		 6191 WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL;
6192 if (brcmf_feat_is_enabled(ifp, BRCMF_FEAT_TDLS))
6193 wiphy->flags |= WIPHY_FLAG_SUPPORTS_TDLS;
7d34b056 6194 if (!ifp->drvr->settings->roamoff)
aa70b4fa
AS		 6195 wiphy->flags |= WIPHY_FLAG_SUPPORTS_FW_ROAM;
6196 wiphy->mgmt_stypes = brcmf_txrx_stypes;
6197 wiphy->max_remain_on_channel_duration = 5000;
7a7a87dc
AS		 6198 if (brcmf_feat_is_enabled(ifp, BRCMF_FEAT_PNO))
6199 brcmf_wiphy_pno_params(wiphy);
aa70b4fa
AS		 6200
6201 /* vendor commands/events support */
6202 wiphy->vendor_commands = brcmf_vendor_cmds;
6203 wiphy->n_vendor_commands = BRCMF_VNDR_CMDS_LAST - 1;
6204
4eb3af7c 6205 if (brcmf_feat_is_enabled(ifp, BRCMF_FEAT_WOWL))
3021ad9a 6206 brcmf_wiphy_wowl_params(wiphy, ifp);
58de92d2
AS		 6207 err = brcmf_fil_cmd_data_get(ifp, BRCMF_C_GET_BANDLIST, &bandlist,
6208 sizeof(bandlist));
6209 if (err) {
6210 brcmf_err("could not obtain band info: err=%d\n", err);
6211 return err;
6212 }
6213 /* first entry in bandlist is number of bands */
6214 n_bands = le32_to_cpu(bandlist[0]);
6215 for (i = 1; i <= n_bands && i < ARRAY_SIZE(bandlist); i++) {
6216 if (bandlist[i] == cpu_to_le32(WLC_BAND_2G)) {
6217 band = kmemdup(&__wl_band_2ghz, sizeof(__wl_band_2ghz),
6218 GFP_KERNEL);
6219 if (!band)
6220 return -ENOMEM;
6221
6222 band->channels = kmemdup(&__wl_2ghz_channels,
6223 sizeof(__wl_2ghz_channels),
6224 GFP_KERNEL);
6225 if (!band->channels) {
6226 kfree(band);
6227 return -ENOMEM;
6228 }
6229
6230 band->n_channels = ARRAY_SIZE(__wl_2ghz_channels);
6231 wiphy->bands[IEEE80211_BAND_2GHZ] = band;
6232 }
6233 if (bandlist[i] == cpu_to_le32(WLC_BAND_5G)) {
6234 band = kmemdup(&__wl_band_5ghz, sizeof(__wl_band_5ghz),
6235 GFP_KERNEL);
6236 if (!band)
6237 return -ENOMEM;
6238
6239 band->channels = kmemdup(&__wl_5ghz_channels,
6240 sizeof(__wl_5ghz_channels),
6241 GFP_KERNEL);
6242 if (!band->channels) {
6243 kfree(band);
6244 return -ENOMEM;
6245 }
6246
6247 band->n_channels = ARRAY_SIZE(__wl_5ghz_channels);
6248 wiphy->bands[IEEE80211_BAND_5GHZ] = band;
6249 }
6250 }
6251 err = brcmf_setup_wiphybands(wiphy);
6252 return err;
5b435de0
AS		 6253}
6254
27a68fe3 6255static s32 brcmf_config_dongle(struct brcmf_cfg80211_info *cfg)
5b435de0
AS		 6256{
6257 struct net_device *ndev;
6258 struct wireless_dev *wdev;
40a23296 6259 struct brcmf_if *ifp;
5b435de0
AS		 6260 s32 power_mode;
6261 s32 err = 0;
6262
27a68fe3 6263 if (cfg->dongle_up)
5b435de0
AS		 6264 return err;
6265
27a68fe3 6266 ndev = cfg_to_ndev(cfg);
5b435de0 6267 wdev = ndev->ieee80211_ptr;
40a23296
HM		 6268 ifp = netdev_priv(ndev);
6269
6270 /* make sure RF is ready for work */
6271 brcmf_fil_cmd_int_set(ifp, BRCMF_C_UP, 0);
5b435de0 6272
1678ba8e 6273 brcmf_dongle_scantime(ifp);
5b435de0 6274
27a68fe3 6275 power_mode = cfg->pwr_save ? PM_FAST : PM_OFF;
40a23296 6276 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_PM, power_mode);
5b435de0
AS		 6277 if (err)
6278 goto default_conf_out;
647c9ae0
AS		 6279 brcmf_dbg(INFO, "power save set to %s\n",
6280 (power_mode ? "enabled" : "disabled"));
5b435de0 6281
1119e23e 6282 err = brcmf_dongle_roam(ifp);
5b435de0
AS		 6283 if (err)
6284 goto default_conf_out;
5dd161ff
FL		 6285 err = brcmf_cfg80211_change_iface(wdev->wiphy, ndev, wdev->iftype,
6286 NULL, NULL);
40a23296 6287 if (err)
5b435de0 6288 goto default_conf_out;
5b435de0 6289
b3657453
HM		 6290 brcmf_configure_arp_offload(ifp, true);
6291
27a68fe3 6292 cfg->dongle_up = true;
40a23296 6293default_conf_out:
5b435de0
AS		 6294
6295 return err;
6296
6297}
6298
bdf5ff51 6299static s32 __brcmf_cfg80211_up(struct brcmf_if *ifp)
5b435de0 6300{
c1179033 6301 set_bit(BRCMF_VIF_STATUS_READY, &ifp->vif->sme_state);
5b435de0 6302
bdf5ff51 6303 return brcmf_config_dongle(ifp->drvr->config);
5b435de0
AS		 6304}
6305
bdf5ff51 6306static s32 __brcmf_cfg80211_down(struct brcmf_if *ifp)
5b435de0 6307{
bdf5ff51 6308 struct brcmf_cfg80211_info *cfg = ifp->drvr->config;
c1179033 6309
5b435de0
AS		 6310 /*
6311 * While going down, if associated with AP disassociate
6312 * from AP to save power
6313 */
903e0eee 6314 if (check_vif_up(ifp->vif)) {
9b7a0ddc 6315 brcmf_link_down(ifp->vif, WLAN_REASON_UNSPECIFIED);
5b435de0
AS		 6316
6317 /* Make sure WPA_Supplicant receives all the event
6318 generated due to DISASSOC call to the fw to keep
6319 the state fw and WPA_Supplicant state consistent
6320 */
6321 brcmf_delay(500);
6322 }
6323
27a68fe3 6324 brcmf_abort_scanning(cfg);
c1179033 6325 clear_bit(BRCMF_VIF_STATUS_READY, &ifp->vif->sme_state);
5b435de0 6326
5b435de0
AS		 6327 return 0;
6328}
6329
bdf5ff51 6330s32 brcmf_cfg80211_up(struct net_device *ndev)
5b435de0 6331{
bdf5ff51
AS		 6332 struct brcmf_if *ifp = netdev_priv(ndev);
6333 struct brcmf_cfg80211_info *cfg = ifp->drvr->config;
5b435de0
AS		 6334 s32 err = 0;
6335
27a68fe3 6336 mutex_lock(&cfg->usr_sync);
bdf5ff51 6337 err = __brcmf_cfg80211_up(ifp);
27a68fe3 6338 mutex_unlock(&cfg->usr_sync);
5b435de0
AS		 6339
6340 return err;
6341}
6342
bdf5ff51 6343s32 brcmf_cfg80211_down(struct net_device *ndev)
5b435de0 6344{
bdf5ff51
AS		 6345 struct brcmf_if *ifp = netdev_priv(ndev);
6346 struct brcmf_cfg80211_info *cfg = ifp->drvr->config;
5b435de0
AS		 6347 s32 err = 0;
6348
27a68fe3 6349 mutex_lock(&cfg->usr_sync);
bdf5ff51 6350 err = __brcmf_cfg80211_down(ifp);
27a68fe3 6351 mutex_unlock(&cfg->usr_sync);
5b435de0
AS		 6352
6353 return err;
6354}
6355
a7965fbb
AS		 6356enum nl80211_iftype brcmf_cfg80211_get_iftype(struct brcmf_if *ifp)
6357{
6358 struct wireless_dev *wdev = &ifp->vif->wdev;
6359
6360 return wdev->iftype;
6361}
6362
bfe81975
HM		 6363bool brcmf_get_vif_state_any(struct brcmf_cfg80211_info *cfg,
6364 unsigned long state)
9f440b7b
AS		 6365{
6366 struct brcmf_cfg80211_vif *vif;
9f440b7b
AS		 6367
6368 list_for_each_entry(vif, &cfg->vif_list, list) {
6369 if (test_bit(state, &vif->sme_state))
e843bb19 6370 return true;
9f440b7b 6371 }
e843bb19 6372 return false;
9f440b7b 6373}
d3c0b633
AS		 6374
6375static inline bool vif_event_equals(struct brcmf_cfg80211_vif_event *event,
6376 u8 action)
6377{
6378 u8 evt_action;
6379
6380 mutex_lock(&event->vif_event_lock);
6381 evt_action = event->action;
6382 mutex_unlock(&event->vif_event_lock);
6383 return evt_action == action;
6384}
6385
6386void brcmf_cfg80211_arm_vif_event(struct brcmf_cfg80211_info *cfg,
6387 struct brcmf_cfg80211_vif *vif)
6388{
6389 struct brcmf_cfg80211_vif_event *event = &cfg->vif_event;
6390
6391 mutex_lock(&event->vif_event_lock);
6392 event->vif = vif;
6393 event->action = 0;
6394 mutex_unlock(&event->vif_event_lock);
6395}
6396
6397bool brcmf_cfg80211_vif_event_armed(struct brcmf_cfg80211_info *cfg)
6398{
6399 struct brcmf_cfg80211_vif_event *event = &cfg->vif_event;
6400 bool armed;
6401
6402 mutex_lock(&event->vif_event_lock);
6403 armed = event->vif != NULL;
6404 mutex_unlock(&event->vif_event_lock);
6405
6406 return armed;
6407}
a9eb0c4b
AS		 6408
6409int brcmf_cfg80211_wait_vif_event(struct brcmf_cfg80211_info *cfg,
6410 u8 action, ulong timeout)
d3c0b633
AS		 6411{
6412 struct brcmf_cfg80211_vif_event *event = &cfg->vif_event;
6413
6414 return wait_event_timeout(event->vif_wq,
6415 vif_event_equals(event, action), timeout);
6416}
6417
73345fd2
HM		 6418static s32 brcmf_translate_country_code(struct brcmf_pub *drvr, char alpha2[2],
6419 struct brcmf_fil_country_le *ccreq)
6420{
6421 struct cc_translate *country_codes;
6422 struct cc_entry *cc;
6423 s32 found_index;
6424 int i;
6425
6426 country_codes = drvr->settings->country_codes;
6427 if (!country_codes) {
6428 brcmf_dbg(TRACE, "No country codes configured for device\n");
6429 return -EINVAL;
6430 }
6431
6432 if ((alpha2[0] == ccreq->country_abbrev[0]) &&
6433 (alpha2[1] == ccreq->country_abbrev[1])) {
6434 brcmf_dbg(TRACE, "Country code already set\n");
6435 return -EAGAIN;
6436 }
6437
6438 found_index = -1;
6439 for (i = 0; i < country_codes->table_size; i++) {
6440 cc = &country_codes->table[i];
6441 if ((cc->iso3166[0] == '\0') && (found_index == -1))
6442 found_index = i;
6443 if ((cc->iso3166[0] == alpha2[0]) &&
6444 (cc->iso3166[1] == alpha2[1])) {
6445 found_index = i;
6446 break;
6447 }
6448 }
6449 if (found_index == -1) {
6450 brcmf_dbg(TRACE, "No country code match found\n");
6451 return -EINVAL;
6452 }
6453 memset(ccreq, 0, sizeof(*ccreq));
6454 ccreq->rev = cpu_to_le32(country_codes->table[found_index].rev);
6455 memcpy(ccreq->ccode, country_codes->table[found_index].cc,
6456 BRCMF_COUNTRY_BUF_SZ);
6457 ccreq->country_abbrev[0] = alpha2[0];
6458 ccreq->country_abbrev[1] = alpha2[1];
6459 ccreq->country_abbrev[2] = 0;
6460
6461 return 0;
6462}
6463
63db1a49
AS		 6464static void brcmf_cfg80211_reg_notifier(struct wiphy *wiphy,
6465 struct regulatory_request *req)
6466{
6467 struct brcmf_cfg80211_info *cfg = wiphy_priv(wiphy);
6468 struct brcmf_if *ifp = netdev_priv(cfg_to_ndev(cfg));
6469 struct brcmf_fil_country_le ccreq;
73345fd2 6470 s32 err;
63db1a49
AS		 6471 int i;
6472
63db1a49
AS		 6473 /* ignore non-ISO3166 country codes */
6474 for (i = 0; i < sizeof(req->alpha2); i++)
6475 if (req->alpha2[i] < 'A' || req->alpha2[i] > 'Z') {
73345fd2
HM		 6476 brcmf_err("not a ISO3166 code (0x%02x 0x%02x)\n",
6477 req->alpha2[0], req->alpha2[1]);
63db1a49
AS		 6478 return;
6479 }
73345fd2
HM		 6480
6481 brcmf_dbg(TRACE, "Enter: initiator=%d, alpha=%c%c\n", req->initiator,
6482 req->alpha2[0], req->alpha2[1]);
6483
6484 err = brcmf_fil_iovar_data_get(ifp, "country", &ccreq, sizeof(ccreq));
6485 if (err) {
6486 brcmf_err("Country code iovar returned err = %d\n", err);
6487 return;
6488 }
6489
6490 err = brcmf_translate_country_code(ifp->drvr, req->alpha2, &ccreq);
6491 if (err)
6492 return;
6493
6494 err = brcmf_fil_iovar_data_set(ifp, "country", &ccreq, sizeof(ccreq));
6495 if (err) {
6496 brcmf_err("Firmware rejected country setting\n");
8afe0ece
AS		 6497 return;
6498 }
6499 brcmf_setup_wiphybands(wiphy);
63db1a49
AS		 6500}
6501
b48d8916
AS		 6502static void brcmf_free_wiphy(struct wiphy *wiphy)
6503{
0882dda3
AS		 6504 int i;
6505
58de92d2
AS		 6506 if (!wiphy)
6507 return;
6508
0882dda3
AS		 6509 if (wiphy->iface_combinations) {
6510 for (i = 0; i < wiphy->n_iface_combinations; i++)
6511 kfree(wiphy->iface_combinations[i].limits);
6512 }
b48d8916
AS		 6513 kfree(wiphy->iface_combinations);
6514 if (wiphy->bands[IEEE80211_BAND_2GHZ]) {
6515 kfree(wiphy->bands[IEEE80211_BAND_2GHZ]->channels);
6516 kfree(wiphy->bands[IEEE80211_BAND_2GHZ]);
6517 }
6518 if (wiphy->bands[IEEE80211_BAND_5GHZ]) {
6519 kfree(wiphy->bands[IEEE80211_BAND_5GHZ]->channels);
6520 kfree(wiphy->bands[IEEE80211_BAND_5GHZ]);
6521 }
6522 wiphy_free(wiphy);
6523}
6524
ccfd1e81 6525struct brcmf_cfg80211_info *brcmf_cfg80211_attach(struct brcmf_pub *drvr,
ae7c03f6
HM		 6526 struct device *busdev,
6527 bool p2pdev_forced)
ccfd1e81 6528{
46f3b6ee 6529 struct net_device *ndev = brcmf_get_ifp(drvr, 0)->ndev;
ccfd1e81
AS		 6530 struct brcmf_cfg80211_info *cfg;
6531 struct wiphy *wiphy;
6532 struct brcmf_cfg80211_vif *vif;
6533 struct brcmf_if *ifp;
6534 s32 err = 0;
6535 s32 io_type;
b48d8916 6536 u16 *cap = NULL;
ccfd1e81
AS		 6537
6538 if (!ndev) {
6539 brcmf_err("ndev is invalid\n");
6540 return NULL;
6541 }
6542
6543 ifp = netdev_priv(ndev);
b48d8916
AS		 6544 wiphy = wiphy_new(&wl_cfg80211_ops, sizeof(struct brcmf_cfg80211_info));
6545 if (!wiphy) {
6546 brcmf_err("Could not allocate wiphy device\n");
ccfd1e81 6547 return NULL;
b48d8916 6548 }
6896f4fb 6549 memcpy(wiphy->perm_addr, drvr->mac, ETH_ALEN);
b48d8916 6550 set_wiphy_dev(wiphy, busdev);
ccfd1e81
AS		 6551
6552 cfg = wiphy_priv(wiphy);
6553 cfg->wiphy = wiphy;
6554 cfg->pub = drvr;
6555 init_vif_event(&cfg->vif_event);
6556 INIT_LIST_HEAD(&cfg->vif_list);
6557
6558 vif = brcmf_alloc_vif(cfg, NL80211_IFTYPE_STATION, false);
b48d8916
AS		 6559 if (IS_ERR(vif))
6560 goto wiphy_out;
ccfd1e81
AS		 6561
6562 vif->ifp = ifp;
6563 vif->wdev.netdev = ndev;
6564 ndev->ieee80211_ptr = &vif->wdev;
6565 SET_NETDEV_DEV(ndev, wiphy_dev(cfg->wiphy));
6566
6567 err = wl_init_priv(cfg);
6568 if (err) {
6569 brcmf_err("Failed to init iwm_priv (%d)\n", err);
b48d8916
AS		 6570 brcmf_free_vif(vif);
6571 goto wiphy_out;
ccfd1e81
AS		 6572 }
6573 ifp->vif = vif;
6574
b48d8916
AS		 6575 /* determine d11 io type before wiphy setup */
6576 err = brcmf_fil_cmd_int_get(ifp, BRCMF_C_GET_VERSION, &io_type);
ccfd1e81 6577 if (err) {
b48d8916
AS		 6578 brcmf_err("Failed to get D11 version (%d)\n", err);
6579 goto priv_out;
ccfd1e81 6580 }
b48d8916
AS		 6581 cfg->d11inf.io_type = (u8)io_type;
6582 brcmu_d11_attach(&cfg->d11inf);
6583
6584 err = brcmf_setup_wiphy(wiphy, ifp);
6585 if (err < 0)
6586 goto priv_out;
6587
6588 brcmf_dbg(INFO, "Registering custom regulatory\n");
63db1a49 6589 wiphy->reg_notifier = brcmf_cfg80211_reg_notifier;
b48d8916
AS		 6590 wiphy->regulatory_flags |= REGULATORY_CUSTOM_REG;
6591 wiphy_apply_custom_regulatory(wiphy, &brcmf_regdom);
6592
6593 /* firmware defaults to 40MHz disabled in 2G band. We signal
6594 * cfg80211 here that we do and have it decide we can enable
6595 * it. But first check if device does support 2G operation.
6596 */
6597 if (wiphy->bands[IEEE80211_BAND_2GHZ]) {
6598 cap = &wiphy->bands[IEEE80211_BAND_2GHZ]->ht_cap.cap;
6599 *cap |= IEEE80211_HT_CAP_SUP_WIDTH_20_40;
6600 }
6601 err = wiphy_register(wiphy);
6602 if (err < 0) {
6603 brcmf_err("Could not register wiphy device (%d)\n", err);
6604 goto priv_out;
ccfd1e81
AS		 6605 }
6606
6607 /* If cfg80211 didn't disable 40MHz HT CAP in wiphy_register(),
6608 * setup 40MHz in 2GHz band and enable OBSS scanning.
6609 */
b48d8916
AS		 6610 if (cap && (*cap & IEEE80211_HT_CAP_SUP_WIDTH_20_40)) {
6611 err = brcmf_enable_bw40_2g(cfg);
ccfd1e81
AS		 6612 if (!err)
6613 err = brcmf_fil_iovar_int_set(ifp, "obss_coex",
6614 BRCMF_OBSS_COEX_AUTO);
b48d8916
AS		 6615 else
6616 *cap &= ~IEEE80211_HT_CAP_SUP_WIDTH_20_40;
ccfd1e81 6617 }
2b76acdb
HM		 6618 /* p2p might require that "if-events" get processed by fweh. So
6619 * activate the already registered event handlers now and activate
6620 * the rest when initialization has completed. drvr->config needs to
6621 * be assigned before activating events.
6622 */
6623 drvr->config = cfg;
6624 err = brcmf_fweh_activate_events(ifp);
6625 if (err) {
6626 brcmf_err("FWEH activation failed (%d)\n", err);
6627 goto wiphy_unreg_out;
6628 }
ccfd1e81 6629
ae7c03f6 6630 err = brcmf_p2p_attach(cfg, p2pdev_forced);
ccfd1e81 6631 if (err) {
b48d8916
AS		 6632 brcmf_err("P2P initilisation failed (%d)\n", err);
6633 goto wiphy_unreg_out;
6634 }
6635 err = brcmf_btcoex_attach(cfg);
6636 if (err) {
6637 brcmf_err("BT-coex initialisation failed (%d)\n", err);
6638 brcmf_p2p_detach(&cfg->p2p);
6639 goto wiphy_unreg_out;
ccfd1e81
AS		 6640 }
6641
a7b82d47
HM		 6642 if (brcmf_feat_is_enabled(ifp, BRCMF_FEAT_TDLS)) {
6643 err = brcmf_fil_iovar_int_set(ifp, "tdls_enable", 1);
6644 if (err) {
6645 brcmf_dbg(INFO, "TDLS not enabled (%d)\n", err);
6646 wiphy->flags &= ~WIPHY_FLAG_SUPPORTS_TDLS;
6647 } else {
6648 brcmf_fweh_register(cfg->pub, BRCMF_E_TDLS_PEER_EVENT,
6649 brcmf_notify_tdls_peer_event);
6650 }
ccfd1e81 6651 }
ccfd1e81 6652
2b76acdb
HM		 6653 /* (re-) activate FWEH event handling */
6654 err = brcmf_fweh_activate_events(ifp);
6655 if (err) {
6656 brcmf_err("FWEH activation failed (%d)\n", err);
6657 goto wiphy_unreg_out;
6658 }
6659
48ed16e8
HM		 6660 /* Fill in some of the advertised nl80211 supported features */
6661 if (brcmf_feat_is_enabled(ifp, BRCMF_FEAT_SCAN_RANDOM_MAC)) {
6662 wiphy->features |= NL80211_FEATURE_SCHED_SCAN_RANDOM_MAC_ADDR;
6663#ifdef CONFIG_PM
6ea09153
FL		 6664 if (wiphy->wowlan &&
6665 wiphy->wowlan->flags & WIPHY_WOWLAN_NET_DETECT)
48ed16e8
HM		 6666 wiphy->features |= NL80211_FEATURE_ND_RANDOM_MAC_ADDR;
6667#endif
6668 }
6669
ccfd1e81
AS		 6670 return cfg;
6671
b48d8916
AS		 6672wiphy_unreg_out:
6673 wiphy_unregister(cfg->wiphy);
6674priv_out:
ccfd1e81 6675 wl_deinit_priv(cfg);
ccfd1e81 6676 brcmf_free_vif(vif);
2b5d348e 6677 ifp->vif = NULL;
b48d8916
AS		 6678wiphy_out:
6679 brcmf_free_wiphy(wiphy);
ccfd1e81
AS		 6680 return NULL;
6681}
6682
6683void brcmf_cfg80211_detach(struct brcmf_cfg80211_info *cfg)
6684{
6685 if (!cfg)
6686 return;
6687
ccfd1e81 6688 brcmf_btcoex_detach(cfg);
f7a40873 6689 wiphy_unregister(cfg->wiphy);
ccfd1e81 6690 wl_deinit_priv(cfg);
b48d8916 6691 brcmf_free_wiphy(cfg->wiphy);
ccfd1e81 6692}
Linux kernel - Deliverables
This page took 0.888766 seconds and 5 git commands to generate.