projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge tag 'backlight-for-linus-3.15' of git://git.kernel.org/pub/scm/linux/kernel...
[deliverable/linux.git] / drivers / net / wireless / brcm80211 / brcmfmac / wl_cfg80211.c
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>
20 #include <linux/etherdevice.h>
21 #include <linux/module.h>
22 #include <net/cfg80211.h>
23 #include <net/netlink.h>
24
25 #include <brcmu_utils.h>
26 #include <defs.h>
27 #include <brcmu_wifi.h>
28 #include "dhd.h"
29 #include "dhd_dbg.h"
30 #include "tracepoint.h"
31 #include "fwil_types.h"
32 #include "p2p.h"
33 #include "btcoex.h"
34 #include "wl_cfg80211.h"
35 #include "fwil.h"
36
37 #define BRCMF_SCAN_IE_LEN_MAX 2048
38 #define BRCMF_PNO_VERSION 2
39 #define BRCMF_PNO_TIME 30
40 #define BRCMF_PNO_REPEAT 4
41 #define BRCMF_PNO_FREQ_EXPO_MAX 3
42 #define BRCMF_PNO_MAX_PFN_COUNT 16
43 #define BRCMF_PNO_ENABLE_ADAPTSCAN_BIT 6
44 #define BRCMF_PNO_HIDDEN_BIT 2
45 #define BRCMF_PNO_WPA_AUTH_ANY 0xFFFFFFFF
46 #define BRCMF_PNO_SCAN_COMPLETE 1
47 #define BRCMF_PNO_SCAN_INCOMPLETE 0
48
49 #define BRCMF_IFACE_MAX_CNT 3
50
51 #define WPA_OUI "\x00\x50\xF2" /* WPA OUI */
52 #define WPA_OUI_TYPE 1
53 #define RSN_OUI "\x00\x0F\xAC" /* RSN OUI */
54 #define WME_OUI_TYPE 2
55 #define WPS_OUI_TYPE 4
56
57 #define VS_IE_FIXED_HDR_LEN 6
58 #define WPA_IE_VERSION_LEN 2
59 #define WPA_IE_MIN_OUI_LEN 4
60 #define WPA_IE_SUITE_COUNT_LEN 2
61
62 #define WPA_CIPHER_NONE 0 /* None */
63 #define WPA_CIPHER_WEP_40 1 /* WEP (40-bit) */
64 #define WPA_CIPHER_TKIP 2 /* TKIP: default for WPA */
65 #define WPA_CIPHER_AES_CCM 4 /* AES (CCM) */
66 #define WPA_CIPHER_WEP_104 5 /* WEP (104-bit) */
67
68 #define RSN_AKM_NONE 0 /* None (IBSS) */
69 #define RSN_AKM_UNSPECIFIED 1 /* Over 802.1x */
70 #define RSN_AKM_PSK 2 /* Pre-shared Key */
71 #define RSN_CAP_LEN 2 /* Length of RSN capabilities */
72 #define RSN_CAP_PTK_REPLAY_CNTR_MASK 0x000C
73
74 #define VNDR_IE_CMD_LEN 4 /* length of the set command
75 * string :"add", "del" (+ NUL)
76 */
77 #define VNDR_IE_COUNT_OFFSET 4
78 #define VNDR_IE_PKTFLAG_OFFSET 8
79 #define VNDR_IE_VSIE_OFFSET 12
80 #define VNDR_IE_HDR_SIZE 12
81 #define VNDR_IE_PARSE_LIMIT 5
82
83 #define DOT11_MGMT_HDR_LEN 24 /* d11 management header len */
84 #define DOT11_BCN_PRB_FIXED_LEN 12 /* beacon/probe fixed length */
85
86 #define BRCMF_SCAN_JOIN_ACTIVE_DWELL_TIME_MS 320
87 #define BRCMF_SCAN_JOIN_PASSIVE_DWELL_TIME_MS 400
88 #define BRCMF_SCAN_JOIN_PROBE_INTERVAL_MS 20
89
90 #define BRCMF_ASSOC_PARAMS_FIXED_SIZE \
91 (sizeof(struct brcmf_assoc_params_le) - sizeof(u16))
92
93 static bool check_vif_up(struct brcmf_cfg80211_vif *vif)
94 {
95 if (!test_bit(BRCMF_VIF_STATUS_READY, &vif->sme_state)) {
96 brcmf_dbg(INFO, "device is not ready : status (%lu)\n",
97 vif->sme_state);
98 return false;
99 }
100 return true;
101 }
102
103 #define CHAN2G(_channel, _freq, _flags) { \
104 .band = IEEE80211_BAND_2GHZ, \
105 .center_freq = (_freq), \
106 .hw_value = (_channel), \
107 .flags = (_flags), \
108 .max_antenna_gain = 0, \
109 .max_power = 30, \
110 }
111
112 #define CHAN5G(_channel, _flags) { \
113 .band = IEEE80211_BAND_5GHZ, \
114 .center_freq = 5000 + (5 * (_channel)), \
115 .hw_value = (_channel), \
116 .flags = (_flags), \
117 .max_antenna_gain = 0, \
118 .max_power = 30, \
119 }
120
121 #define RATE_TO_BASE100KBPS(rate) (((rate) * 10) / 2)
122 #define RATETAB_ENT(_rateid, _flags) \
123 { \
124 .bitrate = RATE_TO_BASE100KBPS(_rateid), \
125 .hw_value = (_rateid), \
126 .flags = (_flags), \
127 }
128
129 static struct ieee80211_rate __wl_rates[] = {
130 RATETAB_ENT(BRCM_RATE_1M, 0),
131 RATETAB_ENT(BRCM_RATE_2M, IEEE80211_RATE_SHORT_PREAMBLE),
132 RATETAB_ENT(BRCM_RATE_5M5, IEEE80211_RATE_SHORT_PREAMBLE),
133 RATETAB_ENT(BRCM_RATE_11M, IEEE80211_RATE_SHORT_PREAMBLE),
134 RATETAB_ENT(BRCM_RATE_6M, 0),
135 RATETAB_ENT(BRCM_RATE_9M, 0),
136 RATETAB_ENT(BRCM_RATE_12M, 0),
137 RATETAB_ENT(BRCM_RATE_18M, 0),
138 RATETAB_ENT(BRCM_RATE_24M, 0),
139 RATETAB_ENT(BRCM_RATE_36M, 0),
140 RATETAB_ENT(BRCM_RATE_48M, 0),
141 RATETAB_ENT(BRCM_RATE_54M, 0),
142 };
143
144 #define wl_a_rates (__wl_rates + 4)
145 #define wl_a_rates_size 8
146 #define wl_g_rates (__wl_rates + 0)
147 #define wl_g_rates_size 12
148
149 static struct ieee80211_channel __wl_2ghz_channels[] = {
150 CHAN2G(1, 2412, 0),
151 CHAN2G(2, 2417, 0),
152 CHAN2G(3, 2422, 0),
153 CHAN2G(4, 2427, 0),
154 CHAN2G(5, 2432, 0),
155 CHAN2G(6, 2437, 0),
156 CHAN2G(7, 2442, 0),
157 CHAN2G(8, 2447, 0),
158 CHAN2G(9, 2452, 0),
159 CHAN2G(10, 2457, 0),
160 CHAN2G(11, 2462, 0),
161 CHAN2G(12, 2467, 0),
162 CHAN2G(13, 2472, 0),
163 CHAN2G(14, 2484, 0),
164 };
165
166 static struct ieee80211_channel __wl_5ghz_a_channels[] = {
167 CHAN5G(34, 0), CHAN5G(36, 0),
168 CHAN5G(38, 0), CHAN5G(40, 0),
169 CHAN5G(42, 0), CHAN5G(44, 0),
170 CHAN5G(46, 0), CHAN5G(48, 0),
171 CHAN5G(52, 0), CHAN5G(56, 0),
172 CHAN5G(60, 0), CHAN5G(64, 0),
173 CHAN5G(100, 0), CHAN5G(104, 0),
174 CHAN5G(108, 0), CHAN5G(112, 0),
175 CHAN5G(116, 0), CHAN5G(120, 0),
176 CHAN5G(124, 0), CHAN5G(128, 0),
177 CHAN5G(132, 0), CHAN5G(136, 0),
178 CHAN5G(140, 0), CHAN5G(149, 0),
179 CHAN5G(153, 0), CHAN5G(157, 0),
180 CHAN5G(161, 0), CHAN5G(165, 0),
181 CHAN5G(184, 0), CHAN5G(188, 0),
182 CHAN5G(192, 0), CHAN5G(196, 0),
183 CHAN5G(200, 0), CHAN5G(204, 0),
184 CHAN5G(208, 0), CHAN5G(212, 0),
185 CHAN5G(216, 0),
186 };
187
188 static struct ieee80211_supported_band __wl_band_2ghz = {
189 .band = IEEE80211_BAND_2GHZ,
190 .channels = __wl_2ghz_channels,
191 .n_channels = ARRAY_SIZE(__wl_2ghz_channels),
192 .bitrates = wl_g_rates,
193 .n_bitrates = wl_g_rates_size,
194 .ht_cap = {IEEE80211_HT_CAP_SUP_WIDTH_20_40, true},
195 };
196
197 static struct ieee80211_supported_band __wl_band_5ghz_a = {
198 .band = IEEE80211_BAND_5GHZ,
199 .channels = __wl_5ghz_a_channels,
200 .n_channels = ARRAY_SIZE(__wl_5ghz_a_channels),
201 .bitrates = wl_a_rates,
202 .n_bitrates = wl_a_rates_size,
203 };
204
205 /* This is to override regulatory domains defined in cfg80211 module (reg.c)
206 * By default world regulatory domain defined in reg.c puts the flags
207 * NL80211_RRF_NO_IR for 5GHz channels (for * 36..48 and 149..165).
208 * With respect to these flags, wpa_supplicant doesn't * start p2p
209 * operations on 5GHz channels. All the changes in world regulatory
210 * domain are to be done here.
211 */
212 static const struct ieee80211_regdomain brcmf_regdom = {
213 .n_reg_rules = 4,
214 .alpha2 = "99",
215 .reg_rules = {
216 /* IEEE 802.11b/g, channels 1..11 */
217 REG_RULE(2412-10, 2472+10, 40, 6, 20, 0),
218 /* If any */
219 /* IEEE 802.11 channel 14 - Only JP enables
220 * this and for 802.11b only
221 */
222 REG_RULE(2484-10, 2484+10, 20, 6, 20, 0),
223 /* IEEE 802.11a, channel 36..64 */
224 REG_RULE(5150-10, 5350+10, 40, 6, 20, 0),
225 /* IEEE 802.11a, channel 100..165 */
226 REG_RULE(5470-10, 5850+10, 40, 6, 20, 0), }
227 };
228
229 static const u32 __wl_cipher_suites[] = {
230 WLAN_CIPHER_SUITE_WEP40,
231 WLAN_CIPHER_SUITE_WEP104,
232 WLAN_CIPHER_SUITE_TKIP,
233 WLAN_CIPHER_SUITE_CCMP,
234 WLAN_CIPHER_SUITE_AES_CMAC,
235 };
236
237 /* Vendor specific ie. id = 221, oui and type defines exact ie */
238 struct brcmf_vs_tlv {
239 u8 id;
240 u8 len;
241 u8 oui[3];
242 u8 oui_type;
243 };
244
245 struct parsed_vndr_ie_info {
246 u8 *ie_ptr;
247 u32 ie_len; /* total length including id & length field */
248 struct brcmf_vs_tlv vndrie;
249 };
250
251 struct parsed_vndr_ies {
252 u32 count;
253 struct parsed_vndr_ie_info ie_info[VNDR_IE_PARSE_LIMIT];
254 };
255
256 static int brcmf_roamoff;
257 module_param_named(roamoff, brcmf_roamoff, int, S_IRUSR);
258 MODULE_PARM_DESC(roamoff, "do not use internal roaming engine");
259
260 /* Quarter dBm units to mW
261 * Table starts at QDBM_OFFSET, so the first entry is mW for qdBm=153
262 * Table is offset so the last entry is largest mW value that fits in
263 * a u16.
264 */
265
266 #define QDBM_OFFSET 153 /* Offset for first entry */
267 #define QDBM_TABLE_LEN 40 /* Table size */
268
269 /* Smallest mW value that will round up to the first table entry, QDBM_OFFSET.
270 * Value is ( mW(QDBM_OFFSET - 1) + mW(QDBM_OFFSET) ) / 2
271 */
272 #define QDBM_TABLE_LOW_BOUND 6493 /* Low bound */
273
274 /* Largest mW value that will round down to the last table entry,
275 * QDBM_OFFSET + QDBM_TABLE_LEN-1.
276 * Value is ( mW(QDBM_OFFSET + QDBM_TABLE_LEN - 1) +
277 * mW(QDBM_OFFSET + QDBM_TABLE_LEN) ) / 2.
278 */
279 #define QDBM_TABLE_HIGH_BOUND 64938 /* High bound */
280
281 static const u16 nqdBm_to_mW_map[QDBM_TABLE_LEN] = {
282 /* qdBm: +0 +1 +2 +3 +4 +5 +6 +7 */
283 /* 153: */ 6683, 7079, 7499, 7943, 8414, 8913, 9441, 10000,
284 /* 161: */ 10593, 11220, 11885, 12589, 13335, 14125, 14962, 15849,
285 /* 169: */ 16788, 17783, 18836, 19953, 21135, 22387, 23714, 25119,
286 /* 177: */ 26607, 28184, 29854, 31623, 33497, 35481, 37584, 39811,
287 /* 185: */ 42170, 44668, 47315, 50119, 53088, 56234, 59566, 63096
288 };
289
290 static u16 brcmf_qdbm_to_mw(u8 qdbm)
291 {
292 uint factor = 1;
293 int idx = qdbm - QDBM_OFFSET;
294
295 if (idx >= QDBM_TABLE_LEN)
296 /* clamp to max u16 mW value */
297 return 0xFFFF;
298
299 /* scale the qdBm index up to the range of the table 0-40
300 * where an offset of 40 qdBm equals a factor of 10 mW.
301 */
302 while (idx < 0) {
303 idx += 40;
304 factor *= 10;
305 }
306
307 /* return the mW value scaled down to the correct factor of 10,
308 * adding in factor/2 to get proper rounding.
309 */
310 return (nqdBm_to_mW_map[idx] + factor / 2) / factor;
311 }
312
313 static u8 brcmf_mw_to_qdbm(u16 mw)
314 {
315 u8 qdbm;
316 int offset;
317 uint mw_uint = mw;
318 uint boundary;
319
320 /* handle boundary case */
321 if (mw_uint <= 1)
322 return 0;
323
324 offset = QDBM_OFFSET;
325
326 /* move mw into the range of the table */
327 while (mw_uint < QDBM_TABLE_LOW_BOUND) {
328 mw_uint *= 10;
329 offset -= 40;
330 }
331
332 for (qdbm = 0; qdbm < QDBM_TABLE_LEN - 1; qdbm++) {
333 boundary = nqdBm_to_mW_map[qdbm] + (nqdBm_to_mW_map[qdbm + 1] -
334 nqdBm_to_mW_map[qdbm]) / 2;
335 if (mw_uint < boundary)
336 break;
337 }
338
339 qdbm += (u8) offset;
340
341 return qdbm;
342 }
343
344 u16 channel_to_chanspec(struct brcmu_d11inf *d11inf,
345 struct ieee80211_channel *ch)
346 {
347 struct brcmu_chan ch_inf;
348
349 ch_inf.chnum = ieee80211_frequency_to_channel(ch->center_freq);
350 ch_inf.bw = BRCMU_CHAN_BW_20;
351 d11inf->encchspec(&ch_inf);
352
353 return ch_inf.chspec;
354 }
355
356 /* Traverse a string of 1-byte tag/1-byte length/variable-length value
357 * triples, returning a pointer to the substring whose first element
358 * matches tag
359 */
360 const struct brcmf_tlv *
361 brcmf_parse_tlvs(const void *buf, int buflen, uint key)
362 {
363 const struct brcmf_tlv *elt = buf;
364 int totlen = buflen;
365
366 /* find tagged parameter */
367 while (totlen >= TLV_HDR_LEN) {
368 int len = elt->len;
369
370 /* validate remaining totlen */
371 if ((elt->id == key) && (totlen >= (len + TLV_HDR_LEN)))
372 return elt;
373
374 elt = (struct brcmf_tlv *)((u8 *)elt + (len + TLV_HDR_LEN));
375 totlen -= (len + TLV_HDR_LEN);
376 }
377
378 return NULL;
379 }
380
381 /* Is any of the tlvs the expected entry? If
382 * not update the tlvs buffer pointer/length.
383 */
384 static bool
385 brcmf_tlv_has_ie(const u8 *ie, const u8 **tlvs, u32 *tlvs_len,
386 const u8 *oui, u32 oui_len, u8 type)
387 {
388 /* If the contents match the OUI and the type */
389 if (ie[TLV_LEN_OFF] >= oui_len + 1 &&
390 !memcmp(&ie[TLV_BODY_OFF], oui, oui_len) &&
391 type == ie[TLV_BODY_OFF + oui_len]) {
392 return true;
393 }
394
395 if (tlvs == NULL)
396 return false;
397 /* point to the next ie */
398 ie += ie[TLV_LEN_OFF] + TLV_HDR_LEN;
399 /* calculate the length of the rest of the buffer */
400 *tlvs_len -= (int)(ie - *tlvs);
401 /* update the pointer to the start of the buffer */
402 *tlvs = ie;
403
404 return false;
405 }
406
407 static struct brcmf_vs_tlv *
408 brcmf_find_wpaie(const u8 *parse, u32 len)
409 {
410 const struct brcmf_tlv *ie;
411
412 while ((ie = brcmf_parse_tlvs(parse, len, WLAN_EID_VENDOR_SPECIFIC))) {
413 if (brcmf_tlv_has_ie((const u8 *)ie, &parse, &len,
414 WPA_OUI, TLV_OUI_LEN, WPA_OUI_TYPE))
415 return (struct brcmf_vs_tlv *)ie;
416 }
417 return NULL;
418 }
419
420 static struct brcmf_vs_tlv *
421 brcmf_find_wpsie(const u8 *parse, u32 len)
422 {
423 const struct brcmf_tlv *ie;
424
425 while ((ie = brcmf_parse_tlvs(parse, len, WLAN_EID_VENDOR_SPECIFIC))) {
426 if (brcmf_tlv_has_ie((u8 *)ie, &parse, &len,
427 WPA_OUI, TLV_OUI_LEN, WPS_OUI_TYPE))
428 return (struct brcmf_vs_tlv *)ie;
429 }
430 return NULL;
431 }
432
433
434 static void convert_key_from_CPU(struct brcmf_wsec_key *key,
435 struct brcmf_wsec_key_le *key_le)
436 {
437 key_le->index = cpu_to_le32(key->index);
438 key_le->len = cpu_to_le32(key->len);
439 key_le->algo = cpu_to_le32(key->algo);
440 key_le->flags = cpu_to_le32(key->flags);
441 key_le->rxiv.hi = cpu_to_le32(key->rxiv.hi);
442 key_le->rxiv.lo = cpu_to_le16(key->rxiv.lo);
443 key_le->iv_initialized = cpu_to_le32(key->iv_initialized);
444 memcpy(key_le->data, key->data, sizeof(key->data));
445 memcpy(key_le->ea, key->ea, sizeof(key->ea));
446 }
447
448 static int
449 send_key_to_dongle(struct net_device *ndev, struct brcmf_wsec_key *key)
450 {
451 int err;
452 struct brcmf_wsec_key_le key_le;
453
454 convert_key_from_CPU(key, &key_le);
455
456 brcmf_netdev_wait_pend8021x(ndev);
457
458 err = brcmf_fil_bsscfg_data_set(netdev_priv(ndev), "wsec_key", &key_le,
459 sizeof(key_le));
460
461 if (err)
462 brcmf_err("wsec_key error (%d)\n", err);
463 return err;
464 }
465
466 static s32
467 brcmf_configure_arp_offload(struct brcmf_if *ifp, bool enable)
468 {
469 s32 err;
470 u32 mode;
471
472 if (enable)
473 mode = BRCMF_ARP_OL_AGENT | BRCMF_ARP_OL_PEER_AUTO_REPLY;
474 else
475 mode = 0;
476
477 /* Try to set and enable ARP offload feature, this may fail, then it */
478 /* is simply not supported and err 0 will be returned */
479 err = brcmf_fil_iovar_int_set(ifp, "arp_ol", mode);
480 if (err) {
481 brcmf_dbg(TRACE, "failed to set ARP offload mode to 0x%x, err = %d\n",
482 mode, err);
483 err = 0;
484 } else {
485 err = brcmf_fil_iovar_int_set(ifp, "arpoe", enable);
486 if (err) {
487 brcmf_dbg(TRACE, "failed to configure (%d) ARP offload err = %d\n",
488 enable, err);
489 err = 0;
490 } else
491 brcmf_dbg(TRACE, "successfully configured (%d) ARP offload to 0x%x\n",
492 enable, mode);
493 }
494
495 return err;
496 }
497
498 static bool brcmf_is_apmode(struct brcmf_cfg80211_vif *vif)
499 {
500 enum nl80211_iftype iftype;
501
502 iftype = vif->wdev.iftype;
503 return iftype == NL80211_IFTYPE_AP || iftype == NL80211_IFTYPE_P2P_GO;
504 }
505
506 static bool brcmf_is_ibssmode(struct brcmf_cfg80211_vif *vif)
507 {
508 return vif->wdev.iftype == NL80211_IFTYPE_ADHOC;
509 }
510
511 static struct wireless_dev *brcmf_cfg80211_add_iface(struct wiphy *wiphy,
512 const char *name,
513 enum nl80211_iftype type,
514 u32 *flags,
515 struct vif_params *params)
516 {
517 brcmf_dbg(TRACE, "enter: %s type %d\n", name, type);
518 switch (type) {
519 case NL80211_IFTYPE_ADHOC:
520 case NL80211_IFTYPE_STATION:
521 case NL80211_IFTYPE_AP:
522 case NL80211_IFTYPE_AP_VLAN:
523 case NL80211_IFTYPE_WDS:
524 case NL80211_IFTYPE_MONITOR:
525 case NL80211_IFTYPE_MESH_POINT:
526 return ERR_PTR(-EOPNOTSUPP);
527 case NL80211_IFTYPE_P2P_CLIENT:
528 case NL80211_IFTYPE_P2P_GO:
529 case NL80211_IFTYPE_P2P_DEVICE:
530 return brcmf_p2p_add_vif(wiphy, name, type, flags, params);
531 case NL80211_IFTYPE_UNSPECIFIED:
532 default:
533 return ERR_PTR(-EINVAL);
534 }
535 }
536
537 void brcmf_set_mpc(struct brcmf_if *ifp, int mpc)
538 {
539 s32 err = 0;
540
541 if (check_vif_up(ifp->vif)) {
542 err = brcmf_fil_iovar_int_set(ifp, "mpc", mpc);
543 if (err) {
544 brcmf_err("fail to set mpc\n");
545 return;
546 }
547 brcmf_dbg(INFO, "MPC : %d\n", mpc);
548 }
549 }
550
551 s32 brcmf_notify_escan_complete(struct brcmf_cfg80211_info *cfg,
552 struct brcmf_if *ifp, bool aborted,
553 bool fw_abort)
554 {
555 struct brcmf_scan_params_le params_le;
556 struct cfg80211_scan_request *scan_request;
557 s32 err = 0;
558
559 brcmf_dbg(SCAN, "Enter\n");
560
561 /* clear scan request, because the FW abort can cause a second call */
562 /* to this functon and might cause a double cfg80211_scan_done */
563 scan_request = cfg->scan_request;
564 cfg->scan_request = NULL;
565
566 if (timer_pending(&cfg->escan_timeout))
567 del_timer_sync(&cfg->escan_timeout);
568
569 if (fw_abort) {
570 /* Do a scan abort to stop the driver's scan engine */
571 brcmf_dbg(SCAN, "ABORT scan in firmware\n");
572 memset(&params_le, 0, sizeof(params_le));
573 memset(params_le.bssid, 0xFF, ETH_ALEN);
574 params_le.bss_type = DOT11_BSSTYPE_ANY;
575 params_le.scan_type = 0;
576 params_le.channel_num = cpu_to_le32(1);
577 params_le.nprobes = cpu_to_le32(1);
578 params_le.active_time = cpu_to_le32(-1);
579 params_le.passive_time = cpu_to_le32(-1);
580 params_le.home_time = cpu_to_le32(-1);
581 /* Scan is aborted by setting channel_list[0] to -1 */
582 params_le.channel_list[0] = cpu_to_le16(-1);
583 /* E-Scan (or anyother type) can be aborted by SCAN */
584 err = brcmf_fil_cmd_data_set(ifp, BRCMF_C_SCAN,
585 &params_le, sizeof(params_le));
586 if (err)
587 brcmf_err("Scan abort failed\n");
588 }
589 /*
590 * e-scan can be initiated by scheduled scan
591 * which takes precedence.
592 */
593 if (cfg->sched_escan) {
594 brcmf_dbg(SCAN, "scheduled scan completed\n");
595 cfg->sched_escan = false;
596 if (!aborted)
597 cfg80211_sched_scan_results(cfg_to_wiphy(cfg));
598 brcmf_set_mpc(ifp, 1);
599 } else if (scan_request) {
600 brcmf_dbg(SCAN, "ESCAN Completed scan: %s\n",
601 aborted ? "Aborted" : "Done");
602 cfg80211_scan_done(scan_request, aborted);
603 brcmf_set_mpc(ifp, 1);
604 }
605 if (!test_and_clear_bit(BRCMF_SCAN_STATUS_BUSY, &cfg->scan_status))
606 brcmf_dbg(SCAN, "Scan complete, probably P2P scan\n");
607
608 return err;
609 }
610
611 static
612 int brcmf_cfg80211_del_iface(struct wiphy *wiphy, struct wireless_dev *wdev)
613 {
614 struct brcmf_cfg80211_info *cfg = wiphy_priv(wiphy);
615 struct net_device *ndev = wdev->netdev;
616
617 /* vif event pending in firmware */
618 if (brcmf_cfg80211_vif_event_armed(cfg))
619 return -EBUSY;
620
621 if (ndev) {
622 if (test_bit(BRCMF_SCAN_STATUS_BUSY, &cfg->scan_status) &&
623 cfg->escan_info.ifp == netdev_priv(ndev))
624 brcmf_notify_escan_complete(cfg, netdev_priv(ndev),
625 true, true);
626
627 brcmf_fil_iovar_int_set(netdev_priv(ndev), "mpc", 1);
628 }
629
630 switch (wdev->iftype) {
631 case NL80211_IFTYPE_ADHOC:
632 case NL80211_IFTYPE_STATION:
633 case NL80211_IFTYPE_AP:
634 case NL80211_IFTYPE_AP_VLAN:
635 case NL80211_IFTYPE_WDS:
636 case NL80211_IFTYPE_MONITOR:
637 case NL80211_IFTYPE_MESH_POINT:
638 return -EOPNOTSUPP;
639 case NL80211_IFTYPE_P2P_CLIENT:
640 case NL80211_IFTYPE_P2P_GO:
641 case NL80211_IFTYPE_P2P_DEVICE:
642 return brcmf_p2p_del_vif(wiphy, wdev);
643 case NL80211_IFTYPE_UNSPECIFIED:
644 default:
645 return -EINVAL;
646 }
647 return -EOPNOTSUPP;
648 }
649
650 static s32
651 brcmf_cfg80211_change_iface(struct wiphy *wiphy, struct net_device *ndev,
652 enum nl80211_iftype type, u32 *flags,
653 struct vif_params *params)
654 {
655 struct brcmf_cfg80211_info *cfg = wiphy_priv(wiphy);
656 struct brcmf_if *ifp = netdev_priv(ndev);
657 struct brcmf_cfg80211_vif *vif = ifp->vif;
658 s32 infra = 0;
659 s32 ap = 0;
660 s32 err = 0;
661
662 brcmf_dbg(TRACE, "Enter, ndev=%p, type=%d\n", ndev, type);
663
664 switch (type) {
665 case NL80211_IFTYPE_MONITOR:
666 case NL80211_IFTYPE_WDS:
667 brcmf_err("type (%d) : currently we do not support this type\n",
668 type);
669 return -EOPNOTSUPP;
670 case NL80211_IFTYPE_ADHOC:
671 infra = 0;
672 break;
673 case NL80211_IFTYPE_STATION:
674 /* Ignore change for p2p IF. Unclear why supplicant does this */
675 if ((vif->wdev.iftype == NL80211_IFTYPE_P2P_CLIENT) ||
676 (vif->wdev.iftype == NL80211_IFTYPE_P2P_GO)) {
677 brcmf_dbg(TRACE, "Ignoring cmd for p2p if\n");
678 /* WAR: It is unexpected to get a change of VIF for P2P
679 * IF, but it happens. The request can not be handled
680 * but returning EPERM causes a crash. Returning 0
681 * without setting ieee80211_ptr->iftype causes trace
682 * (WARN_ON) but it works with wpa_supplicant
683 */
684 return 0;
685 }
686 infra = 1;
687 break;
688 case NL80211_IFTYPE_AP:
689 case NL80211_IFTYPE_P2P_GO:
690 ap = 1;
691 break;
692 default:
693 err = -EINVAL;
694 goto done;
695 }
696
697 if (ap) {
698 if (type == NL80211_IFTYPE_P2P_GO) {
699 brcmf_dbg(INFO, "IF Type = P2P GO\n");
700 err = brcmf_p2p_ifchange(cfg, BRCMF_FIL_P2P_IF_GO);
701 }
702 if (!err) {
703 set_bit(BRCMF_VIF_STATUS_AP_CREATING, &vif->sme_state);
704 brcmf_dbg(INFO, "IF Type = AP\n");
705 }
706 } else {
707 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_INFRA, infra);
708 if (err) {
709 brcmf_err("WLC_SET_INFRA error (%d)\n", err);
710 err = -EAGAIN;
711 goto done;
712 }
713 brcmf_dbg(INFO, "IF Type = %s\n", brcmf_is_ibssmode(vif) ?
714 "Adhoc" : "Infra");
715 }
716 ndev->ieee80211_ptr->iftype = type;
717
718 done:
719 brcmf_dbg(TRACE, "Exit\n");
720
721 return err;
722 }
723
724 static void brcmf_escan_prep(struct brcmf_cfg80211_info *cfg,
725 struct brcmf_scan_params_le *params_le,
726 struct cfg80211_scan_request *request)
727 {
728 u32 n_ssids;
729 u32 n_channels;
730 s32 i;
731 s32 offset;
732 u16 chanspec;
733 char *ptr;
734 struct brcmf_ssid_le ssid_le;
735
736 memset(params_le->bssid, 0xFF, ETH_ALEN);
737 params_le->bss_type = DOT11_BSSTYPE_ANY;
738 params_le->scan_type = 0;
739 params_le->channel_num = 0;
740 params_le->nprobes = cpu_to_le32(-1);
741 params_le->active_time = cpu_to_le32(-1);
742 params_le->passive_time = cpu_to_le32(-1);
743 params_le->home_time = cpu_to_le32(-1);
744 memset(&params_le->ssid_le, 0, sizeof(params_le->ssid_le));
745
746 /* if request is null exit so it will be all channel broadcast scan */
747 if (!request)
748 return;
749
750 n_ssids = request->n_ssids;
751 n_channels = request->n_channels;
752 /* Copy channel array if applicable */
753 brcmf_dbg(SCAN, "### List of channelspecs to scan ### %d\n",
754 n_channels);
755 if (n_channels > 0) {
756 for (i = 0; i < n_channels; i++) {
757 chanspec = channel_to_chanspec(&cfg->d11inf,
758 request->channels[i]);
759 brcmf_dbg(SCAN, "Chan : %d, Channel spec: %x\n",
760 request->channels[i]->hw_value, chanspec);
761 params_le->channel_list[i] = cpu_to_le16(chanspec);
762 }
763 } else {
764 brcmf_dbg(SCAN, "Scanning all channels\n");
765 }
766 /* Copy ssid array if applicable */
767 brcmf_dbg(SCAN, "### List of SSIDs to scan ### %d\n", n_ssids);
768 if (n_ssids > 0) {
769 offset = offsetof(struct brcmf_scan_params_le, channel_list) +
770 n_channels * sizeof(u16);
771 offset = roundup(offset, sizeof(u32));
772 ptr = (char *)params_le + offset;
773 for (i = 0; i < n_ssids; i++) {
774 memset(&ssid_le, 0, sizeof(ssid_le));
775 ssid_le.SSID_len =
776 cpu_to_le32(request->ssids[i].ssid_len);
777 memcpy(ssid_le.SSID, request->ssids[i].ssid,
778 request->ssids[i].ssid_len);
779 if (!ssid_le.SSID_len)
780 brcmf_dbg(SCAN, "%d: Broadcast scan\n", i);
781 else
782 brcmf_dbg(SCAN, "%d: scan for %s size =%d\n",
783 i, ssid_le.SSID, ssid_le.SSID_len);
784 memcpy(ptr, &ssid_le, sizeof(ssid_le));
785 ptr += sizeof(ssid_le);
786 }
787 } else {
788 brcmf_dbg(SCAN, "Broadcast scan %p\n", request->ssids);
789 if ((request->ssids) && request->ssids->ssid_len) {
790 brcmf_dbg(SCAN, "SSID %s len=%d\n",
791 params_le->ssid_le.SSID,
792 request->ssids->ssid_len);
793 params_le->ssid_le.SSID_len =
794 cpu_to_le32(request->ssids->ssid_len);
795 memcpy(&params_le->ssid_le.SSID, request->ssids->ssid,
796 request->ssids->ssid_len);
797 }
798 }
799 /* Adding mask to channel numbers */
800 params_le->channel_num =
801 cpu_to_le32((n_ssids << BRCMF_SCAN_PARAMS_NSSID_SHIFT) |
802 (n_channels & BRCMF_SCAN_PARAMS_COUNT_MASK));
803 }
804
805 static s32
806 brcmf_run_escan(struct brcmf_cfg80211_info *cfg, struct brcmf_if *ifp,
807 struct cfg80211_scan_request *request, u16 action)
808 {
809 s32 params_size = BRCMF_SCAN_PARAMS_FIXED_SIZE +
810 offsetof(struct brcmf_escan_params_le, params_le);
811 struct brcmf_escan_params_le *params;
812 s32 err = 0;
813
814 brcmf_dbg(SCAN, "E-SCAN START\n");
815
816 if (request != NULL) {
817 /* Allocate space for populating ssids in struct */
818 params_size += sizeof(u32) * ((request->n_channels + 1) / 2);
819
820 /* Allocate space for populating ssids in struct */
821 params_size += sizeof(struct brcmf_ssid) * request->n_ssids;
822 }
823
824 params = kzalloc(params_size, GFP_KERNEL);
825 if (!params) {
826 err = -ENOMEM;
827 goto exit;
828 }
829 BUG_ON(params_size + sizeof("escan") >= BRCMF_DCMD_MEDLEN);
830 brcmf_escan_prep(cfg, &params->params_le, request);
831 params->version = cpu_to_le32(BRCMF_ESCAN_REQ_VERSION);
832 params->action = cpu_to_le16(action);
833 params->sync_id = cpu_to_le16(0x1234);
834
835 err = brcmf_fil_iovar_data_set(ifp, "escan", params, params_size);
836 if (err) {
837 if (err == -EBUSY)
838 brcmf_dbg(INFO, "system busy : escan canceled\n");
839 else
840 brcmf_err("error (%d)\n", err);
841 }
842
843 kfree(params);
844 exit:
845 return err;
846 }
847
848 static s32
849 brcmf_do_escan(struct brcmf_cfg80211_info *cfg, struct wiphy *wiphy,
850 struct brcmf_if *ifp, struct cfg80211_scan_request *request)
851 {
852 s32 err;
853 u32 passive_scan;
854 struct brcmf_scan_results *results;
855 struct escan_info *escan = &cfg->escan_info;
856
857 brcmf_dbg(SCAN, "Enter\n");
858 escan->ifp = ifp;
859 escan->wiphy = wiphy;
860 escan->escan_state = WL_ESCAN_STATE_SCANNING;
861 passive_scan = cfg->active_scan ? 0 : 1;
862 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_PASSIVE_SCAN,
863 passive_scan);
864 if (err) {
865 brcmf_err("error (%d)\n", err);
866 return err;
867 }
868 brcmf_set_mpc(ifp, 0);
869 results = (struct brcmf_scan_results *)cfg->escan_info.escan_buf;
870 results->version = 0;
871 results->count = 0;
872 results->buflen = WL_ESCAN_RESULTS_FIXED_SIZE;
873
874 err = escan->run(cfg, ifp, request, WL_ESCAN_ACTION_START);
875 if (err)
876 brcmf_set_mpc(ifp, 1);
877 return err;
878 }
879
880 static s32
881 brcmf_cfg80211_escan(struct wiphy *wiphy, struct brcmf_cfg80211_vif *vif,
882 struct cfg80211_scan_request *request,
883 struct cfg80211_ssid *this_ssid)
884 {
885 struct brcmf_if *ifp = vif->ifp;
886 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy);
887 struct cfg80211_ssid *ssids;
888 struct brcmf_cfg80211_scan_req *sr = &cfg->scan_req_int;
889 u32 passive_scan;
890 bool escan_req;
891 bool spec_scan;
892 s32 err;
893 u32 SSID_len;
894
895 brcmf_dbg(SCAN, "START ESCAN\n");
896
897 if (test_bit(BRCMF_SCAN_STATUS_BUSY, &cfg->scan_status)) {
898 brcmf_err("Scanning already: status (%lu)\n", cfg->scan_status);
899 return -EAGAIN;
900 }
901 if (test_bit(BRCMF_SCAN_STATUS_ABORT, &cfg->scan_status)) {
902 brcmf_err("Scanning being aborted: status (%lu)\n",
903 cfg->scan_status);
904 return -EAGAIN;
905 }
906 if (test_bit(BRCMF_SCAN_STATUS_SUPPRESS, &cfg->scan_status)) {
907 brcmf_err("Scanning suppressed: status (%lu)\n",
908 cfg->scan_status);
909 return -EAGAIN;
910 }
911 if (test_bit(BRCMF_VIF_STATUS_CONNECTING, &ifp->vif->sme_state)) {
912 brcmf_err("Connecting: status (%lu)\n", ifp->vif->sme_state);
913 return -EAGAIN;
914 }
915
916 /* If scan req comes for p2p0, send it over primary I/F */
917 if (vif == cfg->p2p.bss_idx[P2PAPI_BSSCFG_DEVICE].vif)
918 vif = cfg->p2p.bss_idx[P2PAPI_BSSCFG_PRIMARY].vif;
919
920 /* Arm scan timeout timer */
921 mod_timer(&cfg->escan_timeout, jiffies +
922 WL_ESCAN_TIMER_INTERVAL_MS * HZ / 1000);
923
924 escan_req = false;
925 if (request) {
926 /* scan bss */
927 ssids = request->ssids;
928 escan_req = true;
929 } else {
930 /* scan in ibss */
931 /* we don't do escan in ibss */
932 ssids = this_ssid;
933 }
934
935 cfg->scan_request = request;
936 set_bit(BRCMF_SCAN_STATUS_BUSY, &cfg->scan_status);
937 if (escan_req) {
938 cfg->escan_info.run = brcmf_run_escan;
939 err = brcmf_p2p_scan_prep(wiphy, request, vif);
940 if (err)
941 goto scan_out;
942
943 err = brcmf_do_escan(cfg, wiphy, vif->ifp, request);
944 if (err)
945 goto scan_out;
946 } else {
947 brcmf_dbg(SCAN, "ssid \"%s\", ssid_len (%d)\n",
948 ssids->ssid, ssids->ssid_len);
949 memset(&sr->ssid_le, 0, sizeof(sr->ssid_le));
950 SSID_len = min_t(u8, sizeof(sr->ssid_le.SSID), ssids->ssid_len);
951 sr->ssid_le.SSID_len = cpu_to_le32(0);
952 spec_scan = false;
953 if (SSID_len) {
954 memcpy(sr->ssid_le.SSID, ssids->ssid, SSID_len);
955 sr->ssid_le.SSID_len = cpu_to_le32(SSID_len);
956 spec_scan = true;
957 } else
958 brcmf_dbg(SCAN, "Broadcast scan\n");
959
960 passive_scan = cfg->active_scan ? 0 : 1;
961 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_PASSIVE_SCAN,
962 passive_scan);
963 if (err) {
964 brcmf_err("WLC_SET_PASSIVE_SCAN error (%d)\n", err);
965 goto scan_out;
966 }
967 brcmf_set_mpc(ifp, 0);
968 err = brcmf_fil_cmd_data_set(ifp, BRCMF_C_SCAN,
969 &sr->ssid_le, sizeof(sr->ssid_le));
970 if (err) {
971 if (err == -EBUSY)
972 brcmf_dbg(INFO, "BUSY: scan for \"%s\" canceled\n",
973 sr->ssid_le.SSID);
974 else
975 brcmf_err("WLC_SCAN error (%d)\n", err);
976
977 brcmf_set_mpc(ifp, 1);
978 goto scan_out;
979 }
980 }
981
982 return 0;
983
984 scan_out:
985 clear_bit(BRCMF_SCAN_STATUS_BUSY, &cfg->scan_status);
986 if (timer_pending(&cfg->escan_timeout))
987 del_timer_sync(&cfg->escan_timeout);
988 cfg->scan_request = NULL;
989 return err;
990 }
991
992 static s32
993 brcmf_cfg80211_scan(struct wiphy *wiphy, struct cfg80211_scan_request *request)
994 {
995 struct brcmf_cfg80211_vif *vif;
996 s32 err = 0;
997
998 brcmf_dbg(TRACE, "Enter\n");
999 vif = container_of(request->wdev, struct brcmf_cfg80211_vif, wdev);
1000 if (!check_vif_up(vif))
1001 return -EIO;
1002
1003 err = brcmf_cfg80211_escan(wiphy, vif, request, NULL);
1004
1005 if (err)
1006 brcmf_err("scan error (%d)\n", err);
1007
1008 brcmf_dbg(TRACE, "Exit\n");
1009 return err;
1010 }
1011
1012 static s32 brcmf_set_rts(struct net_device *ndev, u32 rts_threshold)
1013 {
1014 s32 err = 0;
1015
1016 err = brcmf_fil_iovar_int_set(netdev_priv(ndev), "rtsthresh",
1017 rts_threshold);
1018 if (err)
1019 brcmf_err("Error (%d)\n", err);
1020
1021 return err;
1022 }
1023
1024 static s32 brcmf_set_frag(struct net_device *ndev, u32 frag_threshold)
1025 {
1026 s32 err = 0;
1027
1028 err = brcmf_fil_iovar_int_set(netdev_priv(ndev), "fragthresh",
1029 frag_threshold);
1030 if (err)
1031 brcmf_err("Error (%d)\n", err);
1032
1033 return err;
1034 }
1035
1036 static s32 brcmf_set_retry(struct net_device *ndev, u32 retry, bool l)
1037 {
1038 s32 err = 0;
1039 u32 cmd = (l ? BRCMF_C_SET_LRL : BRCMF_C_SET_SRL);
1040
1041 err = brcmf_fil_cmd_int_set(netdev_priv(ndev), cmd, retry);
1042 if (err) {
1043 brcmf_err("cmd (%d) , error (%d)\n", cmd, err);
1044 return err;
1045 }
1046 return err;
1047 }
1048
1049 static s32 brcmf_cfg80211_set_wiphy_params(struct wiphy *wiphy, u32 changed)
1050 {
1051 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy);
1052 struct net_device *ndev = cfg_to_ndev(cfg);
1053 struct brcmf_if *ifp = netdev_priv(ndev);
1054 s32 err = 0;
1055
1056 brcmf_dbg(TRACE, "Enter\n");
1057 if (!check_vif_up(ifp->vif))
1058 return -EIO;
1059
1060 if (changed & WIPHY_PARAM_RTS_THRESHOLD &&
1061 (cfg->conf->rts_threshold != wiphy->rts_threshold)) {
1062 cfg->conf->rts_threshold = wiphy->rts_threshold;
1063 err = brcmf_set_rts(ndev, cfg->conf->rts_threshold);
1064 if (!err)
1065 goto done;
1066 }
1067 if (changed & WIPHY_PARAM_FRAG_THRESHOLD &&
1068 (cfg->conf->frag_threshold != wiphy->frag_threshold)) {
1069 cfg->conf->frag_threshold = wiphy->frag_threshold;
1070 err = brcmf_set_frag(ndev, cfg->conf->frag_threshold);
1071 if (!err)
1072 goto done;
1073 }
1074 if (changed & WIPHY_PARAM_RETRY_LONG
1075 && (cfg->conf->retry_long != wiphy->retry_long)) {
1076 cfg->conf->retry_long = wiphy->retry_long;
1077 err = brcmf_set_retry(ndev, cfg->conf->retry_long, true);
1078 if (!err)
1079 goto done;
1080 }
1081 if (changed & WIPHY_PARAM_RETRY_SHORT
1082 && (cfg->conf->retry_short != wiphy->retry_short)) {
1083 cfg->conf->retry_short = wiphy->retry_short;
1084 err = brcmf_set_retry(ndev, cfg->conf->retry_short, false);
1085 if (!err)
1086 goto done;
1087 }
1088
1089 done:
1090 brcmf_dbg(TRACE, "Exit\n");
1091 return err;
1092 }
1093
1094 static void brcmf_init_prof(struct brcmf_cfg80211_profile *prof)
1095 {
1096 memset(prof, 0, sizeof(*prof));
1097 }
1098
1099 static void brcmf_link_down(struct brcmf_cfg80211_vif *vif)
1100 {
1101 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(vif->wdev.wiphy);
1102 s32 err = 0;
1103
1104 brcmf_dbg(TRACE, "Enter\n");
1105
1106 if (test_bit(BRCMF_VIF_STATUS_CONNECTED, &vif->sme_state)) {
1107 brcmf_dbg(INFO, "Call WLC_DISASSOC to stop excess roaming\n ");
1108 err = brcmf_fil_cmd_data_set(vif->ifp,
1109 BRCMF_C_DISASSOC, NULL, 0);
1110 if (err) {
1111 brcmf_err("WLC_DISASSOC failed (%d)\n", err);
1112 }
1113 clear_bit(BRCMF_VIF_STATUS_CONNECTED, &vif->sme_state);
1114 cfg80211_disconnected(vif->wdev.netdev, 0, NULL, 0, GFP_KERNEL);
1115
1116 }
1117 clear_bit(BRCMF_VIF_STATUS_CONNECTING, &vif->sme_state);
1118 clear_bit(BRCMF_SCAN_STATUS_SUPPRESS, &cfg->scan_status);
1119 brcmf_btcoex_set_mode(vif, BRCMF_BTCOEX_ENABLED, 0);
1120 brcmf_dbg(TRACE, "Exit\n");
1121 }
1122
1123 static s32
1124 brcmf_cfg80211_join_ibss(struct wiphy *wiphy, struct net_device *ndev,
1125 struct cfg80211_ibss_params *params)
1126 {
1127 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy);
1128 struct brcmf_if *ifp = netdev_priv(ndev);
1129 struct brcmf_cfg80211_profile *profile = &ifp->vif->profile;
1130 struct brcmf_join_params join_params;
1131 size_t join_params_size = 0;
1132 s32 err = 0;
1133 s32 wsec = 0;
1134 s32 bcnprd;
1135 u16 chanspec;
1136
1137 brcmf_dbg(TRACE, "Enter\n");
1138 if (!check_vif_up(ifp->vif))
1139 return -EIO;
1140
1141 if (params->ssid)
1142 brcmf_dbg(CONN, "SSID: %s\n", params->ssid);
1143 else {
1144 brcmf_dbg(CONN, "SSID: NULL, Not supported\n");
1145 return -EOPNOTSUPP;
1146 }
1147
1148 set_bit(BRCMF_VIF_STATUS_CONNECTING, &ifp->vif->sme_state);
1149
1150 if (params->bssid)
1151 brcmf_dbg(CONN, "BSSID: %pM\n", params->bssid);
1152 else
1153 brcmf_dbg(CONN, "No BSSID specified\n");
1154
1155 if (params->chandef.chan)
1156 brcmf_dbg(CONN, "channel: %d\n",
1157 params->chandef.chan->center_freq);
1158 else
1159 brcmf_dbg(CONN, "no channel specified\n");
1160
1161 if (params->channel_fixed)
1162 brcmf_dbg(CONN, "fixed channel required\n");
1163 else
1164 brcmf_dbg(CONN, "no fixed channel required\n");
1165
1166 if (params->ie && params->ie_len)
1167 brcmf_dbg(CONN, "ie len: %d\n", params->ie_len);
1168 else
1169 brcmf_dbg(CONN, "no ie specified\n");
1170
1171 if (params->beacon_interval)
1172 brcmf_dbg(CONN, "beacon interval: %d\n",
1173 params->beacon_interval);
1174 else
1175 brcmf_dbg(CONN, "no beacon interval specified\n");
1176
1177 if (params->basic_rates)
1178 brcmf_dbg(CONN, "basic rates: %08X\n", params->basic_rates);
1179 else
1180 brcmf_dbg(CONN, "no basic rates specified\n");
1181
1182 if (params->privacy)
1183 brcmf_dbg(CONN, "privacy required\n");
1184 else
1185 brcmf_dbg(CONN, "no privacy required\n");
1186
1187 /* Configure Privacy for starter */
1188 if (params->privacy)
1189 wsec |= WEP_ENABLED;
1190
1191 err = brcmf_fil_iovar_int_set(ifp, "wsec", wsec);
1192 if (err) {
1193 brcmf_err("wsec failed (%d)\n", err);
1194 goto done;
1195 }
1196
1197 /* Configure Beacon Interval for starter */
1198 if (params->beacon_interval)
1199 bcnprd = params->beacon_interval;
1200 else
1201 bcnprd = 100;
1202
1203 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_BCNPRD, bcnprd);
1204 if (err) {
1205 brcmf_err("WLC_SET_BCNPRD failed (%d)\n", err);
1206 goto done;
1207 }
1208
1209 /* Configure required join parameter */
1210 memset(&join_params, 0, sizeof(struct brcmf_join_params));
1211
1212 /* SSID */
1213 profile->ssid.SSID_len = min_t(u32, params->ssid_len, 32);
1214 memcpy(profile->ssid.SSID, params->ssid, profile->ssid.SSID_len);
1215 memcpy(join_params.ssid_le.SSID, params->ssid, profile->ssid.SSID_len);
1216 join_params.ssid_le.SSID_len = cpu_to_le32(profile->ssid.SSID_len);
1217 join_params_size = sizeof(join_params.ssid_le);
1218
1219 /* BSSID */
1220 if (params->bssid) {
1221 memcpy(join_params.params_le.bssid, params->bssid, ETH_ALEN);
1222 join_params_size = sizeof(join_params.ssid_le) +
1223 BRCMF_ASSOC_PARAMS_FIXED_SIZE;
1224 memcpy(profile->bssid, params->bssid, ETH_ALEN);
1225 } else {
1226 memset(join_params.params_le.bssid, 0xFF, ETH_ALEN);
1227 memset(profile->bssid, 0, ETH_ALEN);
1228 }
1229
1230 /* Channel */
1231 if (params->chandef.chan) {
1232 u32 target_channel;
1233
1234 cfg->channel =
1235 ieee80211_frequency_to_channel(
1236 params->chandef.chan->center_freq);
1237 if (params->channel_fixed) {
1238 /* adding chanspec */
1239 chanspec = channel_to_chanspec(&cfg->d11inf,
1240 params->chandef.chan);
1241 join_params.params_le.chanspec_list[0] =
1242 cpu_to_le16(chanspec);
1243 join_params.params_le.chanspec_num = cpu_to_le32(1);
1244 join_params_size += sizeof(join_params.params_le);
1245 }
1246
1247 /* set channel for starter */
1248 target_channel = cfg->channel;
1249 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_CHANNEL,
1250 target_channel);
1251 if (err) {
1252 brcmf_err("WLC_SET_CHANNEL failed (%d)\n", err);
1253 goto done;
1254 }
1255 } else
1256 cfg->channel = 0;
1257
1258 cfg->ibss_starter = false;
1259
1260
1261 err = brcmf_fil_cmd_data_set(ifp, BRCMF_C_SET_SSID,
1262 &join_params, join_params_size);
1263 if (err) {
1264 brcmf_err("WLC_SET_SSID failed (%d)\n", err);
1265 goto done;
1266 }
1267
1268 done:
1269 if (err)
1270 clear_bit(BRCMF_VIF_STATUS_CONNECTING, &ifp->vif->sme_state);
1271 brcmf_dbg(TRACE, "Exit\n");
1272 return err;
1273 }
1274
1275 static s32
1276 brcmf_cfg80211_leave_ibss(struct wiphy *wiphy, struct net_device *ndev)
1277 {
1278 struct brcmf_if *ifp = netdev_priv(ndev);
1279 s32 err = 0;
1280
1281 brcmf_dbg(TRACE, "Enter\n");
1282 if (!check_vif_up(ifp->vif))
1283 return -EIO;
1284
1285 brcmf_link_down(ifp->vif);
1286
1287 brcmf_dbg(TRACE, "Exit\n");
1288
1289 return err;
1290 }
1291
1292 static s32 brcmf_set_wpa_version(struct net_device *ndev,
1293 struct cfg80211_connect_params *sme)
1294 {
1295 struct brcmf_cfg80211_profile *profile = ndev_to_prof(ndev);
1296 struct brcmf_cfg80211_security *sec;
1297 s32 val = 0;
1298 s32 err = 0;
1299
1300 if (sme->crypto.wpa_versions & NL80211_WPA_VERSION_1)
1301 val = WPA_AUTH_PSK | WPA_AUTH_UNSPECIFIED;
1302 else if (sme->crypto.wpa_versions & NL80211_WPA_VERSION_2)
1303 val = WPA2_AUTH_PSK | WPA2_AUTH_UNSPECIFIED;
1304 else
1305 val = WPA_AUTH_DISABLED;
1306 brcmf_dbg(CONN, "setting wpa_auth to 0x%0x\n", val);
1307 err = brcmf_fil_bsscfg_int_set(netdev_priv(ndev), "wpa_auth", val);
1308 if (err) {
1309 brcmf_err("set wpa_auth failed (%d)\n", err);
1310 return err;
1311 }
1312 sec = &profile->sec;
1313 sec->wpa_versions = sme->crypto.wpa_versions;
1314 return err;
1315 }
1316
1317 static s32 brcmf_set_auth_type(struct net_device *ndev,
1318 struct cfg80211_connect_params *sme)
1319 {
1320 struct brcmf_cfg80211_profile *profile = ndev_to_prof(ndev);
1321 struct brcmf_cfg80211_security *sec;
1322 s32 val = 0;
1323 s32 err = 0;
1324
1325 switch (sme->auth_type) {
1326 case NL80211_AUTHTYPE_OPEN_SYSTEM:
1327 val = 0;
1328 brcmf_dbg(CONN, "open system\n");
1329 break;
1330 case NL80211_AUTHTYPE_SHARED_KEY:
1331 val = 1;
1332 brcmf_dbg(CONN, "shared key\n");
1333 break;
1334 case NL80211_AUTHTYPE_AUTOMATIC:
1335 val = 2;
1336 brcmf_dbg(CONN, "automatic\n");
1337 break;
1338 case NL80211_AUTHTYPE_NETWORK_EAP:
1339 brcmf_dbg(CONN, "network eap\n");
1340 default:
1341 val = 2;
1342 brcmf_err("invalid auth type (%d)\n", sme->auth_type);
1343 break;
1344 }
1345
1346 err = brcmf_fil_bsscfg_int_set(netdev_priv(ndev), "auth", val);
1347 if (err) {
1348 brcmf_err("set auth failed (%d)\n", err);
1349 return err;
1350 }
1351 sec = &profile->sec;
1352 sec->auth_type = sme->auth_type;
1353 return err;
1354 }
1355
1356 static s32
1357 brcmf_set_wsec_mode(struct net_device *ndev,
1358 struct cfg80211_connect_params *sme, bool mfp)
1359 {
1360 struct brcmf_cfg80211_profile *profile = ndev_to_prof(ndev);
1361 struct brcmf_cfg80211_security *sec;
1362 s32 pval = 0;
1363 s32 gval = 0;
1364 s32 wsec;
1365 s32 err = 0;
1366
1367 if (sme->crypto.n_ciphers_pairwise) {
1368 switch (sme->crypto.ciphers_pairwise[0]) {
1369 case WLAN_CIPHER_SUITE_WEP40:
1370 case WLAN_CIPHER_SUITE_WEP104:
1371 pval = WEP_ENABLED;
1372 break;
1373 case WLAN_CIPHER_SUITE_TKIP:
1374 pval = TKIP_ENABLED;
1375 break;
1376 case WLAN_CIPHER_SUITE_CCMP:
1377 pval = AES_ENABLED;
1378 break;
1379 case WLAN_CIPHER_SUITE_AES_CMAC:
1380 pval = AES_ENABLED;
1381 break;
1382 default:
1383 brcmf_err("invalid cipher pairwise (%d)\n",
1384 sme->crypto.ciphers_pairwise[0]);
1385 return -EINVAL;
1386 }
1387 }
1388 if (sme->crypto.cipher_group) {
1389 switch (sme->crypto.cipher_group) {
1390 case WLAN_CIPHER_SUITE_WEP40:
1391 case WLAN_CIPHER_SUITE_WEP104:
1392 gval = WEP_ENABLED;
1393 break;
1394 case WLAN_CIPHER_SUITE_TKIP:
1395 gval = TKIP_ENABLED;
1396 break;
1397 case WLAN_CIPHER_SUITE_CCMP:
1398 gval = AES_ENABLED;
1399 break;
1400 case WLAN_CIPHER_SUITE_AES_CMAC:
1401 gval = AES_ENABLED;
1402 break;
1403 default:
1404 brcmf_err("invalid cipher group (%d)\n",
1405 sme->crypto.cipher_group);
1406 return -EINVAL;
1407 }
1408 }
1409
1410 brcmf_dbg(CONN, "pval (%d) gval (%d)\n", pval, gval);
1411 /* In case of privacy, but no security and WPS then simulate */
1412 /* setting AES. WPS-2.0 allows no security */
1413 if (brcmf_find_wpsie(sme->ie, sme->ie_len) && !pval && !gval &&
1414 sme->privacy)
1415 pval = AES_ENABLED;
1416
1417 if (mfp)
1418 wsec = pval | gval | MFP_CAPABLE;
1419 else
1420 wsec = pval | gval;
1421 err = brcmf_fil_bsscfg_int_set(netdev_priv(ndev), "wsec", wsec);
1422 if (err) {
1423 brcmf_err("error (%d)\n", err);
1424 return err;
1425 }
1426
1427 sec = &profile->sec;
1428 sec->cipher_pairwise = sme->crypto.ciphers_pairwise[0];
1429 sec->cipher_group = sme->crypto.cipher_group;
1430
1431 return err;
1432 }
1433
1434 static s32
1435 brcmf_set_key_mgmt(struct net_device *ndev, struct cfg80211_connect_params *sme)
1436 {
1437 struct brcmf_cfg80211_profile *profile = ndev_to_prof(ndev);
1438 struct brcmf_cfg80211_security *sec;
1439 s32 val = 0;
1440 s32 err = 0;
1441
1442 if (sme->crypto.n_akm_suites) {
1443 err = brcmf_fil_bsscfg_int_get(netdev_priv(ndev),
1444 "wpa_auth", &val);
1445 if (err) {
1446 brcmf_err("could not get wpa_auth (%d)\n", err);
1447 return err;
1448 }
1449 if (val & (WPA_AUTH_PSK | WPA_AUTH_UNSPECIFIED)) {
1450 switch (sme->crypto.akm_suites[0]) {
1451 case WLAN_AKM_SUITE_8021X:
1452 val = WPA_AUTH_UNSPECIFIED;
1453 break;
1454 case WLAN_AKM_SUITE_PSK:
1455 val = WPA_AUTH_PSK;
1456 break;
1457 default:
1458 brcmf_err("invalid cipher group (%d)\n",
1459 sme->crypto.cipher_group);
1460 return -EINVAL;
1461 }
1462 } else if (val & (WPA2_AUTH_PSK | WPA2_AUTH_UNSPECIFIED)) {
1463 switch (sme->crypto.akm_suites[0]) {
1464 case WLAN_AKM_SUITE_8021X:
1465 val = WPA2_AUTH_UNSPECIFIED;
1466 break;
1467 case WLAN_AKM_SUITE_PSK:
1468 val = WPA2_AUTH_PSK;
1469 break;
1470 default:
1471 brcmf_err("invalid cipher group (%d)\n",
1472 sme->crypto.cipher_group);
1473 return -EINVAL;
1474 }
1475 }
1476
1477 brcmf_dbg(CONN, "setting wpa_auth to %d\n", val);
1478 err = brcmf_fil_bsscfg_int_set(netdev_priv(ndev),
1479 "wpa_auth", val);
1480 if (err) {
1481 brcmf_err("could not set wpa_auth (%d)\n", err);
1482 return err;
1483 }
1484 }
1485 sec = &profile->sec;
1486 sec->wpa_auth = sme->crypto.akm_suites[0];
1487
1488 return err;
1489 }
1490
1491 static s32
1492 brcmf_set_sharedkey(struct net_device *ndev,
1493 struct cfg80211_connect_params *sme)
1494 {
1495 struct brcmf_cfg80211_profile *profile = ndev_to_prof(ndev);
1496 struct brcmf_cfg80211_security *sec;
1497 struct brcmf_wsec_key key;
1498 s32 val;
1499 s32 err = 0;
1500
1501 brcmf_dbg(CONN, "key len (%d)\n", sme->key_len);
1502
1503 if (sme->key_len == 0)
1504 return 0;
1505
1506 sec = &profile->sec;
1507 brcmf_dbg(CONN, "wpa_versions 0x%x cipher_pairwise 0x%x\n",
1508 sec->wpa_versions, sec->cipher_pairwise);
1509
1510 if (sec->wpa_versions & (NL80211_WPA_VERSION_1 | NL80211_WPA_VERSION_2))
1511 return 0;
1512
1513 if (!(sec->cipher_pairwise &
1514 (WLAN_CIPHER_SUITE_WEP40 | WLAN_CIPHER_SUITE_WEP104)))
1515 return 0;
1516
1517 memset(&key, 0, sizeof(key));
1518 key.len = (u32) sme->key_len;
1519 key.index = (u32) sme->key_idx;
1520 if (key.len > sizeof(key.data)) {
1521 brcmf_err("Too long key length (%u)\n", key.len);
1522 return -EINVAL;
1523 }
1524 memcpy(key.data, sme->key, key.len);
1525 key.flags = BRCMF_PRIMARY_KEY;
1526 switch (sec->cipher_pairwise) {
1527 case WLAN_CIPHER_SUITE_WEP40:
1528 key.algo = CRYPTO_ALGO_WEP1;
1529 break;
1530 case WLAN_CIPHER_SUITE_WEP104:
1531 key.algo = CRYPTO_ALGO_WEP128;
1532 break;
1533 default:
1534 brcmf_err("Invalid algorithm (%d)\n",
1535 sme->crypto.ciphers_pairwise[0]);
1536 return -EINVAL;
1537 }
1538 /* Set the new key/index */
1539 brcmf_dbg(CONN, "key length (%d) key index (%d) algo (%d)\n",
1540 key.len, key.index, key.algo);
1541 brcmf_dbg(CONN, "key \"%s\"\n", key.data);
1542 err = send_key_to_dongle(ndev, &key);
1543 if (err)
1544 return err;
1545
1546 if (sec->auth_type == NL80211_AUTHTYPE_SHARED_KEY) {
1547 brcmf_dbg(CONN, "set auth_type to shared key\n");
1548 val = WL_AUTH_SHARED_KEY; /* shared key */
1549 err = brcmf_fil_bsscfg_int_set(netdev_priv(ndev), "auth", val);
1550 if (err)
1551 brcmf_err("set auth failed (%d)\n", err);
1552 }
1553 return err;
1554 }
1555
1556 static
1557 enum nl80211_auth_type brcmf_war_auth_type(struct brcmf_if *ifp,
1558 enum nl80211_auth_type type)
1559 {
1560 u32 ci;
1561 if (type == NL80211_AUTHTYPE_AUTOMATIC) {
1562 /* shift to ignore chip revision */
1563 ci = brcmf_get_chip_info(ifp) >> 4;
1564 switch (ci) {
1565 case 43236:
1566 brcmf_dbg(CONN, "43236 WAR: use OPEN instead of AUTO\n");
1567 return NL80211_AUTHTYPE_OPEN_SYSTEM;
1568 default:
1569 break;
1570 }
1571 }
1572 return type;
1573 }
1574
1575 static s32
1576 brcmf_cfg80211_connect(struct wiphy *wiphy, struct net_device *ndev,
1577 struct cfg80211_connect_params *sme)
1578 {
1579 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy);
1580 struct brcmf_if *ifp = netdev_priv(ndev);
1581 struct brcmf_cfg80211_profile *profile = &ifp->vif->profile;
1582 struct ieee80211_channel *chan = sme->channel;
1583 struct brcmf_join_params join_params;
1584 size_t join_params_size;
1585 const struct brcmf_tlv *rsn_ie;
1586 const struct brcmf_vs_tlv *wpa_ie;
1587 const void *ie;
1588 u32 ie_len;
1589 struct brcmf_ext_join_params_le *ext_join_params;
1590 u16 chanspec;
1591 s32 err = 0;
1592
1593 brcmf_dbg(TRACE, "Enter\n");
1594 if (!check_vif_up(ifp->vif))
1595 return -EIO;
1596
1597 if (!sme->ssid) {
1598 brcmf_err("Invalid ssid\n");
1599 return -EOPNOTSUPP;
1600 }
1601
1602 if (ifp->vif == cfg->p2p.bss_idx[P2PAPI_BSSCFG_PRIMARY].vif) {
1603 /* A normal (non P2P) connection request setup. */
1604 ie = NULL;
1605 ie_len = 0;
1606 /* find the WPA_IE */
1607 wpa_ie = brcmf_find_wpaie((u8 *)sme->ie, sme->ie_len);
1608 if (wpa_ie) {
1609 ie = wpa_ie;
1610 ie_len = wpa_ie->len + TLV_HDR_LEN;
1611 } else {
1612 /* find the RSN_IE */
1613 rsn_ie = brcmf_parse_tlvs((const u8 *)sme->ie,
1614 sme->ie_len,
1615 WLAN_EID_RSN);
1616 if (rsn_ie) {
1617 ie = rsn_ie;
1618 ie_len = rsn_ie->len + TLV_HDR_LEN;
1619 }
1620 }
1621 brcmf_fil_iovar_data_set(ifp, "wpaie", ie, ie_len);
1622 }
1623
1624 err = brcmf_vif_set_mgmt_ie(ifp->vif, BRCMF_VNDR_IE_ASSOCREQ_FLAG,
1625 sme->ie, sme->ie_len);
1626 if (err)
1627 brcmf_err("Set Assoc REQ IE Failed\n");
1628 else
1629 brcmf_dbg(TRACE, "Applied Vndr IEs for Assoc request\n");
1630
1631 set_bit(BRCMF_VIF_STATUS_CONNECTING, &ifp->vif->sme_state);
1632
1633 if (chan) {
1634 cfg->channel =
1635 ieee80211_frequency_to_channel(chan->center_freq);
1636 chanspec = channel_to_chanspec(&cfg->d11inf, chan);
1637 brcmf_dbg(CONN, "channel=%d, center_req=%d, chanspec=0x%04x\n",
1638 cfg->channel, chan->center_freq, chanspec);
1639 } else {
1640 cfg->channel = 0;
1641 chanspec = 0;
1642 }
1643
1644 brcmf_dbg(INFO, "ie (%p), ie_len (%zd)\n", sme->ie, sme->ie_len);
1645
1646 err = brcmf_set_wpa_version(ndev, sme);
1647 if (err) {
1648 brcmf_err("wl_set_wpa_version failed (%d)\n", err);
1649 goto done;
1650 }
1651
1652 sme->auth_type = brcmf_war_auth_type(ifp, sme->auth_type);
1653 err = brcmf_set_auth_type(ndev, sme);
1654 if (err) {
1655 brcmf_err("wl_set_auth_type failed (%d)\n", err);
1656 goto done;
1657 }
1658
1659 err = brcmf_set_wsec_mode(ndev, sme, sme->mfp == NL80211_MFP_REQUIRED);
1660 if (err) {
1661 brcmf_err("wl_set_set_cipher failed (%d)\n", err);
1662 goto done;
1663 }
1664
1665 err = brcmf_set_key_mgmt(ndev, sme);
1666 if (err) {
1667 brcmf_err("wl_set_key_mgmt failed (%d)\n", err);
1668 goto done;
1669 }
1670
1671 err = brcmf_set_sharedkey(ndev, sme);
1672 if (err) {
1673 brcmf_err("brcmf_set_sharedkey failed (%d)\n", err);
1674 goto done;
1675 }
1676
1677 profile->ssid.SSID_len = min_t(u32, (u32)sizeof(profile->ssid.SSID),
1678 (u32)sme->ssid_len);
1679 memcpy(&profile->ssid.SSID, sme->ssid, profile->ssid.SSID_len);
1680 if (profile->ssid.SSID_len < IEEE80211_MAX_SSID_LEN) {
1681 profile->ssid.SSID[profile->ssid.SSID_len] = 0;
1682 brcmf_dbg(CONN, "SSID \"%s\", len (%d)\n", profile->ssid.SSID,
1683 profile->ssid.SSID_len);
1684 }
1685
1686 /* Join with specific BSSID and cached SSID
1687 * If SSID is zero join based on BSSID only
1688 */
1689 join_params_size = offsetof(struct brcmf_ext_join_params_le, assoc_le) +
1690 offsetof(struct brcmf_assoc_params_le, chanspec_list);
1691 if (cfg->channel)
1692 join_params_size += sizeof(u16);
1693 ext_join_params = kzalloc(join_params_size, GFP_KERNEL);
1694 if (ext_join_params == NULL) {
1695 err = -ENOMEM;
1696 goto done;
1697 }
1698 ext_join_params->ssid_le.SSID_len = cpu_to_le32(profile->ssid.SSID_len);
1699 memcpy(&ext_join_params->ssid_le.SSID, sme->ssid,
1700 profile->ssid.SSID_len);
1701
1702 /* Set up join scan parameters */
1703 ext_join_params->scan_le.scan_type = -1;
1704 ext_join_params->scan_le.home_time = cpu_to_le32(-1);
1705
1706 if (sme->bssid)
1707 memcpy(&ext_join_params->assoc_le.bssid, sme->bssid, ETH_ALEN);
1708 else
1709 memset(&ext_join_params->assoc_le.bssid, 0xFF, ETH_ALEN);
1710
1711 if (cfg->channel) {
1712 ext_join_params->assoc_le.chanspec_num = cpu_to_le32(1);
1713
1714 ext_join_params->assoc_le.chanspec_list[0] =
1715 cpu_to_le16(chanspec);
1716 /* Increase dwell time to receive probe response or detect
1717 * beacon from target AP at a noisy air only during connect
1718 * command.
1719 */
1720 ext_join_params->scan_le.active_time =
1721 cpu_to_le32(BRCMF_SCAN_JOIN_ACTIVE_DWELL_TIME_MS);
1722 ext_join_params->scan_le.passive_time =
1723 cpu_to_le32(BRCMF_SCAN_JOIN_PASSIVE_DWELL_TIME_MS);
1724 /* To sync with presence period of VSDB GO send probe request
1725 * more frequently. Probe request will be stopped when it gets
1726 * probe response from target AP/GO.
1727 */
1728 ext_join_params->scan_le.nprobes =
1729 cpu_to_le32(BRCMF_SCAN_JOIN_ACTIVE_DWELL_TIME_MS /
1730 BRCMF_SCAN_JOIN_PROBE_INTERVAL_MS);
1731 } else {
1732 ext_join_params->scan_le.active_time = cpu_to_le32(-1);
1733 ext_join_params->scan_le.passive_time = cpu_to_le32(-1);
1734 ext_join_params->scan_le.nprobes = cpu_to_le32(-1);
1735 }
1736
1737 err = brcmf_fil_bsscfg_data_set(ifp, "join", ext_join_params,
1738 join_params_size);
1739 kfree(ext_join_params);
1740 if (!err)
1741 /* This is it. join command worked, we are done */
1742 goto done;
1743
1744 /* join command failed, fallback to set ssid */
1745 memset(&join_params, 0, sizeof(join_params));
1746 join_params_size = sizeof(join_params.ssid_le);
1747
1748 memcpy(&join_params.ssid_le.SSID, sme->ssid, profile->ssid.SSID_len);
1749 join_params.ssid_le.SSID_len = cpu_to_le32(profile->ssid.SSID_len);
1750
1751 if (sme->bssid)
1752 memcpy(join_params.params_le.bssid, sme->bssid, ETH_ALEN);
1753 else
1754 memset(join_params.params_le.bssid, 0xFF, ETH_ALEN);
1755
1756 if (cfg->channel) {
1757 join_params.params_le.chanspec_list[0] = cpu_to_le16(chanspec);
1758 join_params.params_le.chanspec_num = cpu_to_le32(1);
1759 join_params_size += sizeof(join_params.params_le);
1760 }
1761 err = brcmf_fil_cmd_data_set(ifp, BRCMF_C_SET_SSID,
1762 &join_params, join_params_size);
1763 if (err)
1764 brcmf_err("BRCMF_C_SET_SSID failed (%d)\n", err);
1765
1766 done:
1767 if (err)
1768 clear_bit(BRCMF_VIF_STATUS_CONNECTING, &ifp->vif->sme_state);
1769 brcmf_dbg(TRACE, "Exit\n");
1770 return err;
1771 }
1772
1773 static s32
1774 brcmf_cfg80211_disconnect(struct wiphy *wiphy, struct net_device *ndev,
1775 u16 reason_code)
1776 {
1777 struct brcmf_if *ifp = netdev_priv(ndev);
1778 struct brcmf_cfg80211_profile *profile = &ifp->vif->profile;
1779 struct brcmf_scb_val_le scbval;
1780 s32 err = 0;
1781
1782 brcmf_dbg(TRACE, "Enter. Reason code = %d\n", reason_code);
1783 if (!check_vif_up(ifp->vif))
1784 return -EIO;
1785
1786 clear_bit(BRCMF_VIF_STATUS_CONNECTED, &ifp->vif->sme_state);
1787 cfg80211_disconnected(ndev, reason_code, NULL, 0, GFP_KERNEL);
1788
1789 memcpy(&scbval.ea, &profile->bssid, ETH_ALEN);
1790 scbval.val = cpu_to_le32(reason_code);
1791 err = brcmf_fil_cmd_data_set(ifp, BRCMF_C_DISASSOC,
1792 &scbval, sizeof(scbval));
1793 if (err)
1794 brcmf_err("error (%d)\n", err);
1795
1796 brcmf_dbg(TRACE, "Exit\n");
1797 return err;
1798 }
1799
1800 static s32
1801 brcmf_cfg80211_set_tx_power(struct wiphy *wiphy, struct wireless_dev *wdev,
1802 enum nl80211_tx_power_setting type, s32 mbm)
1803 {
1804
1805 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy);
1806 struct net_device *ndev = cfg_to_ndev(cfg);
1807 struct brcmf_if *ifp = netdev_priv(ndev);
1808 u16 txpwrmw;
1809 s32 err = 0;
1810 s32 disable = 0;
1811 s32 dbm = MBM_TO_DBM(mbm);
1812
1813 brcmf_dbg(TRACE, "Enter\n");
1814 if (!check_vif_up(ifp->vif))
1815 return -EIO;
1816
1817 switch (type) {
1818 case NL80211_TX_POWER_AUTOMATIC:
1819 break;
1820 case NL80211_TX_POWER_LIMITED:
1821 case NL80211_TX_POWER_FIXED:
1822 if (dbm < 0) {
1823 brcmf_err("TX_POWER_FIXED - dbm is negative\n");
1824 err = -EINVAL;
1825 goto done;
1826 }
1827 break;
1828 }
1829 /* Make sure radio is off or on as far as software is concerned */
1830 disable = WL_RADIO_SW_DISABLE << 16;
1831 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_RADIO, disable);
1832 if (err)
1833 brcmf_err("WLC_SET_RADIO error (%d)\n", err);
1834
1835 if (dbm > 0xffff)
1836 txpwrmw = 0xffff;
1837 else
1838 txpwrmw = (u16) dbm;
1839 err = brcmf_fil_iovar_int_set(ifp, "qtxpower",
1840 (s32)brcmf_mw_to_qdbm(txpwrmw));
1841 if (err)
1842 brcmf_err("qtxpower error (%d)\n", err);
1843 cfg->conf->tx_power = dbm;
1844
1845 done:
1846 brcmf_dbg(TRACE, "Exit\n");
1847 return err;
1848 }
1849
1850 static s32 brcmf_cfg80211_get_tx_power(struct wiphy *wiphy,
1851 struct wireless_dev *wdev,
1852 s32 *dbm)
1853 {
1854 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy);
1855 struct brcmf_if *ifp = netdev_priv(cfg_to_ndev(cfg));
1856 s32 txpwrdbm;
1857 u8 result;
1858 s32 err = 0;
1859
1860 brcmf_dbg(TRACE, "Enter\n");
1861 if (!check_vif_up(ifp->vif))
1862 return -EIO;
1863
1864 err = brcmf_fil_iovar_int_get(ifp, "qtxpower", &txpwrdbm);
1865 if (err) {
1866 brcmf_err("error (%d)\n", err);
1867 goto done;
1868 }
1869
1870 result = (u8) (txpwrdbm & ~WL_TXPWR_OVERRIDE);
1871 *dbm = (s32) brcmf_qdbm_to_mw(result);
1872
1873 done:
1874 brcmf_dbg(TRACE, "Exit\n");
1875 return err;
1876 }
1877
1878 static s32
1879 brcmf_cfg80211_config_default_key(struct wiphy *wiphy, struct net_device *ndev,
1880 u8 key_idx, bool unicast, bool multicast)
1881 {
1882 struct brcmf_if *ifp = netdev_priv(ndev);
1883 u32 index;
1884 u32 wsec;
1885 s32 err = 0;
1886
1887 brcmf_dbg(TRACE, "Enter\n");
1888 brcmf_dbg(CONN, "key index (%d)\n", key_idx);
1889 if (!check_vif_up(ifp->vif))
1890 return -EIO;
1891
1892 err = brcmf_fil_bsscfg_int_get(ifp, "wsec", &wsec);
1893 if (err) {
1894 brcmf_err("WLC_GET_WSEC error (%d)\n", err);
1895 goto done;
1896 }
1897
1898 if (wsec & WEP_ENABLED) {
1899 /* Just select a new current key */
1900 index = key_idx;
1901 err = brcmf_fil_cmd_int_set(ifp,
1902 BRCMF_C_SET_KEY_PRIMARY, index);
1903 if (err)
1904 brcmf_err("error (%d)\n", err);
1905 }
1906 done:
1907 brcmf_dbg(TRACE, "Exit\n");
1908 return err;
1909 }
1910
1911 static s32
1912 brcmf_add_keyext(struct wiphy *wiphy, struct net_device *ndev,
1913 u8 key_idx, const u8 *mac_addr, struct key_params *params)
1914 {
1915 struct brcmf_if *ifp = netdev_priv(ndev);
1916 struct brcmf_wsec_key key;
1917 s32 err = 0;
1918 u8 keybuf[8];
1919
1920 memset(&key, 0, sizeof(key));
1921 key.index = (u32) key_idx;
1922 /* Instead of bcast for ea address for default wep keys,
1923 driver needs it to be Null */
1924 if (!is_multicast_ether_addr(mac_addr))
1925 memcpy((char *)&key.ea, (void *)mac_addr, ETH_ALEN);
1926 key.len = (u32) params->key_len;
1927 /* check for key index change */
1928 if (key.len == 0) {
1929 /* key delete */
1930 err = send_key_to_dongle(ndev, &key);
1931 if (err)
1932 brcmf_err("key delete error (%d)\n", err);
1933 } else {
1934 if (key.len > sizeof(key.data)) {
1935 brcmf_err("Invalid key length (%d)\n", key.len);
1936 return -EINVAL;
1937 }
1938
1939 brcmf_dbg(CONN, "Setting the key index %d\n", key.index);
1940 memcpy(key.data, params->key, key.len);
1941
1942 if (!brcmf_is_apmode(ifp->vif) &&
1943 (params->cipher == WLAN_CIPHER_SUITE_TKIP)) {
1944 brcmf_dbg(CONN, "Swapping RX/TX MIC key\n");
1945 memcpy(keybuf, &key.data[24], sizeof(keybuf));
1946 memcpy(&key.data[24], &key.data[16], sizeof(keybuf));
1947 memcpy(&key.data[16], keybuf, sizeof(keybuf));
1948 }
1949
1950 /* if IW_ENCODE_EXT_RX_SEQ_VALID set */
1951 if (params->seq && params->seq_len == 6) {
1952 /* rx iv */
1953 u8 *ivptr;
1954 ivptr = (u8 *) params->seq;
1955 key.rxiv.hi = (ivptr[5] << 24) | (ivptr[4] << 16) |
1956 (ivptr[3] << 8) | ivptr[2];
1957 key.rxiv.lo = (ivptr[1] << 8) | ivptr[0];
1958 key.iv_initialized = true;
1959 }
1960
1961 switch (params->cipher) {
1962 case WLAN_CIPHER_SUITE_WEP40:
1963 key.algo = CRYPTO_ALGO_WEP1;
1964 brcmf_dbg(CONN, "WLAN_CIPHER_SUITE_WEP40\n");
1965 break;
1966 case WLAN_CIPHER_SUITE_WEP104:
1967 key.algo = CRYPTO_ALGO_WEP128;
1968 brcmf_dbg(CONN, "WLAN_CIPHER_SUITE_WEP104\n");
1969 break;
1970 case WLAN_CIPHER_SUITE_TKIP:
1971 key.algo = CRYPTO_ALGO_TKIP;
1972 brcmf_dbg(CONN, "WLAN_CIPHER_SUITE_TKIP\n");
1973 break;
1974 case WLAN_CIPHER_SUITE_AES_CMAC:
1975 key.algo = CRYPTO_ALGO_AES_CCM;
1976 brcmf_dbg(CONN, "WLAN_CIPHER_SUITE_AES_CMAC\n");
1977 break;
1978 case WLAN_CIPHER_SUITE_CCMP:
1979 key.algo = CRYPTO_ALGO_AES_CCM;
1980 brcmf_dbg(CONN, "WLAN_CIPHER_SUITE_CCMP\n");
1981 break;
1982 default:
1983 brcmf_err("Invalid cipher (0x%x)\n", params->cipher);
1984 return -EINVAL;
1985 }
1986 err = send_key_to_dongle(ndev, &key);
1987 if (err)
1988 brcmf_err("wsec_key error (%d)\n", err);
1989 }
1990 return err;
1991 }
1992
1993 static s32
1994 brcmf_cfg80211_add_key(struct wiphy *wiphy, struct net_device *ndev,
1995 u8 key_idx, bool pairwise, const u8 *mac_addr,
1996 struct key_params *params)
1997 {
1998 struct brcmf_if *ifp = netdev_priv(ndev);
1999 struct brcmf_wsec_key key;
2000 s32 val;
2001 s32 wsec;
2002 s32 err = 0;
2003 u8 keybuf[8];
2004
2005 brcmf_dbg(TRACE, "Enter\n");
2006 brcmf_dbg(CONN, "key index (%d)\n", key_idx);
2007 if (!check_vif_up(ifp->vif))
2008 return -EIO;
2009
2010 if (mac_addr &&
2011 (params->cipher != WLAN_CIPHER_SUITE_WEP40) &&
2012 (params->cipher != WLAN_CIPHER_SUITE_WEP104)) {
2013 brcmf_dbg(TRACE, "Exit");
2014 return brcmf_add_keyext(wiphy, ndev, key_idx, mac_addr, params);
2015 }
2016 memset(&key, 0, sizeof(key));
2017
2018 key.len = (u32) params->key_len;
2019 key.index = (u32) key_idx;
2020
2021 if (key.len > sizeof(key.data)) {
2022 brcmf_err("Too long key length (%u)\n", key.len);
2023 err = -EINVAL;
2024 goto done;
2025 }
2026 memcpy(key.data, params->key, key.len);
2027
2028 key.flags = BRCMF_PRIMARY_KEY;
2029 switch (params->cipher) {
2030 case WLAN_CIPHER_SUITE_WEP40:
2031 key.algo = CRYPTO_ALGO_WEP1;
2032 val = WEP_ENABLED;
2033 brcmf_dbg(CONN, "WLAN_CIPHER_SUITE_WEP40\n");
2034 break;
2035 case WLAN_CIPHER_SUITE_WEP104:
2036 key.algo = CRYPTO_ALGO_WEP128;
2037 val = WEP_ENABLED;
2038 brcmf_dbg(CONN, "WLAN_CIPHER_SUITE_WEP104\n");
2039 break;
2040 case WLAN_CIPHER_SUITE_TKIP:
2041 if (!brcmf_is_apmode(ifp->vif)) {
2042 brcmf_dbg(CONN, "Swapping RX/TX MIC key\n");
2043 memcpy(keybuf, &key.data[24], sizeof(keybuf));
2044 memcpy(&key.data[24], &key.data[16], sizeof(keybuf));
2045 memcpy(&key.data[16], keybuf, sizeof(keybuf));
2046 }
2047 key.algo = CRYPTO_ALGO_TKIP;
2048 val = TKIP_ENABLED;
2049 brcmf_dbg(CONN, "WLAN_CIPHER_SUITE_TKIP\n");
2050 break;
2051 case WLAN_CIPHER_SUITE_AES_CMAC:
2052 key.algo = CRYPTO_ALGO_AES_CCM;
2053 val = AES_ENABLED;
2054 brcmf_dbg(CONN, "WLAN_CIPHER_SUITE_AES_CMAC\n");
2055 break;
2056 case WLAN_CIPHER_SUITE_CCMP:
2057 key.algo = CRYPTO_ALGO_AES_CCM;
2058 val = AES_ENABLED;
2059 brcmf_dbg(CONN, "WLAN_CIPHER_SUITE_CCMP\n");
2060 break;
2061 default:
2062 brcmf_err("Invalid cipher (0x%x)\n", params->cipher);
2063 err = -EINVAL;
2064 goto done;
2065 }
2066
2067 err = send_key_to_dongle(ndev, &key);
2068 if (err)
2069 goto done;
2070
2071 err = brcmf_fil_bsscfg_int_get(ifp, "wsec", &wsec);
2072 if (err) {
2073 brcmf_err("get wsec error (%d)\n", err);
2074 goto done;
2075 }
2076 wsec |= val;
2077 err = brcmf_fil_bsscfg_int_set(ifp, "wsec", wsec);
2078 if (err) {
2079 brcmf_err("set wsec error (%d)\n", err);
2080 goto done;
2081 }
2082
2083 done:
2084 brcmf_dbg(TRACE, "Exit\n");
2085 return err;
2086 }
2087
2088 static s32
2089 brcmf_cfg80211_del_key(struct wiphy *wiphy, struct net_device *ndev,
2090 u8 key_idx, bool pairwise, const u8 *mac_addr)
2091 {
2092 struct brcmf_if *ifp = netdev_priv(ndev);
2093 struct brcmf_wsec_key key;
2094 s32 err = 0;
2095
2096 brcmf_dbg(TRACE, "Enter\n");
2097 if (!check_vif_up(ifp->vif))
2098 return -EIO;
2099
2100 if (key_idx >= DOT11_MAX_DEFAULT_KEYS) {
2101 /* we ignore this key index in this case */
2102 brcmf_err("invalid key index (%d)\n", key_idx);
2103 return -EINVAL;
2104 }
2105
2106 memset(&key, 0, sizeof(key));
2107
2108 key.index = (u32) key_idx;
2109 key.flags = BRCMF_PRIMARY_KEY;
2110 key.algo = CRYPTO_ALGO_OFF;
2111
2112 brcmf_dbg(CONN, "key index (%d)\n", key_idx);
2113
2114 /* Set the new key/index */
2115 err = send_key_to_dongle(ndev, &key);
2116
2117 brcmf_dbg(TRACE, "Exit\n");
2118 return err;
2119 }
2120
2121 static s32
2122 brcmf_cfg80211_get_key(struct wiphy *wiphy, struct net_device *ndev,
2123 u8 key_idx, bool pairwise, const u8 *mac_addr, void *cookie,
2124 void (*callback) (void *cookie, struct key_params * params))
2125 {
2126 struct key_params params;
2127 struct brcmf_if *ifp = netdev_priv(ndev);
2128 struct brcmf_cfg80211_profile *profile = &ifp->vif->profile;
2129 struct brcmf_cfg80211_security *sec;
2130 s32 wsec;
2131 s32 err = 0;
2132
2133 brcmf_dbg(TRACE, "Enter\n");
2134 brcmf_dbg(CONN, "key index (%d)\n", key_idx);
2135 if (!check_vif_up(ifp->vif))
2136 return -EIO;
2137
2138 memset(&params, 0, sizeof(params));
2139
2140 err = brcmf_fil_bsscfg_int_get(ifp, "wsec", &wsec);
2141 if (err) {
2142 brcmf_err("WLC_GET_WSEC error (%d)\n", err);
2143 /* Ignore this error, may happen during DISASSOC */
2144 err = -EAGAIN;
2145 goto done;
2146 }
2147 if (wsec & WEP_ENABLED) {
2148 sec = &profile->sec;
2149 if (sec->cipher_pairwise & WLAN_CIPHER_SUITE_WEP40) {
2150 params.cipher = WLAN_CIPHER_SUITE_WEP40;
2151 brcmf_dbg(CONN, "WLAN_CIPHER_SUITE_WEP40\n");
2152 } else if (sec->cipher_pairwise & WLAN_CIPHER_SUITE_WEP104) {
2153 params.cipher = WLAN_CIPHER_SUITE_WEP104;
2154 brcmf_dbg(CONN, "WLAN_CIPHER_SUITE_WEP104\n");
2155 }
2156 } else if (wsec & TKIP_ENABLED) {
2157 params.cipher = WLAN_CIPHER_SUITE_TKIP;
2158 brcmf_dbg(CONN, "WLAN_CIPHER_SUITE_TKIP\n");
2159 } else if (wsec & AES_ENABLED) {
2160 params.cipher = WLAN_CIPHER_SUITE_AES_CMAC;
2161 brcmf_dbg(CONN, "WLAN_CIPHER_SUITE_AES_CMAC\n");
2162 } else {
2163 brcmf_err("Invalid algo (0x%x)\n", wsec);
2164 err = -EINVAL;
2165 goto done;
2166 }
2167 callback(cookie, &params);
2168
2169 done:
2170 brcmf_dbg(TRACE, "Exit\n");
2171 return err;
2172 }
2173
2174 static s32
2175 brcmf_cfg80211_config_default_mgmt_key(struct wiphy *wiphy,
2176 struct net_device *ndev, u8 key_idx)
2177 {
2178 brcmf_dbg(INFO, "Not supported\n");
2179
2180 return -EOPNOTSUPP;
2181 }
2182
2183 static s32
2184 brcmf_cfg80211_get_station(struct wiphy *wiphy, struct net_device *ndev,
2185 u8 *mac, struct station_info *sinfo)
2186 {
2187 struct brcmf_if *ifp = netdev_priv(ndev);
2188 struct brcmf_cfg80211_profile *profile = &ifp->vif->profile;
2189 struct brcmf_scb_val_le scb_val;
2190 int rssi;
2191 s32 rate;
2192 s32 err = 0;
2193 u8 *bssid = profile->bssid;
2194 struct brcmf_sta_info_le sta_info_le;
2195 u32 beacon_period;
2196 u32 dtim_period;
2197
2198 brcmf_dbg(TRACE, "Enter, MAC %pM\n", mac);
2199 if (!check_vif_up(ifp->vif))
2200 return -EIO;
2201
2202 if (brcmf_is_apmode(ifp->vif)) {
2203 memcpy(&sta_info_le, mac, ETH_ALEN);
2204 err = brcmf_fil_iovar_data_get(ifp, "sta_info",
2205 &sta_info_le,
2206 sizeof(sta_info_le));
2207 if (err < 0) {
2208 brcmf_err("GET STA INFO failed, %d\n", err);
2209 goto done;
2210 }
2211 sinfo->filled = STATION_INFO_INACTIVE_TIME;
2212 sinfo->inactive_time = le32_to_cpu(sta_info_le.idle) * 1000;
2213 if (le32_to_cpu(sta_info_le.flags) & BRCMF_STA_ASSOC) {
2214 sinfo->filled |= STATION_INFO_CONNECTED_TIME;
2215 sinfo->connected_time = le32_to_cpu(sta_info_le.in);
2216 }
2217 brcmf_dbg(TRACE, "STA idle time : %d ms, connected time :%d sec\n",
2218 sinfo->inactive_time, sinfo->connected_time);
2219 } else if (ifp->vif->wdev.iftype == NL80211_IFTYPE_STATION) {
2220 if (memcmp(mac, bssid, ETH_ALEN)) {
2221 brcmf_err("Wrong Mac address cfg_mac-%pM wl_bssid-%pM\n",
2222 mac, bssid);
2223 err = -ENOENT;
2224 goto done;
2225 }
2226 /* Report the current tx rate */
2227 err = brcmf_fil_cmd_int_get(ifp, BRCMF_C_GET_RATE, &rate);
2228 if (err) {
2229 brcmf_err("Could not get rate (%d)\n", err);
2230 goto done;
2231 } else {
2232 sinfo->filled |= STATION_INFO_TX_BITRATE;
2233 sinfo->txrate.legacy = rate * 5;
2234 brcmf_dbg(CONN, "Rate %d Mbps\n", rate / 2);
2235 }
2236
2237 if (test_bit(BRCMF_VIF_STATUS_CONNECTED,
2238 &ifp->vif->sme_state)) {
2239 memset(&scb_val, 0, sizeof(scb_val));
2240 err = brcmf_fil_cmd_data_get(ifp, BRCMF_C_GET_RSSI,
2241 &scb_val, sizeof(scb_val));
2242 if (err) {
2243 brcmf_err("Could not get rssi (%d)\n", err);
2244 goto done;
2245 } else {
2246 rssi = le32_to_cpu(scb_val.val);
2247 sinfo->filled |= STATION_INFO_SIGNAL;
2248 sinfo->signal = rssi;
2249 brcmf_dbg(CONN, "RSSI %d dBm\n", rssi);
2250 }
2251 err = brcmf_fil_cmd_int_get(ifp, BRCMF_C_GET_BCNPRD,
2252 &beacon_period);
2253 if (err) {
2254 brcmf_err("Could not get beacon period (%d)\n",
2255 err);
2256 goto done;
2257 } else {
2258 sinfo->bss_param.beacon_interval =
2259 beacon_period;
2260 brcmf_dbg(CONN, "Beacon peroid %d\n",
2261 beacon_period);
2262 }
2263 err = brcmf_fil_cmd_int_get(ifp, BRCMF_C_GET_DTIMPRD,
2264 &dtim_period);
2265 if (err) {
2266 brcmf_err("Could not get DTIM period (%d)\n",
2267 err);
2268 goto done;
2269 } else {
2270 sinfo->bss_param.dtim_period = dtim_period;
2271 brcmf_dbg(CONN, "DTIM peroid %d\n",
2272 dtim_period);
2273 }
2274 sinfo->filled |= STATION_INFO_BSS_PARAM;
2275 }
2276 } else
2277 err = -EPERM;
2278 done:
2279 brcmf_dbg(TRACE, "Exit\n");
2280 return err;
2281 }
2282
2283 static s32
2284 brcmf_cfg80211_set_power_mgmt(struct wiphy *wiphy, struct net_device *ndev,
2285 bool enabled, s32 timeout)
2286 {
2287 s32 pm;
2288 s32 err = 0;
2289 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy);
2290 struct brcmf_if *ifp = netdev_priv(ndev);
2291
2292 brcmf_dbg(TRACE, "Enter\n");
2293
2294 /*
2295 * Powersave enable/disable request is coming from the
2296 * cfg80211 even before the interface is up. In that
2297 * scenario, driver will be storing the power save
2298 * preference in cfg struct to apply this to
2299 * FW later while initializing the dongle
2300 */
2301 cfg->pwr_save = enabled;
2302 if (!check_vif_up(ifp->vif)) {
2303
2304 brcmf_dbg(INFO, "Device is not ready, storing the value in cfg_info struct\n");
2305 goto done;
2306 }
2307
2308 pm = enabled ? PM_FAST : PM_OFF;
2309 /* Do not enable the power save after assoc if it is a p2p interface */
2310 if (ifp->vif->wdev.iftype == NL80211_IFTYPE_P2P_CLIENT) {
2311 brcmf_dbg(INFO, "Do not enable power save for P2P clients\n");
2312 pm = PM_OFF;
2313 }
2314 brcmf_dbg(INFO, "power save %s\n", (pm ? "enabled" : "disabled"));
2315
2316 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_PM, pm);
2317 if (err) {
2318 if (err == -ENODEV)
2319 brcmf_err("net_device is not ready yet\n");
2320 else
2321 brcmf_err("error (%d)\n", err);
2322 }
2323 done:
2324 brcmf_dbg(TRACE, "Exit\n");
2325 return err;
2326 }
2327
2328 static s32 brcmf_inform_single_bss(struct brcmf_cfg80211_info *cfg,
2329 struct brcmf_bss_info_le *bi)
2330 {
2331 struct wiphy *wiphy = cfg_to_wiphy(cfg);
2332 struct ieee80211_channel *notify_channel;
2333 struct cfg80211_bss *bss;
2334 struct ieee80211_supported_band *band;
2335 struct brcmu_chan ch;
2336 s32 err = 0;
2337 u16 channel;
2338 u32 freq;
2339 u16 notify_capability;
2340 u16 notify_interval;
2341 u8 *notify_ie;
2342 size_t notify_ielen;
2343 s32 notify_signal;
2344
2345 if (le32_to_cpu(bi->length) > WL_BSS_INFO_MAX) {
2346 brcmf_err("Bss info is larger than buffer. Discarding\n");
2347 return 0;
2348 }
2349
2350 if (!bi->ctl_ch) {
2351 ch.chspec = le16_to_cpu(bi->chanspec);
2352 cfg->d11inf.decchspec(&ch);
2353 bi->ctl_ch = ch.chnum;
2354 }
2355 channel = bi->ctl_ch;
2356
2357 if (channel <= CH_MAX_2G_CHANNEL)
2358 band = wiphy->bands[IEEE80211_BAND_2GHZ];
2359 else
2360 band = wiphy->bands[IEEE80211_BAND_5GHZ];
2361
2362 freq = ieee80211_channel_to_frequency(channel, band->band);
2363 notify_channel = ieee80211_get_channel(wiphy, freq);
2364
2365 notify_capability = le16_to_cpu(bi->capability);
2366 notify_interval = le16_to_cpu(bi->beacon_period);
2367 notify_ie = (u8 *)bi + le16_to_cpu(bi->ie_offset);
2368 notify_ielen = le32_to_cpu(bi->ie_length);
2369 notify_signal = (s16)le16_to_cpu(bi->RSSI) * 100;
2370
2371 brcmf_dbg(CONN, "bssid: %pM\n", bi->BSSID);
2372 brcmf_dbg(CONN, "Channel: %d(%d)\n", channel, freq);
2373 brcmf_dbg(CONN, "Capability: %X\n", notify_capability);
2374 brcmf_dbg(CONN, "Beacon interval: %d\n", notify_interval);
2375 brcmf_dbg(CONN, "Signal: %d\n", notify_signal);
2376
2377 bss = cfg80211_inform_bss(wiphy, notify_channel, (const u8 *)bi->BSSID,
2378 0, notify_capability, notify_interval, notify_ie,
2379 notify_ielen, notify_signal, GFP_KERNEL);
2380
2381 if (!bss)
2382 return -ENOMEM;
2383
2384 cfg80211_put_bss(wiphy, bss);
2385
2386 return err;
2387 }
2388
2389 static struct brcmf_bss_info_le *
2390 next_bss_le(struct brcmf_scan_results *list, struct brcmf_bss_info_le *bss)
2391 {
2392 if (bss == NULL)
2393 return list->bss_info_le;
2394 return (struct brcmf_bss_info_le *)((unsigned long)bss +
2395 le32_to_cpu(bss->length));
2396 }
2397
2398 static s32 brcmf_inform_bss(struct brcmf_cfg80211_info *cfg)
2399 {
2400 struct brcmf_scan_results *bss_list;
2401 struct brcmf_bss_info_le *bi = NULL; /* must be initialized */
2402 s32 err = 0;
2403 int i;
2404
2405 bss_list = cfg->bss_list;
2406 if (bss_list->count != 0 &&
2407 bss_list->version != BRCMF_BSS_INFO_VERSION) {
2408 brcmf_err("Version %d != WL_BSS_INFO_VERSION\n",
2409 bss_list->version);
2410 return -EOPNOTSUPP;
2411 }
2412 brcmf_dbg(SCAN, "scanned AP count (%d)\n", bss_list->count);
2413 for (i = 0; i < bss_list->count; i++) {
2414 bi = next_bss_le(bss_list, bi);
2415 err = brcmf_inform_single_bss(cfg, bi);
2416 if (err)
2417 break;
2418 }
2419 return err;
2420 }
2421
2422 static s32 wl_inform_ibss(struct brcmf_cfg80211_info *cfg,
2423 struct net_device *ndev, const u8 *bssid)
2424 {
2425 struct wiphy *wiphy = cfg_to_wiphy(cfg);
2426 struct ieee80211_channel *notify_channel;
2427 struct brcmf_bss_info_le *bi = NULL;
2428 struct ieee80211_supported_band *band;
2429 struct cfg80211_bss *bss;
2430 struct brcmu_chan ch;
2431 u8 *buf = NULL;
2432 s32 err = 0;
2433 u32 freq;
2434 u16 notify_capability;
2435 u16 notify_interval;
2436 u8 *notify_ie;
2437 size_t notify_ielen;
2438 s32 notify_signal;
2439
2440 brcmf_dbg(TRACE, "Enter\n");
2441
2442 buf = kzalloc(WL_BSS_INFO_MAX, GFP_KERNEL);
2443 if (buf == NULL) {
2444 err = -ENOMEM;
2445 goto CleanUp;
2446 }
2447
2448 *(__le32 *)buf = cpu_to_le32(WL_BSS_INFO_MAX);
2449
2450 err = brcmf_fil_cmd_data_get(netdev_priv(ndev), BRCMF_C_GET_BSS_INFO,
2451 buf, WL_BSS_INFO_MAX);
2452 if (err) {
2453 brcmf_err("WLC_GET_BSS_INFO failed: %d\n", err);
2454 goto CleanUp;
2455 }
2456
2457 bi = (struct brcmf_bss_info_le *)(buf + 4);
2458
2459 ch.chspec = le16_to_cpu(bi->chanspec);
2460 cfg->d11inf.decchspec(&ch);
2461
2462 if (ch.band == BRCMU_CHAN_BAND_2G)
2463 band = wiphy->bands[IEEE80211_BAND_2GHZ];
2464 else
2465 band = wiphy->bands[IEEE80211_BAND_5GHZ];
2466
2467 freq = ieee80211_channel_to_frequency(ch.chnum, band->band);
2468 notify_channel = ieee80211_get_channel(wiphy, freq);
2469
2470 notify_capability = le16_to_cpu(bi->capability);
2471 notify_interval = le16_to_cpu(bi->beacon_period);
2472 notify_ie = (u8 *)bi + le16_to_cpu(bi->ie_offset);
2473 notify_ielen = le32_to_cpu(bi->ie_length);
2474 notify_signal = (s16)le16_to_cpu(bi->RSSI) * 100;
2475
2476 brcmf_dbg(CONN, "channel: %d(%d)\n", ch.chnum, freq);
2477 brcmf_dbg(CONN, "capability: %X\n", notify_capability);
2478 brcmf_dbg(CONN, "beacon interval: %d\n", notify_interval);
2479 brcmf_dbg(CONN, "signal: %d\n", notify_signal);
2480
2481 bss = cfg80211_inform_bss(wiphy, notify_channel, bssid,
2482 0, notify_capability, notify_interval,
2483 notify_ie, notify_ielen, notify_signal, GFP_KERNEL);
2484
2485 if (!bss) {
2486 err = -ENOMEM;
2487 goto CleanUp;
2488 }
2489
2490 cfg80211_put_bss(wiphy, bss);
2491
2492 CleanUp:
2493
2494 kfree(buf);
2495
2496 brcmf_dbg(TRACE, "Exit\n");
2497
2498 return err;
2499 }
2500
2501 static s32 brcmf_update_bss_info(struct brcmf_cfg80211_info *cfg,
2502 struct brcmf_if *ifp)
2503 {
2504 struct brcmf_cfg80211_profile *profile = ndev_to_prof(ifp->ndev);
2505 struct brcmf_bss_info_le *bi;
2506 struct brcmf_ssid *ssid;
2507 const struct brcmf_tlv *tim;
2508 u16 beacon_interval;
2509 u8 dtim_period;
2510 size_t ie_len;
2511 u8 *ie;
2512 s32 err = 0;
2513
2514 brcmf_dbg(TRACE, "Enter\n");
2515 if (brcmf_is_ibssmode(ifp->vif))
2516 return err;
2517
2518 ssid = &profile->ssid;
2519
2520 *(__le32 *)cfg->extra_buf = cpu_to_le32(WL_EXTRA_BUF_MAX);
2521 err = brcmf_fil_cmd_data_get(ifp, BRCMF_C_GET_BSS_INFO,
2522 cfg->extra_buf, WL_EXTRA_BUF_MAX);
2523 if (err) {
2524 brcmf_err("Could not get bss info %d\n", err);
2525 goto update_bss_info_out;
2526 }
2527
2528 bi = (struct brcmf_bss_info_le *)(cfg->extra_buf + 4);
2529 err = brcmf_inform_single_bss(cfg, bi);
2530 if (err)
2531 goto update_bss_info_out;
2532
2533 ie = ((u8 *)bi) + le16_to_cpu(bi->ie_offset);
2534 ie_len = le32_to_cpu(bi->ie_length);
2535 beacon_interval = le16_to_cpu(bi->beacon_period);
2536
2537 tim = brcmf_parse_tlvs(ie, ie_len, WLAN_EID_TIM);
2538 if (tim)
2539 dtim_period = tim->data[1];
2540 else {
2541 /*
2542 * active scan was done so we could not get dtim
2543 * information out of probe response.
2544 * so we speficially query dtim information to dongle.
2545 */
2546 u32 var;
2547 err = brcmf_fil_iovar_int_get(ifp, "dtim_assoc", &var);
2548 if (err) {
2549 brcmf_err("wl dtim_assoc failed (%d)\n", err);
2550 goto update_bss_info_out;
2551 }
2552 dtim_period = (u8)var;
2553 }
2554
2555 update_bss_info_out:
2556 brcmf_dbg(TRACE, "Exit");
2557 return err;
2558 }
2559
2560 void brcmf_abort_scanning(struct brcmf_cfg80211_info *cfg)
2561 {
2562 struct escan_info *escan = &cfg->escan_info;
2563
2564 set_bit(BRCMF_SCAN_STATUS_ABORT, &cfg->scan_status);
2565 if (cfg->scan_request) {
2566 escan->escan_state = WL_ESCAN_STATE_IDLE;
2567 brcmf_notify_escan_complete(cfg, escan->ifp, true, true);
2568 }
2569 clear_bit(BRCMF_SCAN_STATUS_BUSY, &cfg->scan_status);
2570 clear_bit(BRCMF_SCAN_STATUS_ABORT, &cfg->scan_status);
2571 }
2572
2573 static void brcmf_cfg80211_escan_timeout_worker(struct work_struct *work)
2574 {
2575 struct brcmf_cfg80211_info *cfg =
2576 container_of(work, struct brcmf_cfg80211_info,
2577 escan_timeout_work);
2578
2579 brcmf_notify_escan_complete(cfg, cfg->escan_info.ifp, true, true);
2580 }
2581
2582 static void brcmf_escan_timeout(unsigned long data)
2583 {
2584 struct brcmf_cfg80211_info *cfg =
2585 (struct brcmf_cfg80211_info *)data;
2586
2587 if (cfg->scan_request) {
2588 brcmf_err("timer expired\n");
2589 schedule_work(&cfg->escan_timeout_work);
2590 }
2591 }
2592
2593 static s32
2594 brcmf_compare_update_same_bss(struct brcmf_cfg80211_info *cfg,
2595 struct brcmf_bss_info_le *bss,
2596 struct brcmf_bss_info_le *bss_info_le)
2597 {
2598 struct brcmu_chan ch_bss, ch_bss_info_le;
2599
2600 ch_bss.chspec = le16_to_cpu(bss->chanspec);
2601 cfg->d11inf.decchspec(&ch_bss);
2602 ch_bss_info_le.chspec = le16_to_cpu(bss_info_le->chanspec);
2603 cfg->d11inf.decchspec(&ch_bss_info_le);
2604
2605 if (!memcmp(&bss_info_le->BSSID, &bss->BSSID, ETH_ALEN) &&
2606 ch_bss.band == ch_bss_info_le.band &&
2607 bss_info_le->SSID_len == bss->SSID_len &&
2608 !memcmp(bss_info_le->SSID, bss->SSID, bss_info_le->SSID_len)) {
2609 if ((bss->flags & BRCMF_BSS_RSSI_ON_CHANNEL) ==
2610 (bss_info_le->flags & BRCMF_BSS_RSSI_ON_CHANNEL)) {
2611 s16 bss_rssi = le16_to_cpu(bss->RSSI);
2612 s16 bss_info_rssi = le16_to_cpu(bss_info_le->RSSI);
2613
2614 /* preserve max RSSI if the measurements are
2615 * both on-channel or both off-channel
2616 */
2617 if (bss_info_rssi > bss_rssi)
2618 bss->RSSI = bss_info_le->RSSI;
2619 } else if ((bss->flags & BRCMF_BSS_RSSI_ON_CHANNEL) &&
2620 (bss_info_le->flags & BRCMF_BSS_RSSI_ON_CHANNEL) == 0) {
2621 /* preserve the on-channel rssi measurement
2622 * if the new measurement is off channel
2623 */
2624 bss->RSSI = bss_info_le->RSSI;
2625 bss->flags |= BRCMF_BSS_RSSI_ON_CHANNEL;
2626 }
2627 return 1;
2628 }
2629 return 0;
2630 }
2631
2632 static s32
2633 brcmf_cfg80211_escan_handler(struct brcmf_if *ifp,
2634 const struct brcmf_event_msg *e, void *data)
2635 {
2636 struct brcmf_cfg80211_info *cfg = ifp->drvr->config;
2637 s32 status;
2638 s32 err = 0;
2639 struct brcmf_escan_result_le *escan_result_le;
2640 struct brcmf_bss_info_le *bss_info_le;
2641 struct brcmf_bss_info_le *bss = NULL;
2642 u32 bi_length;
2643 struct brcmf_scan_results *list;
2644 u32 i;
2645 bool aborted;
2646
2647 status = e->status;
2648
2649 if (!test_bit(BRCMF_SCAN_STATUS_BUSY, &cfg->scan_status)) {
2650 brcmf_err("scan not ready, bssidx=%d\n", ifp->bssidx);
2651 return -EPERM;
2652 }
2653
2654 if (status == BRCMF_E_STATUS_PARTIAL) {
2655 brcmf_dbg(SCAN, "ESCAN Partial result\n");
2656 escan_result_le = (struct brcmf_escan_result_le *) data;
2657 if (!escan_result_le) {
2658 brcmf_err("Invalid escan result (NULL pointer)\n");
2659 goto exit;
2660 }
2661 if (le16_to_cpu(escan_result_le->bss_count) != 1) {
2662 brcmf_err("Invalid bss_count %d: ignoring\n",
2663 escan_result_le->bss_count);
2664 goto exit;
2665 }
2666 bss_info_le = &escan_result_le->bss_info_le;
2667
2668 if (brcmf_p2p_scan_finding_common_channel(cfg, bss_info_le))
2669 goto exit;
2670
2671 if (!cfg->scan_request) {
2672 brcmf_dbg(SCAN, "result without cfg80211 request\n");
2673 goto exit;
2674 }
2675
2676 bi_length = le32_to_cpu(bss_info_le->length);
2677 if (bi_length != (le32_to_cpu(escan_result_le->buflen) -
2678 WL_ESCAN_RESULTS_FIXED_SIZE)) {
2679 brcmf_err("Invalid bss_info length %d: ignoring\n",
2680 bi_length);
2681 goto exit;
2682 }
2683
2684 if (!(cfg_to_wiphy(cfg)->interface_modes &
2685 BIT(NL80211_IFTYPE_ADHOC))) {
2686 if (le16_to_cpu(bss_info_le->capability) &
2687 WLAN_CAPABILITY_IBSS) {
2688 brcmf_err("Ignoring IBSS result\n");
2689 goto exit;
2690 }
2691 }
2692
2693 list = (struct brcmf_scan_results *)
2694 cfg->escan_info.escan_buf;
2695 if (bi_length > WL_ESCAN_BUF_SIZE - list->buflen) {
2696 brcmf_err("Buffer is too small: ignoring\n");
2697 goto exit;
2698 }
2699
2700 for (i = 0; i < list->count; i++) {
2701 bss = bss ? (struct brcmf_bss_info_le *)
2702 ((unsigned char *)bss +
2703 le32_to_cpu(bss->length)) : list->bss_info_le;
2704 if (brcmf_compare_update_same_bss(cfg, bss,
2705 bss_info_le))
2706 goto exit;
2707 }
2708 memcpy(&(cfg->escan_info.escan_buf[list->buflen]),
2709 bss_info_le, bi_length);
2710 list->version = le32_to_cpu(bss_info_le->version);
2711 list->buflen += bi_length;
2712 list->count++;
2713 } else {
2714 cfg->escan_info.escan_state = WL_ESCAN_STATE_IDLE;
2715 if (brcmf_p2p_scan_finding_common_channel(cfg, NULL))
2716 goto exit;
2717 if (cfg->scan_request) {
2718 cfg->bss_list = (struct brcmf_scan_results *)
2719 cfg->escan_info.escan_buf;
2720 brcmf_inform_bss(cfg);
2721 aborted = status != BRCMF_E_STATUS_SUCCESS;
2722 brcmf_notify_escan_complete(cfg, ifp, aborted,
2723 false);
2724 } else
2725 brcmf_dbg(SCAN, "Ignored scan complete result 0x%x\n",
2726 status);
2727 }
2728 exit:
2729 return err;
2730 }
2731
2732 static void brcmf_init_escan(struct brcmf_cfg80211_info *cfg)
2733 {
2734 brcmf_fweh_register(cfg->pub, BRCMF_E_ESCAN_RESULT,
2735 brcmf_cfg80211_escan_handler);
2736 cfg->escan_info.escan_state = WL_ESCAN_STATE_IDLE;
2737 /* Init scan_timeout timer */
2738 init_timer(&cfg->escan_timeout);
2739 cfg->escan_timeout.data = (unsigned long) cfg;
2740 cfg->escan_timeout.function = brcmf_escan_timeout;
2741 INIT_WORK(&cfg->escan_timeout_work,
2742 brcmf_cfg80211_escan_timeout_worker);
2743 }
2744
2745 static __always_inline void brcmf_delay(u32 ms)
2746 {
2747 if (ms < 1000 / HZ) {
2748 cond_resched();
2749 mdelay(ms);
2750 } else {
2751 msleep(ms);
2752 }
2753 }
2754
2755 static s32 brcmf_cfg80211_resume(struct wiphy *wiphy)
2756 {
2757 brcmf_dbg(TRACE, "Enter\n");
2758
2759 return 0;
2760 }
2761
2762 static s32 brcmf_cfg80211_suspend(struct wiphy *wiphy,
2763 struct cfg80211_wowlan *wow)
2764 {
2765 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy);
2766 struct net_device *ndev = cfg_to_ndev(cfg);
2767 struct brcmf_cfg80211_vif *vif;
2768
2769 brcmf_dbg(TRACE, "Enter\n");
2770
2771 /*
2772 * if the primary net_device is not READY there is nothing
2773 * we can do but pray resume goes smoothly.
2774 */
2775 vif = ((struct brcmf_if *)netdev_priv(ndev))->vif;
2776 if (!check_vif_up(vif))
2777 goto exit;
2778
2779 list_for_each_entry(vif, &cfg->vif_list, list) {
2780 if (!test_bit(BRCMF_VIF_STATUS_READY, &vif->sme_state))
2781 continue;
2782 /*
2783 * While going to suspend if associated with AP disassociate
2784 * from AP to save power while system is in suspended state
2785 */
2786 brcmf_link_down(vif);
2787
2788 /* Make sure WPA_Supplicant receives all the event
2789 * generated due to DISASSOC call to the fw to keep
2790 * the state fw and WPA_Supplicant state consistent
2791 */
2792 brcmf_delay(500);
2793 }
2794
2795 /* end any scanning */
2796 if (test_bit(BRCMF_SCAN_STATUS_BUSY, &cfg->scan_status))
2797 brcmf_abort_scanning(cfg);
2798
2799 /* Turn off watchdog timer */
2800 brcmf_set_mpc(netdev_priv(ndev), 1);
2801
2802 exit:
2803 brcmf_dbg(TRACE, "Exit\n");
2804 /* clear any scanning activity */
2805 cfg->scan_status = 0;
2806 return 0;
2807 }
2808
2809 static __used s32
2810 brcmf_update_pmklist(struct net_device *ndev,
2811 struct brcmf_cfg80211_pmk_list *pmk_list, s32 err)
2812 {
2813 int i, j;
2814 int pmkid_len;
2815
2816 pmkid_len = le32_to_cpu(pmk_list->pmkids.npmkid);
2817
2818 brcmf_dbg(CONN, "No of elements %d\n", pmkid_len);
2819 for (i = 0; i < pmkid_len; i++) {
2820 brcmf_dbg(CONN, "PMKID[%d]: %pM =\n", i,
2821 &pmk_list->pmkids.pmkid[i].BSSID);
2822 for (j = 0; j < WLAN_PMKID_LEN; j++)
2823 brcmf_dbg(CONN, "%02x\n",
2824 pmk_list->pmkids.pmkid[i].PMKID[j]);
2825 }
2826
2827 if (!err)
2828 brcmf_fil_iovar_data_set(netdev_priv(ndev), "pmkid_info",
2829 (char *)pmk_list, sizeof(*pmk_list));
2830
2831 return err;
2832 }
2833
2834 static s32
2835 brcmf_cfg80211_set_pmksa(struct wiphy *wiphy, struct net_device *ndev,
2836 struct cfg80211_pmksa *pmksa)
2837 {
2838 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy);
2839 struct brcmf_if *ifp = netdev_priv(ndev);
2840 struct pmkid_list *pmkids = &cfg->pmk_list->pmkids;
2841 s32 err = 0;
2842 int i;
2843 int pmkid_len;
2844
2845 brcmf_dbg(TRACE, "Enter\n");
2846 if (!check_vif_up(ifp->vif))
2847 return -EIO;
2848
2849 pmkid_len = le32_to_cpu(pmkids->npmkid);
2850 for (i = 0; i < pmkid_len; i++)
2851 if (!memcmp(pmksa->bssid, pmkids->pmkid[i].BSSID, ETH_ALEN))
2852 break;
2853 if (i < WL_NUM_PMKIDS_MAX) {
2854 memcpy(pmkids->pmkid[i].BSSID, pmksa->bssid, ETH_ALEN);
2855 memcpy(pmkids->pmkid[i].PMKID, pmksa->pmkid, WLAN_PMKID_LEN);
2856 if (i == pmkid_len) {
2857 pmkid_len++;
2858 pmkids->npmkid = cpu_to_le32(pmkid_len);
2859 }
2860 } else
2861 err = -EINVAL;
2862
2863 brcmf_dbg(CONN, "set_pmksa,IW_PMKSA_ADD - PMKID: %pM =\n",
2864 pmkids->pmkid[pmkid_len].BSSID);
2865 for (i = 0; i < WLAN_PMKID_LEN; i++)
2866 brcmf_dbg(CONN, "%02x\n", pmkids->pmkid[pmkid_len].PMKID[i]);
2867
2868 err = brcmf_update_pmklist(ndev, cfg->pmk_list, err);
2869
2870 brcmf_dbg(TRACE, "Exit\n");
2871 return err;
2872 }
2873
2874 static s32
2875 brcmf_cfg80211_del_pmksa(struct wiphy *wiphy, struct net_device *ndev,
2876 struct cfg80211_pmksa *pmksa)
2877 {
2878 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy);
2879 struct brcmf_if *ifp = netdev_priv(ndev);
2880 struct pmkid_list pmkid;
2881 s32 err = 0;
2882 int i, pmkid_len;
2883
2884 brcmf_dbg(TRACE, "Enter\n");
2885 if (!check_vif_up(ifp->vif))
2886 return -EIO;
2887
2888 memcpy(&pmkid.pmkid[0].BSSID, pmksa->bssid, ETH_ALEN);
2889 memcpy(&pmkid.pmkid[0].PMKID, pmksa->pmkid, WLAN_PMKID_LEN);
2890
2891 brcmf_dbg(CONN, "del_pmksa,IW_PMKSA_REMOVE - PMKID: %pM =\n",
2892 &pmkid.pmkid[0].BSSID);
2893 for (i = 0; i < WLAN_PMKID_LEN; i++)
2894 brcmf_dbg(CONN, "%02x\n", pmkid.pmkid[0].PMKID[i]);
2895
2896 pmkid_len = le32_to_cpu(cfg->pmk_list->pmkids.npmkid);
2897 for (i = 0; i < pmkid_len; i++)
2898 if (!memcmp
2899 (pmksa->bssid, &cfg->pmk_list->pmkids.pmkid[i].BSSID,
2900 ETH_ALEN))
2901 break;
2902
2903 if ((pmkid_len > 0)
2904 && (i < pmkid_len)) {
2905 memset(&cfg->pmk_list->pmkids.pmkid[i], 0,
2906 sizeof(struct pmkid));
2907 for (; i < (pmkid_len - 1); i++) {
2908 memcpy(&cfg->pmk_list->pmkids.pmkid[i].BSSID,
2909 &cfg->pmk_list->pmkids.pmkid[i + 1].BSSID,
2910 ETH_ALEN);
2911 memcpy(&cfg->pmk_list->pmkids.pmkid[i].PMKID,
2912 &cfg->pmk_list->pmkids.pmkid[i + 1].PMKID,
2913 WLAN_PMKID_LEN);
2914 }
2915 cfg->pmk_list->pmkids.npmkid = cpu_to_le32(pmkid_len - 1);
2916 } else
2917 err = -EINVAL;
2918
2919 err = brcmf_update_pmklist(ndev, cfg->pmk_list, err);
2920
2921 brcmf_dbg(TRACE, "Exit\n");
2922 return err;
2923
2924 }
2925
2926 static s32
2927 brcmf_cfg80211_flush_pmksa(struct wiphy *wiphy, struct net_device *ndev)
2928 {
2929 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy);
2930 struct brcmf_if *ifp = netdev_priv(ndev);
2931 s32 err = 0;
2932
2933 brcmf_dbg(TRACE, "Enter\n");
2934 if (!check_vif_up(ifp->vif))
2935 return -EIO;
2936
2937 memset(cfg->pmk_list, 0, sizeof(*cfg->pmk_list));
2938 err = brcmf_update_pmklist(ndev, cfg->pmk_list, err);
2939
2940 brcmf_dbg(TRACE, "Exit\n");
2941 return err;
2942
2943 }
2944
2945 /*
2946 * PFN result doesn't have all the info which are
2947 * required by the supplicant
2948 * (For e.g IEs) Do a target Escan so that sched scan results are reported
2949 * via wl_inform_single_bss in the required format. Escan does require the
2950 * scan request in the form of cfg80211_scan_request. For timebeing, create
2951 * cfg80211_scan_request one out of the received PNO event.
2952 */
2953 static s32
2954 brcmf_notify_sched_scan_results(struct brcmf_if *ifp,
2955 const struct brcmf_event_msg *e, void *data)
2956 {
2957 struct brcmf_cfg80211_info *cfg = ifp->drvr->config;
2958 struct brcmf_pno_net_info_le *netinfo, *netinfo_start;
2959 struct cfg80211_scan_request *request = NULL;
2960 struct cfg80211_ssid *ssid = NULL;
2961 struct ieee80211_channel *channel = NULL;
2962 struct wiphy *wiphy = cfg_to_wiphy(cfg);
2963 int err = 0;
2964 int channel_req = 0;
2965 int band = 0;
2966 struct brcmf_pno_scanresults_le *pfn_result;
2967 u32 result_count;
2968 u32 status;
2969
2970 brcmf_dbg(SCAN, "Enter\n");
2971
2972 if (e->event_code == BRCMF_E_PFN_NET_LOST) {
2973 brcmf_dbg(SCAN, "PFN NET LOST event. Do Nothing\n");
2974 return 0;
2975 }
2976
2977 pfn_result = (struct brcmf_pno_scanresults_le *)data;
2978 result_count = le32_to_cpu(pfn_result->count);
2979 status = le32_to_cpu(pfn_result->status);
2980
2981 /*
2982 * PFN event is limited to fit 512 bytes so we may get
2983 * multiple NET_FOUND events. For now place a warning here.
2984 */
2985 WARN_ON(status != BRCMF_PNO_SCAN_COMPLETE);
2986 brcmf_dbg(SCAN, "PFN NET FOUND event. count: %d\n", result_count);
2987 if (result_count > 0) {
2988 int i;
2989
2990 request = kzalloc(sizeof(*request), GFP_KERNEL);
2991 ssid = kcalloc(result_count, sizeof(*ssid), GFP_KERNEL);
2992 channel = kcalloc(result_count, sizeof(*channel), GFP_KERNEL);
2993 if (!request || !ssid || !channel) {
2994 err = -ENOMEM;
2995 goto out_err;
2996 }
2997
2998 request->wiphy = wiphy;
2999 data += sizeof(struct brcmf_pno_scanresults_le);
3000 netinfo_start = (struct brcmf_pno_net_info_le *)data;
3001
3002 for (i = 0; i < result_count; i++) {
3003 netinfo = &netinfo_start[i];
3004 if (!netinfo) {
3005 brcmf_err("Invalid netinfo ptr. index: %d\n",
3006 i);
3007 err = -EINVAL;
3008 goto out_err;
3009 }
3010
3011 brcmf_dbg(SCAN, "SSID:%s Channel:%d\n",
3012 netinfo->SSID, netinfo->channel);
3013 memcpy(ssid[i].ssid, netinfo->SSID, netinfo->SSID_len);
3014 ssid[i].ssid_len = netinfo->SSID_len;
3015 request->n_ssids++;
3016
3017 channel_req = netinfo->channel;
3018 if (channel_req <= CH_MAX_2G_CHANNEL)
3019 band = NL80211_BAND_2GHZ;
3020 else
3021 band = NL80211_BAND_5GHZ;
3022 channel[i].center_freq =
3023 ieee80211_channel_to_frequency(channel_req,
3024 band);
3025 channel[i].band = band;
3026 channel[i].flags |= IEEE80211_CHAN_NO_HT40;
3027 request->channels[i] = &channel[i];
3028 request->n_channels++;
3029 }
3030
3031 /* assign parsed ssid array */
3032 if (request->n_ssids)
3033 request->ssids = &ssid[0];
3034
3035 if (test_bit(BRCMF_SCAN_STATUS_BUSY, &cfg->scan_status)) {
3036 /* Abort any on-going scan */
3037 brcmf_abort_scanning(cfg);
3038 }
3039
3040 set_bit(BRCMF_SCAN_STATUS_BUSY, &cfg->scan_status);
3041 cfg->escan_info.run = brcmf_run_escan;
3042 err = brcmf_do_escan(cfg, wiphy, ifp, request);
3043 if (err) {
3044 clear_bit(BRCMF_SCAN_STATUS_BUSY, &cfg->scan_status);
3045 goto out_err;
3046 }
3047 cfg->sched_escan = true;
3048 cfg->scan_request = request;
3049 } else {
3050 brcmf_err("FALSE PNO Event. (pfn_count == 0)\n");
3051 goto out_err;
3052 }
3053
3054 kfree(ssid);
3055 kfree(channel);
3056 kfree(request);
3057 return 0;
3058
3059 out_err:
3060 kfree(ssid);
3061 kfree(channel);
3062 kfree(request);
3063 cfg80211_sched_scan_stopped(wiphy);
3064 return err;
3065 }
3066
3067 static int brcmf_dev_pno_clean(struct net_device *ndev)
3068 {
3069 int ret;
3070
3071 /* Disable pfn */
3072 ret = brcmf_fil_iovar_int_set(netdev_priv(ndev), "pfn", 0);
3073 if (ret == 0) {
3074 /* clear pfn */
3075 ret = brcmf_fil_iovar_data_set(netdev_priv(ndev), "pfnclear",
3076 NULL, 0);
3077 }
3078 if (ret < 0)
3079 brcmf_err("failed code %d\n", ret);
3080
3081 return ret;
3082 }
3083
3084 static int brcmf_dev_pno_config(struct net_device *ndev)
3085 {
3086 struct brcmf_pno_param_le pfn_param;
3087
3088 memset(&pfn_param, 0, sizeof(pfn_param));
3089 pfn_param.version = cpu_to_le32(BRCMF_PNO_VERSION);
3090
3091 /* set extra pno params */
3092 pfn_param.flags = cpu_to_le16(1 << BRCMF_PNO_ENABLE_ADAPTSCAN_BIT);
3093 pfn_param.repeat = BRCMF_PNO_REPEAT;
3094 pfn_param.exp = BRCMF_PNO_FREQ_EXPO_MAX;
3095
3096 /* set up pno scan fr */
3097 pfn_param.scan_freq = cpu_to_le32(BRCMF_PNO_TIME);
3098
3099 return brcmf_fil_iovar_data_set(netdev_priv(ndev), "pfn_set",
3100 &pfn_param, sizeof(pfn_param));
3101 }
3102
3103 static int
3104 brcmf_cfg80211_sched_scan_start(struct wiphy *wiphy,
3105 struct net_device *ndev,
3106 struct cfg80211_sched_scan_request *request)
3107 {
3108 struct brcmf_if *ifp = netdev_priv(ndev);
3109 struct brcmf_cfg80211_info *cfg = wiphy_priv(wiphy);
3110 struct brcmf_pno_net_param_le pfn;
3111 int i;
3112 int ret = 0;
3113
3114 brcmf_dbg(SCAN, "Enter n_match_sets:%d n_ssids:%d\n",
3115 request->n_match_sets, request->n_ssids);
3116 if (test_bit(BRCMF_SCAN_STATUS_BUSY, &cfg->scan_status)) {
3117 brcmf_err("Scanning already: status (%lu)\n", cfg->scan_status);
3118 return -EAGAIN;
3119 }
3120 if (test_bit(BRCMF_SCAN_STATUS_SUPPRESS, &cfg->scan_status)) {
3121 brcmf_err("Scanning suppressed: status (%lu)\n",
3122 cfg->scan_status);
3123 return -EAGAIN;
3124 }
3125
3126 if (!request->n_ssids || !request->n_match_sets) {
3127 brcmf_err("Invalid sched scan req!! n_ssids:%d\n",
3128 request->n_ssids);
3129 return -EINVAL;
3130 }
3131
3132 if (request->n_ssids > 0) {
3133 for (i = 0; i < request->n_ssids; i++) {
3134 /* Active scan req for ssids */
3135 brcmf_dbg(SCAN, ">>> Active scan req for ssid (%s)\n",
3136 request->ssids[i].ssid);
3137
3138 /*
3139 * match_set ssids is a supert set of n_ssid list,
3140 * so we need not add these set seperately.
3141 */
3142 }
3143 }
3144
3145 if (request->n_match_sets > 0) {
3146 /* clean up everything */
3147 ret = brcmf_dev_pno_clean(ndev);
3148 if (ret < 0) {
3149 brcmf_err("failed error=%d\n", ret);
3150 return ret;
3151 }
3152
3153 /* configure pno */
3154 ret = brcmf_dev_pno_config(ndev);
3155 if (ret < 0) {
3156 brcmf_err("PNO setup failed!! ret=%d\n", ret);
3157 return -EINVAL;
3158 }
3159
3160 /* configure each match set */
3161 for (i = 0; i < request->n_match_sets; i++) {
3162 struct cfg80211_ssid *ssid;
3163 u32 ssid_len;
3164
3165 ssid = &request->match_sets[i].ssid;
3166 ssid_len = ssid->ssid_len;
3167
3168 if (!ssid_len) {
3169 brcmf_err("skip broadcast ssid\n");
3170 continue;
3171 }
3172 pfn.auth = cpu_to_le32(WLAN_AUTH_OPEN);
3173 pfn.wpa_auth = cpu_to_le32(BRCMF_PNO_WPA_AUTH_ANY);
3174 pfn.wsec = cpu_to_le32(0);
3175 pfn.infra = cpu_to_le32(1);
3176 pfn.flags = cpu_to_le32(1 << BRCMF_PNO_HIDDEN_BIT);
3177 pfn.ssid.SSID_len = cpu_to_le32(ssid_len);
3178 memcpy(pfn.ssid.SSID, ssid->ssid, ssid_len);
3179 ret = brcmf_fil_iovar_data_set(ifp, "pfn_add", &pfn,
3180 sizeof(pfn));
3181 brcmf_dbg(SCAN, ">>> PNO filter %s for ssid (%s)\n",
3182 ret == 0 ? "set" : "failed", ssid->ssid);
3183 }
3184 /* Enable the PNO */
3185 if (brcmf_fil_iovar_int_set(ifp, "pfn", 1) < 0) {
3186 brcmf_err("PNO enable failed!! ret=%d\n", ret);
3187 return -EINVAL;
3188 }
3189 } else {
3190 return -EINVAL;
3191 }
3192
3193 return 0;
3194 }
3195
3196 static int brcmf_cfg80211_sched_scan_stop(struct wiphy *wiphy,
3197 struct net_device *ndev)
3198 {
3199 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy);
3200
3201 brcmf_dbg(SCAN, "enter\n");
3202 brcmf_dev_pno_clean(ndev);
3203 if (cfg->sched_escan)
3204 brcmf_notify_escan_complete(cfg, netdev_priv(ndev), true, true);
3205 return 0;
3206 }
3207
3208 #ifdef CONFIG_NL80211_TESTMODE
3209 static int brcmf_cfg80211_testmode(struct wiphy *wiphy,
3210 struct wireless_dev *wdev,
3211 void *data, int len)
3212 {
3213 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy);
3214 struct net_device *ndev = cfg_to_ndev(cfg);
3215 struct brcmf_dcmd *dcmd = data;
3216 struct sk_buff *reply;
3217 int ret;
3218
3219 brcmf_dbg(TRACE, "cmd %x set %d buf %p len %d\n", dcmd->cmd, dcmd->set,
3220 dcmd->buf, dcmd->len);
3221
3222 if (dcmd->set)
3223 ret = brcmf_fil_cmd_data_set(netdev_priv(ndev), dcmd->cmd,
3224 dcmd->buf, dcmd->len);
3225 else
3226 ret = brcmf_fil_cmd_data_get(netdev_priv(ndev), dcmd->cmd,
3227 dcmd->buf, dcmd->len);
3228 if (ret == 0) {
3229 reply = cfg80211_testmode_alloc_reply_skb(wiphy, sizeof(*dcmd));
3230 nla_put(reply, NL80211_ATTR_TESTDATA, sizeof(*dcmd), dcmd);
3231 ret = cfg80211_testmode_reply(reply);
3232 }
3233 return ret;
3234 }
3235 #endif
3236
3237 static s32 brcmf_configure_opensecurity(struct brcmf_if *ifp)
3238 {
3239 s32 err;
3240
3241 /* set auth */
3242 err = brcmf_fil_bsscfg_int_set(ifp, "auth", 0);
3243 if (err < 0) {
3244 brcmf_err("auth error %d\n", err);
3245 return err;
3246 }
3247 /* set wsec */
3248 err = brcmf_fil_bsscfg_int_set(ifp, "wsec", 0);
3249 if (err < 0) {
3250 brcmf_err("wsec error %d\n", err);
3251 return err;
3252 }
3253 /* set upper-layer auth */
3254 err = brcmf_fil_bsscfg_int_set(ifp, "wpa_auth", WPA_AUTH_NONE);
3255 if (err < 0) {
3256 brcmf_err("wpa_auth error %d\n", err);
3257 return err;
3258 }
3259
3260 return 0;
3261 }
3262
3263 static bool brcmf_valid_wpa_oui(u8 *oui, bool is_rsn_ie)
3264 {
3265 if (is_rsn_ie)
3266 return (memcmp(oui, RSN_OUI, TLV_OUI_LEN) == 0);
3267
3268 return (memcmp(oui, WPA_OUI, TLV_OUI_LEN) == 0);
3269 }
3270
3271 static s32
3272 brcmf_configure_wpaie(struct net_device *ndev,
3273 const struct brcmf_vs_tlv *wpa_ie,
3274 bool is_rsn_ie)
3275 {
3276 struct brcmf_if *ifp = netdev_priv(ndev);
3277 u32 auth = 0; /* d11 open authentication */
3278 u16 count;
3279 s32 err = 0;
3280 s32 len = 0;
3281 u32 i;
3282 u32 wsec;
3283 u32 pval = 0;
3284 u32 gval = 0;
3285 u32 wpa_auth = 0;
3286 u32 offset;
3287 u8 *data;
3288 u16 rsn_cap;
3289 u32 wme_bss_disable;
3290
3291 brcmf_dbg(TRACE, "Enter\n");
3292 if (wpa_ie == NULL)
3293 goto exit;
3294
3295 len = wpa_ie->len + TLV_HDR_LEN;
3296 data = (u8 *)wpa_ie;
3297 offset = TLV_HDR_LEN;
3298 if (!is_rsn_ie)
3299 offset += VS_IE_FIXED_HDR_LEN;
3300 else
3301 offset += WPA_IE_VERSION_LEN;
3302
3303 /* check for multicast cipher suite */
3304 if (offset + WPA_IE_MIN_OUI_LEN > len) {
3305 err = -EINVAL;
3306 brcmf_err("no multicast cipher suite\n");
3307 goto exit;
3308 }
3309
3310 if (!brcmf_valid_wpa_oui(&data[offset], is_rsn_ie)) {
3311 err = -EINVAL;
3312 brcmf_err("ivalid OUI\n");
3313 goto exit;
3314 }
3315 offset += TLV_OUI_LEN;
3316
3317 /* pick up multicast cipher */
3318 switch (data[offset]) {
3319 case WPA_CIPHER_NONE:
3320 gval = 0;
3321 break;
3322 case WPA_CIPHER_WEP_40:
3323 case WPA_CIPHER_WEP_104:
3324 gval = WEP_ENABLED;
3325 break;
3326 case WPA_CIPHER_TKIP:
3327 gval = TKIP_ENABLED;
3328 break;
3329 case WPA_CIPHER_AES_CCM:
3330 gval = AES_ENABLED;
3331 break;
3332 default:
3333 err = -EINVAL;
3334 brcmf_err("Invalid multi cast cipher info\n");
3335 goto exit;
3336 }
3337
3338 offset++;
3339 /* walk thru unicast cipher list and pick up what we recognize */
3340 count = data[offset] + (data[offset + 1] << 8);
3341 offset += WPA_IE_SUITE_COUNT_LEN;
3342 /* Check for unicast suite(s) */
3343 if (offset + (WPA_IE_MIN_OUI_LEN * count) > len) {
3344 err = -EINVAL;
3345 brcmf_err("no unicast cipher suite\n");
3346 goto exit;
3347 }
3348 for (i = 0; i < count; i++) {
3349 if (!brcmf_valid_wpa_oui(&data[offset], is_rsn_ie)) {
3350 err = -EINVAL;
3351 brcmf_err("ivalid OUI\n");
3352 goto exit;
3353 }
3354 offset += TLV_OUI_LEN;
3355 switch (data[offset]) {
3356 case WPA_CIPHER_NONE:
3357 break;
3358 case WPA_CIPHER_WEP_40:
3359 case WPA_CIPHER_WEP_104:
3360 pval |= WEP_ENABLED;
3361 break;
3362 case WPA_CIPHER_TKIP:
3363 pval |= TKIP_ENABLED;
3364 break;
3365 case WPA_CIPHER_AES_CCM:
3366 pval |= AES_ENABLED;
3367 break;
3368 default:
3369 brcmf_err("Ivalid unicast security info\n");
3370 }
3371 offset++;
3372 }
3373 /* walk thru auth management suite list and pick up what we recognize */
3374 count = data[offset] + (data[offset + 1] << 8);
3375 offset += WPA_IE_SUITE_COUNT_LEN;
3376 /* Check for auth key management suite(s) */
3377 if (offset + (WPA_IE_MIN_OUI_LEN * count) > len) {
3378 err = -EINVAL;
3379 brcmf_err("no auth key mgmt suite\n");
3380 goto exit;
3381 }
3382 for (i = 0; i < count; i++) {
3383 if (!brcmf_valid_wpa_oui(&data[offset], is_rsn_ie)) {
3384 err = -EINVAL;
3385 brcmf_err("ivalid OUI\n");
3386 goto exit;
3387 }
3388 offset += TLV_OUI_LEN;
3389 switch (data[offset]) {
3390 case RSN_AKM_NONE:
3391 brcmf_dbg(TRACE, "RSN_AKM_NONE\n");
3392 wpa_auth |= WPA_AUTH_NONE;
3393 break;
3394 case RSN_AKM_UNSPECIFIED:
3395 brcmf_dbg(TRACE, "RSN_AKM_UNSPECIFIED\n");
3396 is_rsn_ie ? (wpa_auth |= WPA2_AUTH_UNSPECIFIED) :
3397 (wpa_auth |= WPA_AUTH_UNSPECIFIED);
3398 break;
3399 case RSN_AKM_PSK:
3400 brcmf_dbg(TRACE, "RSN_AKM_PSK\n");
3401 is_rsn_ie ? (wpa_auth |= WPA2_AUTH_PSK) :
3402 (wpa_auth |= WPA_AUTH_PSK);
3403 break;
3404 default:
3405 brcmf_err("Ivalid key mgmt info\n");
3406 }
3407 offset++;
3408 }
3409
3410 if (is_rsn_ie) {
3411 wme_bss_disable = 1;
3412 if ((offset + RSN_CAP_LEN) <= len) {
3413 rsn_cap = data[offset] + (data[offset + 1] << 8);
3414 if (rsn_cap & RSN_CAP_PTK_REPLAY_CNTR_MASK)
3415 wme_bss_disable = 0;
3416 }
3417 /* set wme_bss_disable to sync RSN Capabilities */
3418 err = brcmf_fil_bsscfg_int_set(ifp, "wme_bss_disable",
3419 wme_bss_disable);
3420 if (err < 0) {
3421 brcmf_err("wme_bss_disable error %d\n", err);
3422 goto exit;
3423 }
3424 }
3425 /* FOR WPS , set SES_OW_ENABLED */
3426 wsec = (pval | gval | SES_OW_ENABLED);
3427
3428 /* set auth */
3429 err = brcmf_fil_bsscfg_int_set(ifp, "auth", auth);
3430 if (err < 0) {
3431 brcmf_err("auth error %d\n", err);
3432 goto exit;
3433 }
3434 /* set wsec */
3435 err = brcmf_fil_bsscfg_int_set(ifp, "wsec", wsec);
3436 if (err < 0) {
3437 brcmf_err("wsec error %d\n", err);
3438 goto exit;
3439 }
3440 /* set upper-layer auth */
3441 err = brcmf_fil_bsscfg_int_set(ifp, "wpa_auth", wpa_auth);
3442 if (err < 0) {
3443 brcmf_err("wpa_auth error %d\n", err);
3444 goto exit;
3445 }
3446
3447 exit:
3448 return err;
3449 }
3450
3451 static s32
3452 brcmf_parse_vndr_ies(const u8 *vndr_ie_buf, u32 vndr_ie_len,
3453 struct parsed_vndr_ies *vndr_ies)
3454 {
3455 s32 err = 0;
3456 struct brcmf_vs_tlv *vndrie;
3457 struct brcmf_tlv *ie;
3458 struct parsed_vndr_ie_info *parsed_info;
3459 s32 remaining_len;
3460
3461 remaining_len = (s32)vndr_ie_len;
3462 memset(vndr_ies, 0, sizeof(*vndr_ies));
3463
3464 ie = (struct brcmf_tlv *)vndr_ie_buf;
3465 while (ie) {
3466 if (ie->id != WLAN_EID_VENDOR_SPECIFIC)
3467 goto next;
3468 vndrie = (struct brcmf_vs_tlv *)ie;
3469 /* len should be bigger than OUI length + one */
3470 if (vndrie->len < (VS_IE_FIXED_HDR_LEN - TLV_HDR_LEN + 1)) {
3471 brcmf_err("invalid vndr ie. length is too small %d\n",
3472 vndrie->len);
3473 goto next;
3474 }
3475 /* if wpa or wme ie, do not add ie */
3476 if (!memcmp(vndrie->oui, (u8 *)WPA_OUI, TLV_OUI_LEN) &&
3477 ((vndrie->oui_type == WPA_OUI_TYPE) ||
3478 (vndrie->oui_type == WME_OUI_TYPE))) {
3479 brcmf_dbg(TRACE, "Found WPA/WME oui. Do not add it\n");
3480 goto next;
3481 }
3482
3483 parsed_info = &vndr_ies->ie_info[vndr_ies->count];
3484
3485 /* save vndr ie information */
3486 parsed_info->ie_ptr = (char *)vndrie;
3487 parsed_info->ie_len = vndrie->len + TLV_HDR_LEN;
3488 memcpy(&parsed_info->vndrie, vndrie, sizeof(*vndrie));
3489
3490 vndr_ies->count++;
3491
3492 brcmf_dbg(TRACE, "** OUI %02x %02x %02x, type 0x%02x\n",
3493 parsed_info->vndrie.oui[0],
3494 parsed_info->vndrie.oui[1],
3495 parsed_info->vndrie.oui[2],
3496 parsed_info->vndrie.oui_type);
3497
3498 if (vndr_ies->count >= VNDR_IE_PARSE_LIMIT)
3499 break;
3500 next:
3501 remaining_len -= (ie->len + TLV_HDR_LEN);
3502 if (remaining_len <= TLV_HDR_LEN)
3503 ie = NULL;
3504 else
3505 ie = (struct brcmf_tlv *)(((u8 *)ie) + ie->len +
3506 TLV_HDR_LEN);
3507 }
3508 return err;
3509 }
3510
3511 static u32
3512 brcmf_vndr_ie(u8 *iebuf, s32 pktflag, u8 *ie_ptr, u32 ie_len, s8 *add_del_cmd)
3513 {
3514
3515 __le32 iecount_le;
3516 __le32 pktflag_le;
3517
3518 strncpy(iebuf, add_del_cmd, VNDR_IE_CMD_LEN - 1);
3519 iebuf[VNDR_IE_CMD_LEN - 1] = '\0';
3520
3521 iecount_le = cpu_to_le32(1);
3522 memcpy(&iebuf[VNDR_IE_COUNT_OFFSET], &iecount_le, sizeof(iecount_le));
3523
3524 pktflag_le = cpu_to_le32(pktflag);
3525 memcpy(&iebuf[VNDR_IE_PKTFLAG_OFFSET], &pktflag_le, sizeof(pktflag_le));
3526
3527 memcpy(&iebuf[VNDR_IE_VSIE_OFFSET], ie_ptr, ie_len);
3528
3529 return ie_len + VNDR_IE_HDR_SIZE;
3530 }
3531
3532 s32 brcmf_vif_set_mgmt_ie(struct brcmf_cfg80211_vif *vif, s32 pktflag,
3533 const u8 *vndr_ie_buf, u32 vndr_ie_len)
3534 {
3535 struct brcmf_if *ifp;
3536 struct vif_saved_ie *saved_ie;
3537 s32 err = 0;
3538 u8 *iovar_ie_buf;
3539 u8 *curr_ie_buf;
3540 u8 *mgmt_ie_buf = NULL;
3541 int mgmt_ie_buf_len;
3542 u32 *mgmt_ie_len;
3543 u32 del_add_ie_buf_len = 0;
3544 u32 total_ie_buf_len = 0;
3545 u32 parsed_ie_buf_len = 0;
3546 struct parsed_vndr_ies old_vndr_ies;
3547 struct parsed_vndr_ies new_vndr_ies;
3548 struct parsed_vndr_ie_info *vndrie_info;
3549 s32 i;
3550 u8 *ptr;
3551 int remained_buf_len;
3552
3553 if (!vif)
3554 return -ENODEV;
3555 ifp = vif->ifp;
3556 saved_ie = &vif->saved_ie;
3557
3558 brcmf_dbg(TRACE, "bssidx %d, pktflag : 0x%02X\n", ifp->bssidx, pktflag);
3559 iovar_ie_buf = kzalloc(WL_EXTRA_BUF_MAX, GFP_KERNEL);
3560 if (!iovar_ie_buf)
3561 return -ENOMEM;
3562 curr_ie_buf = iovar_ie_buf;
3563 switch (pktflag) {
3564 case BRCMF_VNDR_IE_PRBREQ_FLAG:
3565 mgmt_ie_buf = saved_ie->probe_req_ie;
3566 mgmt_ie_len = &saved_ie->probe_req_ie_len;
3567 mgmt_ie_buf_len = sizeof(saved_ie->probe_req_ie);
3568 break;
3569 case BRCMF_VNDR_IE_PRBRSP_FLAG:
3570 mgmt_ie_buf = saved_ie->probe_res_ie;
3571 mgmt_ie_len = &saved_ie->probe_res_ie_len;
3572 mgmt_ie_buf_len = sizeof(saved_ie->probe_res_ie);
3573 break;
3574 case BRCMF_VNDR_IE_BEACON_FLAG:
3575 mgmt_ie_buf = saved_ie->beacon_ie;
3576 mgmt_ie_len = &saved_ie->beacon_ie_len;
3577 mgmt_ie_buf_len = sizeof(saved_ie->beacon_ie);
3578 break;
3579 case BRCMF_VNDR_IE_ASSOCREQ_FLAG:
3580 mgmt_ie_buf = saved_ie->assoc_req_ie;
3581 mgmt_ie_len = &saved_ie->assoc_req_ie_len;
3582 mgmt_ie_buf_len = sizeof(saved_ie->assoc_req_ie);
3583 break;
3584 default:
3585 err = -EPERM;
3586 brcmf_err("not suitable type\n");
3587 goto exit;
3588 }
3589
3590 if (vndr_ie_len > mgmt_ie_buf_len) {
3591 err = -ENOMEM;
3592 brcmf_err("extra IE size too big\n");
3593 goto exit;
3594 }
3595
3596 /* parse and save new vndr_ie in curr_ie_buff before comparing it */
3597 if (vndr_ie_buf && vndr_ie_len && curr_ie_buf) {
3598 ptr = curr_ie_buf;
3599 brcmf_parse_vndr_ies(vndr_ie_buf, vndr_ie_len, &new_vndr_ies);
3600 for (i = 0; i < new_vndr_ies.count; i++) {
3601 vndrie_info = &new_vndr_ies.ie_info[i];
3602 memcpy(ptr + parsed_ie_buf_len, vndrie_info->ie_ptr,
3603 vndrie_info->ie_len);
3604 parsed_ie_buf_len += vndrie_info->ie_len;
3605 }
3606 }
3607
3608 if (mgmt_ie_buf && *mgmt_ie_len) {
3609 if (parsed_ie_buf_len && (parsed_ie_buf_len == *mgmt_ie_len) &&
3610 (memcmp(mgmt_ie_buf, curr_ie_buf,
3611 parsed_ie_buf_len) == 0)) {
3612 brcmf_dbg(TRACE, "Previous mgmt IE equals to current IE\n");
3613 goto exit;
3614 }
3615
3616 /* parse old vndr_ie */
3617 brcmf_parse_vndr_ies(mgmt_ie_buf, *mgmt_ie_len, &old_vndr_ies);
3618
3619 /* make a command to delete old ie */
3620 for (i = 0; i < old_vndr_ies.count; i++) {
3621 vndrie_info = &old_vndr_ies.ie_info[i];
3622
3623 brcmf_dbg(TRACE, "DEL ID : %d, Len: %d , OUI:%02x:%02x:%02x\n",
3624 vndrie_info->vndrie.id,
3625 vndrie_info->vndrie.len,
3626 vndrie_info->vndrie.oui[0],
3627 vndrie_info->vndrie.oui[1],
3628 vndrie_info->vndrie.oui[2]);
3629
3630 del_add_ie_buf_len = brcmf_vndr_ie(curr_ie_buf, pktflag,
3631 vndrie_info->ie_ptr,
3632 vndrie_info->ie_len,
3633 "del");
3634 curr_ie_buf += del_add_ie_buf_len;
3635 total_ie_buf_len += del_add_ie_buf_len;
3636 }
3637 }
3638
3639 *mgmt_ie_len = 0;
3640 /* Add if there is any extra IE */
3641 if (mgmt_ie_buf && parsed_ie_buf_len) {
3642 ptr = mgmt_ie_buf;
3643
3644 remained_buf_len = mgmt_ie_buf_len;
3645
3646 /* make a command to add new ie */
3647 for (i = 0; i < new_vndr_ies.count; i++) {
3648 vndrie_info = &new_vndr_ies.ie_info[i];
3649
3650 /* verify remained buf size before copy data */
3651 if (remained_buf_len < (vndrie_info->vndrie.len +
3652 VNDR_IE_VSIE_OFFSET)) {
3653 brcmf_err("no space in mgmt_ie_buf: len left %d",
3654 remained_buf_len);
3655 break;
3656 }
3657 remained_buf_len -= (vndrie_info->ie_len +
3658 VNDR_IE_VSIE_OFFSET);
3659
3660 brcmf_dbg(TRACE, "ADDED ID : %d, Len: %d, OUI:%02x:%02x:%02x\n",
3661 vndrie_info->vndrie.id,
3662 vndrie_info->vndrie.len,
3663 vndrie_info->vndrie.oui[0],
3664 vndrie_info->vndrie.oui[1],
3665 vndrie_info->vndrie.oui[2]);
3666
3667 del_add_ie_buf_len = brcmf_vndr_ie(curr_ie_buf, pktflag,
3668 vndrie_info->ie_ptr,
3669 vndrie_info->ie_len,
3670 "add");
3671
3672 /* save the parsed IE in wl struct */
3673 memcpy(ptr + (*mgmt_ie_len), vndrie_info->ie_ptr,
3674 vndrie_info->ie_len);
3675 *mgmt_ie_len += vndrie_info->ie_len;
3676
3677 curr_ie_buf += del_add_ie_buf_len;
3678 total_ie_buf_len += del_add_ie_buf_len;
3679 }
3680 }
3681 if (total_ie_buf_len) {
3682 err = brcmf_fil_bsscfg_data_set(ifp, "vndr_ie", iovar_ie_buf,
3683 total_ie_buf_len);
3684 if (err)
3685 brcmf_err("vndr ie set error : %d\n", err);
3686 }
3687
3688 exit:
3689 kfree(iovar_ie_buf);
3690 return err;
3691 }
3692
3693 s32 brcmf_vif_clear_mgmt_ies(struct brcmf_cfg80211_vif *vif)
3694 {
3695 s32 pktflags[] = {
3696 BRCMF_VNDR_IE_PRBREQ_FLAG,
3697 BRCMF_VNDR_IE_PRBRSP_FLAG,
3698 BRCMF_VNDR_IE_BEACON_FLAG
3699 };
3700 int i;
3701
3702 for (i = 0; i < ARRAY_SIZE(pktflags); i++)
3703 brcmf_vif_set_mgmt_ie(vif, pktflags[i], NULL, 0);
3704
3705 memset(&vif->saved_ie, 0, sizeof(vif->saved_ie));
3706 return 0;
3707 }
3708
3709 static s32
3710 brcmf_config_ap_mgmt_ie(struct brcmf_cfg80211_vif *vif,
3711 struct cfg80211_beacon_data *beacon)
3712 {
3713 s32 err;
3714
3715 /* Set Beacon IEs to FW */
3716 err = brcmf_vif_set_mgmt_ie(vif, BRCMF_VNDR_IE_BEACON_FLAG,
3717 beacon->tail, beacon->tail_len);
3718 if (err) {
3719 brcmf_err("Set Beacon IE Failed\n");
3720 return err;
3721 }
3722 brcmf_dbg(TRACE, "Applied Vndr IEs for Beacon\n");
3723
3724 /* Set Probe Response IEs to FW */
3725 err = brcmf_vif_set_mgmt_ie(vif, BRCMF_VNDR_IE_PRBRSP_FLAG,
3726 beacon->proberesp_ies,
3727 beacon->proberesp_ies_len);
3728 if (err)
3729 brcmf_err("Set Probe Resp IE Failed\n");
3730 else
3731 brcmf_dbg(TRACE, "Applied Vndr IEs for Probe Resp\n");
3732
3733 return err;
3734 }
3735
3736 static s32
3737 brcmf_cfg80211_set_channel(struct brcmf_cfg80211_info *cfg,
3738 struct brcmf_if *ifp,
3739 struct ieee80211_channel *channel)
3740 {
3741 u16 chanspec;
3742 s32 err;
3743
3744 brcmf_dbg(TRACE, "band=%d, center_freq=%d\n", channel->band,
3745 channel->center_freq);
3746
3747 chanspec = channel_to_chanspec(&cfg->d11inf, channel);
3748 err = brcmf_fil_iovar_int_set(ifp, "chanspec", chanspec);
3749
3750 return err;
3751 }
3752
3753 static s32
3754 brcmf_cfg80211_start_ap(struct wiphy *wiphy, struct net_device *ndev,
3755 struct cfg80211_ap_settings *settings)
3756 {
3757 s32 ie_offset;
3758 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy);
3759 struct brcmf_if *ifp = netdev_priv(ndev);
3760 const struct brcmf_tlv *ssid_ie;
3761 struct brcmf_ssid_le ssid_le;
3762 s32 err = -EPERM;
3763 const struct brcmf_tlv *rsn_ie;
3764 const struct brcmf_vs_tlv *wpa_ie;
3765 struct brcmf_join_params join_params;
3766 enum nl80211_iftype dev_role;
3767 struct brcmf_fil_bss_enable_le bss_enable;
3768
3769 brcmf_dbg(TRACE, "channel_type=%d, beacon_interval=%d, dtim_period=%d,\n",
3770 cfg80211_get_chandef_type(&settings->chandef),
3771 settings->beacon_interval,
3772 settings->dtim_period);
3773 brcmf_dbg(TRACE, "ssid=%s(%zu), auth_type=%d, inactivity_timeout=%d\n",
3774 settings->ssid, settings->ssid_len, settings->auth_type,
3775 settings->inactivity_timeout);
3776
3777 dev_role = ifp->vif->wdev.iftype;
3778
3779 memset(&ssid_le, 0, sizeof(ssid_le));
3780 if (settings->ssid == NULL || settings->ssid_len == 0) {
3781 ie_offset = DOT11_MGMT_HDR_LEN + DOT11_BCN_PRB_FIXED_LEN;
3782 ssid_ie = brcmf_parse_tlvs(
3783 (u8 *)&settings->beacon.head[ie_offset],
3784 settings->beacon.head_len - ie_offset,
3785 WLAN_EID_SSID);
3786 if (!ssid_ie)
3787 return -EINVAL;
3788
3789 memcpy(ssid_le.SSID, ssid_ie->data, ssid_ie->len);
3790 ssid_le.SSID_len = cpu_to_le32(ssid_ie->len);
3791 brcmf_dbg(TRACE, "SSID is (%s) in Head\n", ssid_le.SSID);
3792 } else {
3793 memcpy(ssid_le.SSID, settings->ssid, settings->ssid_len);
3794 ssid_le.SSID_len = cpu_to_le32((u32)settings->ssid_len);
3795 }
3796
3797 brcmf_set_mpc(ifp, 0);
3798 brcmf_configure_arp_offload(ifp, false);
3799
3800 /* find the RSN_IE */
3801 rsn_ie = brcmf_parse_tlvs((u8 *)settings->beacon.tail,
3802 settings->beacon.tail_len, WLAN_EID_RSN);
3803
3804 /* find the WPA_IE */
3805 wpa_ie = brcmf_find_wpaie((u8 *)settings->beacon.tail,
3806 settings->beacon.tail_len);
3807
3808 if ((wpa_ie != NULL || rsn_ie != NULL)) {
3809 brcmf_dbg(TRACE, "WPA(2) IE is found\n");
3810 if (wpa_ie != NULL) {
3811 /* WPA IE */
3812 err = brcmf_configure_wpaie(ndev, wpa_ie, false);
3813 if (err < 0)
3814 goto exit;
3815 } else {
3816 /* RSN IE */
3817 err = brcmf_configure_wpaie(ndev,
3818 (struct brcmf_vs_tlv *)rsn_ie, true);
3819 if (err < 0)
3820 goto exit;
3821 }
3822 } else {
3823 brcmf_dbg(TRACE, "No WPA(2) IEs found\n");
3824 brcmf_configure_opensecurity(ifp);
3825 }
3826
3827 brcmf_config_ap_mgmt_ie(ifp->vif, &settings->beacon);
3828
3829 err = brcmf_cfg80211_set_channel(cfg, ifp, settings->chandef.chan);
3830 if (err < 0) {
3831 brcmf_err("Set Channel failed, %d\n", err);
3832 goto exit;
3833 }
3834
3835 if (settings->beacon_interval) {
3836 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_BCNPRD,
3837 settings->beacon_interval);
3838 if (err < 0) {
3839 brcmf_err("Beacon Interval Set Error, %d\n", err);
3840 goto exit;
3841 }
3842 }
3843 if (settings->dtim_period) {
3844 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_DTIMPRD,
3845 settings->dtim_period);
3846 if (err < 0) {
3847 brcmf_err("DTIM Interval Set Error, %d\n", err);
3848 goto exit;
3849 }
3850 }
3851
3852 if (dev_role == NL80211_IFTYPE_AP) {
3853 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_DOWN, 1);
3854 if (err < 0) {
3855 brcmf_err("BRCMF_C_DOWN error %d\n", err);
3856 goto exit;
3857 }
3858 brcmf_fil_iovar_int_set(ifp, "apsta", 0);
3859 }
3860
3861 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_INFRA, 1);
3862 if (err < 0) {
3863 brcmf_err("SET INFRA error %d\n", err);
3864 goto exit;
3865 }
3866 if (dev_role == NL80211_IFTYPE_AP) {
3867 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_AP, 1);
3868 if (err < 0) {
3869 brcmf_err("setting AP mode failed %d\n", err);
3870 goto exit;
3871 }
3872 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_UP, 1);
3873 if (err < 0) {
3874 brcmf_err("BRCMF_C_UP error (%d)\n", err);
3875 goto exit;
3876 }
3877
3878 memset(&join_params, 0, sizeof(join_params));
3879 /* join parameters starts with ssid */
3880 memcpy(&join_params.ssid_le, &ssid_le, sizeof(ssid_le));
3881 /* create softap */
3882 err = brcmf_fil_cmd_data_set(ifp, BRCMF_C_SET_SSID,
3883 &join_params, sizeof(join_params));
3884 if (err < 0) {
3885 brcmf_err("SET SSID error (%d)\n", err);
3886 goto exit;
3887 }
3888 brcmf_dbg(TRACE, "AP mode configuration complete\n");
3889 } else {
3890 err = brcmf_fil_bsscfg_data_set(ifp, "ssid", &ssid_le,
3891 sizeof(ssid_le));
3892 if (err < 0) {
3893 brcmf_err("setting ssid failed %d\n", err);
3894 goto exit;
3895 }
3896 bss_enable.bsscfg_idx = cpu_to_le32(ifp->bssidx);
3897 bss_enable.enable = cpu_to_le32(1);
3898 err = brcmf_fil_iovar_data_set(ifp, "bss", &bss_enable,
3899 sizeof(bss_enable));
3900 if (err < 0) {
3901 brcmf_err("bss_enable config failed %d\n", err);
3902 goto exit;
3903 }
3904
3905 brcmf_dbg(TRACE, "GO mode configuration complete\n");
3906 }
3907 clear_bit(BRCMF_VIF_STATUS_AP_CREATING, &ifp->vif->sme_state);
3908 set_bit(BRCMF_VIF_STATUS_AP_CREATED, &ifp->vif->sme_state);
3909
3910 exit:
3911 if (err) {
3912 brcmf_set_mpc(ifp, 1);
3913 brcmf_configure_arp_offload(ifp, true);
3914 }
3915 return err;
3916 }
3917
3918 static int brcmf_cfg80211_stop_ap(struct wiphy *wiphy, struct net_device *ndev)
3919 {
3920 struct brcmf_if *ifp = netdev_priv(ndev);
3921 s32 err;
3922 struct brcmf_fil_bss_enable_le bss_enable;
3923 struct brcmf_join_params join_params;
3924
3925 brcmf_dbg(TRACE, "Enter\n");
3926
3927 if (ifp->vif->wdev.iftype == NL80211_IFTYPE_AP) {
3928 /* Due to most likely deauths outstanding we sleep */
3929 /* first to make sure they get processed by fw. */
3930 msleep(400);
3931
3932 memset(&join_params, 0, sizeof(join_params));
3933 err = brcmf_fil_cmd_data_set(ifp, BRCMF_C_SET_SSID,
3934 &join_params, sizeof(join_params));
3935 if (err < 0)
3936 brcmf_err("SET SSID error (%d)\n", err);
3937 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_UP, 0);
3938 if (err < 0)
3939 brcmf_err("BRCMF_C_UP error %d\n", err);
3940 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_AP, 0);
3941 if (err < 0)
3942 brcmf_err("setting AP mode failed %d\n", err);
3943 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_INFRA, 0);
3944 if (err < 0)
3945 brcmf_err("setting INFRA mode failed %d\n", err);
3946 } else {
3947 bss_enable.bsscfg_idx = cpu_to_le32(ifp->bssidx);
3948 bss_enable.enable = cpu_to_le32(0);
3949 err = brcmf_fil_iovar_data_set(ifp, "bss", &bss_enable,
3950 sizeof(bss_enable));
3951 if (err < 0)
3952 brcmf_err("bss_enable config failed %d\n", err);
3953 }
3954 brcmf_set_mpc(ifp, 1);
3955 brcmf_configure_arp_offload(ifp, true);
3956 set_bit(BRCMF_VIF_STATUS_AP_CREATING, &ifp->vif->sme_state);
3957 clear_bit(BRCMF_VIF_STATUS_AP_CREATED, &ifp->vif->sme_state);
3958
3959 return err;
3960 }
3961
3962 static s32
3963 brcmf_cfg80211_change_beacon(struct wiphy *wiphy, struct net_device *ndev,
3964 struct cfg80211_beacon_data *info)
3965 {
3966 struct brcmf_if *ifp = netdev_priv(ndev);
3967 s32 err;
3968
3969 brcmf_dbg(TRACE, "Enter\n");
3970
3971 err = brcmf_config_ap_mgmt_ie(ifp->vif, info);
3972
3973 return err;
3974 }
3975
3976 static int
3977 brcmf_cfg80211_del_station(struct wiphy *wiphy, struct net_device *ndev,
3978 u8 *mac)
3979 {
3980 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy);
3981 struct brcmf_scb_val_le scbval;
3982 struct brcmf_if *ifp = netdev_priv(ndev);
3983 s32 err;
3984
3985 if (!mac)
3986 return -EFAULT;
3987
3988 brcmf_dbg(TRACE, "Enter %pM\n", mac);
3989
3990 if (ifp->vif == cfg->p2p.bss_idx[P2PAPI_BSSCFG_DEVICE].vif)
3991 ifp = cfg->p2p.bss_idx[P2PAPI_BSSCFG_PRIMARY].vif->ifp;
3992 if (!check_vif_up(ifp->vif))
3993 return -EIO;
3994
3995 memcpy(&scbval.ea, mac, ETH_ALEN);
3996 scbval.val = cpu_to_le32(WLAN_REASON_DEAUTH_LEAVING);
3997 err = brcmf_fil_cmd_data_set(ifp, BRCMF_C_SCB_DEAUTHENTICATE_FOR_REASON,
3998 &scbval, sizeof(scbval));
3999 if (err)
4000 brcmf_err("SCB_DEAUTHENTICATE_FOR_REASON failed %d\n", err);
4001
4002 brcmf_dbg(TRACE, "Exit\n");
4003 return err;
4004 }
4005
4006
4007 static void
4008 brcmf_cfg80211_mgmt_frame_register(struct wiphy *wiphy,
4009 struct wireless_dev *wdev,
4010 u16 frame_type, bool reg)
4011 {
4012 struct brcmf_cfg80211_vif *vif;
4013 u16 mgmt_type;
4014
4015 brcmf_dbg(TRACE, "Enter, frame_type %04x, reg=%d\n", frame_type, reg);
4016
4017 mgmt_type = (frame_type & IEEE80211_FCTL_STYPE) >> 4;
4018 vif = container_of(wdev, struct brcmf_cfg80211_vif, wdev);
4019 if (reg)
4020 vif->mgmt_rx_reg |= BIT(mgmt_type);
4021 else
4022 vif->mgmt_rx_reg &= ~BIT(mgmt_type);
4023 }
4024
4025
4026 static int
4027 brcmf_cfg80211_mgmt_tx(struct wiphy *wiphy, struct wireless_dev *wdev,
4028 struct cfg80211_mgmt_tx_params *params, u64 *cookie)
4029 {
4030 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy);
4031 struct ieee80211_channel *chan = params->chan;
4032 const u8 *buf = params->buf;
4033 size_t len = params->len;
4034 const struct ieee80211_mgmt *mgmt;
4035 struct brcmf_cfg80211_vif *vif;
4036 s32 err = 0;
4037 s32 ie_offset;
4038 s32 ie_len;
4039 struct brcmf_fil_action_frame_le *action_frame;
4040 struct brcmf_fil_af_params_le *af_params;
4041 bool ack;
4042 s32 chan_nr;
4043 u32 freq;
4044
4045 brcmf_dbg(TRACE, "Enter\n");
4046
4047 *cookie = 0;
4048
4049 mgmt = (const struct ieee80211_mgmt *)buf;
4050
4051 if (!ieee80211_is_mgmt(mgmt->frame_control)) {
4052 brcmf_err("Driver only allows MGMT packet type\n");
4053 return -EPERM;
4054 }
4055
4056 vif = container_of(wdev, struct brcmf_cfg80211_vif, wdev);
4057
4058 if (ieee80211_is_probe_resp(mgmt->frame_control)) {
4059 /* Right now the only reason to get a probe response */
4060 /* is for p2p listen response or for p2p GO from */
4061 /* wpa_supplicant. Unfortunately the probe is send */
4062 /* on primary ndev, while dongle wants it on the p2p */
4063 /* vif. Since this is only reason for a probe */
4064 /* response to be sent, the vif is taken from cfg. */
4065 /* If ever desired to send proberesp for non p2p */
4066 /* response then data should be checked for */
4067 /* "DIRECT-". Note in future supplicant will take */
4068 /* dedicated p2p wdev to do this and then this 'hack'*/
4069 /* is not needed anymore. */
4070 ie_offset = DOT11_MGMT_HDR_LEN +
4071 DOT11_BCN_PRB_FIXED_LEN;
4072 ie_len = len - ie_offset;
4073 if (vif == cfg->p2p.bss_idx[P2PAPI_BSSCFG_PRIMARY].vif)
4074 vif = cfg->p2p.bss_idx[P2PAPI_BSSCFG_DEVICE].vif;
4075 err = brcmf_vif_set_mgmt_ie(vif,
4076 BRCMF_VNDR_IE_PRBRSP_FLAG,
4077 &buf[ie_offset],
4078 ie_len);
4079 cfg80211_mgmt_tx_status(wdev, *cookie, buf, len, true,
4080 GFP_KERNEL);
4081 } else if (ieee80211_is_action(mgmt->frame_control)) {
4082 af_params = kzalloc(sizeof(*af_params), GFP_KERNEL);
4083 if (af_params == NULL) {
4084 brcmf_err("unable to allocate frame\n");
4085 err = -ENOMEM;
4086 goto exit;
4087 }
4088 action_frame = &af_params->action_frame;
4089 /* Add the packet Id */
4090 action_frame->packet_id = cpu_to_le32(*cookie);
4091 /* Add BSSID */
4092 memcpy(&action_frame->da[0], &mgmt->da[0], ETH_ALEN);
4093 memcpy(&af_params->bssid[0], &mgmt->bssid[0], ETH_ALEN);
4094 /* Add the length exepted for 802.11 header */
4095 action_frame->len = cpu_to_le16(len - DOT11_MGMT_HDR_LEN);
4096 /* Add the channel. Use the one specified as parameter if any or
4097 * the current one (got from the firmware) otherwise
4098 */
4099 if (chan)
4100 freq = chan->center_freq;
4101 else
4102 brcmf_fil_cmd_int_get(vif->ifp, BRCMF_C_GET_CHANNEL,
4103 &freq);
4104 chan_nr = ieee80211_frequency_to_channel(freq);
4105 af_params->channel = cpu_to_le32(chan_nr);
4106
4107 memcpy(action_frame->data, &buf[DOT11_MGMT_HDR_LEN],
4108 le16_to_cpu(action_frame->len));
4109
4110 brcmf_dbg(TRACE, "Action frame, cookie=%lld, len=%d, freq=%d\n",
4111 *cookie, le16_to_cpu(action_frame->len), freq);
4112
4113 ack = brcmf_p2p_send_action_frame(cfg, cfg_to_ndev(cfg),
4114 af_params);
4115
4116 cfg80211_mgmt_tx_status(wdev, *cookie, buf, len, ack,
4117 GFP_KERNEL);
4118 kfree(af_params);
4119 } else {
4120 brcmf_dbg(TRACE, "Unhandled, fc=%04x!!\n", mgmt->frame_control);
4121 brcmf_dbg_hex_dump(true, buf, len, "payload, len=%Zu\n", len);
4122 }
4123
4124 exit:
4125 return err;
4126 }
4127
4128
4129 static int
4130 brcmf_cfg80211_cancel_remain_on_channel(struct wiphy *wiphy,
4131 struct wireless_dev *wdev,
4132 u64 cookie)
4133 {
4134 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy);
4135 struct brcmf_cfg80211_vif *vif;
4136 int err = 0;
4137
4138 brcmf_dbg(TRACE, "Enter p2p listen cancel\n");
4139
4140 vif = cfg->p2p.bss_idx[P2PAPI_BSSCFG_DEVICE].vif;
4141 if (vif == NULL) {
4142 brcmf_err("No p2p device available for probe response\n");
4143 err = -ENODEV;
4144 goto exit;
4145 }
4146 brcmf_p2p_cancel_remain_on_channel(vif->ifp);
4147 exit:
4148 return err;
4149 }
4150
4151 static int brcmf_cfg80211_crit_proto_start(struct wiphy *wiphy,
4152 struct wireless_dev *wdev,
4153 enum nl80211_crit_proto_id proto,
4154 u16 duration)
4155 {
4156 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy);
4157 struct brcmf_cfg80211_vif *vif;
4158
4159 vif = container_of(wdev, struct brcmf_cfg80211_vif, wdev);
4160
4161 /* only DHCP support for now */
4162 if (proto != NL80211_CRIT_PROTO_DHCP)
4163 return -EINVAL;
4164
4165 /* suppress and abort scanning */
4166 set_bit(BRCMF_SCAN_STATUS_SUPPRESS, &cfg->scan_status);
4167 brcmf_abort_scanning(cfg);
4168
4169 return brcmf_btcoex_set_mode(vif, BRCMF_BTCOEX_DISABLED, duration);
4170 }
4171
4172 static void brcmf_cfg80211_crit_proto_stop(struct wiphy *wiphy,
4173 struct wireless_dev *wdev)
4174 {
4175 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy);
4176 struct brcmf_cfg80211_vif *vif;
4177
4178 vif = container_of(wdev, struct brcmf_cfg80211_vif, wdev);
4179
4180 brcmf_btcoex_set_mode(vif, BRCMF_BTCOEX_ENABLED, 0);
4181 clear_bit(BRCMF_SCAN_STATUS_SUPPRESS, &cfg->scan_status);
4182 }
4183
4184 static int brcmf_convert_nl80211_tdls_oper(enum nl80211_tdls_operation oper)
4185 {
4186 int ret;
4187
4188 switch (oper) {
4189 case NL80211_TDLS_DISCOVERY_REQ:
4190 ret = BRCMF_TDLS_MANUAL_EP_DISCOVERY;
4191 break;
4192 case NL80211_TDLS_SETUP:
4193 ret = BRCMF_TDLS_MANUAL_EP_CREATE;
4194 break;
4195 case NL80211_TDLS_TEARDOWN:
4196 ret = BRCMF_TDLS_MANUAL_EP_DELETE;
4197 break;
4198 default:
4199 brcmf_err("unsupported operation: %d\n", oper);
4200 ret = -EOPNOTSUPP;
4201 }
4202 return ret;
4203 }
4204
4205 static int brcmf_cfg80211_tdls_oper(struct wiphy *wiphy,
4206 struct net_device *ndev, u8 *peer,
4207 enum nl80211_tdls_operation oper)
4208 {
4209 struct brcmf_if *ifp;
4210 struct brcmf_tdls_iovar_le info;
4211 int ret = 0;
4212
4213 ret = brcmf_convert_nl80211_tdls_oper(oper);
4214 if (ret < 0)
4215 return ret;
4216
4217 ifp = netdev_priv(ndev);
4218 memset(&info, 0, sizeof(info));
4219 info.mode = (u8)ret;
4220 if (peer)
4221 memcpy(info.ea, peer, ETH_ALEN);
4222
4223 ret = brcmf_fil_iovar_data_set(ifp, "tdls_endpoint",
4224 &info, sizeof(info));
4225 if (ret < 0)
4226 brcmf_err("tdls_endpoint iovar failed: ret=%d\n", ret);
4227
4228 return ret;
4229 }
4230
4231 static struct cfg80211_ops wl_cfg80211_ops = {
4232 .add_virtual_intf = brcmf_cfg80211_add_iface,
4233 .del_virtual_intf = brcmf_cfg80211_del_iface,
4234 .change_virtual_intf = brcmf_cfg80211_change_iface,
4235 .scan = brcmf_cfg80211_scan,
4236 .set_wiphy_params = brcmf_cfg80211_set_wiphy_params,
4237 .join_ibss = brcmf_cfg80211_join_ibss,
4238 .leave_ibss = brcmf_cfg80211_leave_ibss,
4239 .get_station = brcmf_cfg80211_get_station,
4240 .set_tx_power = brcmf_cfg80211_set_tx_power,
4241 .get_tx_power = brcmf_cfg80211_get_tx_power,
4242 .add_key = brcmf_cfg80211_add_key,
4243 .del_key = brcmf_cfg80211_del_key,
4244 .get_key = brcmf_cfg80211_get_key,
4245 .set_default_key = brcmf_cfg80211_config_default_key,
4246 .set_default_mgmt_key = brcmf_cfg80211_config_default_mgmt_key,
4247 .set_power_mgmt = brcmf_cfg80211_set_power_mgmt,
4248 .connect = brcmf_cfg80211_connect,
4249 .disconnect = brcmf_cfg80211_disconnect,
4250 .suspend = brcmf_cfg80211_suspend,
4251 .resume = brcmf_cfg80211_resume,
4252 .set_pmksa = brcmf_cfg80211_set_pmksa,
4253 .del_pmksa = brcmf_cfg80211_del_pmksa,
4254 .flush_pmksa = brcmf_cfg80211_flush_pmksa,
4255 .start_ap = brcmf_cfg80211_start_ap,
4256 .stop_ap = brcmf_cfg80211_stop_ap,
4257 .change_beacon = brcmf_cfg80211_change_beacon,
4258 .del_station = brcmf_cfg80211_del_station,
4259 .sched_scan_start = brcmf_cfg80211_sched_scan_start,
4260 .sched_scan_stop = brcmf_cfg80211_sched_scan_stop,
4261 .mgmt_frame_register = brcmf_cfg80211_mgmt_frame_register,
4262 .mgmt_tx = brcmf_cfg80211_mgmt_tx,
4263 .remain_on_channel = brcmf_p2p_remain_on_channel,
4264 .cancel_remain_on_channel = brcmf_cfg80211_cancel_remain_on_channel,
4265 .start_p2p_device = brcmf_p2p_start_device,
4266 .stop_p2p_device = brcmf_p2p_stop_device,
4267 .crit_proto_start = brcmf_cfg80211_crit_proto_start,
4268 .crit_proto_stop = brcmf_cfg80211_crit_proto_stop,
4269 .tdls_oper = brcmf_cfg80211_tdls_oper,
4270 CFG80211_TESTMODE_CMD(brcmf_cfg80211_testmode)
4271 };
4272
4273 static void brcmf_wiphy_pno_params(struct wiphy *wiphy)
4274 {
4275 /* scheduled scan settings */
4276 wiphy->max_sched_scan_ssids = BRCMF_PNO_MAX_PFN_COUNT;
4277 wiphy->max_match_sets = BRCMF_PNO_MAX_PFN_COUNT;
4278 wiphy->max_sched_scan_ie_len = BRCMF_SCAN_IE_LEN_MAX;
4279 wiphy->flags |= WIPHY_FLAG_SUPPORTS_SCHED_SCAN;
4280 }
4281
4282 static const struct ieee80211_iface_limit brcmf_iface_limits[] = {
4283 {
4284 .max = 2,
4285 .types = BIT(NL80211_IFTYPE_STATION) |
4286 BIT(NL80211_IFTYPE_ADHOC) |
4287 BIT(NL80211_IFTYPE_AP)
4288 },
4289 {
4290 .max = 1,
4291 .types = BIT(NL80211_IFTYPE_P2P_CLIENT) |
4292 BIT(NL80211_IFTYPE_P2P_GO)
4293 },
4294 {
4295 .max = 1,
4296 .types = BIT(NL80211_IFTYPE_P2P_DEVICE)
4297 }
4298 };
4299 static const struct ieee80211_iface_combination brcmf_iface_combos[] = {
4300 {
4301 .max_interfaces = BRCMF_IFACE_MAX_CNT,
4302 .num_different_channels = 2,
4303 .n_limits = ARRAY_SIZE(brcmf_iface_limits),
4304 .limits = brcmf_iface_limits
4305 }
4306 };
4307
4308 static const struct ieee80211_txrx_stypes
4309 brcmf_txrx_stypes[NUM_NL80211_IFTYPES] = {
4310 [NL80211_IFTYPE_STATION] = {
4311 .tx = 0xffff,
4312 .rx = BIT(IEEE80211_STYPE_ACTION >> 4) |
4313 BIT(IEEE80211_STYPE_PROBE_REQ >> 4)
4314 },
4315 [NL80211_IFTYPE_P2P_CLIENT] = {
4316 .tx = 0xffff,
4317 .rx = BIT(IEEE80211_STYPE_ACTION >> 4) |
4318 BIT(IEEE80211_STYPE_PROBE_REQ >> 4)
4319 },
4320 [NL80211_IFTYPE_P2P_GO] = {
4321 .tx = 0xffff,
4322 .rx = BIT(IEEE80211_STYPE_ASSOC_REQ >> 4) |
4323 BIT(IEEE80211_STYPE_REASSOC_REQ >> 4) |
4324 BIT(IEEE80211_STYPE_PROBE_REQ >> 4) |
4325 BIT(IEEE80211_STYPE_DISASSOC >> 4) |
4326 BIT(IEEE80211_STYPE_AUTH >> 4) |
4327 BIT(IEEE80211_STYPE_DEAUTH >> 4) |
4328 BIT(IEEE80211_STYPE_ACTION >> 4)
4329 },
4330 [NL80211_IFTYPE_P2P_DEVICE] = {
4331 .tx = 0xffff,
4332 .rx = BIT(IEEE80211_STYPE_ACTION >> 4) |
4333 BIT(IEEE80211_STYPE_PROBE_REQ >> 4)
4334 }
4335 };
4336
4337 static struct wiphy *brcmf_setup_wiphy(struct device *phydev)
4338 {
4339 struct wiphy *wiphy;
4340 s32 err = 0;
4341
4342 wiphy = wiphy_new(&wl_cfg80211_ops, sizeof(struct brcmf_cfg80211_info));
4343 if (!wiphy) {
4344 brcmf_err("Could not allocate wiphy device\n");
4345 return ERR_PTR(-ENOMEM);
4346 }
4347 set_wiphy_dev(wiphy, phydev);
4348 wiphy->max_scan_ssids = WL_NUM_SCAN_MAX;
4349 wiphy->max_scan_ie_len = BRCMF_SCAN_IE_LEN_MAX;
4350 wiphy->max_num_pmkids = WL_NUM_PMKIDS_MAX;
4351 wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) |
4352 BIT(NL80211_IFTYPE_ADHOC) |
4353 BIT(NL80211_IFTYPE_AP) |
4354 BIT(NL80211_IFTYPE_P2P_CLIENT) |
4355 BIT(NL80211_IFTYPE_P2P_GO) |
4356 BIT(NL80211_IFTYPE_P2P_DEVICE);
4357 wiphy->iface_combinations = brcmf_iface_combos;
4358 wiphy->n_iface_combinations = ARRAY_SIZE(brcmf_iface_combos);
4359 wiphy->bands[IEEE80211_BAND_2GHZ] = &__wl_band_2ghz;
4360 wiphy->signal_type = CFG80211_SIGNAL_TYPE_MBM;
4361 wiphy->cipher_suites = __wl_cipher_suites;
4362 wiphy->n_cipher_suites = ARRAY_SIZE(__wl_cipher_suites);
4363 wiphy->flags |= WIPHY_FLAG_PS_ON_BY_DEFAULT |
4364 WIPHY_FLAG_OFFCHAN_TX |
4365 WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL |
4366 WIPHY_FLAG_SUPPORTS_TDLS;
4367 wiphy->mgmt_stypes = brcmf_txrx_stypes;
4368 wiphy->max_remain_on_channel_duration = 5000;
4369 brcmf_wiphy_pno_params(wiphy);
4370 brcmf_dbg(INFO, "Registering custom regulatory\n");
4371 wiphy->regulatory_flags |= REGULATORY_CUSTOM_REG;
4372 wiphy_apply_custom_regulatory(wiphy, &brcmf_regdom);
4373 err = wiphy_register(wiphy);
4374 if (err < 0) {
4375 brcmf_err("Could not register wiphy device (%d)\n", err);
4376 wiphy_free(wiphy);
4377 return ERR_PTR(err);
4378 }
4379 return wiphy;
4380 }
4381
4382 struct brcmf_cfg80211_vif *brcmf_alloc_vif(struct brcmf_cfg80211_info *cfg,
4383 enum nl80211_iftype type,
4384 bool pm_block)
4385 {
4386 struct brcmf_cfg80211_vif *vif;
4387
4388 brcmf_dbg(TRACE, "allocating virtual interface (size=%zu)\n",
4389 sizeof(*vif));
4390 vif = kzalloc(sizeof(*vif), GFP_KERNEL);
4391 if (!vif)
4392 return ERR_PTR(-ENOMEM);
4393
4394 vif->wdev.wiphy = cfg->wiphy;
4395 vif->wdev.iftype = type;
4396
4397 vif->pm_block = pm_block;
4398 vif->roam_off = -1;
4399
4400 brcmf_init_prof(&vif->profile);
4401
4402 list_add_tail(&vif->list, &cfg->vif_list);
4403 return vif;
4404 }
4405
4406 void brcmf_free_vif(struct brcmf_cfg80211_vif *vif)
4407 {
4408 list_del(&vif->list);
4409 kfree(vif);
4410 }
4411
4412 void brcmf_cfg80211_free_netdev(struct net_device *ndev)
4413 {
4414 struct brcmf_cfg80211_vif *vif;
4415 struct brcmf_if *ifp;
4416
4417 ifp = netdev_priv(ndev);
4418 vif = ifp->vif;
4419
4420 brcmf_free_vif(vif);
4421 free_netdev(ndev);
4422 }
4423
4424 static bool brcmf_is_linkup(const struct brcmf_event_msg *e)
4425 {
4426 u32 event = e->event_code;
4427 u32 status = e->status;
4428
4429 if (event == BRCMF_E_SET_SSID && status == BRCMF_E_STATUS_SUCCESS) {
4430 brcmf_dbg(CONN, "Processing set ssid\n");
4431 return true;
4432 }
4433
4434 return false;
4435 }
4436
4437 static bool brcmf_is_linkdown(const struct brcmf_event_msg *e)
4438 {
4439 u32 event = e->event_code;
4440 u16 flags = e->flags;
4441
4442 if ((event == BRCMF_E_DEAUTH) || (event == BRCMF_E_DEAUTH_IND) ||
4443 (event == BRCMF_E_DISASSOC_IND) ||
4444 ((event == BRCMF_E_LINK) && (!(flags & BRCMF_EVENT_MSG_LINK)))) {
4445 brcmf_dbg(CONN, "Processing link down\n");
4446 return true;
4447 }
4448 return false;
4449 }
4450
4451 static bool brcmf_is_nonetwork(struct brcmf_cfg80211_info *cfg,
4452 const struct brcmf_event_msg *e)
4453 {
4454 u32 event = e->event_code;
4455 u32 status = e->status;
4456
4457 if (event == BRCMF_E_LINK && status == BRCMF_E_STATUS_NO_NETWORKS) {
4458 brcmf_dbg(CONN, "Processing Link %s & no network found\n",
4459 e->flags & BRCMF_EVENT_MSG_LINK ? "up" : "down");
4460 return true;
4461 }
4462
4463 if (event == BRCMF_E_SET_SSID && status != BRCMF_E_STATUS_SUCCESS) {
4464 brcmf_dbg(CONN, "Processing connecting & no network found\n");
4465 return true;
4466 }
4467
4468 return false;
4469 }
4470
4471 static void brcmf_clear_assoc_ies(struct brcmf_cfg80211_info *cfg)
4472 {
4473 struct brcmf_cfg80211_connect_info *conn_info = cfg_to_conn(cfg);
4474
4475 kfree(conn_info->req_ie);
4476 conn_info->req_ie = NULL;
4477 conn_info->req_ie_len = 0;
4478 kfree(conn_info->resp_ie);
4479 conn_info->resp_ie = NULL;
4480 conn_info->resp_ie_len = 0;
4481 }
4482
4483 static s32 brcmf_get_assoc_ies(struct brcmf_cfg80211_info *cfg,
4484 struct brcmf_if *ifp)
4485 {
4486 struct brcmf_cfg80211_assoc_ielen_le *assoc_info;
4487 struct brcmf_cfg80211_connect_info *conn_info = cfg_to_conn(cfg);
4488 u32 req_len;
4489 u32 resp_len;
4490 s32 err = 0;
4491
4492 brcmf_clear_assoc_ies(cfg);
4493
4494 err = brcmf_fil_iovar_data_get(ifp, "assoc_info",
4495 cfg->extra_buf, WL_ASSOC_INFO_MAX);
4496 if (err) {
4497 brcmf_err("could not get assoc info (%d)\n", err);
4498 return err;
4499 }
4500 assoc_info =
4501 (struct brcmf_cfg80211_assoc_ielen_le *)cfg->extra_buf;
4502 req_len = le32_to_cpu(assoc_info->req_len);
4503 resp_len = le32_to_cpu(assoc_info->resp_len);
4504 if (req_len) {
4505 err = brcmf_fil_iovar_data_get(ifp, "assoc_req_ies",
4506 cfg->extra_buf,
4507 WL_ASSOC_INFO_MAX);
4508 if (err) {
4509 brcmf_err("could not get assoc req (%d)\n", err);
4510 return err;
4511 }
4512 conn_info->req_ie_len = req_len;
4513 conn_info->req_ie =
4514 kmemdup(cfg->extra_buf, conn_info->req_ie_len,
4515 GFP_KERNEL);
4516 } else {
4517 conn_info->req_ie_len = 0;
4518 conn_info->req_ie = NULL;
4519 }
4520 if (resp_len) {
4521 err = brcmf_fil_iovar_data_get(ifp, "assoc_resp_ies",
4522 cfg->extra_buf,
4523 WL_ASSOC_INFO_MAX);
4524 if (err) {
4525 brcmf_err("could not get assoc resp (%d)\n", err);
4526 return err;
4527 }
4528 conn_info->resp_ie_len = resp_len;
4529 conn_info->resp_ie =
4530 kmemdup(cfg->extra_buf, conn_info->resp_ie_len,
4531 GFP_KERNEL);
4532 } else {
4533 conn_info->resp_ie_len = 0;
4534 conn_info->resp_ie = NULL;
4535 }
4536 brcmf_dbg(CONN, "req len (%d) resp len (%d)\n",
4537 conn_info->req_ie_len, conn_info->resp_ie_len);
4538
4539 return err;
4540 }
4541
4542 static s32
4543 brcmf_bss_roaming_done(struct brcmf_cfg80211_info *cfg,
4544 struct net_device *ndev,
4545 const struct brcmf_event_msg *e)
4546 {
4547 struct brcmf_if *ifp = netdev_priv(ndev);
4548 struct brcmf_cfg80211_profile *profile = &ifp->vif->profile;
4549 struct brcmf_cfg80211_connect_info *conn_info = cfg_to_conn(cfg);
4550 struct wiphy *wiphy = cfg_to_wiphy(cfg);
4551 struct ieee80211_channel *notify_channel = NULL;
4552 struct ieee80211_supported_band *band;
4553 struct brcmf_bss_info_le *bi;
4554 struct brcmu_chan ch;
4555 u32 freq;
4556 s32 err = 0;
4557 u8 *buf;
4558
4559 brcmf_dbg(TRACE, "Enter\n");
4560
4561 brcmf_get_assoc_ies(cfg, ifp);
4562 memcpy(profile->bssid, e->addr, ETH_ALEN);
4563 brcmf_update_bss_info(cfg, ifp);
4564
4565 buf = kzalloc(WL_BSS_INFO_MAX, GFP_KERNEL);
4566 if (buf == NULL) {
4567 err = -ENOMEM;
4568 goto done;
4569 }
4570
4571 /* data sent to dongle has to be little endian */
4572 *(__le32 *)buf = cpu_to_le32(WL_BSS_INFO_MAX);
4573 err = brcmf_fil_cmd_data_get(ifp, BRCMF_C_GET_BSS_INFO,
4574 buf, WL_BSS_INFO_MAX);
4575
4576 if (err)
4577 goto done;
4578
4579 bi = (struct brcmf_bss_info_le *)(buf + 4);
4580 ch.chspec = le16_to_cpu(bi->chanspec);
4581 cfg->d11inf.decchspec(&ch);
4582
4583 if (ch.band == BRCMU_CHAN_BAND_2G)
4584 band = wiphy->bands[IEEE80211_BAND_2GHZ];
4585 else
4586 band = wiphy->bands[IEEE80211_BAND_5GHZ];
4587
4588 freq = ieee80211_channel_to_frequency(ch.chnum, band->band);
4589 notify_channel = ieee80211_get_channel(wiphy, freq);
4590
4591 done:
4592 kfree(buf);
4593 cfg80211_roamed(ndev, notify_channel, (u8 *)profile->bssid,
4594 conn_info->req_ie, conn_info->req_ie_len,
4595 conn_info->resp_ie, conn_info->resp_ie_len, GFP_KERNEL);
4596 brcmf_dbg(CONN, "Report roaming result\n");
4597
4598 set_bit(BRCMF_VIF_STATUS_CONNECTED, &ifp->vif->sme_state);
4599 brcmf_dbg(TRACE, "Exit\n");
4600 return err;
4601 }
4602
4603 static s32
4604 brcmf_bss_connect_done(struct brcmf_cfg80211_info *cfg,
4605 struct net_device *ndev, const struct brcmf_event_msg *e,
4606 bool completed)
4607 {
4608 struct brcmf_if *ifp = netdev_priv(ndev);
4609 struct brcmf_cfg80211_profile *profile = &ifp->vif->profile;
4610 struct brcmf_cfg80211_connect_info *conn_info = cfg_to_conn(cfg);
4611 s32 err = 0;
4612
4613 brcmf_dbg(TRACE, "Enter\n");
4614
4615 if (test_and_clear_bit(BRCMF_VIF_STATUS_CONNECTING,
4616 &ifp->vif->sme_state)) {
4617 if (completed) {
4618 brcmf_get_assoc_ies(cfg, ifp);
4619 memcpy(profile->bssid, e->addr, ETH_ALEN);
4620 brcmf_update_bss_info(cfg, ifp);
4621 set_bit(BRCMF_VIF_STATUS_CONNECTED,
4622 &ifp->vif->sme_state);
4623 }
4624 cfg80211_connect_result(ndev,
4625 (u8 *)profile->bssid,
4626 conn_info->req_ie,
4627 conn_info->req_ie_len,
4628 conn_info->resp_ie,
4629 conn_info->resp_ie_len,
4630 completed ? WLAN_STATUS_SUCCESS :
4631 WLAN_STATUS_AUTH_TIMEOUT,
4632 GFP_KERNEL);
4633 brcmf_dbg(CONN, "Report connect result - connection %s\n",
4634 completed ? "succeeded" : "failed");
4635 }
4636 brcmf_dbg(TRACE, "Exit\n");
4637 return err;
4638 }
4639
4640 static s32
4641 brcmf_notify_connect_status_ap(struct brcmf_cfg80211_info *cfg,
4642 struct net_device *ndev,
4643 const struct brcmf_event_msg *e, void *data)
4644 {
4645 static int generation;
4646 u32 event = e->event_code;
4647 u32 reason = e->reason;
4648 struct station_info sinfo;
4649
4650 brcmf_dbg(CONN, "event %d, reason %d\n", event, reason);
4651 if (event == BRCMF_E_LINK && reason == BRCMF_E_REASON_LINK_BSSCFG_DIS &&
4652 ndev != cfg_to_ndev(cfg)) {
4653 brcmf_dbg(CONN, "AP mode link down\n");
4654 complete(&cfg->vif_disabled);
4655 return 0;
4656 }
4657
4658 if (((event == BRCMF_E_ASSOC_IND) || (event == BRCMF_E_REASSOC_IND)) &&
4659 (reason == BRCMF_E_STATUS_SUCCESS)) {
4660 memset(&sinfo, 0, sizeof(sinfo));
4661 sinfo.filled = STATION_INFO_ASSOC_REQ_IES;
4662 if (!data) {
4663 brcmf_err("No IEs present in ASSOC/REASSOC_IND");
4664 return -EINVAL;
4665 }
4666 sinfo.assoc_req_ies = data;
4667 sinfo.assoc_req_ies_len = e->datalen;
4668 generation++;
4669 sinfo.generation = generation;
4670 cfg80211_new_sta(ndev, e->addr, &sinfo, GFP_KERNEL);
4671 } else if ((event == BRCMF_E_DISASSOC_IND) ||
4672 (event == BRCMF_E_DEAUTH_IND) ||
4673 (event == BRCMF_E_DEAUTH)) {
4674 cfg80211_del_sta(ndev, e->addr, GFP_KERNEL);
4675 }
4676 return 0;
4677 }
4678
4679 static s32
4680 brcmf_notify_connect_status(struct brcmf_if *ifp,
4681 const struct brcmf_event_msg *e, void *data)
4682 {
4683 struct brcmf_cfg80211_info *cfg = ifp->drvr->config;
4684 struct net_device *ndev = ifp->ndev;
4685 struct brcmf_cfg80211_profile *profile = &ifp->vif->profile;
4686 struct ieee80211_channel *chan;
4687 s32 err = 0;
4688 u16 reason;
4689
4690 if (brcmf_is_apmode(ifp->vif)) {
4691 err = brcmf_notify_connect_status_ap(cfg, ndev, e, data);
4692 } else if (brcmf_is_linkup(e)) {
4693 brcmf_dbg(CONN, "Linkup\n");
4694 if (brcmf_is_ibssmode(ifp->vif)) {
4695 chan = ieee80211_get_channel(cfg->wiphy, cfg->channel);
4696 memcpy(profile->bssid, e->addr, ETH_ALEN);
4697 wl_inform_ibss(cfg, ndev, e->addr);
4698 cfg80211_ibss_joined(ndev, e->addr, chan, GFP_KERNEL);
4699 clear_bit(BRCMF_VIF_STATUS_CONNECTING,
4700 &ifp->vif->sme_state);
4701 set_bit(BRCMF_VIF_STATUS_CONNECTED,
4702 &ifp->vif->sme_state);
4703 } else
4704 brcmf_bss_connect_done(cfg, ndev, e, true);
4705 } else if (brcmf_is_linkdown(e)) {
4706 brcmf_dbg(CONN, "Linkdown\n");
4707 if (!brcmf_is_ibssmode(ifp->vif)) {
4708 brcmf_bss_connect_done(cfg, ndev, e, false);
4709 if (test_and_clear_bit(BRCMF_VIF_STATUS_CONNECTED,
4710 &ifp->vif->sme_state)) {
4711 reason = 0;
4712 if (((e->event_code == BRCMF_E_DEAUTH_IND) ||
4713 (e->event_code == BRCMF_E_DISASSOC_IND)) &&
4714 (e->reason != WLAN_REASON_UNSPECIFIED))
4715 reason = e->reason;
4716 cfg80211_disconnected(ndev, reason, NULL, 0,
4717 GFP_KERNEL);
4718 }
4719 }
4720 brcmf_link_down(ifp->vif);
4721 brcmf_init_prof(ndev_to_prof(ndev));
4722 if (ndev != cfg_to_ndev(cfg))
4723 complete(&cfg->vif_disabled);
4724 } else if (brcmf_is_nonetwork(cfg, e)) {
4725 if (brcmf_is_ibssmode(ifp->vif))
4726 clear_bit(BRCMF_VIF_STATUS_CONNECTING,
4727 &ifp->vif->sme_state);
4728 else
4729 brcmf_bss_connect_done(cfg, ndev, e, false);
4730 }
4731
4732 return err;
4733 }
4734
4735 static s32
4736 brcmf_notify_roaming_status(struct brcmf_if *ifp,
4737 const struct brcmf_event_msg *e, void *data)
4738 {
4739 struct brcmf_cfg80211_info *cfg = ifp->drvr->config;
4740 s32 err = 0;
4741 u32 event = e->event_code;
4742 u32 status = e->status;
4743
4744 if (event == BRCMF_E_ROAM && status == BRCMF_E_STATUS_SUCCESS) {
4745 if (test_bit(BRCMF_VIF_STATUS_CONNECTED, &ifp->vif->sme_state))
4746 brcmf_bss_roaming_done(cfg, ifp->ndev, e);
4747 else
4748 brcmf_bss_connect_done(cfg, ifp->ndev, e, true);
4749 }
4750
4751 return err;
4752 }
4753
4754 static s32
4755 brcmf_notify_mic_status(struct brcmf_if *ifp,
4756 const struct brcmf_event_msg *e, void *data)
4757 {
4758 u16 flags = e->flags;
4759 enum nl80211_key_type key_type;
4760
4761 if (flags & BRCMF_EVENT_MSG_GROUP)
4762 key_type = NL80211_KEYTYPE_GROUP;
4763 else
4764 key_type = NL80211_KEYTYPE_PAIRWISE;
4765
4766 cfg80211_michael_mic_failure(ifp->ndev, (u8 *)&e->addr, key_type, -1,
4767 NULL, GFP_KERNEL);
4768
4769 return 0;
4770 }
4771
4772 static s32 brcmf_notify_vif_event(struct brcmf_if *ifp,
4773 const struct brcmf_event_msg *e, void *data)
4774 {
4775 struct brcmf_cfg80211_info *cfg = ifp->drvr->config;
4776 struct brcmf_if_event *ifevent = (struct brcmf_if_event *)data;
4777 struct brcmf_cfg80211_vif_event *event = &cfg->vif_event;
4778 struct brcmf_cfg80211_vif *vif;
4779
4780 brcmf_dbg(TRACE, "Enter: action %u flags %u ifidx %u bsscfg %u\n",
4781 ifevent->action, ifevent->flags, ifevent->ifidx,
4782 ifevent->bssidx);
4783
4784 mutex_lock(&event->vif_event_lock);
4785 event->action = ifevent->action;
4786 vif = event->vif;
4787
4788 switch (ifevent->action) {
4789 case BRCMF_E_IF_ADD:
4790 /* waiting process may have timed out */
4791 if (!cfg->vif_event.vif) {
4792 mutex_unlock(&event->vif_event_lock);
4793 return -EBADF;
4794 }
4795
4796 ifp->vif = vif;
4797 vif->ifp = ifp;
4798 if (ifp->ndev) {
4799 vif->wdev.netdev = ifp->ndev;
4800 ifp->ndev->ieee80211_ptr = &vif->wdev;
4801 SET_NETDEV_DEV(ifp->ndev, wiphy_dev(cfg->wiphy));
4802 }
4803 mutex_unlock(&event->vif_event_lock);
4804 wake_up(&event->vif_wq);
4805 return 0;
4806
4807 case BRCMF_E_IF_DEL:
4808 mutex_unlock(&event->vif_event_lock);
4809 /* event may not be upon user request */
4810 if (brcmf_cfg80211_vif_event_armed(cfg))
4811 wake_up(&event->vif_wq);
4812 return 0;
4813
4814 case BRCMF_E_IF_CHANGE:
4815 mutex_unlock(&event->vif_event_lock);
4816 wake_up(&event->vif_wq);
4817 return 0;
4818
4819 default:
4820 mutex_unlock(&event->vif_event_lock);
4821 break;
4822 }
4823 return -EINVAL;
4824 }
4825
4826 static void brcmf_init_conf(struct brcmf_cfg80211_conf *conf)
4827 {
4828 conf->frag_threshold = (u32)-1;
4829 conf->rts_threshold = (u32)-1;
4830 conf->retry_short = (u32)-1;
4831 conf->retry_long = (u32)-1;
4832 conf->tx_power = -1;
4833 }
4834
4835 static void brcmf_register_event_handlers(struct brcmf_cfg80211_info *cfg)
4836 {
4837 brcmf_fweh_register(cfg->pub, BRCMF_E_LINK,
4838 brcmf_notify_connect_status);
4839 brcmf_fweh_register(cfg->pub, BRCMF_E_DEAUTH_IND,
4840 brcmf_notify_connect_status);
4841 brcmf_fweh_register(cfg->pub, BRCMF_E_DEAUTH,
4842 brcmf_notify_connect_status);
4843 brcmf_fweh_register(cfg->pub, BRCMF_E_DISASSOC_IND,
4844 brcmf_notify_connect_status);
4845 brcmf_fweh_register(cfg->pub, BRCMF_E_ASSOC_IND,
4846 brcmf_notify_connect_status);
4847 brcmf_fweh_register(cfg->pub, BRCMF_E_REASSOC_IND,
4848 brcmf_notify_connect_status);
4849 brcmf_fweh_register(cfg->pub, BRCMF_E_ROAM,
4850 brcmf_notify_roaming_status);
4851 brcmf_fweh_register(cfg->pub, BRCMF_E_MIC_ERROR,
4852 brcmf_notify_mic_status);
4853 brcmf_fweh_register(cfg->pub, BRCMF_E_SET_SSID,
4854 brcmf_notify_connect_status);
4855 brcmf_fweh_register(cfg->pub, BRCMF_E_PFN_NET_FOUND,
4856 brcmf_notify_sched_scan_results);
4857 brcmf_fweh_register(cfg->pub, BRCMF_E_IF,
4858 brcmf_notify_vif_event);
4859 brcmf_fweh_register(cfg->pub, BRCMF_E_P2P_PROBEREQ_MSG,
4860 brcmf_p2p_notify_rx_mgmt_p2p_probereq);
4861 brcmf_fweh_register(cfg->pub, BRCMF_E_P2P_DISC_LISTEN_COMPLETE,
4862 brcmf_p2p_notify_listen_complete);
4863 brcmf_fweh_register(cfg->pub, BRCMF_E_ACTION_FRAME_RX,
4864 brcmf_p2p_notify_action_frame_rx);
4865 brcmf_fweh_register(cfg->pub, BRCMF_E_ACTION_FRAME_COMPLETE,
4866 brcmf_p2p_notify_action_tx_complete);
4867 brcmf_fweh_register(cfg->pub, BRCMF_E_ACTION_FRAME_OFF_CHAN_COMPLETE,
4868 brcmf_p2p_notify_action_tx_complete);
4869 }
4870
4871 static void brcmf_deinit_priv_mem(struct brcmf_cfg80211_info *cfg)
4872 {
4873 kfree(cfg->conf);
4874 cfg->conf = NULL;
4875 kfree(cfg->escan_ioctl_buf);
4876 cfg->escan_ioctl_buf = NULL;
4877 kfree(cfg->extra_buf);
4878 cfg->extra_buf = NULL;
4879 kfree(cfg->pmk_list);
4880 cfg->pmk_list = NULL;
4881 }
4882
4883 static s32 brcmf_init_priv_mem(struct brcmf_cfg80211_info *cfg)
4884 {
4885 cfg->conf = kzalloc(sizeof(*cfg->conf), GFP_KERNEL);
4886 if (!cfg->conf)
4887 goto init_priv_mem_out;
4888 cfg->escan_ioctl_buf = kzalloc(BRCMF_DCMD_MEDLEN, GFP_KERNEL);
4889 if (!cfg->escan_ioctl_buf)
4890 goto init_priv_mem_out;
4891 cfg->extra_buf = kzalloc(WL_EXTRA_BUF_MAX, GFP_KERNEL);
4892 if (!cfg->extra_buf)
4893 goto init_priv_mem_out;
4894 cfg->pmk_list = kzalloc(sizeof(*cfg->pmk_list), GFP_KERNEL);
4895 if (!cfg->pmk_list)
4896 goto init_priv_mem_out;
4897
4898 return 0;
4899
4900 init_priv_mem_out:
4901 brcmf_deinit_priv_mem(cfg);
4902
4903 return -ENOMEM;
4904 }
4905
4906 static s32 wl_init_priv(struct brcmf_cfg80211_info *cfg)
4907 {
4908 s32 err = 0;
4909
4910 cfg->scan_request = NULL;
4911 cfg->pwr_save = true;
4912 cfg->active_scan = true; /* we do active scan per default */
4913 cfg->dongle_up = false; /* dongle is not up yet */
4914 err = brcmf_init_priv_mem(cfg);
4915 if (err)
4916 return err;
4917 brcmf_register_event_handlers(cfg);
4918 mutex_init(&cfg->usr_sync);
4919 brcmf_init_escan(cfg);
4920 brcmf_init_conf(cfg->conf);
4921 init_completion(&cfg->vif_disabled);
4922 return err;
4923 }
4924
4925 static void wl_deinit_priv(struct brcmf_cfg80211_info *cfg)
4926 {
4927 cfg->dongle_up = false; /* dongle down */
4928 brcmf_abort_scanning(cfg);
4929 brcmf_deinit_priv_mem(cfg);
4930 }
4931
4932 static void init_vif_event(struct brcmf_cfg80211_vif_event *event)
4933 {
4934 init_waitqueue_head(&event->vif_wq);
4935 mutex_init(&event->vif_event_lock);
4936 }
4937
4938 static int brcmf_enable_bw40_2g(struct brcmf_if *ifp)
4939 {
4940 struct brcmf_fil_bwcap_le band_bwcap;
4941 u32 val;
4942 int err;
4943
4944 /* verify support for bw_cap command */
4945 val = WLC_BAND_5G;
4946 err = brcmf_fil_iovar_int_get(ifp, "bw_cap", &val);
4947
4948 if (!err) {
4949 /* only set 2G bandwidth using bw_cap command */
4950 band_bwcap.band = cpu_to_le32(WLC_BAND_2G);
4951 band_bwcap.bw_cap = cpu_to_le32(WLC_BW_40MHZ_BIT);
4952 err = brcmf_fil_iovar_data_set(ifp, "bw_cap", &band_bwcap,
4953 sizeof(band_bwcap));
4954 } else {
4955 brcmf_dbg(INFO, "fallback to mimo_bw_cap\n");
4956 val = WLC_N_BW_40ALL;
4957 err = brcmf_fil_iovar_int_set(ifp, "mimo_bw_cap", val);
4958 }
4959 return err;
4960 }
4961
4962 struct brcmf_cfg80211_info *brcmf_cfg80211_attach(struct brcmf_pub *drvr,
4963 struct device *busdev)
4964 {
4965 struct net_device *ndev = drvr->iflist[0]->ndev;
4966 struct brcmf_cfg80211_info *cfg;
4967 struct wiphy *wiphy;
4968 struct brcmf_cfg80211_vif *vif;
4969 struct brcmf_if *ifp;
4970 s32 err = 0;
4971 s32 io_type;
4972
4973 if (!ndev) {
4974 brcmf_err("ndev is invalid\n");
4975 return NULL;
4976 }
4977
4978 ifp = netdev_priv(ndev);
4979 wiphy = brcmf_setup_wiphy(busdev);
4980 if (IS_ERR(wiphy))
4981 return NULL;
4982
4983 cfg = wiphy_priv(wiphy);
4984 cfg->wiphy = wiphy;
4985 cfg->pub = drvr;
4986 init_vif_event(&cfg->vif_event);
4987 INIT_LIST_HEAD(&cfg->vif_list);
4988
4989 vif = brcmf_alloc_vif(cfg, NL80211_IFTYPE_STATION, false);
4990 if (IS_ERR(vif)) {
4991 wiphy_free(wiphy);
4992 return NULL;
4993 }
4994
4995 vif->ifp = ifp;
4996 vif->wdev.netdev = ndev;
4997 ndev->ieee80211_ptr = &vif->wdev;
4998 SET_NETDEV_DEV(ndev, wiphy_dev(cfg->wiphy));
4999
5000 err = wl_init_priv(cfg);
5001 if (err) {
5002 brcmf_err("Failed to init iwm_priv (%d)\n", err);
5003 goto cfg80211_attach_out;
5004 }
5005 ifp->vif = vif;
5006
5007 err = brcmf_p2p_attach(cfg);
5008 if (err) {
5009 brcmf_err("P2P initilisation failed (%d)\n", err);
5010 goto cfg80211_p2p_attach_out;
5011 }
5012 err = brcmf_btcoex_attach(cfg);
5013 if (err) {
5014 brcmf_err("BT-coex initialisation failed (%d)\n", err);
5015 brcmf_p2p_detach(&cfg->p2p);
5016 goto cfg80211_p2p_attach_out;
5017 }
5018
5019 /* If cfg80211 didn't disable 40MHz HT CAP in wiphy_register(),
5020 * setup 40MHz in 2GHz band and enable OBSS scanning.
5021 */
5022 if (wiphy->bands[IEEE80211_BAND_2GHZ]->ht_cap.cap &
5023 IEEE80211_HT_CAP_SUP_WIDTH_20_40) {
5024 err = brcmf_enable_bw40_2g(ifp);
5025 if (!err)
5026 err = brcmf_fil_iovar_int_set(ifp, "obss_coex",
5027 BRCMF_OBSS_COEX_AUTO);
5028 }
5029
5030 err = brcmf_fil_iovar_int_set(ifp, "tdls_enable", 1);
5031 if (err) {
5032 brcmf_dbg(INFO, "TDLS not enabled (%d)\n", err);
5033 wiphy->flags &= ~WIPHY_FLAG_SUPPORTS_TDLS;
5034 }
5035
5036 err = brcmf_fil_cmd_int_get(ifp, BRCMF_C_GET_VERSION,
5037 &io_type);
5038 if (err) {
5039 brcmf_err("Failed to get D11 version (%d)\n", err);
5040 goto cfg80211_p2p_attach_out;
5041 }
5042 cfg->d11inf.io_type = (u8)io_type;
5043 brcmu_d11_attach(&cfg->d11inf);
5044
5045 return cfg;
5046
5047 cfg80211_p2p_attach_out:
5048 wl_deinit_priv(cfg);
5049
5050 cfg80211_attach_out:
5051 brcmf_free_vif(vif);
5052 return NULL;
5053 }
5054
5055 void brcmf_cfg80211_detach(struct brcmf_cfg80211_info *cfg)
5056 {
5057 if (!cfg)
5058 return;
5059
5060 WARN_ON(!list_empty(&cfg->vif_list));
5061 wiphy_unregister(cfg->wiphy);
5062 brcmf_btcoex_detach(cfg);
5063 wl_deinit_priv(cfg);
5064 wiphy_free(cfg->wiphy);
5065 }
5066
5067 static s32
5068 brcmf_dongle_roam(struct brcmf_if *ifp, u32 bcn_timeout)
5069 {
5070 s32 err = 0;
5071 __le32 roamtrigger[2];
5072 __le32 roam_delta[2];
5073
5074 /*
5075 * Setup timeout if Beacons are lost and roam is
5076 * off to report link down
5077 */
5078 if (brcmf_roamoff) {
5079 err = brcmf_fil_iovar_int_set(ifp, "bcn_timeout", bcn_timeout);
5080 if (err) {
5081 brcmf_err("bcn_timeout error (%d)\n", err);
5082 goto dongle_rom_out;
5083 }
5084 }
5085
5086 /*
5087 * Enable/Disable built-in roaming to allow supplicant
5088 * to take care of roaming
5089 */
5090 brcmf_dbg(INFO, "Internal Roaming = %s\n",
5091 brcmf_roamoff ? "Off" : "On");
5092 err = brcmf_fil_iovar_int_set(ifp, "roam_off", !!(brcmf_roamoff));
5093 if (err) {
5094 brcmf_err("roam_off error (%d)\n", err);
5095 goto dongle_rom_out;
5096 }
5097
5098 roamtrigger[0] = cpu_to_le32(WL_ROAM_TRIGGER_LEVEL);
5099 roamtrigger[1] = cpu_to_le32(BRCM_BAND_ALL);
5100 err = brcmf_fil_cmd_data_set(ifp, BRCMF_C_SET_ROAM_TRIGGER,
5101 (void *)roamtrigger, sizeof(roamtrigger));
5102 if (err) {
5103 brcmf_err("WLC_SET_ROAM_TRIGGER error (%d)\n", err);
5104 goto dongle_rom_out;
5105 }
5106
5107 roam_delta[0] = cpu_to_le32(WL_ROAM_DELTA);
5108 roam_delta[1] = cpu_to_le32(BRCM_BAND_ALL);
5109 err = brcmf_fil_cmd_data_set(ifp, BRCMF_C_SET_ROAM_DELTA,
5110 (void *)roam_delta, sizeof(roam_delta));
5111 if (err) {
5112 brcmf_err("WLC_SET_ROAM_DELTA error (%d)\n", err);
5113 goto dongle_rom_out;
5114 }
5115
5116 dongle_rom_out:
5117 return err;
5118 }
5119
5120 static s32
5121 brcmf_dongle_scantime(struct brcmf_if *ifp, s32 scan_assoc_time,
5122 s32 scan_unassoc_time, s32 scan_passive_time)
5123 {
5124 s32 err = 0;
5125
5126 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_SCAN_CHANNEL_TIME,
5127 scan_assoc_time);
5128 if (err) {
5129 if (err == -EOPNOTSUPP)
5130 brcmf_dbg(INFO, "Scan assoc time is not supported\n");
5131 else
5132 brcmf_err("Scan assoc time error (%d)\n", err);
5133 goto dongle_scantime_out;
5134 }
5135 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_SCAN_UNASSOC_TIME,
5136 scan_unassoc_time);
5137 if (err) {
5138 if (err == -EOPNOTSUPP)
5139 brcmf_dbg(INFO, "Scan unassoc time is not supported\n");
5140 else
5141 brcmf_err("Scan unassoc time error (%d)\n", err);
5142 goto dongle_scantime_out;
5143 }
5144
5145 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_SCAN_PASSIVE_TIME,
5146 scan_passive_time);
5147 if (err) {
5148 if (err == -EOPNOTSUPP)
5149 brcmf_dbg(INFO, "Scan passive time is not supported\n");
5150 else
5151 brcmf_err("Scan passive time error (%d)\n", err);
5152 goto dongle_scantime_out;
5153 }
5154
5155 dongle_scantime_out:
5156 return err;
5157 }
5158
5159
5160 static s32 brcmf_construct_reginfo(struct brcmf_cfg80211_info *cfg,
5161 u32 bw_cap[])
5162 {
5163 struct brcmf_if *ifp = netdev_priv(cfg_to_ndev(cfg));
5164 struct ieee80211_channel *band_chan_arr;
5165 struct brcmf_chanspec_list *list;
5166 struct brcmu_chan ch;
5167 s32 err;
5168 u8 *pbuf;
5169 u32 i, j;
5170 u32 total;
5171 enum ieee80211_band band;
5172 u32 channel;
5173 u32 *n_cnt;
5174 u32 index;
5175 u32 ht40_flag;
5176 bool update;
5177 u32 array_size;
5178
5179 pbuf = kzalloc(BRCMF_DCMD_MEDLEN, GFP_KERNEL);
5180
5181 if (pbuf == NULL)
5182 return -ENOMEM;
5183
5184 list = (struct brcmf_chanspec_list *)pbuf;
5185
5186 err = brcmf_fil_iovar_data_get(ifp, "chanspecs", pbuf,
5187 BRCMF_DCMD_MEDLEN);
5188 if (err) {
5189 brcmf_err("get chanspecs error (%d)\n", err);
5190 goto exit;
5191 }
5192
5193 __wl_band_2ghz.n_channels = 0;
5194 __wl_band_5ghz_a.n_channels = 0;
5195
5196 total = le32_to_cpu(list->count);
5197 for (i = 0; i < total; i++) {
5198 ch.chspec = (u16)le32_to_cpu(list->element[i]);
5199 cfg->d11inf.decchspec(&ch);
5200
5201 if (ch.band == BRCMU_CHAN_BAND_2G) {
5202 band_chan_arr = __wl_2ghz_channels;
5203 array_size = ARRAY_SIZE(__wl_2ghz_channels);
5204 n_cnt = &__wl_band_2ghz.n_channels;
5205 band = IEEE80211_BAND_2GHZ;
5206 } else if (ch.band == BRCMU_CHAN_BAND_5G) {
5207 band_chan_arr = __wl_5ghz_a_channels;
5208 array_size = ARRAY_SIZE(__wl_5ghz_a_channels);
5209 n_cnt = &__wl_band_5ghz_a.n_channels;
5210 band = IEEE80211_BAND_5GHZ;
5211 } else {
5212 brcmf_err("Invalid channel Spec. 0x%x.\n", ch.chspec);
5213 continue;
5214 }
5215 if (!(bw_cap[band] & WLC_BW_40MHZ_BIT) &&
5216 ch.bw == BRCMU_CHAN_BW_40)
5217 continue;
5218 update = false;
5219 for (j = 0; (j < *n_cnt && (*n_cnt < array_size)); j++) {
5220 if (band_chan_arr[j].hw_value == ch.chnum) {
5221 update = true;
5222 break;
5223 }
5224 }
5225 if (update)
5226 index = j;
5227 else
5228 index = *n_cnt;
5229 if (index < array_size) {
5230 band_chan_arr[index].center_freq =
5231 ieee80211_channel_to_frequency(ch.chnum, band);
5232 band_chan_arr[index].hw_value = ch.chnum;
5233
5234 if (ch.bw == BRCMU_CHAN_BW_40) {
5235 /* assuming the order is HT20, HT40 Upper,
5236 * HT40 lower from chanspecs
5237 */
5238 ht40_flag = band_chan_arr[index].flags &
5239 IEEE80211_CHAN_NO_HT40;
5240 if (ch.sb == BRCMU_CHAN_SB_U) {
5241 if (ht40_flag == IEEE80211_CHAN_NO_HT40)
5242 band_chan_arr[index].flags &=
5243 ~IEEE80211_CHAN_NO_HT40;
5244 band_chan_arr[index].flags |=
5245 IEEE80211_CHAN_NO_HT40PLUS;
5246 } else {
5247 /* It should be one of
5248 * IEEE80211_CHAN_NO_HT40 or
5249 * IEEE80211_CHAN_NO_HT40PLUS
5250 */
5251 band_chan_arr[index].flags &=
5252 ~IEEE80211_CHAN_NO_HT40;
5253 if (ht40_flag == IEEE80211_CHAN_NO_HT40)
5254 band_chan_arr[index].flags |=
5255 IEEE80211_CHAN_NO_HT40MINUS;
5256 }
5257 } else {
5258 band_chan_arr[index].flags =
5259 IEEE80211_CHAN_NO_HT40;
5260 ch.bw = BRCMU_CHAN_BW_20;
5261 cfg->d11inf.encchspec(&ch);
5262 channel = ch.chspec;
5263 err = brcmf_fil_bsscfg_int_get(ifp,
5264 "per_chan_info",
5265 &channel);
5266 if (!err) {
5267 if (channel & WL_CHAN_RADAR)
5268 band_chan_arr[index].flags |=
5269 (IEEE80211_CHAN_RADAR |
5270 IEEE80211_CHAN_NO_IR);
5271 if (channel & WL_CHAN_PASSIVE)
5272 band_chan_arr[index].flags |=
5273 IEEE80211_CHAN_NO_IR;
5274 }
5275 }
5276 if (!update)
5277 (*n_cnt)++;
5278 }
5279 }
5280 exit:
5281 kfree(pbuf);
5282 return err;
5283 }
5284
5285 static void brcmf_get_bwcap(struct brcmf_if *ifp, u32 bw_cap[])
5286 {
5287 u32 band, mimo_bwcap;
5288 int err;
5289
5290 band = WLC_BAND_2G;
5291 err = brcmf_fil_iovar_int_get(ifp, "bw_cap", &band);
5292 if (!err) {
5293 bw_cap[IEEE80211_BAND_2GHZ] = band;
5294 band = WLC_BAND_5G;
5295 err = brcmf_fil_iovar_int_get(ifp, "bw_cap", &band);
5296 if (!err) {
5297 bw_cap[IEEE80211_BAND_5GHZ] = band;
5298 return;
5299 }
5300 WARN_ON(1);
5301 return;
5302 }
5303 brcmf_dbg(INFO, "fallback to mimo_bw_cap info\n");
5304 mimo_bwcap = 0;
5305 err = brcmf_fil_iovar_int_get(ifp, "mimo_bw_cap", &mimo_bwcap);
5306 if (err)
5307 /* assume 20MHz if firmware does not give a clue */
5308 mimo_bwcap = WLC_N_BW_20ALL;
5309
5310 switch (mimo_bwcap) {
5311 case WLC_N_BW_40ALL:
5312 bw_cap[IEEE80211_BAND_2GHZ] |= WLC_BW_40MHZ_BIT;
5313 /* fall-thru */
5314 case WLC_N_BW_20IN2G_40IN5G:
5315 bw_cap[IEEE80211_BAND_5GHZ] |= WLC_BW_40MHZ_BIT;
5316 /* fall-thru */
5317 case WLC_N_BW_20ALL:
5318 bw_cap[IEEE80211_BAND_2GHZ] |= WLC_BW_20MHZ_BIT;
5319 bw_cap[IEEE80211_BAND_5GHZ] |= WLC_BW_20MHZ_BIT;
5320 break;
5321 default:
5322 brcmf_err("invalid mimo_bw_cap value\n");
5323 }
5324 }
5325
5326 static s32 brcmf_update_wiphybands(struct brcmf_cfg80211_info *cfg)
5327 {
5328 struct brcmf_if *ifp = netdev_priv(cfg_to_ndev(cfg));
5329 struct wiphy *wiphy;
5330 s32 phy_list;
5331 u32 band_list[3];
5332 u32 nmode;
5333 u32 bw_cap[2] = { 0, 0 };
5334 u32 rxchain;
5335 u32 nchain;
5336 s8 phy;
5337 s32 err;
5338 u32 nband;
5339 s32 i;
5340 struct ieee80211_supported_band *bands[2] = { NULL, NULL };
5341 struct ieee80211_supported_band *band;
5342
5343 err = brcmf_fil_cmd_data_get(ifp, BRCMF_C_GET_PHYLIST,
5344 &phy_list, sizeof(phy_list));
5345 if (err) {
5346 brcmf_err("BRCMF_C_GET_PHYLIST error (%d)\n", err);
5347 return err;
5348 }
5349
5350 phy = ((char *)&phy_list)[0];
5351 brcmf_dbg(INFO, "BRCMF_C_GET_PHYLIST reported: %c phy\n", phy);
5352
5353
5354 err = brcmf_fil_cmd_data_get(ifp, BRCMF_C_GET_BANDLIST,
5355 &band_list, sizeof(band_list));
5356 if (err) {
5357 brcmf_err("BRCMF_C_GET_BANDLIST error (%d)\n", err);
5358 return err;
5359 }
5360 brcmf_dbg(INFO, "BRCMF_C_GET_BANDLIST reported: 0x%08x 0x%08x 0x%08x phy\n",
5361 band_list[0], band_list[1], band_list[2]);
5362
5363 err = brcmf_fil_iovar_int_get(ifp, "nmode", &nmode);
5364 if (err) {
5365 brcmf_err("nmode error (%d)\n", err);
5366 } else {
5367 brcmf_get_bwcap(ifp, bw_cap);
5368 }
5369 brcmf_dbg(INFO, "nmode=%d, bw_cap=(%d, %d)\n", nmode,
5370 bw_cap[IEEE80211_BAND_2GHZ], bw_cap[IEEE80211_BAND_5GHZ]);
5371
5372 err = brcmf_fil_iovar_int_get(ifp, "rxchain", &rxchain);
5373 if (err) {
5374 brcmf_err("rxchain error (%d)\n", err);
5375 nchain = 1;
5376 } else {
5377 for (nchain = 0; rxchain; nchain++)
5378 rxchain = rxchain & (rxchain - 1);
5379 }
5380 brcmf_dbg(INFO, "nchain=%d\n", nchain);
5381
5382 err = brcmf_construct_reginfo(cfg, bw_cap);
5383 if (err) {
5384 brcmf_err("brcmf_construct_reginfo failed (%d)\n", err);
5385 return err;
5386 }
5387
5388 nband = band_list[0];
5389
5390 for (i = 1; i <= nband && i < ARRAY_SIZE(band_list); i++) {
5391 band = NULL;
5392 if ((band_list[i] == WLC_BAND_5G) &&
5393 (__wl_band_5ghz_a.n_channels > 0))
5394 band = &__wl_band_5ghz_a;
5395 else if ((band_list[i] == WLC_BAND_2G) &&
5396 (__wl_band_2ghz.n_channels > 0))
5397 band = &__wl_band_2ghz;
5398 else
5399 continue;
5400
5401 if (bw_cap[band->band] & WLC_BW_40MHZ_BIT) {
5402 band->ht_cap.cap |= IEEE80211_HT_CAP_SGI_40;
5403 band->ht_cap.cap |= IEEE80211_HT_CAP_SUP_WIDTH_20_40;
5404 }
5405 band->ht_cap.cap |= IEEE80211_HT_CAP_SGI_20;
5406 band->ht_cap.cap |= IEEE80211_HT_CAP_DSSSCCK40;
5407 band->ht_cap.ht_supported = true;
5408 band->ht_cap.ampdu_factor = IEEE80211_HT_MAX_AMPDU_64K;
5409 band->ht_cap.ampdu_density = IEEE80211_HT_MPDU_DENSITY_16;
5410 memset(band->ht_cap.mcs.rx_mask, 0xff, nchain);
5411 band->ht_cap.mcs.tx_params = IEEE80211_HT_MCS_TX_DEFINED;
5412 bands[band->band] = band;
5413 }
5414
5415 wiphy = cfg_to_wiphy(cfg);
5416 wiphy->bands[IEEE80211_BAND_2GHZ] = bands[IEEE80211_BAND_2GHZ];
5417 wiphy->bands[IEEE80211_BAND_5GHZ] = bands[IEEE80211_BAND_5GHZ];
5418 wiphy_apply_custom_regulatory(wiphy, &brcmf_regdom);
5419
5420 return err;
5421 }
5422
5423
5424 static s32 brcmf_dongle_probecap(struct brcmf_cfg80211_info *cfg)
5425 {
5426 return brcmf_update_wiphybands(cfg);
5427 }
5428
5429 static s32 brcmf_config_dongle(struct brcmf_cfg80211_info *cfg)
5430 {
5431 struct net_device *ndev;
5432 struct wireless_dev *wdev;
5433 struct brcmf_if *ifp;
5434 s32 power_mode;
5435 s32 err = 0;
5436
5437 if (cfg->dongle_up)
5438 return err;
5439
5440 ndev = cfg_to_ndev(cfg);
5441 wdev = ndev->ieee80211_ptr;
5442 ifp = netdev_priv(ndev);
5443
5444 /* make sure RF is ready for work */
5445 brcmf_fil_cmd_int_set(ifp, BRCMF_C_UP, 0);
5446
5447 brcmf_dongle_scantime(ifp, WL_SCAN_CHANNEL_TIME,
5448 WL_SCAN_UNASSOC_TIME, WL_SCAN_PASSIVE_TIME);
5449
5450 power_mode = cfg->pwr_save ? PM_FAST : PM_OFF;
5451 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_PM, power_mode);
5452 if (err)
5453 goto default_conf_out;
5454 brcmf_dbg(INFO, "power save set to %s\n",
5455 (power_mode ? "enabled" : "disabled"));
5456
5457 err = brcmf_dongle_roam(ifp, WL_BEACON_TIMEOUT);
5458 if (err)
5459 goto default_conf_out;
5460 err = brcmf_cfg80211_change_iface(wdev->wiphy, ndev, wdev->iftype,
5461 NULL, NULL);
5462 if (err)
5463 goto default_conf_out;
5464 err = brcmf_dongle_probecap(cfg);
5465 if (err)
5466 goto default_conf_out;
5467
5468 brcmf_configure_arp_offload(ifp, true);
5469
5470 cfg->dongle_up = true;
5471 default_conf_out:
5472
5473 return err;
5474
5475 }
5476
5477 static s32 __brcmf_cfg80211_up(struct brcmf_if *ifp)
5478 {
5479 set_bit(BRCMF_VIF_STATUS_READY, &ifp->vif->sme_state);
5480
5481 return brcmf_config_dongle(ifp->drvr->config);
5482 }
5483
5484 static s32 __brcmf_cfg80211_down(struct brcmf_if *ifp)
5485 {
5486 struct brcmf_cfg80211_info *cfg = ifp->drvr->config;
5487
5488 /*
5489 * While going down, if associated with AP disassociate
5490 * from AP to save power
5491 */
5492 if (check_vif_up(ifp->vif)) {
5493 brcmf_link_down(ifp->vif);
5494
5495 /* Make sure WPA_Supplicant receives all the event
5496 generated due to DISASSOC call to the fw to keep
5497 the state fw and WPA_Supplicant state consistent
5498 */
5499 brcmf_delay(500);
5500 }
5501
5502 brcmf_abort_scanning(cfg);
5503 clear_bit(BRCMF_VIF_STATUS_READY, &ifp->vif->sme_state);
5504
5505 return 0;
5506 }
5507
5508 s32 brcmf_cfg80211_up(struct net_device *ndev)
5509 {
5510 struct brcmf_if *ifp = netdev_priv(ndev);
5511 struct brcmf_cfg80211_info *cfg = ifp->drvr->config;
5512 s32 err = 0;
5513
5514 mutex_lock(&cfg->usr_sync);
5515 err = __brcmf_cfg80211_up(ifp);
5516 mutex_unlock(&cfg->usr_sync);
5517
5518 return err;
5519 }
5520
5521 s32 brcmf_cfg80211_down(struct net_device *ndev)
5522 {
5523 struct brcmf_if *ifp = netdev_priv(ndev);
5524 struct brcmf_cfg80211_info *cfg = ifp->drvr->config;
5525 s32 err = 0;
5526
5527 mutex_lock(&cfg->usr_sync);
5528 err = __brcmf_cfg80211_down(ifp);
5529 mutex_unlock(&cfg->usr_sync);
5530
5531 return err;
5532 }
5533
5534 enum nl80211_iftype brcmf_cfg80211_get_iftype(struct brcmf_if *ifp)
5535 {
5536 struct wireless_dev *wdev = &ifp->vif->wdev;
5537
5538 return wdev->iftype;
5539 }
5540
5541 u32 wl_get_vif_state_all(struct brcmf_cfg80211_info *cfg, unsigned long state)
5542 {
5543 struct brcmf_cfg80211_vif *vif;
5544 bool result = 0;
5545
5546 list_for_each_entry(vif, &cfg->vif_list, list) {
5547 if (test_bit(state, &vif->sme_state))
5548 result++;
5549 }
5550 return result;
5551 }
5552
5553 static inline bool vif_event_equals(struct brcmf_cfg80211_vif_event *event,
5554 u8 action)
5555 {
5556 u8 evt_action;
5557
5558 mutex_lock(&event->vif_event_lock);
5559 evt_action = event->action;
5560 mutex_unlock(&event->vif_event_lock);
5561 return evt_action == action;
5562 }
5563
5564 void brcmf_cfg80211_arm_vif_event(struct brcmf_cfg80211_info *cfg,
5565 struct brcmf_cfg80211_vif *vif)
5566 {
5567 struct brcmf_cfg80211_vif_event *event = &cfg->vif_event;
5568
5569 mutex_lock(&event->vif_event_lock);
5570 event->vif = vif;
5571 event->action = 0;
5572 mutex_unlock(&event->vif_event_lock);
5573 }
5574
5575 bool brcmf_cfg80211_vif_event_armed(struct brcmf_cfg80211_info *cfg)
5576 {
5577 struct brcmf_cfg80211_vif_event *event = &cfg->vif_event;
5578 bool armed;
5579
5580 mutex_lock(&event->vif_event_lock);
5581 armed = event->vif != NULL;
5582 mutex_unlock(&event->vif_event_lock);
5583
5584 return armed;
5585 }
5586 int brcmf_cfg80211_wait_vif_event_timeout(struct brcmf_cfg80211_info *cfg,
5587 u8 action, ulong timeout)
5588 {
5589 struct brcmf_cfg80211_vif_event *event = &cfg->vif_event;
5590
5591 return wait_event_timeout(event->vif_wq,
5592 vif_event_equals(event, action), timeout);
5593 }
5594
Linux kernel - Deliverables
This page took 0.204146 seconds and 6 git commands to generate.