2 * Copyright (c) 2010 Broadcom Corporation
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.
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.
17 /* Toplevel file. Relies on dhd_linux.c to send commands to the dongle. */
19 #include <linux/kernel.h>
20 #include <linux/etherdevice.h>
21 #include <linux/module.h>
22 #include <linux/vmalloc.h>
23 #include <net/cfg80211.h>
24 #include <net/netlink.h>
26 #include <brcmu_utils.h>
28 #include <brcmu_wifi.h>
31 #include "tracepoint.h"
32 #include "fwil_types.h"
43 #define BRCMF_SCAN_IE_LEN_MAX 2048
44 #define BRCMF_PNO_VERSION 2
45 #define BRCMF_PNO_TIME 30
46 #define BRCMF_PNO_REPEAT 4
47 #define BRCMF_PNO_FREQ_EXPO_MAX 3
48 #define BRCMF_PNO_MAX_PFN_COUNT 16
49 #define BRCMF_PNO_ENABLE_ADAPTSCAN_BIT 6
50 #define BRCMF_PNO_HIDDEN_BIT 2
51 #define BRCMF_PNO_WPA_AUTH_ANY 0xFFFFFFFF
52 #define BRCMF_PNO_SCAN_COMPLETE 1
53 #define BRCMF_PNO_SCAN_INCOMPLETE 0
55 #define WPA_OUI "\x00\x50\xF2" /* WPA OUI */
56 #define WPA_OUI_TYPE 1
57 #define RSN_OUI "\x00\x0F\xAC" /* RSN OUI */
58 #define WME_OUI_TYPE 2
59 #define WPS_OUI_TYPE 4
61 #define VS_IE_FIXED_HDR_LEN 6
62 #define WPA_IE_VERSION_LEN 2
63 #define WPA_IE_MIN_OUI_LEN 4
64 #define WPA_IE_SUITE_COUNT_LEN 2
66 #define WPA_CIPHER_NONE 0 /* None */
67 #define WPA_CIPHER_WEP_40 1 /* WEP (40-bit) */
68 #define WPA_CIPHER_TKIP 2 /* TKIP: default for WPA */
69 #define WPA_CIPHER_AES_CCM 4 /* AES (CCM) */
70 #define WPA_CIPHER_WEP_104 5 /* WEP (104-bit) */
72 #define RSN_AKM_NONE 0 /* None (IBSS) */
73 #define RSN_AKM_UNSPECIFIED 1 /* Over 802.1x */
74 #define RSN_AKM_PSK 2 /* Pre-shared Key */
75 #define RSN_CAP_LEN 2 /* Length of RSN capabilities */
76 #define RSN_CAP_PTK_REPLAY_CNTR_MASK 0x000C
78 #define VNDR_IE_CMD_LEN 4 /* length of the set command
79 * string :"add", "del" (+ NUL)
81 #define VNDR_IE_COUNT_OFFSET 4
82 #define VNDR_IE_PKTFLAG_OFFSET 8
83 #define VNDR_IE_VSIE_OFFSET 12
84 #define VNDR_IE_HDR_SIZE 12
85 #define VNDR_IE_PARSE_LIMIT 5
87 #define DOT11_MGMT_HDR_LEN 24 /* d11 management header len */
88 #define DOT11_BCN_PRB_FIXED_LEN 12 /* beacon/probe fixed length */
90 #define BRCMF_SCAN_JOIN_ACTIVE_DWELL_TIME_MS 320
91 #define BRCMF_SCAN_JOIN_PASSIVE_DWELL_TIME_MS 400
92 #define BRCMF_SCAN_JOIN_PROBE_INTERVAL_MS 20
94 #define BRCMF_ASSOC_PARAMS_FIXED_SIZE \
95 (sizeof(struct brcmf_assoc_params_le) - sizeof(u16))
97 static bool check_vif_up(struct brcmf_cfg80211_vif *vif)
99 if (!test_bit(BRCMF_VIF_STATUS_READY, &vif->sme_state)) {
100 brcmf_dbg(INFO, "device is not ready : status (%lu)\n",
107 #define RATE_TO_BASE100KBPS(rate) (((rate) * 10) / 2)
108 #define RATETAB_ENT(_rateid, _flags) \
110 .bitrate = RATE_TO_BASE100KBPS(_rateid), \
111 .hw_value = (_rateid), \
115 static struct ieee80211_rate __wl_rates[] = {
116 RATETAB_ENT(BRCM_RATE_1M, 0),
117 RATETAB_ENT(BRCM_RATE_2M, IEEE80211_RATE_SHORT_PREAMBLE),
118 RATETAB_ENT(BRCM_RATE_5M5, IEEE80211_RATE_SHORT_PREAMBLE),
119 RATETAB_ENT(BRCM_RATE_11M, IEEE80211_RATE_SHORT_PREAMBLE),
120 RATETAB_ENT(BRCM_RATE_6M, 0),
121 RATETAB_ENT(BRCM_RATE_9M, 0),
122 RATETAB_ENT(BRCM_RATE_12M, 0),
123 RATETAB_ENT(BRCM_RATE_18M, 0),
124 RATETAB_ENT(BRCM_RATE_24M, 0),
125 RATETAB_ENT(BRCM_RATE_36M, 0),
126 RATETAB_ENT(BRCM_RATE_48M, 0),
127 RATETAB_ENT(BRCM_RATE_54M, 0),
130 #define wl_g_rates (__wl_rates + 0)
131 #define wl_g_rates_size ARRAY_SIZE(__wl_rates)
132 #define wl_a_rates (__wl_rates + 4)
133 #define wl_a_rates_size (wl_g_rates_size - 4)
135 #define CHAN2G(_channel, _freq) { \
136 .band = IEEE80211_BAND_2GHZ, \
137 .center_freq = (_freq), \
138 .hw_value = (_channel), \
139 .flags = IEEE80211_CHAN_DISABLED, \
140 .max_antenna_gain = 0, \
144 #define CHAN5G(_channel) { \
145 .band = IEEE80211_BAND_5GHZ, \
146 .center_freq = 5000 + (5 * (_channel)), \
147 .hw_value = (_channel), \
148 .flags = IEEE80211_CHAN_DISABLED, \
149 .max_antenna_gain = 0, \
153 static struct ieee80211_channel __wl_2ghz_channels[] = {
154 CHAN2G(1, 2412), CHAN2G(2, 2417), CHAN2G(3, 2422), CHAN2G(4, 2427),
155 CHAN2G(5, 2432), CHAN2G(6, 2437), CHAN2G(7, 2442), CHAN2G(8, 2447),
156 CHAN2G(9, 2452), CHAN2G(10, 2457), CHAN2G(11, 2462), CHAN2G(12, 2467),
157 CHAN2G(13, 2472), CHAN2G(14, 2484)
160 static struct ieee80211_channel __wl_5ghz_channels[] = {
161 CHAN5G(34), CHAN5G(36), CHAN5G(38), CHAN5G(40), CHAN5G(42),
162 CHAN5G(44), CHAN5G(46), CHAN5G(48), CHAN5G(52), CHAN5G(56),
163 CHAN5G(60), CHAN5G(64), CHAN5G(100), CHAN5G(104), CHAN5G(108),
164 CHAN5G(112), CHAN5G(116), CHAN5G(120), CHAN5G(124), CHAN5G(128),
165 CHAN5G(132), CHAN5G(136), CHAN5G(140), CHAN5G(144), CHAN5G(149),
166 CHAN5G(153), CHAN5G(157), CHAN5G(161), CHAN5G(165)
169 /* Band templates duplicated per wiphy. The channel info
170 * above is added to the band during setup.
172 static const struct ieee80211_supported_band __wl_band_2ghz = {
173 .band = IEEE80211_BAND_2GHZ,
174 .bitrates = wl_g_rates,
175 .n_bitrates = wl_g_rates_size,
178 static const struct ieee80211_supported_band __wl_band_5ghz = {
179 .band = IEEE80211_BAND_5GHZ,
180 .bitrates = wl_a_rates,
181 .n_bitrates = wl_a_rates_size,
184 /* This is to override regulatory domains defined in cfg80211 module (reg.c)
185 * By default world regulatory domain defined in reg.c puts the flags
186 * NL80211_RRF_NO_IR for 5GHz channels (for * 36..48 and 149..165).
187 * With respect to these flags, wpa_supplicant doesn't * start p2p
188 * operations on 5GHz channels. All the changes in world regulatory
189 * domain are to be done here.
191 static const struct ieee80211_regdomain brcmf_regdom = {
195 /* IEEE 802.11b/g, channels 1..11 */
196 REG_RULE(2412-10, 2472+10, 40, 6, 20, 0),
198 /* IEEE 802.11 channel 14 - Only JP enables
199 * this and for 802.11b only
201 REG_RULE(2484-10, 2484+10, 20, 6, 20, 0),
202 /* IEEE 802.11a, channel 36..64 */
203 REG_RULE(5150-10, 5350+10, 80, 6, 20, 0),
204 /* IEEE 802.11a, channel 100..165 */
205 REG_RULE(5470-10, 5850+10, 80, 6, 20, 0), }
208 static const u32 __wl_cipher_suites[] = {
209 WLAN_CIPHER_SUITE_WEP40,
210 WLAN_CIPHER_SUITE_WEP104,
211 WLAN_CIPHER_SUITE_TKIP,
212 WLAN_CIPHER_SUITE_CCMP,
213 WLAN_CIPHER_SUITE_AES_CMAC,
216 /* Vendor specific ie. id = 221, oui and type defines exact ie */
217 struct brcmf_vs_tlv {
224 struct parsed_vndr_ie_info {
226 u32 ie_len; /* total length including id & length field */
227 struct brcmf_vs_tlv vndrie;
230 struct parsed_vndr_ies {
232 struct parsed_vndr_ie_info ie_info[VNDR_IE_PARSE_LIMIT];
235 static int brcmf_roamoff;
236 module_param_named(roamoff, brcmf_roamoff, int, S_IRUSR);
237 MODULE_PARM_DESC(roamoff, "do not use internal roaming engine");
240 static u16 chandef_to_chanspec(struct brcmu_d11inf *d11inf,
241 struct cfg80211_chan_def *ch)
243 struct brcmu_chan ch_inf;
246 brcmf_dbg(TRACE, "chandef: control %d center %d width %d\n",
247 ch->chan->center_freq, ch->center_freq1, ch->width);
248 ch_inf.chnum = ieee80211_frequency_to_channel(ch->center_freq1);
249 primary_offset = ch->center_freq1 - ch->chan->center_freq;
251 case NL80211_CHAN_WIDTH_20:
252 case NL80211_CHAN_WIDTH_20_NOHT:
253 ch_inf.bw = BRCMU_CHAN_BW_20;
254 WARN_ON(primary_offset != 0);
256 case NL80211_CHAN_WIDTH_40:
257 ch_inf.bw = BRCMU_CHAN_BW_40;
258 if (primary_offset < 0)
259 ch_inf.sb = BRCMU_CHAN_SB_U;
261 ch_inf.sb = BRCMU_CHAN_SB_L;
263 case NL80211_CHAN_WIDTH_80:
264 ch_inf.bw = BRCMU_CHAN_BW_80;
265 if (primary_offset < 0) {
266 if (primary_offset < -CH_10MHZ_APART)
267 ch_inf.sb = BRCMU_CHAN_SB_UU;
269 ch_inf.sb = BRCMU_CHAN_SB_UL;
271 if (primary_offset > CH_10MHZ_APART)
272 ch_inf.sb = BRCMU_CHAN_SB_LL;
274 ch_inf.sb = BRCMU_CHAN_SB_LU;
277 case NL80211_CHAN_WIDTH_80P80:
278 case NL80211_CHAN_WIDTH_160:
279 case NL80211_CHAN_WIDTH_5:
280 case NL80211_CHAN_WIDTH_10:
284 switch (ch->chan->band) {
285 case IEEE80211_BAND_2GHZ:
286 ch_inf.band = BRCMU_CHAN_BAND_2G;
288 case IEEE80211_BAND_5GHZ:
289 ch_inf.band = BRCMU_CHAN_BAND_5G;
291 case IEEE80211_BAND_60GHZ:
295 d11inf->encchspec(&ch_inf);
297 return ch_inf.chspec;
300 u16 channel_to_chanspec(struct brcmu_d11inf *d11inf,
301 struct ieee80211_channel *ch)
303 struct brcmu_chan ch_inf;
305 ch_inf.chnum = ieee80211_frequency_to_channel(ch->center_freq);
306 ch_inf.bw = BRCMU_CHAN_BW_20;
307 d11inf->encchspec(&ch_inf);
309 return ch_inf.chspec;
312 /* Traverse a string of 1-byte tag/1-byte length/variable-length value
313 * triples, returning a pointer to the substring whose first element
316 const struct brcmf_tlv *
317 brcmf_parse_tlvs(const void *buf, int buflen, uint key)
319 const struct brcmf_tlv *elt = buf;
322 /* find tagged parameter */
323 while (totlen >= TLV_HDR_LEN) {
326 /* validate remaining totlen */
327 if ((elt->id == key) && (totlen >= (len + TLV_HDR_LEN)))
330 elt = (struct brcmf_tlv *)((u8 *)elt + (len + TLV_HDR_LEN));
331 totlen -= (len + TLV_HDR_LEN);
337 /* Is any of the tlvs the expected entry? If
338 * not update the tlvs buffer pointer/length.
341 brcmf_tlv_has_ie(const u8 *ie, const u8 **tlvs, u32 *tlvs_len,
342 const u8 *oui, u32 oui_len, u8 type)
344 /* If the contents match the OUI and the type */
345 if (ie[TLV_LEN_OFF] >= oui_len + 1 &&
346 !memcmp(&ie[TLV_BODY_OFF], oui, oui_len) &&
347 type == ie[TLV_BODY_OFF + oui_len]) {
353 /* point to the next ie */
354 ie += ie[TLV_LEN_OFF] + TLV_HDR_LEN;
355 /* calculate the length of the rest of the buffer */
356 *tlvs_len -= (int)(ie - *tlvs);
357 /* update the pointer to the start of the buffer */
363 static struct brcmf_vs_tlv *
364 brcmf_find_wpaie(const u8 *parse, u32 len)
366 const struct brcmf_tlv *ie;
368 while ((ie = brcmf_parse_tlvs(parse, len, WLAN_EID_VENDOR_SPECIFIC))) {
369 if (brcmf_tlv_has_ie((const u8 *)ie, &parse, &len,
370 WPA_OUI, TLV_OUI_LEN, WPA_OUI_TYPE))
371 return (struct brcmf_vs_tlv *)ie;
376 static struct brcmf_vs_tlv *
377 brcmf_find_wpsie(const u8 *parse, u32 len)
379 const struct brcmf_tlv *ie;
381 while ((ie = brcmf_parse_tlvs(parse, len, WLAN_EID_VENDOR_SPECIFIC))) {
382 if (brcmf_tlv_has_ie((u8 *)ie, &parse, &len,
383 WPA_OUI, TLV_OUI_LEN, WPS_OUI_TYPE))
384 return (struct brcmf_vs_tlv *)ie;
389 static int brcmf_vif_change_validate(struct brcmf_cfg80211_info *cfg,
390 struct brcmf_cfg80211_vif *vif,
391 enum nl80211_iftype new_type)
393 int iftype_num[NUM_NL80211_IFTYPES];
394 struct brcmf_cfg80211_vif *pos;
396 memset(&iftype_num[0], 0, sizeof(iftype_num));
397 list_for_each_entry(pos, &cfg->vif_list, list)
399 iftype_num[new_type]++;
401 iftype_num[pos->wdev.iftype]++;
403 return cfg80211_check_combinations(cfg->wiphy, 1, 0, iftype_num);
406 static int brcmf_vif_add_validate(struct brcmf_cfg80211_info *cfg,
407 enum nl80211_iftype new_type)
409 int iftype_num[NUM_NL80211_IFTYPES];
410 struct brcmf_cfg80211_vif *pos;
412 memset(&iftype_num[0], 0, sizeof(iftype_num));
413 list_for_each_entry(pos, &cfg->vif_list, list)
414 iftype_num[pos->wdev.iftype]++;
416 iftype_num[new_type]++;
417 return cfg80211_check_combinations(cfg->wiphy, 1, 0, iftype_num);
420 static void convert_key_from_CPU(struct brcmf_wsec_key *key,
421 struct brcmf_wsec_key_le *key_le)
423 key_le->index = cpu_to_le32(key->index);
424 key_le->len = cpu_to_le32(key->len);
425 key_le->algo = cpu_to_le32(key->algo);
426 key_le->flags = cpu_to_le32(key->flags);
427 key_le->rxiv.hi = cpu_to_le32(key->rxiv.hi);
428 key_le->rxiv.lo = cpu_to_le16(key->rxiv.lo);
429 key_le->iv_initialized = cpu_to_le32(key->iv_initialized);
430 memcpy(key_le->data, key->data, sizeof(key->data));
431 memcpy(key_le->ea, key->ea, sizeof(key->ea));
435 send_key_to_dongle(struct brcmf_if *ifp, struct brcmf_wsec_key *key)
438 struct brcmf_wsec_key_le key_le;
440 convert_key_from_CPU(key, &key_le);
442 brcmf_netdev_wait_pend8021x(ifp);
444 err = brcmf_fil_bsscfg_data_set(ifp, "wsec_key", &key_le,
448 brcmf_err("wsec_key error (%d)\n", err);
453 brcmf_configure_arp_offload(struct brcmf_if *ifp, bool enable)
459 mode = BRCMF_ARP_OL_AGENT | BRCMF_ARP_OL_PEER_AUTO_REPLY;
463 /* Try to set and enable ARP offload feature, this may fail, then it */
464 /* is simply not supported and err 0 will be returned */
465 err = brcmf_fil_iovar_int_set(ifp, "arp_ol", mode);
467 brcmf_dbg(TRACE, "failed to set ARP offload mode to 0x%x, err = %d\n",
471 err = brcmf_fil_iovar_int_set(ifp, "arpoe", enable);
473 brcmf_dbg(TRACE, "failed to configure (%d) ARP offload err = %d\n",
477 brcmf_dbg(TRACE, "successfully configured (%d) ARP offload to 0x%x\n",
485 brcmf_cfg80211_update_proto_addr_mode(struct wireless_dev *wdev)
487 struct brcmf_cfg80211_vif *vif;
488 struct brcmf_if *ifp;
490 vif = container_of(wdev, struct brcmf_cfg80211_vif, wdev);
493 if ((wdev->iftype == NL80211_IFTYPE_ADHOC) ||
494 (wdev->iftype == NL80211_IFTYPE_AP) ||
495 (wdev->iftype == NL80211_IFTYPE_P2P_GO))
496 brcmf_proto_configure_addr_mode(ifp->drvr, ifp->ifidx,
499 brcmf_proto_configure_addr_mode(ifp->drvr, ifp->ifidx,
503 static int brcmf_cfg80211_request_ap_if(struct brcmf_if *ifp)
505 struct brcmf_mbss_ssid_le mbss_ssid_le;
509 memset(&mbss_ssid_le, 0, sizeof(mbss_ssid_le));
510 bsscfgidx = brcmf_get_next_free_bsscfgidx(ifp->drvr);
514 mbss_ssid_le.bsscfgidx = cpu_to_le32(bsscfgidx);
515 mbss_ssid_le.SSID_len = cpu_to_le32(5);
516 sprintf(mbss_ssid_le.SSID, "ssid%d" , bsscfgidx);
518 err = brcmf_fil_bsscfg_data_set(ifp, "bsscfg:ssid", &mbss_ssid_le,
519 sizeof(mbss_ssid_le));
521 brcmf_err("setting ssid failed %d\n", err);
527 * brcmf_ap_add_vif() - create a new AP virtual interface for multiple BSS
529 * @wiphy: wiphy device of new interface.
530 * @name: name of the new interface.
532 * @params: contains mac address for AP device.
535 struct wireless_dev *brcmf_ap_add_vif(struct wiphy *wiphy, const char *name,
536 u32 *flags, struct vif_params *params)
538 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy);
539 struct brcmf_if *ifp = netdev_priv(cfg_to_ndev(cfg));
540 struct brcmf_cfg80211_vif *vif;
543 if (brcmf_cfg80211_vif_event_armed(cfg))
544 return ERR_PTR(-EBUSY);
546 brcmf_dbg(INFO, "Adding vif \"%s\"\n", name);
548 vif = brcmf_alloc_vif(cfg, NL80211_IFTYPE_AP, false);
550 return (struct wireless_dev *)vif;
552 brcmf_cfg80211_arm_vif_event(cfg, vif);
554 err = brcmf_cfg80211_request_ap_if(ifp);
556 brcmf_cfg80211_arm_vif_event(cfg, NULL);
560 /* wait for firmware event */
561 err = brcmf_cfg80211_wait_vif_event_timeout(cfg, BRCMF_E_IF_ADD,
562 msecs_to_jiffies(1500));
563 brcmf_cfg80211_arm_vif_event(cfg, NULL);
565 brcmf_err("timeout occurred\n");
570 /* interface created in firmware */
573 brcmf_err("no if pointer provided\n");
578 strncpy(ifp->ndev->name, name, sizeof(ifp->ndev->name) - 1);
579 err = brcmf_net_attach(ifp, true);
581 brcmf_err("Registering netdevice failed\n");
585 return &ifp->vif->wdev;
592 static bool brcmf_is_apmode(struct brcmf_cfg80211_vif *vif)
594 enum nl80211_iftype iftype;
596 iftype = vif->wdev.iftype;
597 return iftype == NL80211_IFTYPE_AP || iftype == NL80211_IFTYPE_P2P_GO;
600 static bool brcmf_is_ibssmode(struct brcmf_cfg80211_vif *vif)
602 return vif->wdev.iftype == NL80211_IFTYPE_ADHOC;
605 static struct wireless_dev *brcmf_cfg80211_add_iface(struct wiphy *wiphy,
607 unsigned char name_assign_type,
608 enum nl80211_iftype type,
610 struct vif_params *params)
612 struct wireless_dev *wdev;
615 brcmf_dbg(TRACE, "enter: %s type %d\n", name, type);
616 err = brcmf_vif_add_validate(wiphy_to_cfg(wiphy), type);
618 brcmf_err("iface validation failed: err=%d\n", err);
622 case NL80211_IFTYPE_ADHOC:
623 case NL80211_IFTYPE_STATION:
624 case NL80211_IFTYPE_AP_VLAN:
625 case NL80211_IFTYPE_WDS:
626 case NL80211_IFTYPE_MONITOR:
627 case NL80211_IFTYPE_MESH_POINT:
628 return ERR_PTR(-EOPNOTSUPP);
629 case NL80211_IFTYPE_AP:
630 wdev = brcmf_ap_add_vif(wiphy, name, flags, params);
632 brcmf_cfg80211_update_proto_addr_mode(wdev);
634 case NL80211_IFTYPE_P2P_CLIENT:
635 case NL80211_IFTYPE_P2P_GO:
636 case NL80211_IFTYPE_P2P_DEVICE:
637 wdev = brcmf_p2p_add_vif(wiphy, name, name_assign_type, type, flags, params);
639 brcmf_cfg80211_update_proto_addr_mode(wdev);
641 case NL80211_IFTYPE_UNSPECIFIED:
643 return ERR_PTR(-EINVAL);
647 static void brcmf_scan_config_mpc(struct brcmf_if *ifp, int mpc)
649 if (brcmf_feat_is_quirk_enabled(ifp, BRCMF_FEAT_QUIRK_NEED_MPC))
650 brcmf_set_mpc(ifp, mpc);
653 void brcmf_set_mpc(struct brcmf_if *ifp, int mpc)
657 if (check_vif_up(ifp->vif)) {
658 err = brcmf_fil_iovar_int_set(ifp, "mpc", mpc);
660 brcmf_err("fail to set mpc\n");
663 brcmf_dbg(INFO, "MPC : %d\n", mpc);
667 s32 brcmf_notify_escan_complete(struct brcmf_cfg80211_info *cfg,
668 struct brcmf_if *ifp, bool aborted,
671 struct brcmf_scan_params_le params_le;
672 struct cfg80211_scan_request *scan_request;
675 brcmf_dbg(SCAN, "Enter\n");
677 /* clear scan request, because the FW abort can cause a second call */
678 /* to this functon and might cause a double cfg80211_scan_done */
679 scan_request = cfg->scan_request;
680 cfg->scan_request = NULL;
682 if (timer_pending(&cfg->escan_timeout))
683 del_timer_sync(&cfg->escan_timeout);
686 /* Do a scan abort to stop the driver's scan engine */
687 brcmf_dbg(SCAN, "ABORT scan in firmware\n");
688 memset(¶ms_le, 0, sizeof(params_le));
689 eth_broadcast_addr(params_le.bssid);
690 params_le.bss_type = DOT11_BSSTYPE_ANY;
691 params_le.scan_type = 0;
692 params_le.channel_num = cpu_to_le32(1);
693 params_le.nprobes = cpu_to_le32(1);
694 params_le.active_time = cpu_to_le32(-1);
695 params_le.passive_time = cpu_to_le32(-1);
696 params_le.home_time = cpu_to_le32(-1);
697 /* Scan is aborted by setting channel_list[0] to -1 */
698 params_le.channel_list[0] = cpu_to_le16(-1);
699 /* E-Scan (or anyother type) can be aborted by SCAN */
700 err = brcmf_fil_cmd_data_set(ifp, BRCMF_C_SCAN,
701 ¶ms_le, sizeof(params_le));
703 brcmf_err("Scan abort failed\n");
706 brcmf_scan_config_mpc(ifp, 1);
709 * e-scan can be initiated by scheduled scan
710 * which takes precedence.
712 if (cfg->sched_escan) {
713 brcmf_dbg(SCAN, "scheduled scan completed\n");
714 cfg->sched_escan = false;
716 cfg80211_sched_scan_results(cfg_to_wiphy(cfg));
717 } else if (scan_request) {
718 brcmf_dbg(SCAN, "ESCAN Completed scan: %s\n",
719 aborted ? "Aborted" : "Done");
720 cfg80211_scan_done(scan_request, aborted);
722 if (!test_and_clear_bit(BRCMF_SCAN_STATUS_BUSY, &cfg->scan_status))
723 brcmf_dbg(SCAN, "Scan complete, probably P2P scan\n");
729 int brcmf_cfg80211_del_iface(struct wiphy *wiphy, struct wireless_dev *wdev)
731 struct brcmf_cfg80211_info *cfg = wiphy_priv(wiphy);
732 struct net_device *ndev = wdev->netdev;
734 /* vif event pending in firmware */
735 if (brcmf_cfg80211_vif_event_armed(cfg))
739 if (test_bit(BRCMF_SCAN_STATUS_BUSY, &cfg->scan_status) &&
740 cfg->escan_info.ifp == netdev_priv(ndev))
741 brcmf_notify_escan_complete(cfg, netdev_priv(ndev),
744 brcmf_fil_iovar_int_set(netdev_priv(ndev), "mpc", 1);
747 switch (wdev->iftype) {
748 case NL80211_IFTYPE_ADHOC:
749 case NL80211_IFTYPE_STATION:
750 case NL80211_IFTYPE_AP:
751 case NL80211_IFTYPE_AP_VLAN:
752 case NL80211_IFTYPE_WDS:
753 case NL80211_IFTYPE_MONITOR:
754 case NL80211_IFTYPE_MESH_POINT:
756 case NL80211_IFTYPE_P2P_CLIENT:
757 case NL80211_IFTYPE_P2P_GO:
758 case NL80211_IFTYPE_P2P_DEVICE:
759 return brcmf_p2p_del_vif(wiphy, wdev);
760 case NL80211_IFTYPE_UNSPECIFIED:
768 brcmf_cfg80211_change_iface(struct wiphy *wiphy, struct net_device *ndev,
769 enum nl80211_iftype type, u32 *flags,
770 struct vif_params *params)
772 struct brcmf_cfg80211_info *cfg = wiphy_priv(wiphy);
773 struct brcmf_if *ifp = netdev_priv(ndev);
774 struct brcmf_cfg80211_vif *vif = ifp->vif;
779 brcmf_dbg(TRACE, "Enter, idx=%d, type=%d\n", ifp->bssidx, type);
781 /* WAR: There are a number of p2p interface related problems which
782 * need to be handled initially (before doing the validate).
783 * wpa_supplicant tends to do iface changes on p2p device/client/go
784 * which are not always possible/allowed. However we need to return
785 * OK otherwise the wpa_supplicant wont start. The situation differs
786 * on configuration and setup (p2pon=1 module param). The first check
787 * is to see if the request is a change to station for p2p iface.
789 if ((type == NL80211_IFTYPE_STATION) &&
790 ((vif->wdev.iftype == NL80211_IFTYPE_P2P_CLIENT) ||
791 (vif->wdev.iftype == NL80211_IFTYPE_P2P_GO) ||
792 (vif->wdev.iftype == NL80211_IFTYPE_P2P_DEVICE))) {
793 brcmf_dbg(TRACE, "Ignoring cmd for p2p if\n");
794 /* Now depending on whether module param p2pon=1 was used the
795 * response needs to be either 0 or EOPNOTSUPP. The reason is
796 * that if p2pon=1 is used, but a newer supplicant is used then
797 * we should return an error, as this combination wont work.
798 * In other situations 0 is returned and supplicant will start
799 * normally. It will give a trace in cfg80211, but it is the
800 * only way to get it working. Unfortunately this will result
801 * in situation where we wont support new supplicant in
802 * combination with module param p2pon=1, but that is the way
803 * it is. If the user tries this then unloading of driver might
806 if (cfg->p2p.p2pdev_dynamically)
811 err = brcmf_vif_change_validate(wiphy_to_cfg(wiphy), vif, type);
813 brcmf_err("iface validation failed: err=%d\n", err);
817 case NL80211_IFTYPE_MONITOR:
818 case NL80211_IFTYPE_WDS:
819 brcmf_err("type (%d) : currently we do not support this type\n",
822 case NL80211_IFTYPE_ADHOC:
825 case NL80211_IFTYPE_STATION:
828 case NL80211_IFTYPE_AP:
829 case NL80211_IFTYPE_P2P_GO:
838 if (type == NL80211_IFTYPE_P2P_GO) {
839 brcmf_dbg(INFO, "IF Type = P2P GO\n");
840 err = brcmf_p2p_ifchange(cfg, BRCMF_FIL_P2P_IF_GO);
843 brcmf_dbg(INFO, "IF Type = AP\n");
846 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_INFRA, infra);
848 brcmf_err("WLC_SET_INFRA error (%d)\n", err);
852 brcmf_dbg(INFO, "IF Type = %s\n", brcmf_is_ibssmode(vif) ?
855 ndev->ieee80211_ptr->iftype = type;
857 brcmf_cfg80211_update_proto_addr_mode(&vif->wdev);
860 brcmf_dbg(TRACE, "Exit\n");
865 static void brcmf_escan_prep(struct brcmf_cfg80211_info *cfg,
866 struct brcmf_scan_params_le *params_le,
867 struct cfg80211_scan_request *request)
875 struct brcmf_ssid_le ssid_le;
877 eth_broadcast_addr(params_le->bssid);
878 params_le->bss_type = DOT11_BSSTYPE_ANY;
879 params_le->scan_type = 0;
880 params_le->channel_num = 0;
881 params_le->nprobes = cpu_to_le32(-1);
882 params_le->active_time = cpu_to_le32(-1);
883 params_le->passive_time = cpu_to_le32(-1);
884 params_le->home_time = cpu_to_le32(-1);
885 memset(¶ms_le->ssid_le, 0, sizeof(params_le->ssid_le));
887 /* if request is null exit so it will be all channel broadcast scan */
891 n_ssids = request->n_ssids;
892 n_channels = request->n_channels;
893 /* Copy channel array if applicable */
894 brcmf_dbg(SCAN, "### List of channelspecs to scan ### %d\n",
896 if (n_channels > 0) {
897 for (i = 0; i < n_channels; i++) {
898 chanspec = channel_to_chanspec(&cfg->d11inf,
899 request->channels[i]);
900 brcmf_dbg(SCAN, "Chan : %d, Channel spec: %x\n",
901 request->channels[i]->hw_value, chanspec);
902 params_le->channel_list[i] = cpu_to_le16(chanspec);
905 brcmf_dbg(SCAN, "Scanning all channels\n");
907 /* Copy ssid array if applicable */
908 brcmf_dbg(SCAN, "### List of SSIDs to scan ### %d\n", n_ssids);
910 offset = offsetof(struct brcmf_scan_params_le, channel_list) +
911 n_channels * sizeof(u16);
912 offset = roundup(offset, sizeof(u32));
913 ptr = (char *)params_le + offset;
914 for (i = 0; i < n_ssids; i++) {
915 memset(&ssid_le, 0, sizeof(ssid_le));
917 cpu_to_le32(request->ssids[i].ssid_len);
918 memcpy(ssid_le.SSID, request->ssids[i].ssid,
919 request->ssids[i].ssid_len);
920 if (!ssid_le.SSID_len)
921 brcmf_dbg(SCAN, "%d: Broadcast scan\n", i);
923 brcmf_dbg(SCAN, "%d: scan for %s size =%d\n",
924 i, ssid_le.SSID, ssid_le.SSID_len);
925 memcpy(ptr, &ssid_le, sizeof(ssid_le));
926 ptr += sizeof(ssid_le);
929 brcmf_dbg(SCAN, "Broadcast scan %p\n", request->ssids);
930 if ((request->ssids) && request->ssids->ssid_len) {
931 brcmf_dbg(SCAN, "SSID %s len=%d\n",
932 params_le->ssid_le.SSID,
933 request->ssids->ssid_len);
934 params_le->ssid_le.SSID_len =
935 cpu_to_le32(request->ssids->ssid_len);
936 memcpy(¶ms_le->ssid_le.SSID, request->ssids->ssid,
937 request->ssids->ssid_len);
940 /* Adding mask to channel numbers */
941 params_le->channel_num =
942 cpu_to_le32((n_ssids << BRCMF_SCAN_PARAMS_NSSID_SHIFT) |
943 (n_channels & BRCMF_SCAN_PARAMS_COUNT_MASK));
947 brcmf_run_escan(struct brcmf_cfg80211_info *cfg, struct brcmf_if *ifp,
948 struct cfg80211_scan_request *request, u16 action)
950 s32 params_size = BRCMF_SCAN_PARAMS_FIXED_SIZE +
951 offsetof(struct brcmf_escan_params_le, params_le);
952 struct brcmf_escan_params_le *params;
955 brcmf_dbg(SCAN, "E-SCAN START\n");
957 if (request != NULL) {
958 /* Allocate space for populating ssids in struct */
959 params_size += sizeof(u32) * ((request->n_channels + 1) / 2);
961 /* Allocate space for populating ssids in struct */
962 params_size += sizeof(struct brcmf_ssid) * request->n_ssids;
965 params = kzalloc(params_size, GFP_KERNEL);
970 BUG_ON(params_size + sizeof("escan") >= BRCMF_DCMD_MEDLEN);
971 brcmf_escan_prep(cfg, ¶ms->params_le, request);
972 params->version = cpu_to_le32(BRCMF_ESCAN_REQ_VERSION);
973 params->action = cpu_to_le16(action);
974 params->sync_id = cpu_to_le16(0x1234);
976 err = brcmf_fil_iovar_data_set(ifp, "escan", params, params_size);
979 brcmf_dbg(INFO, "system busy : escan canceled\n");
981 brcmf_err("error (%d)\n", err);
990 brcmf_do_escan(struct brcmf_cfg80211_info *cfg, struct wiphy *wiphy,
991 struct brcmf_if *ifp, struct cfg80211_scan_request *request)
995 struct brcmf_scan_results *results;
996 struct escan_info *escan = &cfg->escan_info;
998 brcmf_dbg(SCAN, "Enter\n");
1000 escan->wiphy = wiphy;
1001 escan->escan_state = WL_ESCAN_STATE_SCANNING;
1002 passive_scan = cfg->active_scan ? 0 : 1;
1003 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_PASSIVE_SCAN,
1006 brcmf_err("error (%d)\n", err);
1009 brcmf_scan_config_mpc(ifp, 0);
1010 results = (struct brcmf_scan_results *)cfg->escan_info.escan_buf;
1011 results->version = 0;
1013 results->buflen = WL_ESCAN_RESULTS_FIXED_SIZE;
1015 err = escan->run(cfg, ifp, request, WL_ESCAN_ACTION_START);
1017 brcmf_scan_config_mpc(ifp, 1);
1022 brcmf_cfg80211_escan(struct wiphy *wiphy, struct brcmf_cfg80211_vif *vif,
1023 struct cfg80211_scan_request *request,
1024 struct cfg80211_ssid *this_ssid)
1026 struct brcmf_if *ifp = vif->ifp;
1027 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy);
1028 struct cfg80211_ssid *ssids;
1029 struct brcmf_cfg80211_scan_req *sr = &cfg->scan_req_int;
1036 brcmf_dbg(SCAN, "START ESCAN\n");
1038 if (test_bit(BRCMF_SCAN_STATUS_BUSY, &cfg->scan_status)) {
1039 brcmf_err("Scanning already: status (%lu)\n", cfg->scan_status);
1042 if (test_bit(BRCMF_SCAN_STATUS_ABORT, &cfg->scan_status)) {
1043 brcmf_err("Scanning being aborted: status (%lu)\n",
1047 if (test_bit(BRCMF_SCAN_STATUS_SUPPRESS, &cfg->scan_status)) {
1048 brcmf_err("Scanning suppressed: status (%lu)\n",
1052 if (test_bit(BRCMF_VIF_STATUS_CONNECTING, &ifp->vif->sme_state)) {
1053 brcmf_err("Connecting: status (%lu)\n", ifp->vif->sme_state);
1057 /* If scan req comes for p2p0, send it over primary I/F */
1058 if (vif == cfg->p2p.bss_idx[P2PAPI_BSSCFG_DEVICE].vif)
1059 vif = cfg->p2p.bss_idx[P2PAPI_BSSCFG_PRIMARY].vif;
1064 ssids = request->ssids;
1068 /* we don't do escan in ibss */
1072 cfg->scan_request = request;
1073 set_bit(BRCMF_SCAN_STATUS_BUSY, &cfg->scan_status);
1075 cfg->escan_info.run = brcmf_run_escan;
1076 err = brcmf_p2p_scan_prep(wiphy, request, vif);
1080 err = brcmf_do_escan(cfg, wiphy, vif->ifp, request);
1084 brcmf_dbg(SCAN, "ssid \"%s\", ssid_len (%d)\n",
1085 ssids->ssid, ssids->ssid_len);
1086 memset(&sr->ssid_le, 0, sizeof(sr->ssid_le));
1087 SSID_len = min_t(u8, sizeof(sr->ssid_le.SSID), ssids->ssid_len);
1088 sr->ssid_le.SSID_len = cpu_to_le32(0);
1091 memcpy(sr->ssid_le.SSID, ssids->ssid, SSID_len);
1092 sr->ssid_le.SSID_len = cpu_to_le32(SSID_len);
1095 brcmf_dbg(SCAN, "Broadcast scan\n");
1097 passive_scan = cfg->active_scan ? 0 : 1;
1098 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_PASSIVE_SCAN,
1101 brcmf_err("WLC_SET_PASSIVE_SCAN error (%d)\n", err);
1104 brcmf_scan_config_mpc(ifp, 0);
1105 err = brcmf_fil_cmd_data_set(ifp, BRCMF_C_SCAN,
1106 &sr->ssid_le, sizeof(sr->ssid_le));
1109 brcmf_dbg(INFO, "BUSY: scan for \"%s\" canceled\n",
1112 brcmf_err("WLC_SCAN error (%d)\n", err);
1114 brcmf_scan_config_mpc(ifp, 1);
1119 /* Arm scan timeout timer */
1120 mod_timer(&cfg->escan_timeout, jiffies +
1121 WL_ESCAN_TIMER_INTERVAL_MS * HZ / 1000);
1126 clear_bit(BRCMF_SCAN_STATUS_BUSY, &cfg->scan_status);
1127 cfg->scan_request = NULL;
1132 brcmf_cfg80211_scan(struct wiphy *wiphy, struct cfg80211_scan_request *request)
1134 struct brcmf_cfg80211_vif *vif;
1137 brcmf_dbg(TRACE, "Enter\n");
1138 vif = container_of(request->wdev, struct brcmf_cfg80211_vif, wdev);
1139 if (!check_vif_up(vif))
1142 err = brcmf_cfg80211_escan(wiphy, vif, request, NULL);
1145 brcmf_err("scan error (%d)\n", err);
1147 brcmf_dbg(TRACE, "Exit\n");
1151 static s32 brcmf_set_rts(struct net_device *ndev, u32 rts_threshold)
1155 err = brcmf_fil_iovar_int_set(netdev_priv(ndev), "rtsthresh",
1158 brcmf_err("Error (%d)\n", err);
1163 static s32 brcmf_set_frag(struct net_device *ndev, u32 frag_threshold)
1167 err = brcmf_fil_iovar_int_set(netdev_priv(ndev), "fragthresh",
1170 brcmf_err("Error (%d)\n", err);
1175 static s32 brcmf_set_retry(struct net_device *ndev, u32 retry, bool l)
1178 u32 cmd = (l ? BRCMF_C_SET_LRL : BRCMF_C_SET_SRL);
1180 err = brcmf_fil_cmd_int_set(netdev_priv(ndev), cmd, retry);
1182 brcmf_err("cmd (%d) , error (%d)\n", cmd, err);
1188 static s32 brcmf_cfg80211_set_wiphy_params(struct wiphy *wiphy, u32 changed)
1190 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy);
1191 struct net_device *ndev = cfg_to_ndev(cfg);
1192 struct brcmf_if *ifp = netdev_priv(ndev);
1195 brcmf_dbg(TRACE, "Enter\n");
1196 if (!check_vif_up(ifp->vif))
1199 if (changed & WIPHY_PARAM_RTS_THRESHOLD &&
1200 (cfg->conf->rts_threshold != wiphy->rts_threshold)) {
1201 cfg->conf->rts_threshold = wiphy->rts_threshold;
1202 err = brcmf_set_rts(ndev, cfg->conf->rts_threshold);
1206 if (changed & WIPHY_PARAM_FRAG_THRESHOLD &&
1207 (cfg->conf->frag_threshold != wiphy->frag_threshold)) {
1208 cfg->conf->frag_threshold = wiphy->frag_threshold;
1209 err = brcmf_set_frag(ndev, cfg->conf->frag_threshold);
1213 if (changed & WIPHY_PARAM_RETRY_LONG
1214 && (cfg->conf->retry_long != wiphy->retry_long)) {
1215 cfg->conf->retry_long = wiphy->retry_long;
1216 err = brcmf_set_retry(ndev, cfg->conf->retry_long, true);
1220 if (changed & WIPHY_PARAM_RETRY_SHORT
1221 && (cfg->conf->retry_short != wiphy->retry_short)) {
1222 cfg->conf->retry_short = wiphy->retry_short;
1223 err = brcmf_set_retry(ndev, cfg->conf->retry_short, false);
1229 brcmf_dbg(TRACE, "Exit\n");
1233 static void brcmf_init_prof(struct brcmf_cfg80211_profile *prof)
1235 memset(prof, 0, sizeof(*prof));
1238 static u16 brcmf_map_fw_linkdown_reason(const struct brcmf_event_msg *e)
1242 switch (e->event_code) {
1243 case BRCMF_E_DEAUTH:
1244 case BRCMF_E_DEAUTH_IND:
1245 case BRCMF_E_DISASSOC_IND:
1256 static void brcmf_link_down(struct brcmf_cfg80211_vif *vif, u16 reason)
1258 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(vif->wdev.wiphy);
1261 brcmf_dbg(TRACE, "Enter\n");
1263 if (test_bit(BRCMF_VIF_STATUS_CONNECTED, &vif->sme_state)) {
1264 brcmf_dbg(INFO, "Call WLC_DISASSOC to stop excess roaming\n ");
1265 err = brcmf_fil_cmd_data_set(vif->ifp,
1266 BRCMF_C_DISASSOC, NULL, 0);
1268 brcmf_err("WLC_DISASSOC failed (%d)\n", err);
1270 clear_bit(BRCMF_VIF_STATUS_CONNECTED, &vif->sme_state);
1271 cfg80211_disconnected(vif->wdev.netdev, reason, NULL, 0,
1275 clear_bit(BRCMF_VIF_STATUS_CONNECTING, &vif->sme_state);
1276 clear_bit(BRCMF_SCAN_STATUS_SUPPRESS, &cfg->scan_status);
1277 brcmf_btcoex_set_mode(vif, BRCMF_BTCOEX_ENABLED, 0);
1278 brcmf_dbg(TRACE, "Exit\n");
1282 brcmf_cfg80211_join_ibss(struct wiphy *wiphy, struct net_device *ndev,
1283 struct cfg80211_ibss_params *params)
1285 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy);
1286 struct brcmf_if *ifp = netdev_priv(ndev);
1287 struct brcmf_cfg80211_profile *profile = &ifp->vif->profile;
1288 struct brcmf_join_params join_params;
1289 size_t join_params_size = 0;
1295 brcmf_dbg(TRACE, "Enter\n");
1296 if (!check_vif_up(ifp->vif))
1300 brcmf_dbg(CONN, "SSID: %s\n", params->ssid);
1302 brcmf_dbg(CONN, "SSID: NULL, Not supported\n");
1306 set_bit(BRCMF_VIF_STATUS_CONNECTING, &ifp->vif->sme_state);
1309 brcmf_dbg(CONN, "BSSID: %pM\n", params->bssid);
1311 brcmf_dbg(CONN, "No BSSID specified\n");
1313 if (params->chandef.chan)
1314 brcmf_dbg(CONN, "channel: %d\n",
1315 params->chandef.chan->center_freq);
1317 brcmf_dbg(CONN, "no channel specified\n");
1319 if (params->channel_fixed)
1320 brcmf_dbg(CONN, "fixed channel required\n");
1322 brcmf_dbg(CONN, "no fixed channel required\n");
1324 if (params->ie && params->ie_len)
1325 brcmf_dbg(CONN, "ie len: %d\n", params->ie_len);
1327 brcmf_dbg(CONN, "no ie specified\n");
1329 if (params->beacon_interval)
1330 brcmf_dbg(CONN, "beacon interval: %d\n",
1331 params->beacon_interval);
1333 brcmf_dbg(CONN, "no beacon interval specified\n");
1335 if (params->basic_rates)
1336 brcmf_dbg(CONN, "basic rates: %08X\n", params->basic_rates);
1338 brcmf_dbg(CONN, "no basic rates specified\n");
1340 if (params->privacy)
1341 brcmf_dbg(CONN, "privacy required\n");
1343 brcmf_dbg(CONN, "no privacy required\n");
1345 /* Configure Privacy for starter */
1346 if (params->privacy)
1347 wsec |= WEP_ENABLED;
1349 err = brcmf_fil_iovar_int_set(ifp, "wsec", wsec);
1351 brcmf_err("wsec failed (%d)\n", err);
1355 /* Configure Beacon Interval for starter */
1356 if (params->beacon_interval)
1357 bcnprd = params->beacon_interval;
1361 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_BCNPRD, bcnprd);
1363 brcmf_err("WLC_SET_BCNPRD failed (%d)\n", err);
1367 /* Configure required join parameter */
1368 memset(&join_params, 0, sizeof(struct brcmf_join_params));
1371 profile->ssid.SSID_len = min_t(u32, params->ssid_len, 32);
1372 memcpy(profile->ssid.SSID, params->ssid, profile->ssid.SSID_len);
1373 memcpy(join_params.ssid_le.SSID, params->ssid, profile->ssid.SSID_len);
1374 join_params.ssid_le.SSID_len = cpu_to_le32(profile->ssid.SSID_len);
1375 join_params_size = sizeof(join_params.ssid_le);
1378 if (params->bssid) {
1379 memcpy(join_params.params_le.bssid, params->bssid, ETH_ALEN);
1380 join_params_size = sizeof(join_params.ssid_le) +
1381 BRCMF_ASSOC_PARAMS_FIXED_SIZE;
1382 memcpy(profile->bssid, params->bssid, ETH_ALEN);
1384 eth_broadcast_addr(join_params.params_le.bssid);
1385 eth_zero_addr(profile->bssid);
1389 if (params->chandef.chan) {
1393 ieee80211_frequency_to_channel(
1394 params->chandef.chan->center_freq);
1395 if (params->channel_fixed) {
1396 /* adding chanspec */
1397 chanspec = chandef_to_chanspec(&cfg->d11inf,
1399 join_params.params_le.chanspec_list[0] =
1400 cpu_to_le16(chanspec);
1401 join_params.params_le.chanspec_num = cpu_to_le32(1);
1402 join_params_size += sizeof(join_params.params_le);
1405 /* set channel for starter */
1406 target_channel = cfg->channel;
1407 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_CHANNEL,
1410 brcmf_err("WLC_SET_CHANNEL failed (%d)\n", err);
1416 cfg->ibss_starter = false;
1419 err = brcmf_fil_cmd_data_set(ifp, BRCMF_C_SET_SSID,
1420 &join_params, join_params_size);
1422 brcmf_err("WLC_SET_SSID failed (%d)\n", err);
1428 clear_bit(BRCMF_VIF_STATUS_CONNECTING, &ifp->vif->sme_state);
1429 brcmf_dbg(TRACE, "Exit\n");
1434 brcmf_cfg80211_leave_ibss(struct wiphy *wiphy, struct net_device *ndev)
1436 struct brcmf_if *ifp = netdev_priv(ndev);
1438 brcmf_dbg(TRACE, "Enter\n");
1439 if (!check_vif_up(ifp->vif))
1442 brcmf_link_down(ifp->vif, WLAN_REASON_DEAUTH_LEAVING);
1444 brcmf_dbg(TRACE, "Exit\n");
1449 static s32 brcmf_set_wpa_version(struct net_device *ndev,
1450 struct cfg80211_connect_params *sme)
1452 struct brcmf_cfg80211_profile *profile = ndev_to_prof(ndev);
1453 struct brcmf_cfg80211_security *sec;
1457 if (sme->crypto.wpa_versions & NL80211_WPA_VERSION_1)
1458 val = WPA_AUTH_PSK | WPA_AUTH_UNSPECIFIED;
1459 else if (sme->crypto.wpa_versions & NL80211_WPA_VERSION_2)
1460 val = WPA2_AUTH_PSK | WPA2_AUTH_UNSPECIFIED;
1462 val = WPA_AUTH_DISABLED;
1463 brcmf_dbg(CONN, "setting wpa_auth to 0x%0x\n", val);
1464 err = brcmf_fil_bsscfg_int_set(netdev_priv(ndev), "wpa_auth", val);
1466 brcmf_err("set wpa_auth failed (%d)\n", err);
1469 sec = &profile->sec;
1470 sec->wpa_versions = sme->crypto.wpa_versions;
1474 static s32 brcmf_set_auth_type(struct net_device *ndev,
1475 struct cfg80211_connect_params *sme)
1477 struct brcmf_cfg80211_profile *profile = ndev_to_prof(ndev);
1478 struct brcmf_cfg80211_security *sec;
1482 switch (sme->auth_type) {
1483 case NL80211_AUTHTYPE_OPEN_SYSTEM:
1485 brcmf_dbg(CONN, "open system\n");
1487 case NL80211_AUTHTYPE_SHARED_KEY:
1489 brcmf_dbg(CONN, "shared key\n");
1491 case NL80211_AUTHTYPE_AUTOMATIC:
1493 brcmf_dbg(CONN, "automatic\n");
1495 case NL80211_AUTHTYPE_NETWORK_EAP:
1496 brcmf_dbg(CONN, "network eap\n");
1499 brcmf_err("invalid auth type (%d)\n", sme->auth_type);
1503 err = brcmf_fil_bsscfg_int_set(netdev_priv(ndev), "auth", val);
1505 brcmf_err("set auth failed (%d)\n", err);
1508 sec = &profile->sec;
1509 sec->auth_type = sme->auth_type;
1514 brcmf_set_wsec_mode(struct net_device *ndev,
1515 struct cfg80211_connect_params *sme, bool mfp)
1517 struct brcmf_cfg80211_profile *profile = ndev_to_prof(ndev);
1518 struct brcmf_cfg80211_security *sec;
1524 if (sme->crypto.n_ciphers_pairwise) {
1525 switch (sme->crypto.ciphers_pairwise[0]) {
1526 case WLAN_CIPHER_SUITE_WEP40:
1527 case WLAN_CIPHER_SUITE_WEP104:
1530 case WLAN_CIPHER_SUITE_TKIP:
1531 pval = TKIP_ENABLED;
1533 case WLAN_CIPHER_SUITE_CCMP:
1536 case WLAN_CIPHER_SUITE_AES_CMAC:
1540 brcmf_err("invalid cipher pairwise (%d)\n",
1541 sme->crypto.ciphers_pairwise[0]);
1545 if (sme->crypto.cipher_group) {
1546 switch (sme->crypto.cipher_group) {
1547 case WLAN_CIPHER_SUITE_WEP40:
1548 case WLAN_CIPHER_SUITE_WEP104:
1551 case WLAN_CIPHER_SUITE_TKIP:
1552 gval = TKIP_ENABLED;
1554 case WLAN_CIPHER_SUITE_CCMP:
1557 case WLAN_CIPHER_SUITE_AES_CMAC:
1561 brcmf_err("invalid cipher group (%d)\n",
1562 sme->crypto.cipher_group);
1567 brcmf_dbg(CONN, "pval (%d) gval (%d)\n", pval, gval);
1568 /* In case of privacy, but no security and WPS then simulate */
1569 /* setting AES. WPS-2.0 allows no security */
1570 if (brcmf_find_wpsie(sme->ie, sme->ie_len) && !pval && !gval &&
1575 wsec = pval | gval | MFP_CAPABLE;
1578 err = brcmf_fil_bsscfg_int_set(netdev_priv(ndev), "wsec", wsec);
1580 brcmf_err("error (%d)\n", err);
1584 sec = &profile->sec;
1585 sec->cipher_pairwise = sme->crypto.ciphers_pairwise[0];
1586 sec->cipher_group = sme->crypto.cipher_group;
1592 brcmf_set_key_mgmt(struct net_device *ndev, struct cfg80211_connect_params *sme)
1594 struct brcmf_cfg80211_profile *profile = ndev_to_prof(ndev);
1595 struct brcmf_cfg80211_security *sec;
1599 if (sme->crypto.n_akm_suites) {
1600 err = brcmf_fil_bsscfg_int_get(netdev_priv(ndev),
1603 brcmf_err("could not get wpa_auth (%d)\n", err);
1606 if (val & (WPA_AUTH_PSK | WPA_AUTH_UNSPECIFIED)) {
1607 switch (sme->crypto.akm_suites[0]) {
1608 case WLAN_AKM_SUITE_8021X:
1609 val = WPA_AUTH_UNSPECIFIED;
1611 case WLAN_AKM_SUITE_PSK:
1615 brcmf_err("invalid cipher group (%d)\n",
1616 sme->crypto.cipher_group);
1619 } else if (val & (WPA2_AUTH_PSK | WPA2_AUTH_UNSPECIFIED)) {
1620 switch (sme->crypto.akm_suites[0]) {
1621 case WLAN_AKM_SUITE_8021X:
1622 val = WPA2_AUTH_UNSPECIFIED;
1624 case WLAN_AKM_SUITE_PSK:
1625 val = WPA2_AUTH_PSK;
1628 brcmf_err("invalid cipher group (%d)\n",
1629 sme->crypto.cipher_group);
1634 brcmf_dbg(CONN, "setting wpa_auth to %d\n", val);
1635 err = brcmf_fil_bsscfg_int_set(netdev_priv(ndev),
1638 brcmf_err("could not set wpa_auth (%d)\n", err);
1642 sec = &profile->sec;
1643 sec->wpa_auth = sme->crypto.akm_suites[0];
1649 brcmf_set_sharedkey(struct net_device *ndev,
1650 struct cfg80211_connect_params *sme)
1652 struct brcmf_cfg80211_profile *profile = ndev_to_prof(ndev);
1653 struct brcmf_cfg80211_security *sec;
1654 struct brcmf_wsec_key key;
1658 brcmf_dbg(CONN, "key len (%d)\n", sme->key_len);
1660 if (sme->key_len == 0)
1663 sec = &profile->sec;
1664 brcmf_dbg(CONN, "wpa_versions 0x%x cipher_pairwise 0x%x\n",
1665 sec->wpa_versions, sec->cipher_pairwise);
1667 if (sec->wpa_versions & (NL80211_WPA_VERSION_1 | NL80211_WPA_VERSION_2))
1670 if (!(sec->cipher_pairwise &
1671 (WLAN_CIPHER_SUITE_WEP40 | WLAN_CIPHER_SUITE_WEP104)))
1674 memset(&key, 0, sizeof(key));
1675 key.len = (u32) sme->key_len;
1676 key.index = (u32) sme->key_idx;
1677 if (key.len > sizeof(key.data)) {
1678 brcmf_err("Too long key length (%u)\n", key.len);
1681 memcpy(key.data, sme->key, key.len);
1682 key.flags = BRCMF_PRIMARY_KEY;
1683 switch (sec->cipher_pairwise) {
1684 case WLAN_CIPHER_SUITE_WEP40:
1685 key.algo = CRYPTO_ALGO_WEP1;
1687 case WLAN_CIPHER_SUITE_WEP104:
1688 key.algo = CRYPTO_ALGO_WEP128;
1691 brcmf_err("Invalid algorithm (%d)\n",
1692 sme->crypto.ciphers_pairwise[0]);
1695 /* Set the new key/index */
1696 brcmf_dbg(CONN, "key length (%d) key index (%d) algo (%d)\n",
1697 key.len, key.index, key.algo);
1698 brcmf_dbg(CONN, "key \"%s\"\n", key.data);
1699 err = send_key_to_dongle(netdev_priv(ndev), &key);
1703 if (sec->auth_type == NL80211_AUTHTYPE_SHARED_KEY) {
1704 brcmf_dbg(CONN, "set auth_type to shared key\n");
1705 val = WL_AUTH_SHARED_KEY; /* shared key */
1706 err = brcmf_fil_bsscfg_int_set(netdev_priv(ndev), "auth", val);
1708 brcmf_err("set auth failed (%d)\n", err);
1714 enum nl80211_auth_type brcmf_war_auth_type(struct brcmf_if *ifp,
1715 enum nl80211_auth_type type)
1717 if (type == NL80211_AUTHTYPE_AUTOMATIC &&
1718 brcmf_feat_is_quirk_enabled(ifp, BRCMF_FEAT_QUIRK_AUTO_AUTH)) {
1719 brcmf_dbg(CONN, "WAR: use OPEN instead of AUTO\n");
1720 type = NL80211_AUTHTYPE_OPEN_SYSTEM;
1726 brcmf_cfg80211_connect(struct wiphy *wiphy, struct net_device *ndev,
1727 struct cfg80211_connect_params *sme)
1729 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy);
1730 struct brcmf_if *ifp = netdev_priv(ndev);
1731 struct brcmf_cfg80211_profile *profile = &ifp->vif->profile;
1732 struct ieee80211_channel *chan = sme->channel;
1733 struct brcmf_join_params join_params;
1734 size_t join_params_size;
1735 const struct brcmf_tlv *rsn_ie;
1736 const struct brcmf_vs_tlv *wpa_ie;
1739 struct brcmf_ext_join_params_le *ext_join_params;
1743 brcmf_dbg(TRACE, "Enter\n");
1744 if (!check_vif_up(ifp->vif))
1748 brcmf_err("Invalid ssid\n");
1752 if (ifp->vif == cfg->p2p.bss_idx[P2PAPI_BSSCFG_PRIMARY].vif) {
1753 /* A normal (non P2P) connection request setup. */
1756 /* find the WPA_IE */
1757 wpa_ie = brcmf_find_wpaie((u8 *)sme->ie, sme->ie_len);
1760 ie_len = wpa_ie->len + TLV_HDR_LEN;
1762 /* find the RSN_IE */
1763 rsn_ie = brcmf_parse_tlvs((const u8 *)sme->ie,
1768 ie_len = rsn_ie->len + TLV_HDR_LEN;
1771 brcmf_fil_iovar_data_set(ifp, "wpaie", ie, ie_len);
1774 err = brcmf_vif_set_mgmt_ie(ifp->vif, BRCMF_VNDR_IE_ASSOCREQ_FLAG,
1775 sme->ie, sme->ie_len);
1777 brcmf_err("Set Assoc REQ IE Failed\n");
1779 brcmf_dbg(TRACE, "Applied Vndr IEs for Assoc request\n");
1781 set_bit(BRCMF_VIF_STATUS_CONNECTING, &ifp->vif->sme_state);
1785 ieee80211_frequency_to_channel(chan->center_freq);
1786 chanspec = channel_to_chanspec(&cfg->d11inf, chan);
1787 brcmf_dbg(CONN, "channel=%d, center_req=%d, chanspec=0x%04x\n",
1788 cfg->channel, chan->center_freq, chanspec);
1794 brcmf_dbg(INFO, "ie (%p), ie_len (%zd)\n", sme->ie, sme->ie_len);
1796 err = brcmf_set_wpa_version(ndev, sme);
1798 brcmf_err("wl_set_wpa_version failed (%d)\n", err);
1802 sme->auth_type = brcmf_war_auth_type(ifp, sme->auth_type);
1803 err = brcmf_set_auth_type(ndev, sme);
1805 brcmf_err("wl_set_auth_type failed (%d)\n", err);
1809 err = brcmf_set_wsec_mode(ndev, sme, sme->mfp == NL80211_MFP_REQUIRED);
1811 brcmf_err("wl_set_set_cipher failed (%d)\n", err);
1815 err = brcmf_set_key_mgmt(ndev, sme);
1817 brcmf_err("wl_set_key_mgmt failed (%d)\n", err);
1821 err = brcmf_set_sharedkey(ndev, sme);
1823 brcmf_err("brcmf_set_sharedkey failed (%d)\n", err);
1827 profile->ssid.SSID_len = min_t(u32, (u32)sizeof(profile->ssid.SSID),
1828 (u32)sme->ssid_len);
1829 memcpy(&profile->ssid.SSID, sme->ssid, profile->ssid.SSID_len);
1830 if (profile->ssid.SSID_len < IEEE80211_MAX_SSID_LEN) {
1831 profile->ssid.SSID[profile->ssid.SSID_len] = 0;
1832 brcmf_dbg(CONN, "SSID \"%s\", len (%d)\n", profile->ssid.SSID,
1833 profile->ssid.SSID_len);
1836 /* Join with specific BSSID and cached SSID
1837 * If SSID is zero join based on BSSID only
1839 join_params_size = offsetof(struct brcmf_ext_join_params_le, assoc_le) +
1840 offsetof(struct brcmf_assoc_params_le, chanspec_list);
1842 join_params_size += sizeof(u16);
1843 ext_join_params = kzalloc(join_params_size, GFP_KERNEL);
1844 if (ext_join_params == NULL) {
1848 ext_join_params->ssid_le.SSID_len = cpu_to_le32(profile->ssid.SSID_len);
1849 memcpy(&ext_join_params->ssid_le.SSID, sme->ssid,
1850 profile->ssid.SSID_len);
1852 /* Set up join scan parameters */
1853 ext_join_params->scan_le.scan_type = -1;
1854 ext_join_params->scan_le.home_time = cpu_to_le32(-1);
1857 memcpy(&ext_join_params->assoc_le.bssid, sme->bssid, ETH_ALEN);
1859 eth_broadcast_addr(ext_join_params->assoc_le.bssid);
1862 ext_join_params->assoc_le.chanspec_num = cpu_to_le32(1);
1864 ext_join_params->assoc_le.chanspec_list[0] =
1865 cpu_to_le16(chanspec);
1866 /* Increase dwell time to receive probe response or detect
1867 * beacon from target AP at a noisy air only during connect
1870 ext_join_params->scan_le.active_time =
1871 cpu_to_le32(BRCMF_SCAN_JOIN_ACTIVE_DWELL_TIME_MS);
1872 ext_join_params->scan_le.passive_time =
1873 cpu_to_le32(BRCMF_SCAN_JOIN_PASSIVE_DWELL_TIME_MS);
1874 /* To sync with presence period of VSDB GO send probe request
1875 * more frequently. Probe request will be stopped when it gets
1876 * probe response from target AP/GO.
1878 ext_join_params->scan_le.nprobes =
1879 cpu_to_le32(BRCMF_SCAN_JOIN_ACTIVE_DWELL_TIME_MS /
1880 BRCMF_SCAN_JOIN_PROBE_INTERVAL_MS);
1882 ext_join_params->scan_le.active_time = cpu_to_le32(-1);
1883 ext_join_params->scan_le.passive_time = cpu_to_le32(-1);
1884 ext_join_params->scan_le.nprobes = cpu_to_le32(-1);
1887 err = brcmf_fil_bsscfg_data_set(ifp, "join", ext_join_params,
1889 kfree(ext_join_params);
1891 /* This is it. join command worked, we are done */
1894 /* join command failed, fallback to set ssid */
1895 memset(&join_params, 0, sizeof(join_params));
1896 join_params_size = sizeof(join_params.ssid_le);
1898 memcpy(&join_params.ssid_le.SSID, sme->ssid, profile->ssid.SSID_len);
1899 join_params.ssid_le.SSID_len = cpu_to_le32(profile->ssid.SSID_len);
1902 memcpy(join_params.params_le.bssid, sme->bssid, ETH_ALEN);
1904 eth_broadcast_addr(join_params.params_le.bssid);
1907 join_params.params_le.chanspec_list[0] = cpu_to_le16(chanspec);
1908 join_params.params_le.chanspec_num = cpu_to_le32(1);
1909 join_params_size += sizeof(join_params.params_le);
1911 err = brcmf_fil_cmd_data_set(ifp, BRCMF_C_SET_SSID,
1912 &join_params, join_params_size);
1914 brcmf_err("BRCMF_C_SET_SSID failed (%d)\n", err);
1918 clear_bit(BRCMF_VIF_STATUS_CONNECTING, &ifp->vif->sme_state);
1919 brcmf_dbg(TRACE, "Exit\n");
1924 brcmf_cfg80211_disconnect(struct wiphy *wiphy, struct net_device *ndev,
1927 struct brcmf_if *ifp = netdev_priv(ndev);
1928 struct brcmf_cfg80211_profile *profile = &ifp->vif->profile;
1929 struct brcmf_scb_val_le scbval;
1932 brcmf_dbg(TRACE, "Enter. Reason code = %d\n", reason_code);
1933 if (!check_vif_up(ifp->vif))
1936 clear_bit(BRCMF_VIF_STATUS_CONNECTED, &ifp->vif->sme_state);
1937 clear_bit(BRCMF_VIF_STATUS_CONNECTING, &ifp->vif->sme_state);
1938 cfg80211_disconnected(ndev, reason_code, NULL, 0, true, GFP_KERNEL);
1940 memcpy(&scbval.ea, &profile->bssid, ETH_ALEN);
1941 scbval.val = cpu_to_le32(reason_code);
1942 err = brcmf_fil_cmd_data_set(ifp, BRCMF_C_DISASSOC,
1943 &scbval, sizeof(scbval));
1945 brcmf_err("error (%d)\n", err);
1947 brcmf_dbg(TRACE, "Exit\n");
1952 brcmf_cfg80211_set_tx_power(struct wiphy *wiphy, struct wireless_dev *wdev,
1953 enum nl80211_tx_power_setting type, s32 mbm)
1955 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy);
1956 struct net_device *ndev = cfg_to_ndev(cfg);
1957 struct brcmf_if *ifp = netdev_priv(ndev);
1962 brcmf_dbg(TRACE, "Enter %d %d\n", type, mbm);
1963 if (!check_vif_up(ifp->vif))
1967 case NL80211_TX_POWER_AUTOMATIC:
1969 case NL80211_TX_POWER_LIMITED:
1970 case NL80211_TX_POWER_FIXED:
1972 brcmf_err("TX_POWER_FIXED - dbm is negative\n");
1976 qdbm = MBM_TO_DBM(4 * mbm);
1979 qdbm |= WL_TXPWR_OVERRIDE;
1982 brcmf_err("Unsupported type %d\n", type);
1986 /* Make sure radio is off or on as far as software is concerned */
1987 disable = WL_RADIO_SW_DISABLE << 16;
1988 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_RADIO, disable);
1990 brcmf_err("WLC_SET_RADIO error (%d)\n", err);
1992 err = brcmf_fil_iovar_int_set(ifp, "qtxpower", qdbm);
1994 brcmf_err("qtxpower error (%d)\n", err);
1997 brcmf_dbg(TRACE, "Exit %d (qdbm)\n", qdbm & ~WL_TXPWR_OVERRIDE);
2002 brcmf_cfg80211_get_tx_power(struct wiphy *wiphy, struct wireless_dev *wdev,
2005 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy);
2006 struct net_device *ndev = cfg_to_ndev(cfg);
2007 struct brcmf_if *ifp = netdev_priv(ndev);
2011 brcmf_dbg(TRACE, "Enter\n");
2012 if (!check_vif_up(ifp->vif))
2015 err = brcmf_fil_iovar_int_get(ifp, "qtxpower", &qdbm);
2017 brcmf_err("error (%d)\n", err);
2020 *dbm = (qdbm & ~WL_TXPWR_OVERRIDE) / 4;
2023 brcmf_dbg(TRACE, "Exit (0x%x %d)\n", qdbm, *dbm);
2028 brcmf_cfg80211_config_default_key(struct wiphy *wiphy, struct net_device *ndev,
2029 u8 key_idx, bool unicast, bool multicast)
2031 struct brcmf_if *ifp = netdev_priv(ndev);
2036 brcmf_dbg(TRACE, "Enter\n");
2037 brcmf_dbg(CONN, "key index (%d)\n", key_idx);
2038 if (!check_vif_up(ifp->vif))
2041 err = brcmf_fil_bsscfg_int_get(ifp, "wsec", &wsec);
2043 brcmf_err("WLC_GET_WSEC error (%d)\n", err);
2047 if (wsec & WEP_ENABLED) {
2048 /* Just select a new current key */
2050 err = brcmf_fil_cmd_int_set(ifp,
2051 BRCMF_C_SET_KEY_PRIMARY, index);
2053 brcmf_err("error (%d)\n", err);
2056 brcmf_dbg(TRACE, "Exit\n");
2061 brcmf_add_keyext(struct wiphy *wiphy, struct net_device *ndev,
2062 u8 key_idx, const u8 *mac_addr, struct key_params *params)
2064 struct brcmf_if *ifp = netdev_priv(ndev);
2065 struct brcmf_wsec_key key;
2069 memset(&key, 0, sizeof(key));
2070 key.index = (u32) key_idx;
2071 /* Instead of bcast for ea address for default wep keys,
2072 driver needs it to be Null */
2073 if (!is_multicast_ether_addr(mac_addr))
2074 memcpy((char *)&key.ea, (void *)mac_addr, ETH_ALEN);
2075 key.len = (u32) params->key_len;
2076 /* check for key index change */
2079 err = send_key_to_dongle(ifp, &key);
2081 brcmf_err("key delete error (%d)\n", err);
2083 if (key.len > sizeof(key.data)) {
2084 brcmf_err("Invalid key length (%d)\n", key.len);
2088 brcmf_dbg(CONN, "Setting the key index %d\n", key.index);
2089 memcpy(key.data, params->key, key.len);
2091 if (!brcmf_is_apmode(ifp->vif) &&
2092 (params->cipher == WLAN_CIPHER_SUITE_TKIP)) {
2093 brcmf_dbg(CONN, "Swapping RX/TX MIC key\n");
2094 memcpy(keybuf, &key.data[24], sizeof(keybuf));
2095 memcpy(&key.data[24], &key.data[16], sizeof(keybuf));
2096 memcpy(&key.data[16], keybuf, sizeof(keybuf));
2099 /* if IW_ENCODE_EXT_RX_SEQ_VALID set */
2100 if (params->seq && params->seq_len == 6) {
2103 ivptr = (u8 *) params->seq;
2104 key.rxiv.hi = (ivptr[5] << 24) | (ivptr[4] << 16) |
2105 (ivptr[3] << 8) | ivptr[2];
2106 key.rxiv.lo = (ivptr[1] << 8) | ivptr[0];
2107 key.iv_initialized = true;
2110 switch (params->cipher) {
2111 case WLAN_CIPHER_SUITE_WEP40:
2112 key.algo = CRYPTO_ALGO_WEP1;
2113 brcmf_dbg(CONN, "WLAN_CIPHER_SUITE_WEP40\n");
2115 case WLAN_CIPHER_SUITE_WEP104:
2116 key.algo = CRYPTO_ALGO_WEP128;
2117 brcmf_dbg(CONN, "WLAN_CIPHER_SUITE_WEP104\n");
2119 case WLAN_CIPHER_SUITE_TKIP:
2120 key.algo = CRYPTO_ALGO_TKIP;
2121 brcmf_dbg(CONN, "WLAN_CIPHER_SUITE_TKIP\n");
2123 case WLAN_CIPHER_SUITE_AES_CMAC:
2124 key.algo = CRYPTO_ALGO_AES_CCM;
2125 brcmf_dbg(CONN, "WLAN_CIPHER_SUITE_AES_CMAC\n");
2127 case WLAN_CIPHER_SUITE_CCMP:
2128 key.algo = CRYPTO_ALGO_AES_CCM;
2129 brcmf_dbg(CONN, "WLAN_CIPHER_SUITE_CCMP\n");
2132 brcmf_err("Invalid cipher (0x%x)\n", params->cipher);
2135 err = send_key_to_dongle(ifp, &key);
2137 brcmf_err("wsec_key error (%d)\n", err);
2143 brcmf_cfg80211_add_key(struct wiphy *wiphy, struct net_device *ndev,
2144 u8 key_idx, bool pairwise, const u8 *mac_addr,
2145 struct key_params *params)
2147 struct brcmf_if *ifp = netdev_priv(ndev);
2148 struct brcmf_wsec_key *key;
2154 brcmf_dbg(TRACE, "Enter\n");
2155 brcmf_dbg(CONN, "key index (%d)\n", key_idx);
2156 if (!check_vif_up(ifp->vif))
2159 if (key_idx >= BRCMF_MAX_DEFAULT_KEYS) {
2160 /* we ignore this key index in this case */
2161 brcmf_err("invalid key index (%d)\n", key_idx);
2166 (params->cipher != WLAN_CIPHER_SUITE_WEP40) &&
2167 (params->cipher != WLAN_CIPHER_SUITE_WEP104)) {
2168 brcmf_dbg(TRACE, "Exit");
2169 return brcmf_add_keyext(wiphy, ndev, key_idx, mac_addr, params);
2172 key = &ifp->vif->profile.key[key_idx];
2173 memset(key, 0, sizeof(*key));
2175 if (params->key_len > sizeof(key->data)) {
2176 brcmf_err("Too long key length (%u)\n", params->key_len);
2180 key->len = params->key_len;
2181 key->index = key_idx;
2183 memcpy(key->data, params->key, key->len);
2185 key->flags = BRCMF_PRIMARY_KEY;
2186 switch (params->cipher) {
2187 case WLAN_CIPHER_SUITE_WEP40:
2188 key->algo = CRYPTO_ALGO_WEP1;
2190 brcmf_dbg(CONN, "WLAN_CIPHER_SUITE_WEP40\n");
2192 case WLAN_CIPHER_SUITE_WEP104:
2193 key->algo = CRYPTO_ALGO_WEP128;
2195 brcmf_dbg(CONN, "WLAN_CIPHER_SUITE_WEP104\n");
2197 case WLAN_CIPHER_SUITE_TKIP:
2198 if (!brcmf_is_apmode(ifp->vif)) {
2199 brcmf_dbg(CONN, "Swapping RX/TX MIC key\n");
2200 memcpy(keybuf, &key->data[24], sizeof(keybuf));
2201 memcpy(&key->data[24], &key->data[16], sizeof(keybuf));
2202 memcpy(&key->data[16], keybuf, sizeof(keybuf));
2204 key->algo = CRYPTO_ALGO_TKIP;
2206 brcmf_dbg(CONN, "WLAN_CIPHER_SUITE_TKIP\n");
2208 case WLAN_CIPHER_SUITE_AES_CMAC:
2209 key->algo = CRYPTO_ALGO_AES_CCM;
2211 brcmf_dbg(CONN, "WLAN_CIPHER_SUITE_AES_CMAC\n");
2213 case WLAN_CIPHER_SUITE_CCMP:
2214 key->algo = CRYPTO_ALGO_AES_CCM;
2216 brcmf_dbg(CONN, "WLAN_CIPHER_SUITE_CCMP\n");
2219 brcmf_err("Invalid cipher (0x%x)\n", params->cipher);
2224 err = send_key_to_dongle(ifp, key);
2228 err = brcmf_fil_bsscfg_int_get(ifp, "wsec", &wsec);
2230 brcmf_err("get wsec error (%d)\n", err);
2234 err = brcmf_fil_bsscfg_int_set(ifp, "wsec", wsec);
2236 brcmf_err("set wsec error (%d)\n", err);
2241 brcmf_dbg(TRACE, "Exit\n");
2246 brcmf_cfg80211_del_key(struct wiphy *wiphy, struct net_device *ndev,
2247 u8 key_idx, bool pairwise, const u8 *mac_addr)
2249 struct brcmf_if *ifp = netdev_priv(ndev);
2250 struct brcmf_wsec_key key;
2253 brcmf_dbg(TRACE, "Enter\n");
2254 if (!check_vif_up(ifp->vif))
2257 if (key_idx >= BRCMF_MAX_DEFAULT_KEYS) {
2258 /* we ignore this key index in this case */
2262 memset(&key, 0, sizeof(key));
2264 key.index = (u32) key_idx;
2265 key.flags = BRCMF_PRIMARY_KEY;
2266 key.algo = CRYPTO_ALGO_OFF;
2268 brcmf_dbg(CONN, "key index (%d)\n", key_idx);
2270 /* Set the new key/index */
2271 err = send_key_to_dongle(ifp, &key);
2273 brcmf_dbg(TRACE, "Exit\n");
2278 brcmf_cfg80211_get_key(struct wiphy *wiphy, struct net_device *ndev,
2279 u8 key_idx, bool pairwise, const u8 *mac_addr, void *cookie,
2280 void (*callback) (void *cookie, struct key_params * params))
2282 struct key_params params;
2283 struct brcmf_if *ifp = netdev_priv(ndev);
2284 struct brcmf_cfg80211_profile *profile = &ifp->vif->profile;
2285 struct brcmf_cfg80211_security *sec;
2289 brcmf_dbg(TRACE, "Enter\n");
2290 brcmf_dbg(CONN, "key index (%d)\n", key_idx);
2291 if (!check_vif_up(ifp->vif))
2294 memset(¶ms, 0, sizeof(params));
2296 err = brcmf_fil_bsscfg_int_get(ifp, "wsec", &wsec);
2298 brcmf_err("WLC_GET_WSEC error (%d)\n", err);
2299 /* Ignore this error, may happen during DISASSOC */
2303 if (wsec & WEP_ENABLED) {
2304 sec = &profile->sec;
2305 if (sec->cipher_pairwise & WLAN_CIPHER_SUITE_WEP40) {
2306 params.cipher = WLAN_CIPHER_SUITE_WEP40;
2307 brcmf_dbg(CONN, "WLAN_CIPHER_SUITE_WEP40\n");
2308 } else if (sec->cipher_pairwise & WLAN_CIPHER_SUITE_WEP104) {
2309 params.cipher = WLAN_CIPHER_SUITE_WEP104;
2310 brcmf_dbg(CONN, "WLAN_CIPHER_SUITE_WEP104\n");
2312 } else if (wsec & TKIP_ENABLED) {
2313 params.cipher = WLAN_CIPHER_SUITE_TKIP;
2314 brcmf_dbg(CONN, "WLAN_CIPHER_SUITE_TKIP\n");
2315 } else if (wsec & AES_ENABLED) {
2316 params.cipher = WLAN_CIPHER_SUITE_AES_CMAC;
2317 brcmf_dbg(CONN, "WLAN_CIPHER_SUITE_AES_CMAC\n");
2319 brcmf_err("Invalid algo (0x%x)\n", wsec);
2323 callback(cookie, ¶ms);
2326 brcmf_dbg(TRACE, "Exit\n");
2331 brcmf_cfg80211_config_default_mgmt_key(struct wiphy *wiphy,
2332 struct net_device *ndev, u8 key_idx)
2334 brcmf_dbg(INFO, "Not supported\n");
2340 brcmf_cfg80211_reconfigure_wep(struct brcmf_if *ifp)
2344 struct brcmf_wsec_key *key;
2347 for (key_idx = 0; key_idx < BRCMF_MAX_DEFAULT_KEYS; key_idx++) {
2348 key = &ifp->vif->profile.key[key_idx];
2349 if ((key->algo == CRYPTO_ALGO_WEP1) ||
2350 (key->algo == CRYPTO_ALGO_WEP128))
2353 if (key_idx == BRCMF_MAX_DEFAULT_KEYS)
2356 err = send_key_to_dongle(ifp, key);
2358 brcmf_err("Setting WEP key failed (%d)\n", err);
2361 err = brcmf_fil_bsscfg_int_get(ifp, "wsec", &wsec);
2363 brcmf_err("get wsec error (%d)\n", err);
2366 wsec |= WEP_ENABLED;
2367 err = brcmf_fil_bsscfg_int_set(ifp, "wsec", wsec);
2369 brcmf_err("set wsec error (%d)\n", err);
2372 static void brcmf_convert_sta_flags(u32 fw_sta_flags, struct station_info *si)
2374 struct nl80211_sta_flag_update *sfu;
2376 brcmf_dbg(TRACE, "flags %08x\n", fw_sta_flags);
2377 si->filled |= BIT(NL80211_STA_INFO_STA_FLAGS);
2378 sfu = &si->sta_flags;
2379 sfu->mask = BIT(NL80211_STA_FLAG_WME) |
2380 BIT(NL80211_STA_FLAG_AUTHENTICATED) |
2381 BIT(NL80211_STA_FLAG_ASSOCIATED) |
2382 BIT(NL80211_STA_FLAG_AUTHORIZED);
2383 if (fw_sta_flags & BRCMF_STA_WME)
2384 sfu->set |= BIT(NL80211_STA_FLAG_WME);
2385 if (fw_sta_flags & BRCMF_STA_AUTHE)
2386 sfu->set |= BIT(NL80211_STA_FLAG_AUTHENTICATED);
2387 if (fw_sta_flags & BRCMF_STA_ASSOC)
2388 sfu->set |= BIT(NL80211_STA_FLAG_ASSOCIATED);
2389 if (fw_sta_flags & BRCMF_STA_AUTHO)
2390 sfu->set |= BIT(NL80211_STA_FLAG_AUTHORIZED);
2393 static void brcmf_fill_bss_param(struct brcmf_if *ifp, struct station_info *si)
2397 struct brcmf_bss_info_le bss_le;
2402 buf = kzalloc(WL_BSS_INFO_MAX, GFP_KERNEL);
2406 buf->len = cpu_to_le32(WL_BSS_INFO_MAX);
2407 err = brcmf_fil_cmd_data_get(ifp, BRCMF_C_GET_BSS_INFO, buf,
2410 brcmf_err("Failed to get bss info (%d)\n", err);
2413 si->filled |= BIT(NL80211_STA_INFO_BSS_PARAM);
2414 si->bss_param.beacon_interval = le16_to_cpu(buf->bss_le.beacon_period);
2415 si->bss_param.dtim_period = buf->bss_le.dtim_period;
2416 capability = le16_to_cpu(buf->bss_le.capability);
2417 if (capability & IEEE80211_HT_STBC_PARAM_DUAL_CTS_PROT)
2418 si->bss_param.flags |= BSS_PARAM_FLAGS_CTS_PROT;
2419 if (capability & WLAN_CAPABILITY_SHORT_PREAMBLE)
2420 si->bss_param.flags |= BSS_PARAM_FLAGS_SHORT_PREAMBLE;
2421 if (capability & WLAN_CAPABILITY_SHORT_SLOT_TIME)
2422 si->bss_param.flags |= BSS_PARAM_FLAGS_SHORT_SLOT_TIME;
2426 brcmf_cfg80211_get_station(struct wiphy *wiphy, struct net_device *ndev,
2427 const u8 *mac, struct station_info *sinfo)
2429 struct brcmf_if *ifp = netdev_priv(ndev);
2431 struct brcmf_sta_info_le sta_info_le;
2438 brcmf_dbg(TRACE, "Enter, MAC %pM\n", mac);
2439 if (!check_vif_up(ifp->vif))
2442 memset(&sta_info_le, 0, sizeof(sta_info_le));
2443 memcpy(&sta_info_le, mac, ETH_ALEN);
2444 err = brcmf_fil_iovar_data_get(ifp, "tdls_sta_info",
2446 sizeof(sta_info_le));
2447 is_tdls_peer = !err;
2449 err = brcmf_fil_iovar_data_get(ifp, "sta_info",
2451 sizeof(sta_info_le));
2453 brcmf_err("GET STA INFO failed, %d\n", err);
2457 brcmf_dbg(TRACE, "version %d\n", le16_to_cpu(sta_info_le.ver));
2458 sinfo->filled = BIT(NL80211_STA_INFO_INACTIVE_TIME);
2459 sinfo->inactive_time = le32_to_cpu(sta_info_le.idle) * 1000;
2460 sta_flags = le32_to_cpu(sta_info_le.flags);
2461 brcmf_convert_sta_flags(sta_flags, sinfo);
2462 sinfo->sta_flags.mask |= BIT(NL80211_STA_FLAG_TDLS_PEER);
2464 sinfo->sta_flags.set |= BIT(NL80211_STA_FLAG_TDLS_PEER);
2466 sinfo->sta_flags.set &= ~BIT(NL80211_STA_FLAG_TDLS_PEER);
2467 if (sta_flags & BRCMF_STA_ASSOC) {
2468 sinfo->filled |= BIT(NL80211_STA_INFO_CONNECTED_TIME);
2469 sinfo->connected_time = le32_to_cpu(sta_info_le.in);
2470 brcmf_fill_bss_param(ifp, sinfo);
2472 if (sta_flags & BRCMF_STA_SCBSTATS) {
2473 sinfo->filled |= BIT(NL80211_STA_INFO_TX_FAILED);
2474 sinfo->tx_failed = le32_to_cpu(sta_info_le.tx_failures);
2475 sinfo->filled |= BIT(NL80211_STA_INFO_TX_PACKETS);
2476 sinfo->tx_packets = le32_to_cpu(sta_info_le.tx_pkts);
2477 sinfo->tx_packets += le32_to_cpu(sta_info_le.tx_mcast_pkts);
2478 sinfo->filled |= BIT(NL80211_STA_INFO_RX_PACKETS);
2479 sinfo->rx_packets = le32_to_cpu(sta_info_le.rx_ucast_pkts);
2480 sinfo->rx_packets += le32_to_cpu(sta_info_le.rx_mcast_pkts);
2481 if (sinfo->tx_packets) {
2482 sinfo->filled |= BIT(NL80211_STA_INFO_TX_BITRATE);
2483 sinfo->txrate.legacy =
2484 le32_to_cpu(sta_info_le.tx_rate) / 100;
2486 if (sinfo->rx_packets) {
2487 sinfo->filled |= BIT(NL80211_STA_INFO_RX_BITRATE);
2488 sinfo->rxrate.legacy =
2489 le32_to_cpu(sta_info_le.rx_rate) / 100;
2491 if (le16_to_cpu(sta_info_le.ver) >= 4) {
2492 sinfo->filled |= BIT(NL80211_STA_INFO_TX_BYTES);
2493 sinfo->tx_bytes = le64_to_cpu(sta_info_le.tx_tot_bytes);
2494 sinfo->filled |= BIT(NL80211_STA_INFO_RX_BYTES);
2495 sinfo->rx_bytes = le64_to_cpu(sta_info_le.rx_tot_bytes);
2499 for (i = 0; i < BRCMF_ANT_MAX; i++) {
2500 if (sta_info_le.rssi[i]) {
2501 sinfo->chain_signal_avg[count_rssi] =
2502 sta_info_le.rssi[i];
2503 sinfo->chain_signal[count_rssi] =
2504 sta_info_le.rssi[i];
2505 total_rssi += sta_info_le.rssi[i];
2510 sinfo->filled |= BIT(NL80211_STA_INFO_CHAIN_SIGNAL);
2511 sinfo->chains = count_rssi;
2513 sinfo->filled |= BIT(NL80211_STA_INFO_SIGNAL);
2514 total_rssi /= count_rssi;
2515 sinfo->signal = total_rssi;
2519 brcmf_dbg(TRACE, "Exit\n");
2524 brcmf_cfg80211_dump_station(struct wiphy *wiphy, struct net_device *ndev,
2525 int idx, u8 *mac, struct station_info *sinfo)
2527 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy);
2528 struct brcmf_if *ifp = netdev_priv(ndev);
2531 brcmf_dbg(TRACE, "Enter, idx %d\n", idx);
2534 cfg->assoclist.count = cpu_to_le32(BRCMF_MAX_ASSOCLIST);
2535 err = brcmf_fil_cmd_data_get(ifp, BRCMF_C_GET_ASSOCLIST,
2537 sizeof(cfg->assoclist));
2539 brcmf_err("BRCMF_C_GET_ASSOCLIST unsupported, err=%d\n",
2541 cfg->assoclist.count = 0;
2545 if (idx < le32_to_cpu(cfg->assoclist.count)) {
2546 memcpy(mac, cfg->assoclist.mac[idx], ETH_ALEN);
2547 return brcmf_cfg80211_get_station(wiphy, ndev, mac, sinfo);
2553 brcmf_cfg80211_set_power_mgmt(struct wiphy *wiphy, struct net_device *ndev,
2554 bool enabled, s32 timeout)
2558 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy);
2559 struct brcmf_if *ifp = netdev_priv(ndev);
2561 brcmf_dbg(TRACE, "Enter\n");
2564 * Powersave enable/disable request is coming from the
2565 * cfg80211 even before the interface is up. In that
2566 * scenario, driver will be storing the power save
2567 * preference in cfg struct to apply this to
2568 * FW later while initializing the dongle
2570 cfg->pwr_save = enabled;
2571 if (!check_vif_up(ifp->vif)) {
2573 brcmf_dbg(INFO, "Device is not ready, storing the value in cfg_info struct\n");
2577 pm = enabled ? PM_FAST : PM_OFF;
2578 /* Do not enable the power save after assoc if it is a p2p interface */
2579 if (ifp->vif->wdev.iftype == NL80211_IFTYPE_P2P_CLIENT) {
2580 brcmf_dbg(INFO, "Do not enable power save for P2P clients\n");
2583 brcmf_dbg(INFO, "power save %s\n", (pm ? "enabled" : "disabled"));
2585 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_PM, pm);
2588 brcmf_err("net_device is not ready yet\n");
2590 brcmf_err("error (%d)\n", err);
2593 brcmf_dbg(TRACE, "Exit\n");
2597 static s32 brcmf_inform_single_bss(struct brcmf_cfg80211_info *cfg,
2598 struct brcmf_bss_info_le *bi)
2600 struct wiphy *wiphy = cfg_to_wiphy(cfg);
2601 struct ieee80211_channel *notify_channel;
2602 struct cfg80211_bss *bss;
2603 struct ieee80211_supported_band *band;
2604 struct brcmu_chan ch;
2607 u16 notify_capability;
2608 u16 notify_interval;
2610 size_t notify_ielen;
2613 if (le32_to_cpu(bi->length) > WL_BSS_INFO_MAX) {
2614 brcmf_err("Bss info is larger than buffer. Discarding\n");
2619 ch.chspec = le16_to_cpu(bi->chanspec);
2620 cfg->d11inf.decchspec(&ch);
2621 bi->ctl_ch = ch.chnum;
2623 channel = bi->ctl_ch;
2625 if (channel <= CH_MAX_2G_CHANNEL)
2626 band = wiphy->bands[IEEE80211_BAND_2GHZ];
2628 band = wiphy->bands[IEEE80211_BAND_5GHZ];
2630 freq = ieee80211_channel_to_frequency(channel, band->band);
2631 notify_channel = ieee80211_get_channel(wiphy, freq);
2633 notify_capability = le16_to_cpu(bi->capability);
2634 notify_interval = le16_to_cpu(bi->beacon_period);
2635 notify_ie = (u8 *)bi + le16_to_cpu(bi->ie_offset);
2636 notify_ielen = le32_to_cpu(bi->ie_length);
2637 notify_signal = (s16)le16_to_cpu(bi->RSSI) * 100;
2639 brcmf_dbg(CONN, "bssid: %pM\n", bi->BSSID);
2640 brcmf_dbg(CONN, "Channel: %d(%d)\n", channel, freq);
2641 brcmf_dbg(CONN, "Capability: %X\n", notify_capability);
2642 brcmf_dbg(CONN, "Beacon interval: %d\n", notify_interval);
2643 brcmf_dbg(CONN, "Signal: %d\n", notify_signal);
2645 bss = cfg80211_inform_bss(wiphy, notify_channel,
2646 CFG80211_BSS_FTYPE_UNKNOWN,
2647 (const u8 *)bi->BSSID,
2648 0, notify_capability,
2649 notify_interval, notify_ie,
2650 notify_ielen, notify_signal,
2656 cfg80211_put_bss(wiphy, bss);
2661 static struct brcmf_bss_info_le *
2662 next_bss_le(struct brcmf_scan_results *list, struct brcmf_bss_info_le *bss)
2665 return list->bss_info_le;
2666 return (struct brcmf_bss_info_le *)((unsigned long)bss +
2667 le32_to_cpu(bss->length));
2670 static s32 brcmf_inform_bss(struct brcmf_cfg80211_info *cfg)
2672 struct brcmf_scan_results *bss_list;
2673 struct brcmf_bss_info_le *bi = NULL; /* must be initialized */
2677 bss_list = (struct brcmf_scan_results *)cfg->escan_info.escan_buf;
2678 if (bss_list->count != 0 &&
2679 bss_list->version != BRCMF_BSS_INFO_VERSION) {
2680 brcmf_err("Version %d != WL_BSS_INFO_VERSION\n",
2684 brcmf_dbg(SCAN, "scanned AP count (%d)\n", bss_list->count);
2685 for (i = 0; i < bss_list->count; i++) {
2686 bi = next_bss_le(bss_list, bi);
2687 err = brcmf_inform_single_bss(cfg, bi);
2694 static s32 wl_inform_ibss(struct brcmf_cfg80211_info *cfg,
2695 struct net_device *ndev, const u8 *bssid)
2697 struct wiphy *wiphy = cfg_to_wiphy(cfg);
2698 struct ieee80211_channel *notify_channel;
2699 struct brcmf_bss_info_le *bi = NULL;
2700 struct ieee80211_supported_band *band;
2701 struct cfg80211_bss *bss;
2702 struct brcmu_chan ch;
2706 u16 notify_capability;
2707 u16 notify_interval;
2709 size_t notify_ielen;
2712 brcmf_dbg(TRACE, "Enter\n");
2714 buf = kzalloc(WL_BSS_INFO_MAX, GFP_KERNEL);
2720 *(__le32 *)buf = cpu_to_le32(WL_BSS_INFO_MAX);
2722 err = brcmf_fil_cmd_data_get(netdev_priv(ndev), BRCMF_C_GET_BSS_INFO,
2723 buf, WL_BSS_INFO_MAX);
2725 brcmf_err("WLC_GET_BSS_INFO failed: %d\n", err);
2729 bi = (struct brcmf_bss_info_le *)(buf + 4);
2731 ch.chspec = le16_to_cpu(bi->chanspec);
2732 cfg->d11inf.decchspec(&ch);
2734 if (ch.band == BRCMU_CHAN_BAND_2G)
2735 band = wiphy->bands[IEEE80211_BAND_2GHZ];
2737 band = wiphy->bands[IEEE80211_BAND_5GHZ];
2739 freq = ieee80211_channel_to_frequency(ch.chnum, band->band);
2740 notify_channel = ieee80211_get_channel(wiphy, freq);
2742 notify_capability = le16_to_cpu(bi->capability);
2743 notify_interval = le16_to_cpu(bi->beacon_period);
2744 notify_ie = (u8 *)bi + le16_to_cpu(bi->ie_offset);
2745 notify_ielen = le32_to_cpu(bi->ie_length);
2746 notify_signal = (s16)le16_to_cpu(bi->RSSI) * 100;
2748 brcmf_dbg(CONN, "channel: %d(%d)\n", ch.chnum, freq);
2749 brcmf_dbg(CONN, "capability: %X\n", notify_capability);
2750 brcmf_dbg(CONN, "beacon interval: %d\n", notify_interval);
2751 brcmf_dbg(CONN, "signal: %d\n", notify_signal);
2753 bss = cfg80211_inform_bss(wiphy, notify_channel,
2754 CFG80211_BSS_FTYPE_UNKNOWN, bssid, 0,
2755 notify_capability, notify_interval,
2756 notify_ie, notify_ielen, notify_signal,
2764 cfg80211_put_bss(wiphy, bss);
2770 brcmf_dbg(TRACE, "Exit\n");
2775 static s32 brcmf_update_bss_info(struct brcmf_cfg80211_info *cfg,
2776 struct brcmf_if *ifp)
2778 struct brcmf_cfg80211_profile *profile = ndev_to_prof(ifp->ndev);
2779 struct brcmf_bss_info_le *bi;
2780 struct brcmf_ssid *ssid;
2781 const struct brcmf_tlv *tim;
2782 u16 beacon_interval;
2788 brcmf_dbg(TRACE, "Enter\n");
2789 if (brcmf_is_ibssmode(ifp->vif))
2792 ssid = &profile->ssid;
2794 *(__le32 *)cfg->extra_buf = cpu_to_le32(WL_EXTRA_BUF_MAX);
2795 err = brcmf_fil_cmd_data_get(ifp, BRCMF_C_GET_BSS_INFO,
2796 cfg->extra_buf, WL_EXTRA_BUF_MAX);
2798 brcmf_err("Could not get bss info %d\n", err);
2799 goto update_bss_info_out;
2802 bi = (struct brcmf_bss_info_le *)(cfg->extra_buf + 4);
2803 err = brcmf_inform_single_bss(cfg, bi);
2805 goto update_bss_info_out;
2807 ie = ((u8 *)bi) + le16_to_cpu(bi->ie_offset);
2808 ie_len = le32_to_cpu(bi->ie_length);
2809 beacon_interval = le16_to_cpu(bi->beacon_period);
2811 tim = brcmf_parse_tlvs(ie, ie_len, WLAN_EID_TIM);
2813 dtim_period = tim->data[1];
2816 * active scan was done so we could not get dtim
2817 * information out of probe response.
2818 * so we speficially query dtim information to dongle.
2821 err = brcmf_fil_iovar_int_get(ifp, "dtim_assoc", &var);
2823 brcmf_err("wl dtim_assoc failed (%d)\n", err);
2824 goto update_bss_info_out;
2826 dtim_period = (u8)var;
2829 update_bss_info_out:
2830 brcmf_dbg(TRACE, "Exit");
2834 void brcmf_abort_scanning(struct brcmf_cfg80211_info *cfg)
2836 struct escan_info *escan = &cfg->escan_info;
2838 set_bit(BRCMF_SCAN_STATUS_ABORT, &cfg->scan_status);
2839 if (cfg->scan_request) {
2840 escan->escan_state = WL_ESCAN_STATE_IDLE;
2841 brcmf_notify_escan_complete(cfg, escan->ifp, true, true);
2843 clear_bit(BRCMF_SCAN_STATUS_BUSY, &cfg->scan_status);
2844 clear_bit(BRCMF_SCAN_STATUS_ABORT, &cfg->scan_status);
2847 static void brcmf_cfg80211_escan_timeout_worker(struct work_struct *work)
2849 struct brcmf_cfg80211_info *cfg =
2850 container_of(work, struct brcmf_cfg80211_info,
2851 escan_timeout_work);
2853 brcmf_inform_bss(cfg);
2854 brcmf_notify_escan_complete(cfg, cfg->escan_info.ifp, true, true);
2857 static void brcmf_escan_timeout(unsigned long data)
2859 struct brcmf_cfg80211_info *cfg =
2860 (struct brcmf_cfg80211_info *)data;
2862 if (cfg->scan_request) {
2863 brcmf_err("timer expired\n");
2864 schedule_work(&cfg->escan_timeout_work);
2869 brcmf_compare_update_same_bss(struct brcmf_cfg80211_info *cfg,
2870 struct brcmf_bss_info_le *bss,
2871 struct brcmf_bss_info_le *bss_info_le)
2873 struct brcmu_chan ch_bss, ch_bss_info_le;
2875 ch_bss.chspec = le16_to_cpu(bss->chanspec);
2876 cfg->d11inf.decchspec(&ch_bss);
2877 ch_bss_info_le.chspec = le16_to_cpu(bss_info_le->chanspec);
2878 cfg->d11inf.decchspec(&ch_bss_info_le);
2880 if (!memcmp(&bss_info_le->BSSID, &bss->BSSID, ETH_ALEN) &&
2881 ch_bss.band == ch_bss_info_le.band &&
2882 bss_info_le->SSID_len == bss->SSID_len &&
2883 !memcmp(bss_info_le->SSID, bss->SSID, bss_info_le->SSID_len)) {
2884 if ((bss->flags & BRCMF_BSS_RSSI_ON_CHANNEL) ==
2885 (bss_info_le->flags & BRCMF_BSS_RSSI_ON_CHANNEL)) {
2886 s16 bss_rssi = le16_to_cpu(bss->RSSI);
2887 s16 bss_info_rssi = le16_to_cpu(bss_info_le->RSSI);
2889 /* preserve max RSSI if the measurements are
2890 * both on-channel or both off-channel
2892 if (bss_info_rssi > bss_rssi)
2893 bss->RSSI = bss_info_le->RSSI;
2894 } else if ((bss->flags & BRCMF_BSS_RSSI_ON_CHANNEL) &&
2895 (bss_info_le->flags & BRCMF_BSS_RSSI_ON_CHANNEL) == 0) {
2896 /* preserve the on-channel rssi measurement
2897 * if the new measurement is off channel
2899 bss->RSSI = bss_info_le->RSSI;
2900 bss->flags |= BRCMF_BSS_RSSI_ON_CHANNEL;
2908 brcmf_cfg80211_escan_handler(struct brcmf_if *ifp,
2909 const struct brcmf_event_msg *e, void *data)
2911 struct brcmf_cfg80211_info *cfg = ifp->drvr->config;
2913 struct brcmf_escan_result_le *escan_result_le;
2914 struct brcmf_bss_info_le *bss_info_le;
2915 struct brcmf_bss_info_le *bss = NULL;
2917 struct brcmf_scan_results *list;
2923 if (!test_bit(BRCMF_SCAN_STATUS_BUSY, &cfg->scan_status)) {
2924 brcmf_err("scan not ready, bssidx=%d\n", ifp->bssidx);
2928 if (status == BRCMF_E_STATUS_PARTIAL) {
2929 brcmf_dbg(SCAN, "ESCAN Partial result\n");
2930 escan_result_le = (struct brcmf_escan_result_le *) data;
2931 if (!escan_result_le) {
2932 brcmf_err("Invalid escan result (NULL pointer)\n");
2935 if (le16_to_cpu(escan_result_le->bss_count) != 1) {
2936 brcmf_err("Invalid bss_count %d: ignoring\n",
2937 escan_result_le->bss_count);
2940 bss_info_le = &escan_result_le->bss_info_le;
2942 if (brcmf_p2p_scan_finding_common_channel(cfg, bss_info_le))
2945 if (!cfg->scan_request) {
2946 brcmf_dbg(SCAN, "result without cfg80211 request\n");
2950 bi_length = le32_to_cpu(bss_info_le->length);
2951 if (bi_length != (le32_to_cpu(escan_result_le->buflen) -
2952 WL_ESCAN_RESULTS_FIXED_SIZE)) {
2953 brcmf_err("Invalid bss_info length %d: ignoring\n",
2958 if (!(cfg_to_wiphy(cfg)->interface_modes &
2959 BIT(NL80211_IFTYPE_ADHOC))) {
2960 if (le16_to_cpu(bss_info_le->capability) &
2961 WLAN_CAPABILITY_IBSS) {
2962 brcmf_err("Ignoring IBSS result\n");
2967 list = (struct brcmf_scan_results *)
2968 cfg->escan_info.escan_buf;
2969 if (bi_length > WL_ESCAN_BUF_SIZE - list->buflen) {
2970 brcmf_err("Buffer is too small: ignoring\n");
2974 for (i = 0; i < list->count; i++) {
2975 bss = bss ? (struct brcmf_bss_info_le *)
2976 ((unsigned char *)bss +
2977 le32_to_cpu(bss->length)) : list->bss_info_le;
2978 if (brcmf_compare_update_same_bss(cfg, bss,
2982 memcpy(&(cfg->escan_info.escan_buf[list->buflen]),
2983 bss_info_le, bi_length);
2984 list->version = le32_to_cpu(bss_info_le->version);
2985 list->buflen += bi_length;
2988 cfg->escan_info.escan_state = WL_ESCAN_STATE_IDLE;
2989 if (brcmf_p2p_scan_finding_common_channel(cfg, NULL))
2991 if (cfg->scan_request) {
2992 brcmf_inform_bss(cfg);
2993 aborted = status != BRCMF_E_STATUS_SUCCESS;
2994 brcmf_notify_escan_complete(cfg, ifp, aborted, false);
2996 brcmf_dbg(SCAN, "Ignored scan complete result 0x%x\n",
3003 static void brcmf_init_escan(struct brcmf_cfg80211_info *cfg)
3005 brcmf_fweh_register(cfg->pub, BRCMF_E_ESCAN_RESULT,
3006 brcmf_cfg80211_escan_handler);
3007 cfg->escan_info.escan_state = WL_ESCAN_STATE_IDLE;
3008 /* Init scan_timeout timer */
3009 init_timer(&cfg->escan_timeout);
3010 cfg->escan_timeout.data = (unsigned long) cfg;
3011 cfg->escan_timeout.function = brcmf_escan_timeout;
3012 INIT_WORK(&cfg->escan_timeout_work,
3013 brcmf_cfg80211_escan_timeout_worker);
3016 static __always_inline void brcmf_delay(u32 ms)
3018 if (ms < 1000 / HZ) {
3026 static s32 brcmf_config_wowl_pattern(struct brcmf_if *ifp, u8 cmd[4],
3027 u8 *pattern, u32 patternsize, u8 *mask,
3030 struct brcmf_fil_wowl_pattern_le *filter;
3037 masksize = (patternsize + 7) / 8;
3038 patternoffset = sizeof(*filter) - sizeof(filter->cmd) + masksize;
3040 bufsize = sizeof(*filter) + patternsize + masksize;
3041 buf = kzalloc(bufsize, GFP_KERNEL);
3044 filter = (struct brcmf_fil_wowl_pattern_le *)buf;
3046 memcpy(filter->cmd, cmd, 4);
3047 filter->masksize = cpu_to_le32(masksize);
3048 filter->offset = cpu_to_le32(packet_offset);
3049 filter->patternoffset = cpu_to_le32(patternoffset);
3050 filter->patternsize = cpu_to_le32(patternsize);
3051 filter->type = cpu_to_le32(BRCMF_WOWL_PATTERN_TYPE_BITMAP);
3053 if ((mask) && (masksize))
3054 memcpy(buf + sizeof(*filter), mask, masksize);
3055 if ((pattern) && (patternsize))
3056 memcpy(buf + sizeof(*filter) + masksize, pattern, patternsize);
3058 ret = brcmf_fil_iovar_data_set(ifp, "wowl_pattern", buf, bufsize);
3064 static s32 brcmf_cfg80211_resume(struct wiphy *wiphy)
3066 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy);
3067 struct net_device *ndev = cfg_to_ndev(cfg);
3068 struct brcmf_if *ifp = netdev_priv(ndev);
3070 brcmf_dbg(TRACE, "Enter\n");
3072 if (cfg->wowl_enabled) {
3073 brcmf_configure_arp_offload(ifp, true);
3074 brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_PM,
3075 cfg->pre_wowl_pmmode);
3076 brcmf_fil_iovar_int_set(ifp, "wowl_clear", 0);
3077 brcmf_config_wowl_pattern(ifp, "clr", NULL, 0, NULL, 0);
3078 cfg->wowl_enabled = false;
3083 static void brcmf_configure_wowl(struct brcmf_cfg80211_info *cfg,
3084 struct brcmf_if *ifp,
3085 struct cfg80211_wowlan *wowl)
3090 brcmf_dbg(TRACE, "Suspend, wowl config.\n");
3092 brcmf_configure_arp_offload(ifp, false);
3093 brcmf_fil_cmd_int_get(ifp, BRCMF_C_GET_PM, &cfg->pre_wowl_pmmode);
3094 brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_PM, PM_MAX);
3097 if (wowl->disconnect)
3098 wowl_config = BRCMF_WOWL_DIS | BRCMF_WOWL_BCN | BRCMF_WOWL_RETR;
3099 if (wowl->magic_pkt)
3100 wowl_config |= BRCMF_WOWL_MAGIC;
3101 if ((wowl->patterns) && (wowl->n_patterns)) {
3102 wowl_config |= BRCMF_WOWL_NET;
3103 for (i = 0; i < wowl->n_patterns; i++) {
3104 brcmf_config_wowl_pattern(ifp, "add",
3105 (u8 *)wowl->patterns[i].pattern,
3106 wowl->patterns[i].pattern_len,
3107 (u8 *)wowl->patterns[i].mask,
3108 wowl->patterns[i].pkt_offset);
3111 brcmf_fil_iovar_int_set(ifp, "wowl", wowl_config);
3112 brcmf_fil_iovar_int_set(ifp, "wowl_activate", 1);
3113 brcmf_bus_wowl_config(cfg->pub->bus_if, true);
3114 cfg->wowl_enabled = true;
3117 static s32 brcmf_cfg80211_suspend(struct wiphy *wiphy,
3118 struct cfg80211_wowlan *wowl)
3120 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy);
3121 struct net_device *ndev = cfg_to_ndev(cfg);
3122 struct brcmf_if *ifp = netdev_priv(ndev);
3123 struct brcmf_cfg80211_vif *vif;
3125 brcmf_dbg(TRACE, "Enter\n");
3127 /* if the primary net_device is not READY there is nothing
3128 * we can do but pray resume goes smoothly.
3130 if (!check_vif_up(ifp->vif))
3133 /* end any scanning */
3134 if (test_bit(BRCMF_SCAN_STATUS_BUSY, &cfg->scan_status))
3135 brcmf_abort_scanning(cfg);
3138 brcmf_bus_wowl_config(cfg->pub->bus_if, false);
3139 list_for_each_entry(vif, &cfg->vif_list, list) {
3140 if (!test_bit(BRCMF_VIF_STATUS_READY, &vif->sme_state))
3142 /* While going to suspend if associated with AP
3143 * disassociate from AP to save power while system is
3144 * in suspended state
3146 brcmf_link_down(vif, WLAN_REASON_UNSPECIFIED);
3147 /* Make sure WPA_Supplicant receives all the event
3148 * generated due to DISASSOC call to the fw to keep
3149 * the state fw and WPA_Supplicant state consistent
3154 brcmf_set_mpc(ifp, 1);
3157 /* Configure WOWL paramaters */
3158 brcmf_configure_wowl(cfg, ifp, wowl);
3162 brcmf_dbg(TRACE, "Exit\n");
3163 /* clear any scanning activity */
3164 cfg->scan_status = 0;
3169 brcmf_update_pmklist(struct net_device *ndev,
3170 struct brcmf_cfg80211_pmk_list *pmk_list, s32 err)
3175 pmkid_len = le32_to_cpu(pmk_list->pmkids.npmkid);
3177 brcmf_dbg(CONN, "No of elements %d\n", pmkid_len);
3178 for (i = 0; i < pmkid_len; i++) {
3179 brcmf_dbg(CONN, "PMKID[%d]: %pM =\n", i,
3180 &pmk_list->pmkids.pmkid[i].BSSID);
3181 for (j = 0; j < WLAN_PMKID_LEN; j++)
3182 brcmf_dbg(CONN, "%02x\n",
3183 pmk_list->pmkids.pmkid[i].PMKID[j]);
3187 brcmf_fil_iovar_data_set(netdev_priv(ndev), "pmkid_info",
3188 (char *)pmk_list, sizeof(*pmk_list));
3194 brcmf_cfg80211_set_pmksa(struct wiphy *wiphy, struct net_device *ndev,
3195 struct cfg80211_pmksa *pmksa)
3197 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy);
3198 struct brcmf_if *ifp = netdev_priv(ndev);
3199 struct pmkid_list *pmkids = &cfg->pmk_list->pmkids;
3203 brcmf_dbg(TRACE, "Enter\n");
3204 if (!check_vif_up(ifp->vif))
3207 pmkid_len = le32_to_cpu(pmkids->npmkid);
3208 for (i = 0; i < pmkid_len; i++)
3209 if (!memcmp(pmksa->bssid, pmkids->pmkid[i].BSSID, ETH_ALEN))
3211 if (i < WL_NUM_PMKIDS_MAX) {
3212 memcpy(pmkids->pmkid[i].BSSID, pmksa->bssid, ETH_ALEN);
3213 memcpy(pmkids->pmkid[i].PMKID, pmksa->pmkid, WLAN_PMKID_LEN);
3214 if (i == pmkid_len) {
3216 pmkids->npmkid = cpu_to_le32(pmkid_len);
3221 brcmf_dbg(CONN, "set_pmksa,IW_PMKSA_ADD - PMKID: %pM =\n",
3222 pmkids->pmkid[pmkid_len].BSSID);
3223 for (i = 0; i < WLAN_PMKID_LEN; i++)
3224 brcmf_dbg(CONN, "%02x\n", pmkids->pmkid[pmkid_len].PMKID[i]);
3226 err = brcmf_update_pmklist(ndev, cfg->pmk_list, err);
3228 brcmf_dbg(TRACE, "Exit\n");
3233 brcmf_cfg80211_del_pmksa(struct wiphy *wiphy, struct net_device *ndev,
3234 struct cfg80211_pmksa *pmksa)
3236 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy);
3237 struct brcmf_if *ifp = netdev_priv(ndev);
3238 struct pmkid_list pmkid;
3242 brcmf_dbg(TRACE, "Enter\n");
3243 if (!check_vif_up(ifp->vif))
3246 memcpy(&pmkid.pmkid[0].BSSID, pmksa->bssid, ETH_ALEN);
3247 memcpy(&pmkid.pmkid[0].PMKID, pmksa->pmkid, WLAN_PMKID_LEN);
3249 brcmf_dbg(CONN, "del_pmksa,IW_PMKSA_REMOVE - PMKID: %pM =\n",
3250 &pmkid.pmkid[0].BSSID);
3251 for (i = 0; i < WLAN_PMKID_LEN; i++)
3252 brcmf_dbg(CONN, "%02x\n", pmkid.pmkid[0].PMKID[i]);
3254 pmkid_len = le32_to_cpu(cfg->pmk_list->pmkids.npmkid);
3255 for (i = 0; i < pmkid_len; i++)
3257 (pmksa->bssid, &cfg->pmk_list->pmkids.pmkid[i].BSSID,
3262 && (i < pmkid_len)) {
3263 memset(&cfg->pmk_list->pmkids.pmkid[i], 0,
3264 sizeof(struct pmkid));
3265 for (; i < (pmkid_len - 1); i++) {
3266 memcpy(&cfg->pmk_list->pmkids.pmkid[i].BSSID,
3267 &cfg->pmk_list->pmkids.pmkid[i + 1].BSSID,
3269 memcpy(&cfg->pmk_list->pmkids.pmkid[i].PMKID,
3270 &cfg->pmk_list->pmkids.pmkid[i + 1].PMKID,
3273 cfg->pmk_list->pmkids.npmkid = cpu_to_le32(pmkid_len - 1);
3277 err = brcmf_update_pmklist(ndev, cfg->pmk_list, err);
3279 brcmf_dbg(TRACE, "Exit\n");
3285 brcmf_cfg80211_flush_pmksa(struct wiphy *wiphy, struct net_device *ndev)
3287 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy);
3288 struct brcmf_if *ifp = netdev_priv(ndev);
3291 brcmf_dbg(TRACE, "Enter\n");
3292 if (!check_vif_up(ifp->vif))
3295 memset(cfg->pmk_list, 0, sizeof(*cfg->pmk_list));
3296 err = brcmf_update_pmklist(ndev, cfg->pmk_list, err);
3298 brcmf_dbg(TRACE, "Exit\n");
3304 * PFN result doesn't have all the info which are
3305 * required by the supplicant
3306 * (For e.g IEs) Do a target Escan so that sched scan results are reported
3307 * via wl_inform_single_bss in the required format. Escan does require the
3308 * scan request in the form of cfg80211_scan_request. For timebeing, create
3309 * cfg80211_scan_request one out of the received PNO event.
3312 brcmf_notify_sched_scan_results(struct brcmf_if *ifp,
3313 const struct brcmf_event_msg *e, void *data)
3315 struct brcmf_cfg80211_info *cfg = ifp->drvr->config;
3316 struct brcmf_pno_net_info_le *netinfo, *netinfo_start;
3317 struct cfg80211_scan_request *request = NULL;
3318 struct cfg80211_ssid *ssid = NULL;
3319 struct ieee80211_channel *channel = NULL;
3320 struct wiphy *wiphy = cfg_to_wiphy(cfg);
3322 int channel_req = 0;
3324 struct brcmf_pno_scanresults_le *pfn_result;
3328 brcmf_dbg(SCAN, "Enter\n");
3330 if (e->event_code == BRCMF_E_PFN_NET_LOST) {
3331 brcmf_dbg(SCAN, "PFN NET LOST event. Do Nothing\n");
3335 pfn_result = (struct brcmf_pno_scanresults_le *)data;
3336 result_count = le32_to_cpu(pfn_result->count);
3337 status = le32_to_cpu(pfn_result->status);
3340 * PFN event is limited to fit 512 bytes so we may get
3341 * multiple NET_FOUND events. For now place a warning here.
3343 WARN_ON(status != BRCMF_PNO_SCAN_COMPLETE);
3344 brcmf_dbg(SCAN, "PFN NET FOUND event. count: %d\n", result_count);
3345 if (result_count > 0) {
3348 request = kzalloc(sizeof(*request), GFP_KERNEL);
3349 ssid = kcalloc(result_count, sizeof(*ssid), GFP_KERNEL);
3350 channel = kcalloc(result_count, sizeof(*channel), GFP_KERNEL);
3351 if (!request || !ssid || !channel) {
3356 request->wiphy = wiphy;
3357 data += sizeof(struct brcmf_pno_scanresults_le);
3358 netinfo_start = (struct brcmf_pno_net_info_le *)data;
3360 for (i = 0; i < result_count; i++) {
3361 netinfo = &netinfo_start[i];
3363 brcmf_err("Invalid netinfo ptr. index: %d\n",
3369 brcmf_dbg(SCAN, "SSID:%s Channel:%d\n",
3370 netinfo->SSID, netinfo->channel);
3371 memcpy(ssid[i].ssid, netinfo->SSID, netinfo->SSID_len);
3372 ssid[i].ssid_len = netinfo->SSID_len;
3375 channel_req = netinfo->channel;
3376 if (channel_req <= CH_MAX_2G_CHANNEL)
3377 band = NL80211_BAND_2GHZ;
3379 band = NL80211_BAND_5GHZ;
3380 channel[i].center_freq =
3381 ieee80211_channel_to_frequency(channel_req,
3383 channel[i].band = band;
3384 channel[i].flags |= IEEE80211_CHAN_NO_HT40;
3385 request->channels[i] = &channel[i];
3386 request->n_channels++;
3389 /* assign parsed ssid array */
3390 if (request->n_ssids)
3391 request->ssids = &ssid[0];
3393 if (test_bit(BRCMF_SCAN_STATUS_BUSY, &cfg->scan_status)) {
3394 /* Abort any on-going scan */
3395 brcmf_abort_scanning(cfg);
3398 set_bit(BRCMF_SCAN_STATUS_BUSY, &cfg->scan_status);
3399 cfg->escan_info.run = brcmf_run_escan;
3400 err = brcmf_do_escan(cfg, wiphy, ifp, request);
3402 clear_bit(BRCMF_SCAN_STATUS_BUSY, &cfg->scan_status);
3405 cfg->sched_escan = true;
3406 cfg->scan_request = request;
3408 brcmf_err("FALSE PNO Event. (pfn_count == 0)\n");
3421 cfg80211_sched_scan_stopped(wiphy);
3425 static int brcmf_dev_pno_clean(struct net_device *ndev)
3430 ret = brcmf_fil_iovar_int_set(netdev_priv(ndev), "pfn", 0);
3433 ret = brcmf_fil_iovar_data_set(netdev_priv(ndev), "pfnclear",
3437 brcmf_err("failed code %d\n", ret);
3442 static int brcmf_dev_pno_config(struct net_device *ndev)
3444 struct brcmf_pno_param_le pfn_param;
3446 memset(&pfn_param, 0, sizeof(pfn_param));
3447 pfn_param.version = cpu_to_le32(BRCMF_PNO_VERSION);
3449 /* set extra pno params */
3450 pfn_param.flags = cpu_to_le16(1 << BRCMF_PNO_ENABLE_ADAPTSCAN_BIT);
3451 pfn_param.repeat = BRCMF_PNO_REPEAT;
3452 pfn_param.exp = BRCMF_PNO_FREQ_EXPO_MAX;
3454 /* set up pno scan fr */
3455 pfn_param.scan_freq = cpu_to_le32(BRCMF_PNO_TIME);
3457 return brcmf_fil_iovar_data_set(netdev_priv(ndev), "pfn_set",
3458 &pfn_param, sizeof(pfn_param));
3462 brcmf_cfg80211_sched_scan_start(struct wiphy *wiphy,
3463 struct net_device *ndev,
3464 struct cfg80211_sched_scan_request *request)
3466 struct brcmf_if *ifp = netdev_priv(ndev);
3467 struct brcmf_cfg80211_info *cfg = wiphy_priv(wiphy);
3468 struct brcmf_pno_net_param_le pfn;
3472 brcmf_dbg(SCAN, "Enter n_match_sets:%d n_ssids:%d\n",
3473 request->n_match_sets, request->n_ssids);
3474 if (test_bit(BRCMF_SCAN_STATUS_BUSY, &cfg->scan_status)) {
3475 brcmf_err("Scanning already: status (%lu)\n", cfg->scan_status);
3478 if (test_bit(BRCMF_SCAN_STATUS_SUPPRESS, &cfg->scan_status)) {
3479 brcmf_err("Scanning suppressed: status (%lu)\n",
3484 if (!request->n_ssids || !request->n_match_sets) {
3485 brcmf_dbg(SCAN, "Invalid sched scan req!! n_ssids:%d\n",
3490 if (request->n_ssids > 0) {
3491 for (i = 0; i < request->n_ssids; i++) {
3492 /* Active scan req for ssids */
3493 brcmf_dbg(SCAN, ">>> Active scan req for ssid (%s)\n",
3494 request->ssids[i].ssid);
3497 * match_set ssids is a supert set of n_ssid list,
3498 * so we need not add these set seperately.
3503 if (request->n_match_sets > 0) {
3504 /* clean up everything */
3505 ret = brcmf_dev_pno_clean(ndev);
3507 brcmf_err("failed error=%d\n", ret);
3512 ret = brcmf_dev_pno_config(ndev);
3514 brcmf_err("PNO setup failed!! ret=%d\n", ret);
3518 /* configure each match set */
3519 for (i = 0; i < request->n_match_sets; i++) {
3520 struct cfg80211_ssid *ssid;
3523 ssid = &request->match_sets[i].ssid;
3524 ssid_len = ssid->ssid_len;
3527 brcmf_err("skip broadcast ssid\n");
3530 pfn.auth = cpu_to_le32(WLAN_AUTH_OPEN);
3531 pfn.wpa_auth = cpu_to_le32(BRCMF_PNO_WPA_AUTH_ANY);
3532 pfn.wsec = cpu_to_le32(0);
3533 pfn.infra = cpu_to_le32(1);
3534 pfn.flags = cpu_to_le32(1 << BRCMF_PNO_HIDDEN_BIT);
3535 pfn.ssid.SSID_len = cpu_to_le32(ssid_len);
3536 memcpy(pfn.ssid.SSID, ssid->ssid, ssid_len);
3537 ret = brcmf_fil_iovar_data_set(ifp, "pfn_add", &pfn,
3539 brcmf_dbg(SCAN, ">>> PNO filter %s for ssid (%s)\n",
3540 ret == 0 ? "set" : "failed", ssid->ssid);
3542 /* Enable the PNO */
3543 if (brcmf_fil_iovar_int_set(ifp, "pfn", 1) < 0) {
3544 brcmf_err("PNO enable failed!! ret=%d\n", ret);
3554 static int brcmf_cfg80211_sched_scan_stop(struct wiphy *wiphy,
3555 struct net_device *ndev)
3557 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy);
3559 brcmf_dbg(SCAN, "enter\n");
3560 brcmf_dev_pno_clean(ndev);
3561 if (cfg->sched_escan)
3562 brcmf_notify_escan_complete(cfg, netdev_priv(ndev), true, true);
3566 static s32 brcmf_configure_opensecurity(struct brcmf_if *ifp)
3571 err = brcmf_fil_bsscfg_int_set(ifp, "auth", 0);
3573 brcmf_err("auth error %d\n", err);
3577 err = brcmf_fil_bsscfg_int_set(ifp, "wsec", 0);
3579 brcmf_err("wsec error %d\n", err);
3582 /* set upper-layer auth */
3583 err = brcmf_fil_bsscfg_int_set(ifp, "wpa_auth", WPA_AUTH_NONE);
3585 brcmf_err("wpa_auth error %d\n", err);
3592 static bool brcmf_valid_wpa_oui(u8 *oui, bool is_rsn_ie)
3595 return (memcmp(oui, RSN_OUI, TLV_OUI_LEN) == 0);
3597 return (memcmp(oui, WPA_OUI, TLV_OUI_LEN) == 0);
3601 brcmf_configure_wpaie(struct brcmf_if *ifp,
3602 const struct brcmf_vs_tlv *wpa_ie,
3605 u32 auth = 0; /* d11 open authentication */
3617 u32 wme_bss_disable;
3619 brcmf_dbg(TRACE, "Enter\n");
3623 len = wpa_ie->len + TLV_HDR_LEN;
3624 data = (u8 *)wpa_ie;
3625 offset = TLV_HDR_LEN;
3627 offset += VS_IE_FIXED_HDR_LEN;
3629 offset += WPA_IE_VERSION_LEN;
3631 /* check for multicast cipher suite */
3632 if (offset + WPA_IE_MIN_OUI_LEN > len) {
3634 brcmf_err("no multicast cipher suite\n");
3638 if (!brcmf_valid_wpa_oui(&data[offset], is_rsn_ie)) {
3640 brcmf_err("ivalid OUI\n");
3643 offset += TLV_OUI_LEN;
3645 /* pick up multicast cipher */
3646 switch (data[offset]) {
3647 case WPA_CIPHER_NONE:
3650 case WPA_CIPHER_WEP_40:
3651 case WPA_CIPHER_WEP_104:
3654 case WPA_CIPHER_TKIP:
3655 gval = TKIP_ENABLED;
3657 case WPA_CIPHER_AES_CCM:
3662 brcmf_err("Invalid multi cast cipher info\n");
3667 /* walk thru unicast cipher list and pick up what we recognize */
3668 count = data[offset] + (data[offset + 1] << 8);
3669 offset += WPA_IE_SUITE_COUNT_LEN;
3670 /* Check for unicast suite(s) */
3671 if (offset + (WPA_IE_MIN_OUI_LEN * count) > len) {
3673 brcmf_err("no unicast cipher suite\n");
3676 for (i = 0; i < count; i++) {
3677 if (!brcmf_valid_wpa_oui(&data[offset], is_rsn_ie)) {
3679 brcmf_err("ivalid OUI\n");
3682 offset += TLV_OUI_LEN;
3683 switch (data[offset]) {
3684 case WPA_CIPHER_NONE:
3686 case WPA_CIPHER_WEP_40:
3687 case WPA_CIPHER_WEP_104:
3688 pval |= WEP_ENABLED;
3690 case WPA_CIPHER_TKIP:
3691 pval |= TKIP_ENABLED;
3693 case WPA_CIPHER_AES_CCM:
3694 pval |= AES_ENABLED;
3697 brcmf_err("Ivalid unicast security info\n");
3701 /* walk thru auth management suite list and pick up what we recognize */
3702 count = data[offset] + (data[offset + 1] << 8);
3703 offset += WPA_IE_SUITE_COUNT_LEN;
3704 /* Check for auth key management suite(s) */
3705 if (offset + (WPA_IE_MIN_OUI_LEN * count) > len) {
3707 brcmf_err("no auth key mgmt suite\n");
3710 for (i = 0; i < count; i++) {
3711 if (!brcmf_valid_wpa_oui(&data[offset], is_rsn_ie)) {
3713 brcmf_err("ivalid OUI\n");
3716 offset += TLV_OUI_LEN;
3717 switch (data[offset]) {
3719 brcmf_dbg(TRACE, "RSN_AKM_NONE\n");
3720 wpa_auth |= WPA_AUTH_NONE;
3722 case RSN_AKM_UNSPECIFIED:
3723 brcmf_dbg(TRACE, "RSN_AKM_UNSPECIFIED\n");
3724 is_rsn_ie ? (wpa_auth |= WPA2_AUTH_UNSPECIFIED) :
3725 (wpa_auth |= WPA_AUTH_UNSPECIFIED);
3728 brcmf_dbg(TRACE, "RSN_AKM_PSK\n");
3729 is_rsn_ie ? (wpa_auth |= WPA2_AUTH_PSK) :
3730 (wpa_auth |= WPA_AUTH_PSK);
3733 brcmf_err("Ivalid key mgmt info\n");
3739 wme_bss_disable = 1;
3740 if ((offset + RSN_CAP_LEN) <= len) {
3741 rsn_cap = data[offset] + (data[offset + 1] << 8);
3742 if (rsn_cap & RSN_CAP_PTK_REPLAY_CNTR_MASK)
3743 wme_bss_disable = 0;
3745 /* set wme_bss_disable to sync RSN Capabilities */
3746 err = brcmf_fil_bsscfg_int_set(ifp, "wme_bss_disable",
3749 brcmf_err("wme_bss_disable error %d\n", err);
3753 /* FOR WPS , set SES_OW_ENABLED */
3754 wsec = (pval | gval | SES_OW_ENABLED);
3757 err = brcmf_fil_bsscfg_int_set(ifp, "auth", auth);
3759 brcmf_err("auth error %d\n", err);
3763 err = brcmf_fil_bsscfg_int_set(ifp, "wsec", wsec);
3765 brcmf_err("wsec error %d\n", err);
3768 /* set upper-layer auth */
3769 err = brcmf_fil_bsscfg_int_set(ifp, "wpa_auth", wpa_auth);
3771 brcmf_err("wpa_auth error %d\n", err);
3780 brcmf_parse_vndr_ies(const u8 *vndr_ie_buf, u32 vndr_ie_len,
3781 struct parsed_vndr_ies *vndr_ies)
3783 struct brcmf_vs_tlv *vndrie;
3784 struct brcmf_tlv *ie;
3785 struct parsed_vndr_ie_info *parsed_info;
3788 remaining_len = (s32)vndr_ie_len;
3789 memset(vndr_ies, 0, sizeof(*vndr_ies));
3791 ie = (struct brcmf_tlv *)vndr_ie_buf;
3793 if (ie->id != WLAN_EID_VENDOR_SPECIFIC)
3795 vndrie = (struct brcmf_vs_tlv *)ie;
3796 /* len should be bigger than OUI length + one */
3797 if (vndrie->len < (VS_IE_FIXED_HDR_LEN - TLV_HDR_LEN + 1)) {
3798 brcmf_err("invalid vndr ie. length is too small %d\n",
3802 /* if wpa or wme ie, do not add ie */
3803 if (!memcmp(vndrie->oui, (u8 *)WPA_OUI, TLV_OUI_LEN) &&
3804 ((vndrie->oui_type == WPA_OUI_TYPE) ||
3805 (vndrie->oui_type == WME_OUI_TYPE))) {
3806 brcmf_dbg(TRACE, "Found WPA/WME oui. Do not add it\n");
3810 parsed_info = &vndr_ies->ie_info[vndr_ies->count];
3812 /* save vndr ie information */
3813 parsed_info->ie_ptr = (char *)vndrie;
3814 parsed_info->ie_len = vndrie->len + TLV_HDR_LEN;
3815 memcpy(&parsed_info->vndrie, vndrie, sizeof(*vndrie));
3819 brcmf_dbg(TRACE, "** OUI %02x %02x %02x, type 0x%02x\n",
3820 parsed_info->vndrie.oui[0],
3821 parsed_info->vndrie.oui[1],
3822 parsed_info->vndrie.oui[2],
3823 parsed_info->vndrie.oui_type);
3825 if (vndr_ies->count >= VNDR_IE_PARSE_LIMIT)
3828 remaining_len -= (ie->len + TLV_HDR_LEN);
3829 if (remaining_len <= TLV_HDR_LEN)
3832 ie = (struct brcmf_tlv *)(((u8 *)ie) + ie->len +
3839 brcmf_vndr_ie(u8 *iebuf, s32 pktflag, u8 *ie_ptr, u32 ie_len, s8 *add_del_cmd)
3842 strncpy(iebuf, add_del_cmd, VNDR_IE_CMD_LEN - 1);
3843 iebuf[VNDR_IE_CMD_LEN - 1] = '\0';
3845 put_unaligned_le32(1, &iebuf[VNDR_IE_COUNT_OFFSET]);
3847 put_unaligned_le32(pktflag, &iebuf[VNDR_IE_PKTFLAG_OFFSET]);
3849 memcpy(&iebuf[VNDR_IE_VSIE_OFFSET], ie_ptr, ie_len);
3851 return ie_len + VNDR_IE_HDR_SIZE;
3854 s32 brcmf_vif_set_mgmt_ie(struct brcmf_cfg80211_vif *vif, s32 pktflag,
3855 const u8 *vndr_ie_buf, u32 vndr_ie_len)
3857 struct brcmf_if *ifp;
3858 struct vif_saved_ie *saved_ie;
3862 u8 *mgmt_ie_buf = NULL;
3863 int mgmt_ie_buf_len;
3865 u32 del_add_ie_buf_len = 0;
3866 u32 total_ie_buf_len = 0;
3867 u32 parsed_ie_buf_len = 0;
3868 struct parsed_vndr_ies old_vndr_ies;
3869 struct parsed_vndr_ies new_vndr_ies;
3870 struct parsed_vndr_ie_info *vndrie_info;
3873 int remained_buf_len;
3878 saved_ie = &vif->saved_ie;
3880 brcmf_dbg(TRACE, "bssidx %d, pktflag : 0x%02X\n", ifp->bssidx, pktflag);
3881 iovar_ie_buf = kzalloc(WL_EXTRA_BUF_MAX, GFP_KERNEL);
3884 curr_ie_buf = iovar_ie_buf;
3886 case BRCMF_VNDR_IE_PRBREQ_FLAG:
3887 mgmt_ie_buf = saved_ie->probe_req_ie;
3888 mgmt_ie_len = &saved_ie->probe_req_ie_len;
3889 mgmt_ie_buf_len = sizeof(saved_ie->probe_req_ie);
3891 case BRCMF_VNDR_IE_PRBRSP_FLAG:
3892 mgmt_ie_buf = saved_ie->probe_res_ie;
3893 mgmt_ie_len = &saved_ie->probe_res_ie_len;
3894 mgmt_ie_buf_len = sizeof(saved_ie->probe_res_ie);
3896 case BRCMF_VNDR_IE_BEACON_FLAG:
3897 mgmt_ie_buf = saved_ie->beacon_ie;
3898 mgmt_ie_len = &saved_ie->beacon_ie_len;
3899 mgmt_ie_buf_len = sizeof(saved_ie->beacon_ie);
3901 case BRCMF_VNDR_IE_ASSOCREQ_FLAG:
3902 mgmt_ie_buf = saved_ie->assoc_req_ie;
3903 mgmt_ie_len = &saved_ie->assoc_req_ie_len;
3904 mgmt_ie_buf_len = sizeof(saved_ie->assoc_req_ie);
3908 brcmf_err("not suitable type\n");
3912 if (vndr_ie_len > mgmt_ie_buf_len) {
3914 brcmf_err("extra IE size too big\n");
3918 /* parse and save new vndr_ie in curr_ie_buff before comparing it */
3919 if (vndr_ie_buf && vndr_ie_len && curr_ie_buf) {
3921 brcmf_parse_vndr_ies(vndr_ie_buf, vndr_ie_len, &new_vndr_ies);
3922 for (i = 0; i < new_vndr_ies.count; i++) {
3923 vndrie_info = &new_vndr_ies.ie_info[i];
3924 memcpy(ptr + parsed_ie_buf_len, vndrie_info->ie_ptr,
3925 vndrie_info->ie_len);
3926 parsed_ie_buf_len += vndrie_info->ie_len;
3930 if (mgmt_ie_buf && *mgmt_ie_len) {
3931 if (parsed_ie_buf_len && (parsed_ie_buf_len == *mgmt_ie_len) &&
3932 (memcmp(mgmt_ie_buf, curr_ie_buf,
3933 parsed_ie_buf_len) == 0)) {
3934 brcmf_dbg(TRACE, "Previous mgmt IE equals to current IE\n");
3938 /* parse old vndr_ie */
3939 brcmf_parse_vndr_ies(mgmt_ie_buf, *mgmt_ie_len, &old_vndr_ies);
3941 /* make a command to delete old ie */
3942 for (i = 0; i < old_vndr_ies.count; i++) {
3943 vndrie_info = &old_vndr_ies.ie_info[i];
3945 brcmf_dbg(TRACE, "DEL ID : %d, Len: %d , OUI:%02x:%02x:%02x\n",
3946 vndrie_info->vndrie.id,
3947 vndrie_info->vndrie.len,
3948 vndrie_info->vndrie.oui[0],
3949 vndrie_info->vndrie.oui[1],
3950 vndrie_info->vndrie.oui[2]);
3952 del_add_ie_buf_len = brcmf_vndr_ie(curr_ie_buf, pktflag,
3953 vndrie_info->ie_ptr,
3954 vndrie_info->ie_len,
3956 curr_ie_buf += del_add_ie_buf_len;
3957 total_ie_buf_len += del_add_ie_buf_len;
3962 /* Add if there is any extra IE */
3963 if (mgmt_ie_buf && parsed_ie_buf_len) {
3966 remained_buf_len = mgmt_ie_buf_len;
3968 /* make a command to add new ie */
3969 for (i = 0; i < new_vndr_ies.count; i++) {
3970 vndrie_info = &new_vndr_ies.ie_info[i];
3972 /* verify remained buf size before copy data */
3973 if (remained_buf_len < (vndrie_info->vndrie.len +
3974 VNDR_IE_VSIE_OFFSET)) {
3975 brcmf_err("no space in mgmt_ie_buf: len left %d",
3979 remained_buf_len -= (vndrie_info->ie_len +
3980 VNDR_IE_VSIE_OFFSET);
3982 brcmf_dbg(TRACE, "ADDED ID : %d, Len: %d, OUI:%02x:%02x:%02x\n",
3983 vndrie_info->vndrie.id,
3984 vndrie_info->vndrie.len,
3985 vndrie_info->vndrie.oui[0],
3986 vndrie_info->vndrie.oui[1],
3987 vndrie_info->vndrie.oui[2]);
3989 del_add_ie_buf_len = brcmf_vndr_ie(curr_ie_buf, pktflag,
3990 vndrie_info->ie_ptr,
3991 vndrie_info->ie_len,
3994 /* save the parsed IE in wl struct */
3995 memcpy(ptr + (*mgmt_ie_len), vndrie_info->ie_ptr,
3996 vndrie_info->ie_len);
3997 *mgmt_ie_len += vndrie_info->ie_len;
3999 curr_ie_buf += del_add_ie_buf_len;
4000 total_ie_buf_len += del_add_ie_buf_len;
4003 if (total_ie_buf_len) {
4004 err = brcmf_fil_bsscfg_data_set(ifp, "vndr_ie", iovar_ie_buf,
4007 brcmf_err("vndr ie set error : %d\n", err);
4011 kfree(iovar_ie_buf);
4015 s32 brcmf_vif_clear_mgmt_ies(struct brcmf_cfg80211_vif *vif)
4018 BRCMF_VNDR_IE_PRBREQ_FLAG,
4019 BRCMF_VNDR_IE_PRBRSP_FLAG,
4020 BRCMF_VNDR_IE_BEACON_FLAG
4024 for (i = 0; i < ARRAY_SIZE(pktflags); i++)
4025 brcmf_vif_set_mgmt_ie(vif, pktflags[i], NULL, 0);
4027 memset(&vif->saved_ie, 0, sizeof(vif->saved_ie));
4032 brcmf_config_ap_mgmt_ie(struct brcmf_cfg80211_vif *vif,
4033 struct cfg80211_beacon_data *beacon)
4037 /* Set Beacon IEs to FW */
4038 err = brcmf_vif_set_mgmt_ie(vif, BRCMF_VNDR_IE_BEACON_FLAG,
4039 beacon->tail, beacon->tail_len);
4041 brcmf_err("Set Beacon IE Failed\n");
4044 brcmf_dbg(TRACE, "Applied Vndr IEs for Beacon\n");
4046 /* Set Probe Response IEs to FW */
4047 err = brcmf_vif_set_mgmt_ie(vif, BRCMF_VNDR_IE_PRBRSP_FLAG,
4048 beacon->proberesp_ies,
4049 beacon->proberesp_ies_len);
4051 brcmf_err("Set Probe Resp IE Failed\n");
4053 brcmf_dbg(TRACE, "Applied Vndr IEs for Probe Resp\n");
4059 brcmf_cfg80211_start_ap(struct wiphy *wiphy, struct net_device *ndev,
4060 struct cfg80211_ap_settings *settings)
4063 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy);
4064 struct brcmf_if *ifp = netdev_priv(ndev);
4065 const struct brcmf_tlv *ssid_ie;
4066 const struct brcmf_tlv *country_ie;
4067 struct brcmf_ssid_le ssid_le;
4069 const struct brcmf_tlv *rsn_ie;
4070 const struct brcmf_vs_tlv *wpa_ie;
4071 struct brcmf_join_params join_params;
4072 enum nl80211_iftype dev_role;
4073 struct brcmf_fil_bss_enable_le bss_enable;
4078 brcmf_dbg(TRACE, "ctrlchn=%d, center=%d, bw=%d, beacon_interval=%d, dtim_period=%d,\n",
4079 settings->chandef.chan->hw_value,
4080 settings->chandef.center_freq1, settings->chandef.width,
4081 settings->beacon_interval, settings->dtim_period);
4082 brcmf_dbg(TRACE, "ssid=%s(%zu), auth_type=%d, inactivity_timeout=%d\n",
4083 settings->ssid, settings->ssid_len, settings->auth_type,
4084 settings->inactivity_timeout);
4085 dev_role = ifp->vif->wdev.iftype;
4086 mbss = ifp->vif->mbss;
4088 /* store current 11d setting */
4089 brcmf_fil_cmd_int_get(ifp, BRCMF_C_GET_REGULATORY, &ifp->vif->is_11d);
4090 country_ie = brcmf_parse_tlvs((u8 *)settings->beacon.tail,
4091 settings->beacon.tail_len,
4093 is_11d = country_ie ? 1 : 0;
4095 memset(&ssid_le, 0, sizeof(ssid_le));
4096 if (settings->ssid == NULL || settings->ssid_len == 0) {
4097 ie_offset = DOT11_MGMT_HDR_LEN + DOT11_BCN_PRB_FIXED_LEN;
4098 ssid_ie = brcmf_parse_tlvs(
4099 (u8 *)&settings->beacon.head[ie_offset],
4100 settings->beacon.head_len - ie_offset,
4105 memcpy(ssid_le.SSID, ssid_ie->data, ssid_ie->len);
4106 ssid_le.SSID_len = cpu_to_le32(ssid_ie->len);
4107 brcmf_dbg(TRACE, "SSID is (%s) in Head\n", ssid_le.SSID);
4109 memcpy(ssid_le.SSID, settings->ssid, settings->ssid_len);
4110 ssid_le.SSID_len = cpu_to_le32((u32)settings->ssid_len);
4114 brcmf_set_mpc(ifp, 0);
4115 brcmf_configure_arp_offload(ifp, false);
4118 /* find the RSN_IE */
4119 rsn_ie = brcmf_parse_tlvs((u8 *)settings->beacon.tail,
4120 settings->beacon.tail_len, WLAN_EID_RSN);
4122 /* find the WPA_IE */
4123 wpa_ie = brcmf_find_wpaie((u8 *)settings->beacon.tail,
4124 settings->beacon.tail_len);
4126 if ((wpa_ie != NULL || rsn_ie != NULL)) {
4127 brcmf_dbg(TRACE, "WPA(2) IE is found\n");
4128 if (wpa_ie != NULL) {
4130 err = brcmf_configure_wpaie(ifp, wpa_ie, false);
4134 struct brcmf_vs_tlv *tmp_ie;
4136 tmp_ie = (struct brcmf_vs_tlv *)rsn_ie;
4139 err = brcmf_configure_wpaie(ifp, tmp_ie, true);
4144 brcmf_dbg(TRACE, "No WPA(2) IEs found\n");
4145 brcmf_configure_opensecurity(ifp);
4148 brcmf_config_ap_mgmt_ie(ifp->vif, &settings->beacon);
4151 chanspec = chandef_to_chanspec(&cfg->d11inf,
4152 &settings->chandef);
4153 err = brcmf_fil_iovar_int_set(ifp, "chanspec", chanspec);
4155 brcmf_err("Set Channel failed: chspec=%d, %d\n",
4160 if (is_11d != ifp->vif->is_11d) {
4161 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_REGULATORY,
4164 brcmf_err("Regulatory Set Error, %d\n", err);
4168 if (settings->beacon_interval) {
4169 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_BCNPRD,
4170 settings->beacon_interval);
4172 brcmf_err("Beacon Interval Set Error, %d\n",
4177 if (settings->dtim_period) {
4178 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_DTIMPRD,
4179 settings->dtim_period);
4181 brcmf_err("DTIM Interval Set Error, %d\n", err);
4186 if ((dev_role == NL80211_IFTYPE_AP) &&
4187 ((ifp->ifidx == 0) ||
4188 !brcmf_feat_is_enabled(ifp, BRCMF_FEAT_RSDB))) {
4189 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_DOWN, 1);
4191 brcmf_err("BRCMF_C_DOWN error %d\n", err);
4194 brcmf_fil_iovar_int_set(ifp, "apsta", 0);
4197 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_INFRA, 1);
4199 brcmf_err("SET INFRA error %d\n", err);
4202 } else if (WARN_ON(is_11d != ifp->vif->is_11d)) {
4203 /* Multiple-BSS should use same 11d configuration */
4207 if (dev_role == NL80211_IFTYPE_AP) {
4208 if ((brcmf_feat_is_enabled(ifp, BRCMF_FEAT_MBSS)) && (!mbss))
4209 brcmf_fil_iovar_int_set(ifp, "mbss", 1);
4211 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_AP, 1);
4213 brcmf_err("setting AP mode failed %d\n", err);
4216 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_UP, 1);
4218 brcmf_err("BRCMF_C_UP error (%d)\n", err);
4221 /* On DOWN the firmware removes the WEP keys, reconfigure
4222 * them if they were set.
4224 brcmf_cfg80211_reconfigure_wep(ifp);
4226 memset(&join_params, 0, sizeof(join_params));
4227 /* join parameters starts with ssid */
4228 memcpy(&join_params.ssid_le, &ssid_le, sizeof(ssid_le));
4230 err = brcmf_fil_cmd_data_set(ifp, BRCMF_C_SET_SSID,
4231 &join_params, sizeof(join_params));
4233 brcmf_err("SET SSID error (%d)\n", err);
4236 brcmf_dbg(TRACE, "AP mode configuration complete\n");
4238 err = brcmf_fil_bsscfg_data_set(ifp, "ssid", &ssid_le,
4241 brcmf_err("setting ssid failed %d\n", err);
4244 bss_enable.bsscfg_idx = cpu_to_le32(ifp->bssidx);
4245 bss_enable.enable = cpu_to_le32(1);
4246 err = brcmf_fil_iovar_data_set(ifp, "bss", &bss_enable,
4247 sizeof(bss_enable));
4249 brcmf_err("bss_enable config failed %d\n", err);
4253 brcmf_dbg(TRACE, "GO mode configuration complete\n");
4255 set_bit(BRCMF_VIF_STATUS_AP_CREATED, &ifp->vif->sme_state);
4256 brcmf_net_setcarrier(ifp, true);
4259 if ((err) && (!mbss)) {
4260 brcmf_set_mpc(ifp, 1);
4261 brcmf_configure_arp_offload(ifp, true);
4266 static int brcmf_cfg80211_stop_ap(struct wiphy *wiphy, struct net_device *ndev)
4268 struct brcmf_if *ifp = netdev_priv(ndev);
4270 struct brcmf_fil_bss_enable_le bss_enable;
4271 struct brcmf_join_params join_params;
4273 brcmf_dbg(TRACE, "Enter\n");
4275 if (ifp->vif->wdev.iftype == NL80211_IFTYPE_AP) {
4276 /* Due to most likely deauths outstanding we sleep */
4277 /* first to make sure they get processed by fw. */
4280 if (ifp->vif->mbss) {
4281 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_DOWN, 1);
4285 memset(&join_params, 0, sizeof(join_params));
4286 err = brcmf_fil_cmd_data_set(ifp, BRCMF_C_SET_SSID,
4287 &join_params, sizeof(join_params));
4289 brcmf_err("SET SSID error (%d)\n", err);
4290 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_DOWN, 1);
4292 brcmf_err("BRCMF_C_DOWN error %d\n", err);
4293 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_AP, 0);
4295 brcmf_err("setting AP mode failed %d\n", err);
4296 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_INFRA, 0);
4298 brcmf_err("setting INFRA mode failed %d\n", err);
4299 if (brcmf_feat_is_enabled(ifp, BRCMF_FEAT_MBSS))
4300 brcmf_fil_iovar_int_set(ifp, "mbss", 0);
4301 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_REGULATORY,
4304 brcmf_err("restoring REGULATORY setting failed %d\n",
4306 /* Bring device back up so it can be used again */
4307 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_UP, 1);
4309 brcmf_err("BRCMF_C_UP error %d\n", err);
4311 bss_enable.bsscfg_idx = cpu_to_le32(ifp->bssidx);
4312 bss_enable.enable = cpu_to_le32(0);
4313 err = brcmf_fil_iovar_data_set(ifp, "bss", &bss_enable,
4314 sizeof(bss_enable));
4316 brcmf_err("bss_enable config failed %d\n", err);
4318 brcmf_set_mpc(ifp, 1);
4319 brcmf_configure_arp_offload(ifp, true);
4320 clear_bit(BRCMF_VIF_STATUS_AP_CREATED, &ifp->vif->sme_state);
4321 brcmf_net_setcarrier(ifp, false);
4327 brcmf_cfg80211_change_beacon(struct wiphy *wiphy, struct net_device *ndev,
4328 struct cfg80211_beacon_data *info)
4330 struct brcmf_if *ifp = netdev_priv(ndev);
4333 brcmf_dbg(TRACE, "Enter\n");
4335 err = brcmf_config_ap_mgmt_ie(ifp->vif, info);
4341 brcmf_cfg80211_del_station(struct wiphy *wiphy, struct net_device *ndev,
4342 struct station_del_parameters *params)
4344 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy);
4345 struct brcmf_scb_val_le scbval;
4346 struct brcmf_if *ifp = netdev_priv(ndev);
4352 brcmf_dbg(TRACE, "Enter %pM\n", params->mac);
4354 if (ifp->vif == cfg->p2p.bss_idx[P2PAPI_BSSCFG_DEVICE].vif)
4355 ifp = cfg->p2p.bss_idx[P2PAPI_BSSCFG_PRIMARY].vif->ifp;
4356 if (!check_vif_up(ifp->vif))
4359 memcpy(&scbval.ea, params->mac, ETH_ALEN);
4360 scbval.val = cpu_to_le32(params->reason_code);
4361 err = brcmf_fil_cmd_data_set(ifp, BRCMF_C_SCB_DEAUTHENTICATE_FOR_REASON,
4362 &scbval, sizeof(scbval));
4364 brcmf_err("SCB_DEAUTHENTICATE_FOR_REASON failed %d\n", err);
4366 brcmf_dbg(TRACE, "Exit\n");
4371 brcmf_cfg80211_change_station(struct wiphy *wiphy, struct net_device *ndev,
4372 const u8 *mac, struct station_parameters *params)
4374 struct brcmf_if *ifp = netdev_priv(ndev);
4377 brcmf_dbg(TRACE, "Enter, MAC %pM, mask 0x%04x set 0x%04x\n", mac,
4378 params->sta_flags_mask, params->sta_flags_set);
4380 /* Ignore all 00 MAC */
4381 if (is_zero_ether_addr(mac))
4384 if (!(params->sta_flags_mask & BIT(NL80211_STA_FLAG_AUTHORIZED)))
4387 if (params->sta_flags_set & BIT(NL80211_STA_FLAG_AUTHORIZED))
4388 err = brcmf_fil_cmd_data_set(ifp, BRCMF_C_SET_SCB_AUTHORIZE,
4389 (void *)mac, ETH_ALEN);
4391 err = brcmf_fil_cmd_data_set(ifp, BRCMF_C_SET_SCB_DEAUTHORIZE,
4392 (void *)mac, ETH_ALEN);
4394 brcmf_err("Setting SCB (de-)authorize failed, %d\n", err);
4400 brcmf_cfg80211_mgmt_frame_register(struct wiphy *wiphy,
4401 struct wireless_dev *wdev,
4402 u16 frame_type, bool reg)
4404 struct brcmf_cfg80211_vif *vif;
4407 brcmf_dbg(TRACE, "Enter, frame_type %04x, reg=%d\n", frame_type, reg);
4409 mgmt_type = (frame_type & IEEE80211_FCTL_STYPE) >> 4;
4410 vif = container_of(wdev, struct brcmf_cfg80211_vif, wdev);
4412 vif->mgmt_rx_reg |= BIT(mgmt_type);
4414 vif->mgmt_rx_reg &= ~BIT(mgmt_type);
4419 brcmf_cfg80211_mgmt_tx(struct wiphy *wiphy, struct wireless_dev *wdev,
4420 struct cfg80211_mgmt_tx_params *params, u64 *cookie)
4422 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy);
4423 struct ieee80211_channel *chan = params->chan;
4424 const u8 *buf = params->buf;
4425 size_t len = params->len;
4426 const struct ieee80211_mgmt *mgmt;
4427 struct brcmf_cfg80211_vif *vif;
4431 struct brcmf_fil_action_frame_le *action_frame;
4432 struct brcmf_fil_af_params_le *af_params;
4437 brcmf_dbg(TRACE, "Enter\n");
4441 mgmt = (const struct ieee80211_mgmt *)buf;
4443 if (!ieee80211_is_mgmt(mgmt->frame_control)) {
4444 brcmf_err("Driver only allows MGMT packet type\n");
4448 vif = container_of(wdev, struct brcmf_cfg80211_vif, wdev);
4450 if (ieee80211_is_probe_resp(mgmt->frame_control)) {
4451 /* Right now the only reason to get a probe response */
4452 /* is for p2p listen response or for p2p GO from */
4453 /* wpa_supplicant. Unfortunately the probe is send */
4454 /* on primary ndev, while dongle wants it on the p2p */
4455 /* vif. Since this is only reason for a probe */
4456 /* response to be sent, the vif is taken from cfg. */
4457 /* If ever desired to send proberesp for non p2p */
4458 /* response then data should be checked for */
4459 /* "DIRECT-". Note in future supplicant will take */
4460 /* dedicated p2p wdev to do this and then this 'hack'*/
4461 /* is not needed anymore. */
4462 ie_offset = DOT11_MGMT_HDR_LEN +
4463 DOT11_BCN_PRB_FIXED_LEN;
4464 ie_len = len - ie_offset;
4465 if (vif == cfg->p2p.bss_idx[P2PAPI_BSSCFG_PRIMARY].vif)
4466 vif = cfg->p2p.bss_idx[P2PAPI_BSSCFG_DEVICE].vif;
4467 err = brcmf_vif_set_mgmt_ie(vif,
4468 BRCMF_VNDR_IE_PRBRSP_FLAG,
4471 cfg80211_mgmt_tx_status(wdev, *cookie, buf, len, true,
4473 } else if (ieee80211_is_action(mgmt->frame_control)) {
4474 af_params = kzalloc(sizeof(*af_params), GFP_KERNEL);
4475 if (af_params == NULL) {
4476 brcmf_err("unable to allocate frame\n");
4480 action_frame = &af_params->action_frame;
4481 /* Add the packet Id */
4482 action_frame->packet_id = cpu_to_le32(*cookie);
4484 memcpy(&action_frame->da[0], &mgmt->da[0], ETH_ALEN);
4485 memcpy(&af_params->bssid[0], &mgmt->bssid[0], ETH_ALEN);
4486 /* Add the length exepted for 802.11 header */
4487 action_frame->len = cpu_to_le16(len - DOT11_MGMT_HDR_LEN);
4488 /* Add the channel. Use the one specified as parameter if any or
4489 * the current one (got from the firmware) otherwise
4492 freq = chan->center_freq;
4494 brcmf_fil_cmd_int_get(vif->ifp, BRCMF_C_GET_CHANNEL,
4496 chan_nr = ieee80211_frequency_to_channel(freq);
4497 af_params->channel = cpu_to_le32(chan_nr);
4499 memcpy(action_frame->data, &buf[DOT11_MGMT_HDR_LEN],
4500 le16_to_cpu(action_frame->len));
4502 brcmf_dbg(TRACE, "Action frame, cookie=%lld, len=%d, freq=%d\n",
4503 *cookie, le16_to_cpu(action_frame->len), freq);
4505 ack = brcmf_p2p_send_action_frame(cfg, cfg_to_ndev(cfg),
4508 cfg80211_mgmt_tx_status(wdev, *cookie, buf, len, ack,
4512 brcmf_dbg(TRACE, "Unhandled, fc=%04x!!\n", mgmt->frame_control);
4513 brcmf_dbg_hex_dump(true, buf, len, "payload, len=%Zu\n", len);
4522 brcmf_cfg80211_cancel_remain_on_channel(struct wiphy *wiphy,
4523 struct wireless_dev *wdev,
4526 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy);
4527 struct brcmf_cfg80211_vif *vif;
4530 brcmf_dbg(TRACE, "Enter p2p listen cancel\n");
4532 vif = cfg->p2p.bss_idx[P2PAPI_BSSCFG_DEVICE].vif;
4534 brcmf_err("No p2p device available for probe response\n");
4538 brcmf_p2p_cancel_remain_on_channel(vif->ifp);
4543 static int brcmf_cfg80211_crit_proto_start(struct wiphy *wiphy,
4544 struct wireless_dev *wdev,
4545 enum nl80211_crit_proto_id proto,
4548 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy);
4549 struct brcmf_cfg80211_vif *vif;
4551 vif = container_of(wdev, struct brcmf_cfg80211_vif, wdev);
4553 /* only DHCP support for now */
4554 if (proto != NL80211_CRIT_PROTO_DHCP)
4557 /* suppress and abort scanning */
4558 set_bit(BRCMF_SCAN_STATUS_SUPPRESS, &cfg->scan_status);
4559 brcmf_abort_scanning(cfg);
4561 return brcmf_btcoex_set_mode(vif, BRCMF_BTCOEX_DISABLED, duration);
4564 static void brcmf_cfg80211_crit_proto_stop(struct wiphy *wiphy,
4565 struct wireless_dev *wdev)
4567 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy);
4568 struct brcmf_cfg80211_vif *vif;
4570 vif = container_of(wdev, struct brcmf_cfg80211_vif, wdev);
4572 brcmf_btcoex_set_mode(vif, BRCMF_BTCOEX_ENABLED, 0);
4573 clear_bit(BRCMF_SCAN_STATUS_SUPPRESS, &cfg->scan_status);
4577 brcmf_notify_tdls_peer_event(struct brcmf_if *ifp,
4578 const struct brcmf_event_msg *e, void *data)
4580 switch (e->reason) {
4581 case BRCMF_E_REASON_TDLS_PEER_DISCOVERED:
4582 brcmf_dbg(TRACE, "TDLS Peer Discovered\n");
4584 case BRCMF_E_REASON_TDLS_PEER_CONNECTED:
4585 brcmf_dbg(TRACE, "TDLS Peer Connected\n");
4586 brcmf_proto_add_tdls_peer(ifp->drvr, ifp->ifidx, (u8 *)e->addr);
4588 case BRCMF_E_REASON_TDLS_PEER_DISCONNECTED:
4589 brcmf_dbg(TRACE, "TDLS Peer Disconnected\n");
4590 brcmf_proto_delete_peer(ifp->drvr, ifp->ifidx, (u8 *)e->addr);
4597 static int brcmf_convert_nl80211_tdls_oper(enum nl80211_tdls_operation oper)
4602 case NL80211_TDLS_DISCOVERY_REQ:
4603 ret = BRCMF_TDLS_MANUAL_EP_DISCOVERY;
4605 case NL80211_TDLS_SETUP:
4606 ret = BRCMF_TDLS_MANUAL_EP_CREATE;
4608 case NL80211_TDLS_TEARDOWN:
4609 ret = BRCMF_TDLS_MANUAL_EP_DELETE;
4612 brcmf_err("unsupported operation: %d\n", oper);
4618 static int brcmf_cfg80211_tdls_oper(struct wiphy *wiphy,
4619 struct net_device *ndev, const u8 *peer,
4620 enum nl80211_tdls_operation oper)
4622 struct brcmf_if *ifp;
4623 struct brcmf_tdls_iovar_le info;
4626 ret = brcmf_convert_nl80211_tdls_oper(oper);
4630 ifp = netdev_priv(ndev);
4631 memset(&info, 0, sizeof(info));
4632 info.mode = (u8)ret;
4634 memcpy(info.ea, peer, ETH_ALEN);
4636 ret = brcmf_fil_iovar_data_set(ifp, "tdls_endpoint",
4637 &info, sizeof(info));
4639 brcmf_err("tdls_endpoint iovar failed: ret=%d\n", ret);
4644 static struct cfg80211_ops wl_cfg80211_ops = {
4645 .add_virtual_intf = brcmf_cfg80211_add_iface,
4646 .del_virtual_intf = brcmf_cfg80211_del_iface,
4647 .change_virtual_intf = brcmf_cfg80211_change_iface,
4648 .scan = brcmf_cfg80211_scan,
4649 .set_wiphy_params = brcmf_cfg80211_set_wiphy_params,
4650 .join_ibss = brcmf_cfg80211_join_ibss,
4651 .leave_ibss = brcmf_cfg80211_leave_ibss,
4652 .get_station = brcmf_cfg80211_get_station,
4653 .dump_station = brcmf_cfg80211_dump_station,
4654 .set_tx_power = brcmf_cfg80211_set_tx_power,
4655 .get_tx_power = brcmf_cfg80211_get_tx_power,
4656 .add_key = brcmf_cfg80211_add_key,
4657 .del_key = brcmf_cfg80211_del_key,
4658 .get_key = brcmf_cfg80211_get_key,
4659 .set_default_key = brcmf_cfg80211_config_default_key,
4660 .set_default_mgmt_key = brcmf_cfg80211_config_default_mgmt_key,
4661 .set_power_mgmt = brcmf_cfg80211_set_power_mgmt,
4662 .connect = brcmf_cfg80211_connect,
4663 .disconnect = brcmf_cfg80211_disconnect,
4664 .suspend = brcmf_cfg80211_suspend,
4665 .resume = brcmf_cfg80211_resume,
4666 .set_pmksa = brcmf_cfg80211_set_pmksa,
4667 .del_pmksa = brcmf_cfg80211_del_pmksa,
4668 .flush_pmksa = brcmf_cfg80211_flush_pmksa,
4669 .start_ap = brcmf_cfg80211_start_ap,
4670 .stop_ap = brcmf_cfg80211_stop_ap,
4671 .change_beacon = brcmf_cfg80211_change_beacon,
4672 .del_station = brcmf_cfg80211_del_station,
4673 .change_station = brcmf_cfg80211_change_station,
4674 .sched_scan_start = brcmf_cfg80211_sched_scan_start,
4675 .sched_scan_stop = brcmf_cfg80211_sched_scan_stop,
4676 .mgmt_frame_register = brcmf_cfg80211_mgmt_frame_register,
4677 .mgmt_tx = brcmf_cfg80211_mgmt_tx,
4678 .remain_on_channel = brcmf_p2p_remain_on_channel,
4679 .cancel_remain_on_channel = brcmf_cfg80211_cancel_remain_on_channel,
4680 .start_p2p_device = brcmf_p2p_start_device,
4681 .stop_p2p_device = brcmf_p2p_stop_device,
4682 .crit_proto_start = brcmf_cfg80211_crit_proto_start,
4683 .crit_proto_stop = brcmf_cfg80211_crit_proto_stop,
4684 .tdls_oper = brcmf_cfg80211_tdls_oper,
4687 struct brcmf_cfg80211_vif *brcmf_alloc_vif(struct brcmf_cfg80211_info *cfg,
4688 enum nl80211_iftype type,
4691 struct brcmf_cfg80211_vif *vif_walk;
4692 struct brcmf_cfg80211_vif *vif;
4695 brcmf_dbg(TRACE, "allocating virtual interface (size=%zu)\n",
4697 vif = kzalloc(sizeof(*vif), GFP_KERNEL);
4699 return ERR_PTR(-ENOMEM);
4701 vif->wdev.wiphy = cfg->wiphy;
4702 vif->wdev.iftype = type;
4704 vif->pm_block = pm_block;
4707 brcmf_init_prof(&vif->profile);
4709 if (type == NL80211_IFTYPE_AP) {
4711 list_for_each_entry(vif_walk, &cfg->vif_list, list) {
4712 if (vif_walk->wdev.iftype == NL80211_IFTYPE_AP) {
4720 list_add_tail(&vif->list, &cfg->vif_list);
4724 void brcmf_free_vif(struct brcmf_cfg80211_vif *vif)
4726 list_del(&vif->list);
4730 void brcmf_cfg80211_free_netdev(struct net_device *ndev)
4732 struct brcmf_cfg80211_vif *vif;
4733 struct brcmf_if *ifp;
4735 ifp = netdev_priv(ndev);
4739 brcmf_free_vif(vif);
4743 static bool brcmf_is_linkup(const struct brcmf_event_msg *e)
4745 u32 event = e->event_code;
4746 u32 status = e->status;
4748 if (event == BRCMF_E_SET_SSID && status == BRCMF_E_STATUS_SUCCESS) {
4749 brcmf_dbg(CONN, "Processing set ssid\n");
4756 static bool brcmf_is_linkdown(const struct brcmf_event_msg *e)
4758 u32 event = e->event_code;
4759 u16 flags = e->flags;
4761 if ((event == BRCMF_E_DEAUTH) || (event == BRCMF_E_DEAUTH_IND) ||
4762 (event == BRCMF_E_DISASSOC_IND) ||
4763 ((event == BRCMF_E_LINK) && (!(flags & BRCMF_EVENT_MSG_LINK)))) {
4764 brcmf_dbg(CONN, "Processing link down\n");
4770 static bool brcmf_is_nonetwork(struct brcmf_cfg80211_info *cfg,
4771 const struct brcmf_event_msg *e)
4773 u32 event = e->event_code;
4774 u32 status = e->status;
4776 if (event == BRCMF_E_LINK && status == BRCMF_E_STATUS_NO_NETWORKS) {
4777 brcmf_dbg(CONN, "Processing Link %s & no network found\n",
4778 e->flags & BRCMF_EVENT_MSG_LINK ? "up" : "down");
4782 if (event == BRCMF_E_SET_SSID && status != BRCMF_E_STATUS_SUCCESS) {
4783 brcmf_dbg(CONN, "Processing connecting & no network found\n");
4790 static void brcmf_clear_assoc_ies(struct brcmf_cfg80211_info *cfg)
4792 struct brcmf_cfg80211_connect_info *conn_info = cfg_to_conn(cfg);
4794 kfree(conn_info->req_ie);
4795 conn_info->req_ie = NULL;
4796 conn_info->req_ie_len = 0;
4797 kfree(conn_info->resp_ie);
4798 conn_info->resp_ie = NULL;
4799 conn_info->resp_ie_len = 0;
4802 static s32 brcmf_get_assoc_ies(struct brcmf_cfg80211_info *cfg,
4803 struct brcmf_if *ifp)
4805 struct brcmf_cfg80211_assoc_ielen_le *assoc_info;
4806 struct brcmf_cfg80211_connect_info *conn_info = cfg_to_conn(cfg);
4811 brcmf_clear_assoc_ies(cfg);
4813 err = brcmf_fil_iovar_data_get(ifp, "assoc_info",
4814 cfg->extra_buf, WL_ASSOC_INFO_MAX);
4816 brcmf_err("could not get assoc info (%d)\n", err);
4820 (struct brcmf_cfg80211_assoc_ielen_le *)cfg->extra_buf;
4821 req_len = le32_to_cpu(assoc_info->req_len);
4822 resp_len = le32_to_cpu(assoc_info->resp_len);
4824 err = brcmf_fil_iovar_data_get(ifp, "assoc_req_ies",
4828 brcmf_err("could not get assoc req (%d)\n", err);
4831 conn_info->req_ie_len = req_len;
4833 kmemdup(cfg->extra_buf, conn_info->req_ie_len,
4836 conn_info->req_ie_len = 0;
4837 conn_info->req_ie = NULL;
4840 err = brcmf_fil_iovar_data_get(ifp, "assoc_resp_ies",
4844 brcmf_err("could not get assoc resp (%d)\n", err);
4847 conn_info->resp_ie_len = resp_len;
4848 conn_info->resp_ie =
4849 kmemdup(cfg->extra_buf, conn_info->resp_ie_len,
4852 conn_info->resp_ie_len = 0;
4853 conn_info->resp_ie = NULL;
4855 brcmf_dbg(CONN, "req len (%d) resp len (%d)\n",
4856 conn_info->req_ie_len, conn_info->resp_ie_len);
4862 brcmf_bss_roaming_done(struct brcmf_cfg80211_info *cfg,
4863 struct net_device *ndev,
4864 const struct brcmf_event_msg *e)
4866 struct brcmf_if *ifp = netdev_priv(ndev);
4867 struct brcmf_cfg80211_profile *profile = &ifp->vif->profile;
4868 struct brcmf_cfg80211_connect_info *conn_info = cfg_to_conn(cfg);
4869 struct wiphy *wiphy = cfg_to_wiphy(cfg);
4870 struct ieee80211_channel *notify_channel = NULL;
4871 struct ieee80211_supported_band *band;
4872 struct brcmf_bss_info_le *bi;
4873 struct brcmu_chan ch;
4878 brcmf_dbg(TRACE, "Enter\n");
4880 brcmf_get_assoc_ies(cfg, ifp);
4881 memcpy(profile->bssid, e->addr, ETH_ALEN);
4882 brcmf_update_bss_info(cfg, ifp);
4884 buf = kzalloc(WL_BSS_INFO_MAX, GFP_KERNEL);
4890 /* data sent to dongle has to be little endian */
4891 *(__le32 *)buf = cpu_to_le32(WL_BSS_INFO_MAX);
4892 err = brcmf_fil_cmd_data_get(ifp, BRCMF_C_GET_BSS_INFO,
4893 buf, WL_BSS_INFO_MAX);
4898 bi = (struct brcmf_bss_info_le *)(buf + 4);
4899 ch.chspec = le16_to_cpu(bi->chanspec);
4900 cfg->d11inf.decchspec(&ch);
4902 if (ch.band == BRCMU_CHAN_BAND_2G)
4903 band = wiphy->bands[IEEE80211_BAND_2GHZ];
4905 band = wiphy->bands[IEEE80211_BAND_5GHZ];
4907 freq = ieee80211_channel_to_frequency(ch.chnum, band->band);
4908 notify_channel = ieee80211_get_channel(wiphy, freq);
4912 cfg80211_roamed(ndev, notify_channel, (u8 *)profile->bssid,
4913 conn_info->req_ie, conn_info->req_ie_len,
4914 conn_info->resp_ie, conn_info->resp_ie_len, GFP_KERNEL);
4915 brcmf_dbg(CONN, "Report roaming result\n");
4917 set_bit(BRCMF_VIF_STATUS_CONNECTED, &ifp->vif->sme_state);
4918 brcmf_dbg(TRACE, "Exit\n");
4923 brcmf_bss_connect_done(struct brcmf_cfg80211_info *cfg,
4924 struct net_device *ndev, const struct brcmf_event_msg *e,
4927 struct brcmf_if *ifp = netdev_priv(ndev);
4928 struct brcmf_cfg80211_profile *profile = &ifp->vif->profile;
4929 struct brcmf_cfg80211_connect_info *conn_info = cfg_to_conn(cfg);
4931 brcmf_dbg(TRACE, "Enter\n");
4933 if (test_and_clear_bit(BRCMF_VIF_STATUS_CONNECTING,
4934 &ifp->vif->sme_state)) {
4936 brcmf_get_assoc_ies(cfg, ifp);
4937 memcpy(profile->bssid, e->addr, ETH_ALEN);
4938 brcmf_update_bss_info(cfg, ifp);
4939 set_bit(BRCMF_VIF_STATUS_CONNECTED,
4940 &ifp->vif->sme_state);
4942 cfg80211_connect_result(ndev,
4943 (u8 *)profile->bssid,
4945 conn_info->req_ie_len,
4947 conn_info->resp_ie_len,
4948 completed ? WLAN_STATUS_SUCCESS :
4949 WLAN_STATUS_AUTH_TIMEOUT,
4951 brcmf_dbg(CONN, "Report connect result - connection %s\n",
4952 completed ? "succeeded" : "failed");
4954 brcmf_dbg(TRACE, "Exit\n");
4959 brcmf_notify_connect_status_ap(struct brcmf_cfg80211_info *cfg,
4960 struct net_device *ndev,
4961 const struct brcmf_event_msg *e, void *data)
4963 struct brcmf_if *ifp = netdev_priv(ndev);
4964 static int generation;
4965 u32 event = e->event_code;
4966 u32 reason = e->reason;
4967 struct station_info sinfo;
4969 brcmf_dbg(CONN, "event %d, reason %d\n", event, reason);
4970 if (event == BRCMF_E_LINK && reason == BRCMF_E_REASON_LINK_BSSCFG_DIS &&
4971 ndev != cfg_to_ndev(cfg)) {
4972 brcmf_dbg(CONN, "AP mode link down\n");
4973 complete(&cfg->vif_disabled);
4975 brcmf_remove_interface(ifp);
4979 if (((event == BRCMF_E_ASSOC_IND) || (event == BRCMF_E_REASSOC_IND)) &&
4980 (reason == BRCMF_E_STATUS_SUCCESS)) {
4981 memset(&sinfo, 0, sizeof(sinfo));
4983 brcmf_err("No IEs present in ASSOC/REASSOC_IND");
4986 sinfo.assoc_req_ies = data;
4987 sinfo.assoc_req_ies_len = e->datalen;
4989 sinfo.generation = generation;
4990 cfg80211_new_sta(ndev, e->addr, &sinfo, GFP_KERNEL);
4991 } else if ((event == BRCMF_E_DISASSOC_IND) ||
4992 (event == BRCMF_E_DEAUTH_IND) ||
4993 (event == BRCMF_E_DEAUTH)) {
4994 cfg80211_del_sta(ndev, e->addr, GFP_KERNEL);
5000 brcmf_notify_connect_status(struct brcmf_if *ifp,
5001 const struct brcmf_event_msg *e, void *data)
5003 struct brcmf_cfg80211_info *cfg = ifp->drvr->config;
5004 struct net_device *ndev = ifp->ndev;
5005 struct brcmf_cfg80211_profile *profile = &ifp->vif->profile;
5006 struct ieee80211_channel *chan;
5009 if ((e->event_code == BRCMF_E_DEAUTH) ||
5010 (e->event_code == BRCMF_E_DEAUTH_IND) ||
5011 (e->event_code == BRCMF_E_DISASSOC_IND) ||
5012 ((e->event_code == BRCMF_E_LINK) && (!e->flags))) {
5013 brcmf_proto_delete_peer(ifp->drvr, ifp->ifidx, (u8 *)e->addr);
5016 if (brcmf_is_apmode(ifp->vif)) {
5017 err = brcmf_notify_connect_status_ap(cfg, ndev, e, data);
5018 } else if (brcmf_is_linkup(e)) {
5019 brcmf_dbg(CONN, "Linkup\n");
5020 if (brcmf_is_ibssmode(ifp->vif)) {
5021 chan = ieee80211_get_channel(cfg->wiphy, cfg->channel);
5022 memcpy(profile->bssid, e->addr, ETH_ALEN);
5023 wl_inform_ibss(cfg, ndev, e->addr);
5024 cfg80211_ibss_joined(ndev, e->addr, chan, GFP_KERNEL);
5025 clear_bit(BRCMF_VIF_STATUS_CONNECTING,
5026 &ifp->vif->sme_state);
5027 set_bit(BRCMF_VIF_STATUS_CONNECTED,
5028 &ifp->vif->sme_state);
5030 brcmf_bss_connect_done(cfg, ndev, e, true);
5031 brcmf_net_setcarrier(ifp, true);
5032 } else if (brcmf_is_linkdown(e)) {
5033 brcmf_dbg(CONN, "Linkdown\n");
5034 if (!brcmf_is_ibssmode(ifp->vif)) {
5035 brcmf_bss_connect_done(cfg, ndev, e, false);
5037 brcmf_link_down(ifp->vif, brcmf_map_fw_linkdown_reason(e));
5038 brcmf_init_prof(ndev_to_prof(ndev));
5039 if (ndev != cfg_to_ndev(cfg))
5040 complete(&cfg->vif_disabled);
5041 brcmf_net_setcarrier(ifp, false);
5042 } else if (brcmf_is_nonetwork(cfg, e)) {
5043 if (brcmf_is_ibssmode(ifp->vif))
5044 clear_bit(BRCMF_VIF_STATUS_CONNECTING,
5045 &ifp->vif->sme_state);
5047 brcmf_bss_connect_done(cfg, ndev, e, false);
5054 brcmf_notify_roaming_status(struct brcmf_if *ifp,
5055 const struct brcmf_event_msg *e, void *data)
5057 struct brcmf_cfg80211_info *cfg = ifp->drvr->config;
5058 u32 event = e->event_code;
5059 u32 status = e->status;
5061 if (event == BRCMF_E_ROAM && status == BRCMF_E_STATUS_SUCCESS) {
5062 if (test_bit(BRCMF_VIF_STATUS_CONNECTED, &ifp->vif->sme_state))
5063 brcmf_bss_roaming_done(cfg, ifp->ndev, e);
5065 brcmf_bss_connect_done(cfg, ifp->ndev, e, true);
5072 brcmf_notify_mic_status(struct brcmf_if *ifp,
5073 const struct brcmf_event_msg *e, void *data)
5075 u16 flags = e->flags;
5076 enum nl80211_key_type key_type;
5078 if (flags & BRCMF_EVENT_MSG_GROUP)
5079 key_type = NL80211_KEYTYPE_GROUP;
5081 key_type = NL80211_KEYTYPE_PAIRWISE;
5083 cfg80211_michael_mic_failure(ifp->ndev, (u8 *)&e->addr, key_type, -1,
5089 static s32 brcmf_notify_vif_event(struct brcmf_if *ifp,
5090 const struct brcmf_event_msg *e, void *data)
5092 struct brcmf_cfg80211_info *cfg = ifp->drvr->config;
5093 struct brcmf_if_event *ifevent = (struct brcmf_if_event *)data;
5094 struct brcmf_cfg80211_vif_event *event = &cfg->vif_event;
5095 struct brcmf_cfg80211_vif *vif;
5097 brcmf_dbg(TRACE, "Enter: action %u flags %u ifidx %u bsscfg %u\n",
5098 ifevent->action, ifevent->flags, ifevent->ifidx,
5101 mutex_lock(&event->vif_event_lock);
5102 event->action = ifevent->action;
5105 switch (ifevent->action) {
5106 case BRCMF_E_IF_ADD:
5107 /* waiting process may have timed out */
5108 if (!cfg->vif_event.vif) {
5109 mutex_unlock(&event->vif_event_lock);
5116 vif->wdev.netdev = ifp->ndev;
5117 ifp->ndev->ieee80211_ptr = &vif->wdev;
5118 SET_NETDEV_DEV(ifp->ndev, wiphy_dev(cfg->wiphy));
5120 mutex_unlock(&event->vif_event_lock);
5121 wake_up(&event->vif_wq);
5124 case BRCMF_E_IF_DEL:
5125 mutex_unlock(&event->vif_event_lock);
5126 /* event may not be upon user request */
5127 if (brcmf_cfg80211_vif_event_armed(cfg))
5128 wake_up(&event->vif_wq);
5131 case BRCMF_E_IF_CHANGE:
5132 mutex_unlock(&event->vif_event_lock);
5133 wake_up(&event->vif_wq);
5137 mutex_unlock(&event->vif_event_lock);
5143 static void brcmf_init_conf(struct brcmf_cfg80211_conf *conf)
5145 conf->frag_threshold = (u32)-1;
5146 conf->rts_threshold = (u32)-1;
5147 conf->retry_short = (u32)-1;
5148 conf->retry_long = (u32)-1;
5149 conf->tx_power = -1;
5152 static void brcmf_register_event_handlers(struct brcmf_cfg80211_info *cfg)
5154 brcmf_fweh_register(cfg->pub, BRCMF_E_LINK,
5155 brcmf_notify_connect_status);
5156 brcmf_fweh_register(cfg->pub, BRCMF_E_DEAUTH_IND,
5157 brcmf_notify_connect_status);
5158 brcmf_fweh_register(cfg->pub, BRCMF_E_DEAUTH,
5159 brcmf_notify_connect_status);
5160 brcmf_fweh_register(cfg->pub, BRCMF_E_DISASSOC_IND,
5161 brcmf_notify_connect_status);
5162 brcmf_fweh_register(cfg->pub, BRCMF_E_ASSOC_IND,
5163 brcmf_notify_connect_status);
5164 brcmf_fweh_register(cfg->pub, BRCMF_E_REASSOC_IND,
5165 brcmf_notify_connect_status);
5166 brcmf_fweh_register(cfg->pub, BRCMF_E_ROAM,
5167 brcmf_notify_roaming_status);
5168 brcmf_fweh_register(cfg->pub, BRCMF_E_MIC_ERROR,
5169 brcmf_notify_mic_status);
5170 brcmf_fweh_register(cfg->pub, BRCMF_E_SET_SSID,
5171 brcmf_notify_connect_status);
5172 brcmf_fweh_register(cfg->pub, BRCMF_E_PFN_NET_FOUND,
5173 brcmf_notify_sched_scan_results);
5174 brcmf_fweh_register(cfg->pub, BRCMF_E_IF,
5175 brcmf_notify_vif_event);
5176 brcmf_fweh_register(cfg->pub, BRCMF_E_P2P_PROBEREQ_MSG,
5177 brcmf_p2p_notify_rx_mgmt_p2p_probereq);
5178 brcmf_fweh_register(cfg->pub, BRCMF_E_P2P_DISC_LISTEN_COMPLETE,
5179 brcmf_p2p_notify_listen_complete);
5180 brcmf_fweh_register(cfg->pub, BRCMF_E_ACTION_FRAME_RX,
5181 brcmf_p2p_notify_action_frame_rx);
5182 brcmf_fweh_register(cfg->pub, BRCMF_E_ACTION_FRAME_COMPLETE,
5183 brcmf_p2p_notify_action_tx_complete);
5184 brcmf_fweh_register(cfg->pub, BRCMF_E_ACTION_FRAME_OFF_CHAN_COMPLETE,
5185 brcmf_p2p_notify_action_tx_complete);
5188 static void brcmf_deinit_priv_mem(struct brcmf_cfg80211_info *cfg)
5192 kfree(cfg->escan_ioctl_buf);
5193 cfg->escan_ioctl_buf = NULL;
5194 kfree(cfg->extra_buf);
5195 cfg->extra_buf = NULL;
5196 kfree(cfg->pmk_list);
5197 cfg->pmk_list = NULL;
5200 static s32 brcmf_init_priv_mem(struct brcmf_cfg80211_info *cfg)
5202 cfg->conf = kzalloc(sizeof(*cfg->conf), GFP_KERNEL);
5204 goto init_priv_mem_out;
5205 cfg->escan_ioctl_buf = kzalloc(BRCMF_DCMD_MEDLEN, GFP_KERNEL);
5206 if (!cfg->escan_ioctl_buf)
5207 goto init_priv_mem_out;
5208 cfg->extra_buf = kzalloc(WL_EXTRA_BUF_MAX, GFP_KERNEL);
5209 if (!cfg->extra_buf)
5210 goto init_priv_mem_out;
5211 cfg->pmk_list = kzalloc(sizeof(*cfg->pmk_list), GFP_KERNEL);
5213 goto init_priv_mem_out;
5218 brcmf_deinit_priv_mem(cfg);
5223 static s32 wl_init_priv(struct brcmf_cfg80211_info *cfg)
5227 cfg->scan_request = NULL;
5228 cfg->pwr_save = true;
5229 cfg->active_scan = true; /* we do active scan per default */
5230 cfg->dongle_up = false; /* dongle is not up yet */
5231 err = brcmf_init_priv_mem(cfg);
5234 brcmf_register_event_handlers(cfg);
5235 mutex_init(&cfg->usr_sync);
5236 brcmf_init_escan(cfg);
5237 brcmf_init_conf(cfg->conf);
5238 init_completion(&cfg->vif_disabled);
5242 static void wl_deinit_priv(struct brcmf_cfg80211_info *cfg)
5244 cfg->dongle_up = false; /* dongle down */
5245 brcmf_abort_scanning(cfg);
5246 brcmf_deinit_priv_mem(cfg);
5249 static void init_vif_event(struct brcmf_cfg80211_vif_event *event)
5251 init_waitqueue_head(&event->vif_wq);
5252 mutex_init(&event->vif_event_lock);
5256 brcmf_dongle_roam(struct brcmf_if *ifp, u32 bcn_timeout)
5259 __le32 roamtrigger[2];
5260 __le32 roam_delta[2];
5263 * Setup timeout if Beacons are lost and roam is
5264 * off to report link down
5266 if (brcmf_roamoff) {
5267 err = brcmf_fil_iovar_int_set(ifp, "bcn_timeout", bcn_timeout);
5269 brcmf_err("bcn_timeout error (%d)\n", err);
5270 goto dongle_rom_out;
5275 * Enable/Disable built-in roaming to allow supplicant
5276 * to take care of roaming
5278 brcmf_dbg(INFO, "Internal Roaming = %s\n",
5279 brcmf_roamoff ? "Off" : "On");
5280 err = brcmf_fil_iovar_int_set(ifp, "roam_off", !!(brcmf_roamoff));
5282 brcmf_err("roam_off error (%d)\n", err);
5283 goto dongle_rom_out;
5286 roamtrigger[0] = cpu_to_le32(WL_ROAM_TRIGGER_LEVEL);
5287 roamtrigger[1] = cpu_to_le32(BRCM_BAND_ALL);
5288 err = brcmf_fil_cmd_data_set(ifp, BRCMF_C_SET_ROAM_TRIGGER,
5289 (void *)roamtrigger, sizeof(roamtrigger));
5291 brcmf_err("WLC_SET_ROAM_TRIGGER error (%d)\n", err);
5292 goto dongle_rom_out;
5295 roam_delta[0] = cpu_to_le32(WL_ROAM_DELTA);
5296 roam_delta[1] = cpu_to_le32(BRCM_BAND_ALL);
5297 err = brcmf_fil_cmd_data_set(ifp, BRCMF_C_SET_ROAM_DELTA,
5298 (void *)roam_delta, sizeof(roam_delta));
5300 brcmf_err("WLC_SET_ROAM_DELTA error (%d)\n", err);
5301 goto dongle_rom_out;
5309 brcmf_dongle_scantime(struct brcmf_if *ifp, s32 scan_assoc_time,
5310 s32 scan_unassoc_time, s32 scan_passive_time)
5314 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_SCAN_CHANNEL_TIME,
5317 if (err == -EOPNOTSUPP)
5318 brcmf_dbg(INFO, "Scan assoc time is not supported\n");
5320 brcmf_err("Scan assoc time error (%d)\n", err);
5321 goto dongle_scantime_out;
5323 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_SCAN_UNASSOC_TIME,
5326 if (err == -EOPNOTSUPP)
5327 brcmf_dbg(INFO, "Scan unassoc time is not supported\n");
5329 brcmf_err("Scan unassoc time error (%d)\n", err);
5330 goto dongle_scantime_out;
5333 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_SCAN_PASSIVE_TIME,
5336 if (err == -EOPNOTSUPP)
5337 brcmf_dbg(INFO, "Scan passive time is not supported\n");
5339 brcmf_err("Scan passive time error (%d)\n", err);
5340 goto dongle_scantime_out;
5343 dongle_scantime_out:
5347 static void brcmf_update_bw40_channel_flag(struct ieee80211_channel *channel,
5348 struct brcmu_chan *ch)
5352 ht40_flag = channel->flags & IEEE80211_CHAN_NO_HT40;
5353 if (ch->sb == BRCMU_CHAN_SB_U) {
5354 if (ht40_flag == IEEE80211_CHAN_NO_HT40)
5355 channel->flags &= ~IEEE80211_CHAN_NO_HT40;
5356 channel->flags |= IEEE80211_CHAN_NO_HT40PLUS;
5358 /* It should be one of
5359 * IEEE80211_CHAN_NO_HT40 or
5360 * IEEE80211_CHAN_NO_HT40PLUS
5362 channel->flags &= ~IEEE80211_CHAN_NO_HT40;
5363 if (ht40_flag == IEEE80211_CHAN_NO_HT40)
5364 channel->flags |= IEEE80211_CHAN_NO_HT40MINUS;
5368 static int brcmf_construct_chaninfo(struct brcmf_cfg80211_info *cfg,
5371 struct brcmf_if *ifp = netdev_priv(cfg_to_ndev(cfg));
5372 struct ieee80211_supported_band *band;
5373 struct ieee80211_channel *channel;
5374 struct wiphy *wiphy;
5375 struct brcmf_chanspec_list *list;
5376 struct brcmu_chan ch;
5384 pbuf = kzalloc(BRCMF_DCMD_MEDLEN, GFP_KERNEL);
5389 list = (struct brcmf_chanspec_list *)pbuf;
5391 err = brcmf_fil_iovar_data_get(ifp, "chanspecs", pbuf,
5394 brcmf_err("get chanspecs error (%d)\n", err);
5398 wiphy = cfg_to_wiphy(cfg);
5399 band = wiphy->bands[IEEE80211_BAND_2GHZ];
5401 for (i = 0; i < band->n_channels; i++)
5402 band->channels[i].flags = IEEE80211_CHAN_DISABLED;
5403 band = wiphy->bands[IEEE80211_BAND_5GHZ];
5405 for (i = 0; i < band->n_channels; i++)
5406 band->channels[i].flags = IEEE80211_CHAN_DISABLED;
5408 total = le32_to_cpu(list->count);
5409 for (i = 0; i < total; i++) {
5410 ch.chspec = (u16)le32_to_cpu(list->element[i]);
5411 cfg->d11inf.decchspec(&ch);
5413 if (ch.band == BRCMU_CHAN_BAND_2G) {
5414 band = wiphy->bands[IEEE80211_BAND_2GHZ];
5415 } else if (ch.band == BRCMU_CHAN_BAND_5G) {
5416 band = wiphy->bands[IEEE80211_BAND_5GHZ];
5418 brcmf_err("Invalid channel Spec. 0x%x.\n", ch.chspec);
5423 if (!(bw_cap[band->band] & WLC_BW_40MHZ_BIT) &&
5424 ch.bw == BRCMU_CHAN_BW_40)
5426 if (!(bw_cap[band->band] & WLC_BW_80MHZ_BIT) &&
5427 ch.bw == BRCMU_CHAN_BW_80)
5430 channel = band->channels;
5431 index = band->n_channels;
5432 for (j = 0; j < band->n_channels; j++) {
5433 if (channel[j].hw_value == ch.chnum) {
5438 channel[index].center_freq =
5439 ieee80211_channel_to_frequency(ch.chnum, band->band);
5440 channel[index].hw_value = ch.chnum;
5442 /* assuming the chanspecs order is HT20,
5443 * HT40 upper, HT40 lower, and VHT80.
5445 if (ch.bw == BRCMU_CHAN_BW_80) {
5446 channel[index].flags &= ~IEEE80211_CHAN_NO_80MHZ;
5447 } else if (ch.bw == BRCMU_CHAN_BW_40) {
5448 brcmf_update_bw40_channel_flag(&channel[index], &ch);
5450 /* enable the channel and disable other bandwidths
5451 * for now as mentioned order assure they are enabled
5452 * for subsequent chanspecs.
5454 channel[index].flags = IEEE80211_CHAN_NO_HT40 |
5455 IEEE80211_CHAN_NO_80MHZ;
5456 ch.bw = BRCMU_CHAN_BW_20;
5457 cfg->d11inf.encchspec(&ch);
5458 chaninfo = ch.chspec;
5459 err = brcmf_fil_bsscfg_int_get(ifp, "per_chan_info",
5462 if (chaninfo & WL_CHAN_RADAR)
5463 channel[index].flags |=
5464 (IEEE80211_CHAN_RADAR |
5465 IEEE80211_CHAN_NO_IR);
5466 if (chaninfo & WL_CHAN_PASSIVE)
5467 channel[index].flags |=
5468 IEEE80211_CHAN_NO_IR;
5478 static int brcmf_enable_bw40_2g(struct brcmf_cfg80211_info *cfg)
5480 struct brcmf_if *ifp = netdev_priv(cfg_to_ndev(cfg));
5481 struct ieee80211_supported_band *band;
5482 struct brcmf_fil_bwcap_le band_bwcap;
5483 struct brcmf_chanspec_list *list;
5487 struct brcmu_chan ch;
5491 /* verify support for bw_cap command */
5493 err = brcmf_fil_iovar_int_get(ifp, "bw_cap", &val);
5496 /* only set 2G bandwidth using bw_cap command */
5497 band_bwcap.band = cpu_to_le32(WLC_BAND_2G);
5498 band_bwcap.bw_cap = cpu_to_le32(WLC_BW_CAP_40MHZ);
5499 err = brcmf_fil_iovar_data_set(ifp, "bw_cap", &band_bwcap,
5500 sizeof(band_bwcap));
5502 brcmf_dbg(INFO, "fallback to mimo_bw_cap\n");
5503 val = WLC_N_BW_40ALL;
5504 err = brcmf_fil_iovar_int_set(ifp, "mimo_bw_cap", val);
5508 /* update channel info in 2G band */
5509 pbuf = kzalloc(BRCMF_DCMD_MEDLEN, GFP_KERNEL);
5514 ch.band = BRCMU_CHAN_BAND_2G;
5515 ch.bw = BRCMU_CHAN_BW_40;
5516 ch.sb = BRCMU_CHAN_SB_NONE;
5518 cfg->d11inf.encchspec(&ch);
5520 /* pass encoded chanspec in query */
5521 *(__le16 *)pbuf = cpu_to_le16(ch.chspec);
5523 err = brcmf_fil_iovar_data_get(ifp, "chanspecs", pbuf,
5526 brcmf_err("get chanspecs error (%d)\n", err);
5531 band = cfg_to_wiphy(cfg)->bands[IEEE80211_BAND_2GHZ];
5532 list = (struct brcmf_chanspec_list *)pbuf;
5533 num_chan = le32_to_cpu(list->count);
5534 for (i = 0; i < num_chan; i++) {
5535 ch.chspec = (u16)le32_to_cpu(list->element[i]);
5536 cfg->d11inf.decchspec(&ch);
5537 if (WARN_ON(ch.band != BRCMU_CHAN_BAND_2G))
5539 if (WARN_ON(ch.bw != BRCMU_CHAN_BW_40))
5541 for (j = 0; j < band->n_channels; j++) {
5542 if (band->channels[j].hw_value == ch.chnum)
5545 if (WARN_ON(j == band->n_channels))
5548 brcmf_update_bw40_channel_flag(&band->channels[j], &ch);
5555 static void brcmf_get_bwcap(struct brcmf_if *ifp, u32 bw_cap[])
5557 u32 band, mimo_bwcap;
5561 err = brcmf_fil_iovar_int_get(ifp, "bw_cap", &band);
5563 bw_cap[IEEE80211_BAND_2GHZ] = band;
5565 err = brcmf_fil_iovar_int_get(ifp, "bw_cap", &band);
5567 bw_cap[IEEE80211_BAND_5GHZ] = band;
5573 brcmf_dbg(INFO, "fallback to mimo_bw_cap info\n");
5575 err = brcmf_fil_iovar_int_get(ifp, "mimo_bw_cap", &mimo_bwcap);
5577 /* assume 20MHz if firmware does not give a clue */
5578 mimo_bwcap = WLC_N_BW_20ALL;
5580 switch (mimo_bwcap) {
5581 case WLC_N_BW_40ALL:
5582 bw_cap[IEEE80211_BAND_2GHZ] |= WLC_BW_40MHZ_BIT;
5584 case WLC_N_BW_20IN2G_40IN5G:
5585 bw_cap[IEEE80211_BAND_5GHZ] |= WLC_BW_40MHZ_BIT;
5587 case WLC_N_BW_20ALL:
5588 bw_cap[IEEE80211_BAND_2GHZ] |= WLC_BW_20MHZ_BIT;
5589 bw_cap[IEEE80211_BAND_5GHZ] |= WLC_BW_20MHZ_BIT;
5592 brcmf_err("invalid mimo_bw_cap value\n");
5596 static void brcmf_update_ht_cap(struct ieee80211_supported_band *band,
5597 u32 bw_cap[2], u32 nchain)
5599 band->ht_cap.ht_supported = true;
5600 if (bw_cap[band->band] & WLC_BW_40MHZ_BIT) {
5601 band->ht_cap.cap |= IEEE80211_HT_CAP_SGI_40;
5602 band->ht_cap.cap |= IEEE80211_HT_CAP_SUP_WIDTH_20_40;
5604 band->ht_cap.cap |= IEEE80211_HT_CAP_SGI_20;
5605 band->ht_cap.cap |= IEEE80211_HT_CAP_DSSSCCK40;
5606 band->ht_cap.ampdu_factor = IEEE80211_HT_MAX_AMPDU_64K;
5607 band->ht_cap.ampdu_density = IEEE80211_HT_MPDU_DENSITY_16;
5608 memset(band->ht_cap.mcs.rx_mask, 0xff, nchain);
5609 band->ht_cap.mcs.tx_params = IEEE80211_HT_MCS_TX_DEFINED;
5612 static __le16 brcmf_get_mcs_map(u32 nchain, enum ieee80211_vht_mcs_support supp)
5617 for (i = 0, mcs_map = 0xFFFF; i < nchain; i++)
5618 mcs_map = (mcs_map << 2) | supp;
5620 return cpu_to_le16(mcs_map);
5623 static void brcmf_update_vht_cap(struct ieee80211_supported_band *band,
5624 u32 bw_cap[2], u32 nchain)
5628 /* not allowed in 2.4G band */
5629 if (band->band == IEEE80211_BAND_2GHZ)
5632 band->vht_cap.vht_supported = true;
5633 /* 80MHz is mandatory */
5634 band->vht_cap.cap |= IEEE80211_VHT_CAP_SHORT_GI_80;
5635 if (bw_cap[band->band] & WLC_BW_160MHZ_BIT) {
5636 band->vht_cap.cap |= IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160MHZ;
5637 band->vht_cap.cap |= IEEE80211_VHT_CAP_SHORT_GI_160;
5639 /* all support 256-QAM */
5640 mcs_map = brcmf_get_mcs_map(nchain, IEEE80211_VHT_MCS_SUPPORT_0_9);
5641 band->vht_cap.vht_mcs.rx_mcs_map = mcs_map;
5642 band->vht_cap.vht_mcs.tx_mcs_map = mcs_map;
5645 static int brcmf_setup_wiphybands(struct wiphy *wiphy)
5647 struct brcmf_cfg80211_info *cfg = wiphy_priv(wiphy);
5648 struct brcmf_if *ifp = netdev_priv(cfg_to_ndev(cfg));
5651 u32 bw_cap[2] = { WLC_BW_20MHZ_BIT, WLC_BW_20MHZ_BIT };
5656 struct ieee80211_supported_band *band;
5658 (void)brcmf_fil_iovar_int_get(ifp, "vhtmode", &vhtmode);
5659 err = brcmf_fil_iovar_int_get(ifp, "nmode", &nmode);
5661 brcmf_err("nmode error (%d)\n", err);
5663 brcmf_get_bwcap(ifp, bw_cap);
5665 brcmf_dbg(INFO, "nmode=%d, vhtmode=%d, bw_cap=(%d, %d)\n",
5666 nmode, vhtmode, bw_cap[IEEE80211_BAND_2GHZ],
5667 bw_cap[IEEE80211_BAND_5GHZ]);
5669 err = brcmf_fil_iovar_int_get(ifp, "rxchain", &rxchain);
5671 brcmf_err("rxchain error (%d)\n", err);
5674 for (nchain = 0; rxchain; nchain++)
5675 rxchain = rxchain & (rxchain - 1);
5677 brcmf_dbg(INFO, "nchain=%d\n", nchain);
5679 err = brcmf_construct_chaninfo(cfg, bw_cap);
5681 brcmf_err("brcmf_construct_chaninfo failed (%d)\n", err);
5685 wiphy = cfg_to_wiphy(cfg);
5686 for (i = 0; i < ARRAY_SIZE(wiphy->bands); i++) {
5687 band = wiphy->bands[i];
5692 brcmf_update_ht_cap(band, bw_cap, nchain);
5694 brcmf_update_vht_cap(band, bw_cap, nchain);
5700 static const struct ieee80211_txrx_stypes
5701 brcmf_txrx_stypes[NUM_NL80211_IFTYPES] = {
5702 [NL80211_IFTYPE_STATION] = {
5704 .rx = BIT(IEEE80211_STYPE_ACTION >> 4) |
5705 BIT(IEEE80211_STYPE_PROBE_REQ >> 4)
5707 [NL80211_IFTYPE_P2P_CLIENT] = {
5709 .rx = BIT(IEEE80211_STYPE_ACTION >> 4) |
5710 BIT(IEEE80211_STYPE_PROBE_REQ >> 4)
5712 [NL80211_IFTYPE_P2P_GO] = {
5714 .rx = BIT(IEEE80211_STYPE_ASSOC_REQ >> 4) |
5715 BIT(IEEE80211_STYPE_REASSOC_REQ >> 4) |
5716 BIT(IEEE80211_STYPE_PROBE_REQ >> 4) |
5717 BIT(IEEE80211_STYPE_DISASSOC >> 4) |
5718 BIT(IEEE80211_STYPE_AUTH >> 4) |
5719 BIT(IEEE80211_STYPE_DEAUTH >> 4) |
5720 BIT(IEEE80211_STYPE_ACTION >> 4)
5722 [NL80211_IFTYPE_P2P_DEVICE] = {
5724 .rx = BIT(IEEE80211_STYPE_ACTION >> 4) |
5725 BIT(IEEE80211_STYPE_PROBE_REQ >> 4)
5730 * brcmf_setup_ifmodes() - determine interface modes and combinations.
5732 * @wiphy: wiphy object.
5733 * @ifp: interface object needed for feat module api.
5735 * The interface modes and combinations are determined dynamically here
5736 * based on firmware functionality.
5738 * no p2p and no mbss:
5740 * #STA <= 1, #AP <= 1, channels = 1, 2 total
5744 * #STA <= 1, #AP <= 1, channels = 1, 2 total
5745 * #AP <= 4, matching BI, channels = 1, 4 total
5747 * p2p, no mchan, and mbss:
5749 * #STA <= 1, #P2P-DEV <= 1, #{P2P-CL, P2P-GO} <= 1, channels = 1, 3 total
5750 * #STA <= 1, #P2P-DEV <= 1, #AP <= 1, #P2P-CL <= 1, channels = 1, 4 total
5751 * #AP <= 4, matching BI, channels = 1, 4 total
5753 * p2p, mchan, and mbss:
5755 * #STA <= 1, #P2P-DEV <= 1, #{P2P-CL, P2P-GO} <= 1, channels = 2, 3 total
5756 * #STA <= 1, #P2P-DEV <= 1, #AP <= 1, #P2P-CL <= 1, channels = 1, 4 total
5757 * #AP <= 4, matching BI, channels = 1, 4 total
5759 static int brcmf_setup_ifmodes(struct wiphy *wiphy, struct brcmf_if *ifp)
5761 struct ieee80211_iface_combination *combo = NULL;
5762 struct ieee80211_iface_limit *c0_limits = NULL;
5763 struct ieee80211_iface_limit *p2p_limits = NULL;
5764 struct ieee80211_iface_limit *mbss_limits = NULL;
5768 mbss = brcmf_feat_is_enabled(ifp, BRCMF_FEAT_MBSS);
5769 p2p = brcmf_feat_is_enabled(ifp, BRCMF_FEAT_P2P);
5771 n_combos = 1 + !!p2p + !!mbss;
5772 combo = kcalloc(n_combos, sizeof(*combo), GFP_KERNEL);
5776 c0_limits = kcalloc(p2p ? 3 : 2, sizeof(*c0_limits), GFP_KERNEL);
5781 p2p_limits = kcalloc(4, sizeof(*p2p_limits), GFP_KERNEL);
5787 mbss_limits = kcalloc(1, sizeof(*mbss_limits), GFP_KERNEL);
5792 wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) |
5793 BIT(NL80211_IFTYPE_ADHOC) |
5794 BIT(NL80211_IFTYPE_AP);
5798 combo[c].num_different_channels = 1;
5799 c0_limits[i].max = 1;
5800 c0_limits[i++].types = BIT(NL80211_IFTYPE_STATION);
5802 if (brcmf_feat_is_enabled(ifp, BRCMF_FEAT_MCHAN))
5803 combo[c].num_different_channels = 2;
5804 wiphy->interface_modes |= BIT(NL80211_IFTYPE_P2P_CLIENT) |
5805 BIT(NL80211_IFTYPE_P2P_GO) |
5806 BIT(NL80211_IFTYPE_P2P_DEVICE);
5807 c0_limits[i].max = 1;
5808 c0_limits[i++].types = BIT(NL80211_IFTYPE_P2P_DEVICE);
5809 c0_limits[i].max = 1;
5810 c0_limits[i++].types = BIT(NL80211_IFTYPE_P2P_CLIENT) |
5811 BIT(NL80211_IFTYPE_P2P_GO);
5813 c0_limits[i].max = 1;
5814 c0_limits[i++].types = BIT(NL80211_IFTYPE_AP);
5816 combo[c].max_interfaces = i;
5817 combo[c].n_limits = i;
5818 combo[c].limits = c0_limits;
5823 combo[c].num_different_channels = 1;
5824 p2p_limits[i].max = 1;
5825 p2p_limits[i++].types = BIT(NL80211_IFTYPE_STATION);
5826 p2p_limits[i].max = 1;
5827 p2p_limits[i++].types = BIT(NL80211_IFTYPE_AP);
5828 p2p_limits[i].max = 1;
5829 p2p_limits[i++].types = BIT(NL80211_IFTYPE_P2P_CLIENT);
5830 p2p_limits[i].max = 1;
5831 p2p_limits[i++].types = BIT(NL80211_IFTYPE_P2P_DEVICE);
5832 combo[c].max_interfaces = i;
5833 combo[c].n_limits = i;
5834 combo[c].limits = p2p_limits;
5839 combo[c].beacon_int_infra_match = true;
5840 combo[c].num_different_channels = 1;
5841 mbss_limits[0].max = 4;
5842 mbss_limits[0].types = BIT(NL80211_IFTYPE_AP);
5843 combo[c].max_interfaces = 4;
5844 combo[c].n_limits = 1;
5845 combo[c].limits = mbss_limits;
5847 wiphy->n_iface_combinations = n_combos;
5848 wiphy->iface_combinations = combo;
5859 static void brcmf_wiphy_pno_params(struct wiphy *wiphy)
5861 /* scheduled scan settings */
5862 wiphy->max_sched_scan_ssids = BRCMF_PNO_MAX_PFN_COUNT;
5863 wiphy->max_match_sets = BRCMF_PNO_MAX_PFN_COUNT;
5864 wiphy->max_sched_scan_ie_len = BRCMF_SCAN_IE_LEN_MAX;
5865 wiphy->flags |= WIPHY_FLAG_SUPPORTS_SCHED_SCAN;
5869 static const struct wiphy_wowlan_support brcmf_wowlan_support = {
5870 .flags = WIPHY_WOWLAN_MAGIC_PKT | WIPHY_WOWLAN_DISCONNECT,
5871 .n_patterns = BRCMF_WOWL_MAXPATTERNS,
5872 .pattern_max_len = BRCMF_WOWL_MAXPATTERNSIZE,
5873 .pattern_min_len = 1,
5874 .max_pkt_offset = 1500,
5878 static void brcmf_wiphy_wowl_params(struct wiphy *wiphy)
5882 wiphy->wowlan = &brcmf_wowlan_support;
5886 static int brcmf_setup_wiphy(struct wiphy *wiphy, struct brcmf_if *ifp)
5888 struct brcmf_pub *drvr = ifp->drvr;
5889 const struct ieee80211_iface_combination *combo;
5890 struct ieee80211_supported_band *band;
5891 u16 max_interfaces = 0;
5896 wiphy->max_scan_ssids = WL_NUM_SCAN_MAX;
5897 wiphy->max_scan_ie_len = BRCMF_SCAN_IE_LEN_MAX;
5898 wiphy->max_num_pmkids = WL_NUM_PMKIDS_MAX;
5900 err = brcmf_setup_ifmodes(wiphy, ifp);
5904 for (i = 0, combo = wiphy->iface_combinations;
5905 i < wiphy->n_iface_combinations; i++, combo++) {
5906 max_interfaces = max(max_interfaces, combo->max_interfaces);
5909 for (i = 0; i < max_interfaces && i < ARRAY_SIZE(drvr->addresses);
5911 u8 *addr = drvr->addresses[i].addr;
5913 memcpy(addr, drvr->mac, ETH_ALEN);
5916 addr[ETH_ALEN - 1] ^= i;
5919 wiphy->addresses = drvr->addresses;
5920 wiphy->n_addresses = i;
5922 wiphy->signal_type = CFG80211_SIGNAL_TYPE_MBM;
5923 wiphy->cipher_suites = __wl_cipher_suites;
5924 wiphy->n_cipher_suites = ARRAY_SIZE(__wl_cipher_suites);
5925 wiphy->flags |= WIPHY_FLAG_PS_ON_BY_DEFAULT |
5926 WIPHY_FLAG_OFFCHAN_TX |
5927 WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL |
5928 WIPHY_FLAG_SUPPORTS_TDLS;
5930 wiphy->flags |= WIPHY_FLAG_SUPPORTS_FW_ROAM;
5931 wiphy->mgmt_stypes = brcmf_txrx_stypes;
5932 wiphy->max_remain_on_channel_duration = 5000;
5933 if (brcmf_feat_is_enabled(ifp, BRCMF_FEAT_PNO))
5934 brcmf_wiphy_pno_params(wiphy);
5936 /* vendor commands/events support */
5937 wiphy->vendor_commands = brcmf_vendor_cmds;
5938 wiphy->n_vendor_commands = BRCMF_VNDR_CMDS_LAST - 1;
5940 if (brcmf_feat_is_enabled(ifp, BRCMF_FEAT_WOWL))
5941 brcmf_wiphy_wowl_params(wiphy);
5943 err = brcmf_fil_cmd_data_get(ifp, BRCMF_C_GET_BANDLIST, &bandlist,
5946 brcmf_err("could not obtain band info: err=%d\n", err);
5949 /* first entry in bandlist is number of bands */
5950 n_bands = le32_to_cpu(bandlist[0]);
5951 for (i = 1; i <= n_bands && i < ARRAY_SIZE(bandlist); i++) {
5952 if (bandlist[i] == cpu_to_le32(WLC_BAND_2G)) {
5953 band = kmemdup(&__wl_band_2ghz, sizeof(__wl_band_2ghz),
5958 band->channels = kmemdup(&__wl_2ghz_channels,
5959 sizeof(__wl_2ghz_channels),
5961 if (!band->channels) {
5966 band->n_channels = ARRAY_SIZE(__wl_2ghz_channels);
5967 wiphy->bands[IEEE80211_BAND_2GHZ] = band;
5969 if (bandlist[i] == cpu_to_le32(WLC_BAND_5G)) {
5970 band = kmemdup(&__wl_band_5ghz, sizeof(__wl_band_5ghz),
5975 band->channels = kmemdup(&__wl_5ghz_channels,
5976 sizeof(__wl_5ghz_channels),
5978 if (!band->channels) {
5983 band->n_channels = ARRAY_SIZE(__wl_5ghz_channels);
5984 wiphy->bands[IEEE80211_BAND_5GHZ] = band;
5987 err = brcmf_setup_wiphybands(wiphy);
5991 static s32 brcmf_config_dongle(struct brcmf_cfg80211_info *cfg)
5993 struct net_device *ndev;
5994 struct wireless_dev *wdev;
5995 struct brcmf_if *ifp;
6002 ndev = cfg_to_ndev(cfg);
6003 wdev = ndev->ieee80211_ptr;
6004 ifp = netdev_priv(ndev);
6006 /* make sure RF is ready for work */
6007 brcmf_fil_cmd_int_set(ifp, BRCMF_C_UP, 0);
6009 brcmf_dongle_scantime(ifp, WL_SCAN_CHANNEL_TIME,
6010 WL_SCAN_UNASSOC_TIME, WL_SCAN_PASSIVE_TIME);
6012 power_mode = cfg->pwr_save ? PM_FAST : PM_OFF;
6013 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_PM, power_mode);
6015 goto default_conf_out;
6016 brcmf_dbg(INFO, "power save set to %s\n",
6017 (power_mode ? "enabled" : "disabled"));
6019 err = brcmf_dongle_roam(ifp, WL_BEACON_TIMEOUT);
6021 goto default_conf_out;
6022 err = brcmf_cfg80211_change_iface(wdev->wiphy, ndev, wdev->iftype,
6025 goto default_conf_out;
6027 brcmf_configure_arp_offload(ifp, true);
6029 cfg->dongle_up = true;
6036 static s32 __brcmf_cfg80211_up(struct brcmf_if *ifp)
6038 set_bit(BRCMF_VIF_STATUS_READY, &ifp->vif->sme_state);
6040 return brcmf_config_dongle(ifp->drvr->config);
6043 static s32 __brcmf_cfg80211_down(struct brcmf_if *ifp)
6045 struct brcmf_cfg80211_info *cfg = ifp->drvr->config;
6048 * While going down, if associated with AP disassociate
6049 * from AP to save power
6051 if (check_vif_up(ifp->vif)) {
6052 brcmf_link_down(ifp->vif, WLAN_REASON_UNSPECIFIED);
6054 /* Make sure WPA_Supplicant receives all the event
6055 generated due to DISASSOC call to the fw to keep
6056 the state fw and WPA_Supplicant state consistent
6061 brcmf_abort_scanning(cfg);
6062 clear_bit(BRCMF_VIF_STATUS_READY, &ifp->vif->sme_state);
6067 s32 brcmf_cfg80211_up(struct net_device *ndev)
6069 struct brcmf_if *ifp = netdev_priv(ndev);
6070 struct brcmf_cfg80211_info *cfg = ifp->drvr->config;
6073 mutex_lock(&cfg->usr_sync);
6074 err = __brcmf_cfg80211_up(ifp);
6075 mutex_unlock(&cfg->usr_sync);
6080 s32 brcmf_cfg80211_down(struct net_device *ndev)
6082 struct brcmf_if *ifp = netdev_priv(ndev);
6083 struct brcmf_cfg80211_info *cfg = ifp->drvr->config;
6086 mutex_lock(&cfg->usr_sync);
6087 err = __brcmf_cfg80211_down(ifp);
6088 mutex_unlock(&cfg->usr_sync);
6093 enum nl80211_iftype brcmf_cfg80211_get_iftype(struct brcmf_if *ifp)
6095 struct wireless_dev *wdev = &ifp->vif->wdev;
6097 return wdev->iftype;
6100 bool brcmf_get_vif_state_any(struct brcmf_cfg80211_info *cfg,
6101 unsigned long state)
6103 struct brcmf_cfg80211_vif *vif;
6105 list_for_each_entry(vif, &cfg->vif_list, list) {
6106 if (test_bit(state, &vif->sme_state))
6112 static inline bool vif_event_equals(struct brcmf_cfg80211_vif_event *event,
6117 mutex_lock(&event->vif_event_lock);
6118 evt_action = event->action;
6119 mutex_unlock(&event->vif_event_lock);
6120 return evt_action == action;
6123 void brcmf_cfg80211_arm_vif_event(struct brcmf_cfg80211_info *cfg,
6124 struct brcmf_cfg80211_vif *vif)
6126 struct brcmf_cfg80211_vif_event *event = &cfg->vif_event;
6128 mutex_lock(&event->vif_event_lock);
6131 mutex_unlock(&event->vif_event_lock);
6134 bool brcmf_cfg80211_vif_event_armed(struct brcmf_cfg80211_info *cfg)
6136 struct brcmf_cfg80211_vif_event *event = &cfg->vif_event;
6139 mutex_lock(&event->vif_event_lock);
6140 armed = event->vif != NULL;
6141 mutex_unlock(&event->vif_event_lock);
6145 int brcmf_cfg80211_wait_vif_event_timeout(struct brcmf_cfg80211_info *cfg,
6146 u8 action, ulong timeout)
6148 struct brcmf_cfg80211_vif_event *event = &cfg->vif_event;
6150 return wait_event_timeout(event->vif_wq,
6151 vif_event_equals(event, action), timeout);
6154 static void brcmf_cfg80211_reg_notifier(struct wiphy *wiphy,
6155 struct regulatory_request *req)
6157 struct brcmf_cfg80211_info *cfg = wiphy_priv(wiphy);
6158 struct brcmf_if *ifp = netdev_priv(cfg_to_ndev(cfg));
6159 struct brcmf_fil_country_le ccreq;
6162 brcmf_dbg(TRACE, "enter: initiator=%d, alpha=%c%c\n", req->initiator,
6163 req->alpha2[0], req->alpha2[1]);
6165 /* ignore non-ISO3166 country codes */
6166 for (i = 0; i < sizeof(req->alpha2); i++)
6167 if (req->alpha2[i] < 'A' || req->alpha2[i] > 'Z') {
6168 brcmf_err("not a ISO3166 code\n");
6171 memset(&ccreq, 0, sizeof(ccreq));
6172 ccreq.rev = cpu_to_le32(-1);
6173 memcpy(ccreq.ccode, req->alpha2, sizeof(req->alpha2));
6174 if (brcmf_fil_iovar_data_set(ifp, "country", &ccreq, sizeof(ccreq))) {
6175 brcmf_err("firmware rejected country setting\n");
6178 brcmf_setup_wiphybands(wiphy);
6181 static void brcmf_free_wiphy(struct wiphy *wiphy)
6188 if (wiphy->iface_combinations) {
6189 for (i = 0; i < wiphy->n_iface_combinations; i++)
6190 kfree(wiphy->iface_combinations[i].limits);
6192 kfree(wiphy->iface_combinations);
6193 if (wiphy->bands[IEEE80211_BAND_2GHZ]) {
6194 kfree(wiphy->bands[IEEE80211_BAND_2GHZ]->channels);
6195 kfree(wiphy->bands[IEEE80211_BAND_2GHZ]);
6197 if (wiphy->bands[IEEE80211_BAND_5GHZ]) {
6198 kfree(wiphy->bands[IEEE80211_BAND_5GHZ]->channels);
6199 kfree(wiphy->bands[IEEE80211_BAND_5GHZ]);
6204 struct brcmf_cfg80211_info *brcmf_cfg80211_attach(struct brcmf_pub *drvr,
6205 struct device *busdev,
6208 struct net_device *ndev = brcmf_get_ifp(drvr, 0)->ndev;
6209 struct brcmf_cfg80211_info *cfg;
6210 struct wiphy *wiphy;
6211 struct brcmf_cfg80211_vif *vif;
6212 struct brcmf_if *ifp;
6218 brcmf_err("ndev is invalid\n");
6222 ifp = netdev_priv(ndev);
6223 wiphy = wiphy_new(&wl_cfg80211_ops, sizeof(struct brcmf_cfg80211_info));
6225 brcmf_err("Could not allocate wiphy device\n");
6228 memcpy(wiphy->perm_addr, drvr->mac, ETH_ALEN);
6229 set_wiphy_dev(wiphy, busdev);
6231 cfg = wiphy_priv(wiphy);
6234 init_vif_event(&cfg->vif_event);
6235 INIT_LIST_HEAD(&cfg->vif_list);
6237 vif = brcmf_alloc_vif(cfg, NL80211_IFTYPE_STATION, false);
6242 vif->wdev.netdev = ndev;
6243 ndev->ieee80211_ptr = &vif->wdev;
6244 SET_NETDEV_DEV(ndev, wiphy_dev(cfg->wiphy));
6246 err = wl_init_priv(cfg);
6248 brcmf_err("Failed to init iwm_priv (%d)\n", err);
6249 brcmf_free_vif(vif);
6254 /* determine d11 io type before wiphy setup */
6255 err = brcmf_fil_cmd_int_get(ifp, BRCMF_C_GET_VERSION, &io_type);
6257 brcmf_err("Failed to get D11 version (%d)\n", err);
6260 cfg->d11inf.io_type = (u8)io_type;
6261 brcmu_d11_attach(&cfg->d11inf);
6263 err = brcmf_setup_wiphy(wiphy, ifp);
6267 brcmf_dbg(INFO, "Registering custom regulatory\n");
6268 wiphy->reg_notifier = brcmf_cfg80211_reg_notifier;
6269 wiphy->regulatory_flags |= REGULATORY_CUSTOM_REG;
6270 wiphy_apply_custom_regulatory(wiphy, &brcmf_regdom);
6272 /* firmware defaults to 40MHz disabled in 2G band. We signal
6273 * cfg80211 here that we do and have it decide we can enable
6274 * it. But first check if device does support 2G operation.
6276 if (wiphy->bands[IEEE80211_BAND_2GHZ]) {
6277 cap = &wiphy->bands[IEEE80211_BAND_2GHZ]->ht_cap.cap;
6278 *cap |= IEEE80211_HT_CAP_SUP_WIDTH_20_40;
6280 err = wiphy_register(wiphy);
6282 brcmf_err("Could not register wiphy device (%d)\n", err);
6286 /* If cfg80211 didn't disable 40MHz HT CAP in wiphy_register(),
6287 * setup 40MHz in 2GHz band and enable OBSS scanning.
6289 if (cap && (*cap & IEEE80211_HT_CAP_SUP_WIDTH_20_40)) {
6290 err = brcmf_enable_bw40_2g(cfg);
6292 err = brcmf_fil_iovar_int_set(ifp, "obss_coex",
6293 BRCMF_OBSS_COEX_AUTO);
6295 *cap &= ~IEEE80211_HT_CAP_SUP_WIDTH_20_40;
6297 /* p2p might require that "if-events" get processed by fweh. So
6298 * activate the already registered event handlers now and activate
6299 * the rest when initialization has completed. drvr->config needs to
6300 * be assigned before activating events.
6303 err = brcmf_fweh_activate_events(ifp);
6305 brcmf_err("FWEH activation failed (%d)\n", err);
6306 goto wiphy_unreg_out;
6309 err = brcmf_p2p_attach(cfg, p2pdev_forced);
6311 brcmf_err("P2P initilisation failed (%d)\n", err);
6312 goto wiphy_unreg_out;
6314 err = brcmf_btcoex_attach(cfg);
6316 brcmf_err("BT-coex initialisation failed (%d)\n", err);
6317 brcmf_p2p_detach(&cfg->p2p);
6318 goto wiphy_unreg_out;
6321 err = brcmf_fil_iovar_int_set(ifp, "tdls_enable", 1);
6323 brcmf_dbg(INFO, "TDLS not enabled (%d)\n", err);
6324 wiphy->flags &= ~WIPHY_FLAG_SUPPORTS_TDLS;
6326 brcmf_fweh_register(cfg->pub, BRCMF_E_TDLS_PEER_EVENT,
6327 brcmf_notify_tdls_peer_event);
6330 /* (re-) activate FWEH event handling */
6331 err = brcmf_fweh_activate_events(ifp);
6333 brcmf_err("FWEH activation failed (%d)\n", err);
6334 goto wiphy_unreg_out;
6340 wiphy_unregister(cfg->wiphy);
6342 wl_deinit_priv(cfg);
6343 brcmf_free_vif(vif);
6346 brcmf_free_wiphy(wiphy);
6350 void brcmf_cfg80211_detach(struct brcmf_cfg80211_info *cfg)
6355 brcmf_btcoex_detach(cfg);
6356 wiphy_unregister(cfg->wiphy);
6357 wl_deinit_priv(cfg);
6358 brcmf_free_wiphy(cfg->wiphy);