1 // SPDX-License-Identifier: ISC 2 /* 3 * Copyright (c) 2010 Broadcom Corporation 4 */ 5 6 /* Toplevel file. Relies on dhd_linux.c to send commands to the dongle. */ 7 8 #include <linux/kernel.h> 9 #include <linux/etherdevice.h> 10 #include <linux/module.h> 11 #include <linux/vmalloc.h> 12 #include <net/cfg80211.h> 13 #include <net/netlink.h> 14 #include <uapi/linux/if_arp.h> 15 16 #include <brcmu_utils.h> 17 #include <defs.h> 18 #include <brcmu_wifi.h> 19 #include <brcm_hw_ids.h> 20 #include "core.h" 21 #include "debug.h" 22 #include "tracepoint.h" 23 #include "fwil_types.h" 24 #include "p2p.h" 25 #include "btcoex.h" 26 #include "pno.h" 27 #include "fwsignal.h" 28 #include "cfg80211.h" 29 #include "feature.h" 30 #include "fwil.h" 31 #include "proto.h" 32 #include "vendor.h" 33 #include "bus.h" 34 #include "common.h" 35 #include "fwvid.h" 36 37 #define BRCMF_SCAN_IE_LEN_MAX 2048 38 39 #define WPA_OUI "\x00\x50\xF2" /* WPA OUI */ 40 #define WPA_OUI_TYPE 1 41 #define RSN_OUI "\x00\x0F\xAC" /* RSN OUI */ 42 #define WME_OUI_TYPE 2 43 #define WPS_OUI_TYPE 4 44 45 #define VS_IE_FIXED_HDR_LEN 6 46 #define WPA_IE_VERSION_LEN 2 47 #define WPA_IE_MIN_OUI_LEN 4 48 #define WPA_IE_SUITE_COUNT_LEN 2 49 50 #define WPA_CIPHER_NONE 0 /* None */ 51 #define WPA_CIPHER_WEP_40 1 /* WEP (40-bit) */ 52 #define WPA_CIPHER_TKIP 2 /* TKIP: default for WPA */ 53 #define WPA_CIPHER_AES_CCM 4 /* AES (CCM) */ 54 #define WPA_CIPHER_WEP_104 5 /* WEP (104-bit) */ 55 56 #define RSN_AKM_NONE 0 /* None (IBSS) */ 57 #define RSN_AKM_UNSPECIFIED 1 /* Over 802.1x */ 58 #define RSN_AKM_PSK 2 /* Pre-shared Key */ 59 #define RSN_AKM_SHA256_1X 5 /* SHA256, 802.1X */ 60 #define RSN_AKM_SHA256_PSK 6 /* SHA256, Pre-shared Key */ 61 #define RSN_AKM_SAE 8 /* SAE */ 62 #define RSN_CAP_LEN 2 /* Length of RSN capabilities */ 63 #define RSN_CAP_PTK_REPLAY_CNTR_MASK (BIT(2) | BIT(3)) 64 #define RSN_CAP_MFPR_MASK BIT(6) 65 #define RSN_CAP_MFPC_MASK BIT(7) 66 #define RSN_PMKID_COUNT_LEN 2 67 68 #define VNDR_IE_CMD_LEN 4 /* length of the set command 69 * string :"add", "del" (+ NUL) 70 */ 71 #define VNDR_IE_COUNT_OFFSET 4 72 #define VNDR_IE_PKTFLAG_OFFSET 8 73 #define VNDR_IE_VSIE_OFFSET 12 74 #define VNDR_IE_HDR_SIZE 12 75 #define VNDR_IE_PARSE_LIMIT 5 76 77 #define DOT11_MGMT_HDR_LEN 24 /* d11 management header len */ 78 #define DOT11_BCN_PRB_FIXED_LEN 12 /* beacon/probe fixed length */ 79 80 #define BRCMF_SCAN_JOIN_ACTIVE_DWELL_TIME_MS 320 81 #define BRCMF_SCAN_JOIN_PASSIVE_DWELL_TIME_MS 400 82 #define BRCMF_SCAN_JOIN_PROBE_INTERVAL_MS 20 83 84 #define BRCMF_SCAN_CHANNEL_TIME 40 85 #define BRCMF_SCAN_UNASSOC_TIME 40 86 #define BRCMF_SCAN_PASSIVE_TIME 120 87 88 #define BRCMF_ND_INFO_TIMEOUT msecs_to_jiffies(2000) 89 90 #define BRCMF_PS_MAX_TIMEOUT_MS 2000 91 92 /* Dump obss definitions */ 93 #define ACS_MSRMNT_DELAY 80 94 #define CHAN_NOISE_DUMMY (-80) 95 #define OBSS_TOKEN_IDX 15 96 #define IBSS_TOKEN_IDX 15 97 #define TX_TOKEN_IDX 14 98 #define CTG_TOKEN_IDX 13 99 #define PKT_TOKEN_IDX 15 100 #define IDLE_TOKEN_IDX 12 101 102 #define BRCMF_ASSOC_PARAMS_FIXED_SIZE \ 103 (sizeof(struct brcmf_assoc_params_le) - sizeof(u16)) 104 105 #define BRCMF_MAX_CHANSPEC_LIST \ 106 (BRCMF_DCMD_MEDLEN / sizeof(__le32) - 1) 107 108 struct brcmf_dump_survey { 109 u32 obss; 110 u32 ibss; 111 u32 no_ctg; 112 u32 no_pckt; 113 u32 tx; 114 u32 idle; 115 }; 116 117 struct cca_stats_n_flags { 118 u32 msrmnt_time; /* Time for Measurement (msec) */ 119 u32 msrmnt_done; /* flag set when measurement complete */ 120 char buf[1]; 121 }; 122 123 struct cca_msrmnt_query { 124 u32 msrmnt_query; 125 u32 time_req; 126 }; 127 128 static bool check_vif_up(struct brcmf_cfg80211_vif *vif) 129 { 130 if (!test_bit(BRCMF_VIF_STATUS_READY, &vif->sme_state)) { 131 brcmf_dbg(INFO, "device is not ready : status (%lu)\n", 132 vif->sme_state); 133 return false; 134 } 135 return true; 136 } 137 138 #define RATE_TO_BASE100KBPS(rate) (((rate) * 10) / 2) 139 #define RATETAB_ENT(_rateid, _flags) \ 140 { \ 141 .bitrate = RATE_TO_BASE100KBPS(_rateid), \ 142 .hw_value = (_rateid), \ 143 .flags = (_flags), \ 144 } 145 146 static struct ieee80211_rate __wl_rates[] = { 147 RATETAB_ENT(BRCM_RATE_1M, 0), 148 RATETAB_ENT(BRCM_RATE_2M, IEEE80211_RATE_SHORT_PREAMBLE), 149 RATETAB_ENT(BRCM_RATE_5M5, IEEE80211_RATE_SHORT_PREAMBLE), 150 RATETAB_ENT(BRCM_RATE_11M, IEEE80211_RATE_SHORT_PREAMBLE), 151 RATETAB_ENT(BRCM_RATE_6M, 0), 152 RATETAB_ENT(BRCM_RATE_9M, 0), 153 RATETAB_ENT(BRCM_RATE_12M, 0), 154 RATETAB_ENT(BRCM_RATE_18M, 0), 155 RATETAB_ENT(BRCM_RATE_24M, 0), 156 RATETAB_ENT(BRCM_RATE_36M, 0), 157 RATETAB_ENT(BRCM_RATE_48M, 0), 158 RATETAB_ENT(BRCM_RATE_54M, 0), 159 }; 160 161 #define wl_g_rates (__wl_rates + 0) 162 #define wl_g_rates_size ARRAY_SIZE(__wl_rates) 163 #define wl_a_rates (__wl_rates + 4) 164 #define wl_a_rates_size (wl_g_rates_size - 4) 165 166 #define CHAN2G(_channel, _freq) { \ 167 .band = NL80211_BAND_2GHZ, \ 168 .center_freq = (_freq), \ 169 .hw_value = (_channel), \ 170 .max_antenna_gain = 0, \ 171 .max_power = 30, \ 172 } 173 174 #define CHAN5G(_channel) { \ 175 .band = NL80211_BAND_5GHZ, \ 176 .center_freq = 5000 + (5 * (_channel)), \ 177 .hw_value = (_channel), \ 178 .max_antenna_gain = 0, \ 179 .max_power = 30, \ 180 } 181 182 static struct ieee80211_channel __wl_2ghz_channels[] = { 183 CHAN2G(1, 2412), CHAN2G(2, 2417), CHAN2G(3, 2422), CHAN2G(4, 2427), 184 CHAN2G(5, 2432), CHAN2G(6, 2437), CHAN2G(7, 2442), CHAN2G(8, 2447), 185 CHAN2G(9, 2452), CHAN2G(10, 2457), CHAN2G(11, 2462), CHAN2G(12, 2467), 186 CHAN2G(13, 2472), CHAN2G(14, 2484) 187 }; 188 189 static struct ieee80211_channel __wl_5ghz_channels[] = { 190 CHAN5G(34), CHAN5G(36), CHAN5G(38), CHAN5G(40), CHAN5G(42), 191 CHAN5G(44), CHAN5G(46), CHAN5G(48), CHAN5G(52), CHAN5G(56), 192 CHAN5G(60), CHAN5G(64), CHAN5G(100), CHAN5G(104), CHAN5G(108), 193 CHAN5G(112), CHAN5G(116), CHAN5G(120), CHAN5G(124), CHAN5G(128), 194 CHAN5G(132), CHAN5G(136), CHAN5G(140), CHAN5G(144), CHAN5G(149), 195 CHAN5G(153), CHAN5G(157), CHAN5G(161), CHAN5G(165) 196 }; 197 198 /* Band templates duplicated per wiphy. The channel info 199 * above is added to the band during setup. 200 */ 201 static const struct ieee80211_supported_band __wl_band_2ghz = { 202 .band = NL80211_BAND_2GHZ, 203 .bitrates = wl_g_rates, 204 .n_bitrates = wl_g_rates_size, 205 }; 206 207 static const struct ieee80211_supported_band __wl_band_5ghz = { 208 .band = NL80211_BAND_5GHZ, 209 .bitrates = wl_a_rates, 210 .n_bitrates = wl_a_rates_size, 211 }; 212 213 /* This is to override regulatory domains defined in cfg80211 module (reg.c) 214 * By default world regulatory domain defined in reg.c puts the flags 215 * NL80211_RRF_NO_IR for 5GHz channels (for * 36..48 and 149..165). 216 * With respect to these flags, wpa_supplicant doesn't * start p2p 217 * operations on 5GHz channels. All the changes in world regulatory 218 * domain are to be done here. 219 */ 220 static const struct ieee80211_regdomain brcmf_regdom = { 221 .n_reg_rules = 4, 222 .alpha2 = "99", 223 .reg_rules = { 224 /* IEEE 802.11b/g, channels 1..11 */ 225 REG_RULE(2412-10, 2472+10, 40, 6, 20, 0), 226 /* If any */ 227 /* IEEE 802.11 channel 14 - Only JP enables 228 * this and for 802.11b only 229 */ 230 REG_RULE(2484-10, 2484+10, 20, 6, 20, 0), 231 /* IEEE 802.11a, channel 36..64 */ 232 REG_RULE(5150-10, 5350+10, 160, 6, 20, 0), 233 /* IEEE 802.11a, channel 100..165 */ 234 REG_RULE(5470-10, 5850+10, 160, 6, 20, 0), } 235 }; 236 237 /* Note: brcmf_cipher_suites is an array of int defining which cipher suites 238 * are supported. A pointer to this array and the number of entries is passed 239 * on to upper layers. AES_CMAC defines whether or not the driver supports MFP. 240 * So the cipher suite AES_CMAC has to be the last one in the array, and when 241 * device does not support MFP then the number of suites will be decreased by 1 242 */ 243 static const u32 brcmf_cipher_suites[] = { 244 WLAN_CIPHER_SUITE_WEP40, 245 WLAN_CIPHER_SUITE_WEP104, 246 WLAN_CIPHER_SUITE_TKIP, 247 WLAN_CIPHER_SUITE_CCMP, 248 /* Keep as last entry: */ 249 WLAN_CIPHER_SUITE_AES_CMAC 250 }; 251 252 /* Vendor specific ie. id = 221, oui and type defines exact ie */ 253 struct brcmf_vs_tlv { 254 u8 id; 255 u8 len; 256 u8 oui[3]; 257 u8 oui_type; 258 }; 259 260 struct parsed_vndr_ie_info { 261 u8 *ie_ptr; 262 u32 ie_len; /* total length including id & length field */ 263 struct brcmf_vs_tlv vndrie; 264 }; 265 266 struct parsed_vndr_ies { 267 u32 count; 268 struct parsed_vndr_ie_info ie_info[VNDR_IE_PARSE_LIMIT]; 269 }; 270 271 #define WL_INTERFACE_CREATE_VER_1 1 272 #define WL_INTERFACE_CREATE_VER_2 2 273 #define WL_INTERFACE_CREATE_VER_3 3 274 #define WL_INTERFACE_CREATE_VER_MAX WL_INTERFACE_CREATE_VER_3 275 276 #define WL_INTERFACE_MAC_DONT_USE 0x0 277 #define WL_INTERFACE_MAC_USE 0x2 278 279 #define WL_INTERFACE_CREATE_STA 0x0 280 #define WL_INTERFACE_CREATE_AP 0x1 281 282 struct wl_interface_create_v1 { 283 u16 ver; /* structure version */ 284 u32 flags; /* flags for operation */ 285 u8 mac_addr[ETH_ALEN]; /* MAC address */ 286 u32 wlc_index; /* optional for wlc index */ 287 }; 288 289 struct wl_interface_create_v2 { 290 u16 ver; /* structure version */ 291 u8 pad1[2]; 292 u32 flags; /* flags for operation */ 293 u8 mac_addr[ETH_ALEN]; /* MAC address */ 294 u8 iftype; /* type of interface created */ 295 u8 pad2; 296 u32 wlc_index; /* optional for wlc index */ 297 }; 298 299 struct wl_interface_create_v3 { 300 u16 ver; /* structure version */ 301 u16 len; /* length of structure + data */ 302 u16 fixed_len; /* length of structure */ 303 u8 iftype; /* type of interface created */ 304 u8 wlc_index; /* optional for wlc index */ 305 u32 flags; /* flags for operation */ 306 u8 mac_addr[ETH_ALEN]; /* MAC address */ 307 u8 bssid[ETH_ALEN]; /* optional for BSSID */ 308 u8 if_index; /* interface index request */ 309 u8 pad[3]; 310 u8 data[]; /* Optional for specific data */ 311 }; 312 313 static u8 nl80211_band_to_fwil(enum nl80211_band band) 314 { 315 switch (band) { 316 case NL80211_BAND_2GHZ: 317 return WLC_BAND_2G; 318 case NL80211_BAND_5GHZ: 319 return WLC_BAND_5G; 320 default: 321 WARN_ON(1); 322 break; 323 } 324 return 0; 325 } 326 327 static u16 chandef_to_chanspec(struct brcmu_d11inf *d11inf, 328 struct cfg80211_chan_def *ch) 329 { 330 struct brcmu_chan ch_inf; 331 s32 primary_offset; 332 333 brcmf_dbg(TRACE, "chandef: control %d center %d width %d\n", 334 ch->chan->center_freq, ch->center_freq1, ch->width); 335 ch_inf.chnum = ieee80211_frequency_to_channel(ch->center_freq1); 336 primary_offset = ch->chan->center_freq - ch->center_freq1; 337 switch (ch->width) { 338 case NL80211_CHAN_WIDTH_20: 339 case NL80211_CHAN_WIDTH_20_NOHT: 340 ch_inf.bw = BRCMU_CHAN_BW_20; 341 WARN_ON(primary_offset != 0); 342 break; 343 case NL80211_CHAN_WIDTH_40: 344 ch_inf.bw = BRCMU_CHAN_BW_40; 345 if (primary_offset > 0) 346 ch_inf.sb = BRCMU_CHAN_SB_U; 347 else 348 ch_inf.sb = BRCMU_CHAN_SB_L; 349 break; 350 case NL80211_CHAN_WIDTH_80: 351 ch_inf.bw = BRCMU_CHAN_BW_80; 352 if (primary_offset == -30) 353 ch_inf.sb = BRCMU_CHAN_SB_LL; 354 else if (primary_offset == -10) 355 ch_inf.sb = BRCMU_CHAN_SB_LU; 356 else if (primary_offset == 10) 357 ch_inf.sb = BRCMU_CHAN_SB_UL; 358 else 359 ch_inf.sb = BRCMU_CHAN_SB_UU; 360 break; 361 case NL80211_CHAN_WIDTH_160: 362 ch_inf.bw = BRCMU_CHAN_BW_160; 363 if (primary_offset == -70) 364 ch_inf.sb = BRCMU_CHAN_SB_LLL; 365 else if (primary_offset == -50) 366 ch_inf.sb = BRCMU_CHAN_SB_LLU; 367 else if (primary_offset == -30) 368 ch_inf.sb = BRCMU_CHAN_SB_LUL; 369 else if (primary_offset == -10) 370 ch_inf.sb = BRCMU_CHAN_SB_LUU; 371 else if (primary_offset == 10) 372 ch_inf.sb = BRCMU_CHAN_SB_ULL; 373 else if (primary_offset == 30) 374 ch_inf.sb = BRCMU_CHAN_SB_ULU; 375 else if (primary_offset == 50) 376 ch_inf.sb = BRCMU_CHAN_SB_UUL; 377 else 378 ch_inf.sb = BRCMU_CHAN_SB_UUU; 379 break; 380 case NL80211_CHAN_WIDTH_80P80: 381 case NL80211_CHAN_WIDTH_5: 382 case NL80211_CHAN_WIDTH_10: 383 default: 384 WARN_ON_ONCE(1); 385 } 386 switch (ch->chan->band) { 387 case NL80211_BAND_2GHZ: 388 ch_inf.band = BRCMU_CHAN_BAND_2G; 389 break; 390 case NL80211_BAND_5GHZ: 391 ch_inf.band = BRCMU_CHAN_BAND_5G; 392 break; 393 case NL80211_BAND_60GHZ: 394 default: 395 WARN_ON_ONCE(1); 396 } 397 d11inf->encchspec(&ch_inf); 398 399 brcmf_dbg(TRACE, "chanspec: 0x%x\n", ch_inf.chspec); 400 return ch_inf.chspec; 401 } 402 403 u16 channel_to_chanspec(struct brcmu_d11inf *d11inf, 404 struct ieee80211_channel *ch) 405 { 406 struct brcmu_chan ch_inf; 407 408 ch_inf.chnum = ieee80211_frequency_to_channel(ch->center_freq); 409 ch_inf.bw = BRCMU_CHAN_BW_20; 410 d11inf->encchspec(&ch_inf); 411 412 return ch_inf.chspec; 413 } 414 415 /* Traverse a string of 1-byte tag/1-byte length/variable-length value 416 * triples, returning a pointer to the substring whose first element 417 * matches tag 418 */ 419 static const struct brcmf_tlv * 420 brcmf_parse_tlvs(const void *buf, int buflen, uint key) 421 { 422 const struct brcmf_tlv *elt = buf; 423 int totlen = buflen; 424 425 /* find tagged parameter */ 426 while (totlen >= TLV_HDR_LEN) { 427 int len = elt->len; 428 429 /* validate remaining totlen */ 430 if ((elt->id == key) && (totlen >= (len + TLV_HDR_LEN))) 431 return elt; 432 433 elt = (struct brcmf_tlv *)((u8 *)elt + (len + TLV_HDR_LEN)); 434 totlen -= (len + TLV_HDR_LEN); 435 } 436 437 return NULL; 438 } 439 440 /* Is any of the tlvs the expected entry? If 441 * not update the tlvs buffer pointer/length. 442 */ 443 static bool 444 brcmf_tlv_has_ie(const u8 *ie, const u8 **tlvs, u32 *tlvs_len, 445 const u8 *oui, u32 oui_len, u8 type) 446 { 447 /* If the contents match the OUI and the type */ 448 if (ie[TLV_LEN_OFF] >= oui_len + 1 && 449 !memcmp(&ie[TLV_BODY_OFF], oui, oui_len) && 450 type == ie[TLV_BODY_OFF + oui_len]) { 451 return true; 452 } 453 454 if (tlvs == NULL) 455 return false; 456 /* point to the next ie */ 457 ie += ie[TLV_LEN_OFF] + TLV_HDR_LEN; 458 /* calculate the length of the rest of the buffer */ 459 *tlvs_len -= (int)(ie - *tlvs); 460 /* update the pointer to the start of the buffer */ 461 *tlvs = ie; 462 463 return false; 464 } 465 466 static struct brcmf_vs_tlv * 467 brcmf_find_wpaie(const u8 *parse, u32 len) 468 { 469 const struct brcmf_tlv *ie; 470 471 while ((ie = brcmf_parse_tlvs(parse, len, WLAN_EID_VENDOR_SPECIFIC))) { 472 if (brcmf_tlv_has_ie((const u8 *)ie, &parse, &len, 473 WPA_OUI, TLV_OUI_LEN, WPA_OUI_TYPE)) 474 return (struct brcmf_vs_tlv *)ie; 475 } 476 return NULL; 477 } 478 479 static struct brcmf_vs_tlv * 480 brcmf_find_wpsie(const u8 *parse, u32 len) 481 { 482 const struct brcmf_tlv *ie; 483 484 while ((ie = brcmf_parse_tlvs(parse, len, WLAN_EID_VENDOR_SPECIFIC))) { 485 if (brcmf_tlv_has_ie((u8 *)ie, &parse, &len, 486 WPA_OUI, TLV_OUI_LEN, WPS_OUI_TYPE)) 487 return (struct brcmf_vs_tlv *)ie; 488 } 489 return NULL; 490 } 491 492 static int brcmf_vif_change_validate(struct brcmf_cfg80211_info *cfg, 493 struct brcmf_cfg80211_vif *vif, 494 enum nl80211_iftype new_type) 495 { 496 struct brcmf_cfg80211_vif *pos; 497 bool check_combos = false; 498 int ret = 0; 499 struct iface_combination_params params = { 500 .num_different_channels = 1, 501 }; 502 503 list_for_each_entry(pos, &cfg->vif_list, list) 504 if (pos == vif) { 505 params.iftype_num[new_type]++; 506 } else { 507 /* concurrent interfaces so need check combinations */ 508 check_combos = true; 509 params.iftype_num[pos->wdev.iftype]++; 510 } 511 512 if (check_combos) 513 ret = cfg80211_check_combinations(cfg->wiphy, ¶ms); 514 515 return ret; 516 } 517 518 static int brcmf_vif_add_validate(struct brcmf_cfg80211_info *cfg, 519 enum nl80211_iftype new_type) 520 { 521 struct brcmf_cfg80211_vif *pos; 522 struct iface_combination_params params = { 523 .num_different_channels = 1, 524 }; 525 526 list_for_each_entry(pos, &cfg->vif_list, list) 527 params.iftype_num[pos->wdev.iftype]++; 528 529 params.iftype_num[new_type]++; 530 return cfg80211_check_combinations(cfg->wiphy, ¶ms); 531 } 532 533 static void convert_key_from_CPU(struct brcmf_wsec_key *key, 534 struct brcmf_wsec_key_le *key_le) 535 { 536 key_le->index = cpu_to_le32(key->index); 537 key_le->len = cpu_to_le32(key->len); 538 key_le->algo = cpu_to_le32(key->algo); 539 key_le->flags = cpu_to_le32(key->flags); 540 key_le->rxiv.hi = cpu_to_le32(key->rxiv.hi); 541 key_le->rxiv.lo = cpu_to_le16(key->rxiv.lo); 542 key_le->iv_initialized = cpu_to_le32(key->iv_initialized); 543 memcpy(key_le->data, key->data, sizeof(key->data)); 544 memcpy(key_le->ea, key->ea, sizeof(key->ea)); 545 } 546 547 static int 548 send_key_to_dongle(struct brcmf_if *ifp, struct brcmf_wsec_key *key) 549 { 550 struct brcmf_pub *drvr = ifp->drvr; 551 int err; 552 struct brcmf_wsec_key_le key_le; 553 554 convert_key_from_CPU(key, &key_le); 555 556 brcmf_netdev_wait_pend8021x(ifp); 557 558 err = brcmf_fil_bsscfg_data_set(ifp, "wsec_key", &key_le, 559 sizeof(key_le)); 560 561 if (err) 562 bphy_err(drvr, "wsec_key error (%d)\n", err); 563 return err; 564 } 565 566 static void 567 brcmf_cfg80211_update_proto_addr_mode(struct wireless_dev *wdev) 568 { 569 struct brcmf_cfg80211_vif *vif; 570 struct brcmf_if *ifp; 571 572 vif = container_of(wdev, struct brcmf_cfg80211_vif, wdev); 573 ifp = vif->ifp; 574 575 if ((wdev->iftype == NL80211_IFTYPE_ADHOC) || 576 (wdev->iftype == NL80211_IFTYPE_AP) || 577 (wdev->iftype == NL80211_IFTYPE_P2P_GO)) 578 brcmf_proto_configure_addr_mode(ifp->drvr, ifp->ifidx, 579 ADDR_DIRECT); 580 else 581 brcmf_proto_configure_addr_mode(ifp->drvr, ifp->ifidx, 582 ADDR_INDIRECT); 583 } 584 585 static int brcmf_get_first_free_bsscfgidx(struct brcmf_pub *drvr) 586 { 587 int bsscfgidx; 588 589 for (bsscfgidx = 0; bsscfgidx < BRCMF_MAX_IFS; bsscfgidx++) { 590 /* bsscfgidx 1 is reserved for legacy P2P */ 591 if (bsscfgidx == 1) 592 continue; 593 if (!drvr->iflist[bsscfgidx]) 594 return bsscfgidx; 595 } 596 597 return -ENOMEM; 598 } 599 600 static void brcmf_set_vif_sta_macaddr(struct brcmf_if *ifp, u8 *mac_addr) 601 { 602 u8 mac_idx = ifp->drvr->sta_mac_idx; 603 604 /* set difference MAC address with locally administered bit */ 605 memcpy(mac_addr, ifp->mac_addr, ETH_ALEN); 606 mac_addr[0] |= 0x02; 607 mac_addr[3] ^= mac_idx ? 0xC0 : 0xA0; 608 mac_idx++; 609 mac_idx = mac_idx % 2; 610 ifp->drvr->sta_mac_idx = mac_idx; 611 } 612 613 static int brcmf_cfg80211_request_sta_if(struct brcmf_if *ifp, u8 *macaddr) 614 { 615 struct wl_interface_create_v1 iface_v1; 616 struct wl_interface_create_v2 iface_v2; 617 struct wl_interface_create_v3 iface_v3; 618 u32 iface_create_ver; 619 int err; 620 621 /* interface_create version 1 */ 622 memset(&iface_v1, 0, sizeof(iface_v1)); 623 iface_v1.ver = WL_INTERFACE_CREATE_VER_1; 624 iface_v1.flags = WL_INTERFACE_CREATE_STA | 625 WL_INTERFACE_MAC_USE; 626 if (!is_zero_ether_addr(macaddr)) 627 memcpy(iface_v1.mac_addr, macaddr, ETH_ALEN); 628 else 629 brcmf_set_vif_sta_macaddr(ifp, iface_v1.mac_addr); 630 631 err = brcmf_fil_iovar_data_get(ifp, "interface_create", 632 &iface_v1, 633 sizeof(iface_v1)); 634 if (err) { 635 brcmf_info("failed to create interface(v1), err=%d\n", 636 err); 637 } else { 638 brcmf_dbg(INFO, "interface created(v1)\n"); 639 return 0; 640 } 641 642 /* interface_create version 2 */ 643 memset(&iface_v2, 0, sizeof(iface_v2)); 644 iface_v2.ver = WL_INTERFACE_CREATE_VER_2; 645 iface_v2.flags = WL_INTERFACE_MAC_USE; 646 iface_v2.iftype = WL_INTERFACE_CREATE_STA; 647 if (!is_zero_ether_addr(macaddr)) 648 memcpy(iface_v2.mac_addr, macaddr, ETH_ALEN); 649 else 650 brcmf_set_vif_sta_macaddr(ifp, iface_v2.mac_addr); 651 652 err = brcmf_fil_iovar_data_get(ifp, "interface_create", 653 &iface_v2, 654 sizeof(iface_v2)); 655 if (err) { 656 brcmf_info("failed to create interface(v2), err=%d\n", 657 err); 658 } else { 659 brcmf_dbg(INFO, "interface created(v2)\n"); 660 return 0; 661 } 662 663 /* interface_create version 3+ */ 664 /* get supported version from firmware side */ 665 iface_create_ver = 0; 666 err = brcmf_fil_bsscfg_int_get(ifp, "interface_create", 667 &iface_create_ver); 668 if (err) { 669 brcmf_err("fail to get supported version, err=%d\n", err); 670 return -EOPNOTSUPP; 671 } 672 673 switch (iface_create_ver) { 674 case WL_INTERFACE_CREATE_VER_3: 675 memset(&iface_v3, 0, sizeof(iface_v3)); 676 iface_v3.ver = WL_INTERFACE_CREATE_VER_3; 677 iface_v3.flags = WL_INTERFACE_MAC_USE; 678 iface_v3.iftype = WL_INTERFACE_CREATE_STA; 679 if (!is_zero_ether_addr(macaddr)) 680 memcpy(iface_v3.mac_addr, macaddr, ETH_ALEN); 681 else 682 brcmf_set_vif_sta_macaddr(ifp, iface_v3.mac_addr); 683 684 err = brcmf_fil_iovar_data_get(ifp, "interface_create", 685 &iface_v3, 686 sizeof(iface_v3)); 687 688 if (!err) 689 brcmf_dbg(INFO, "interface created(v3)\n"); 690 break; 691 default: 692 brcmf_err("not support interface create(v%d)\n", 693 iface_create_ver); 694 err = -EOPNOTSUPP; 695 break; 696 } 697 698 if (err) { 699 brcmf_info("station interface creation failed (%d)\n", 700 err); 701 return -EIO; 702 } 703 704 return 0; 705 } 706 707 static int brcmf_cfg80211_request_ap_if(struct brcmf_if *ifp) 708 { 709 struct wl_interface_create_v1 iface_v1; 710 struct wl_interface_create_v2 iface_v2; 711 struct wl_interface_create_v3 iface_v3; 712 u32 iface_create_ver; 713 struct brcmf_pub *drvr = ifp->drvr; 714 struct brcmf_mbss_ssid_le mbss_ssid_le; 715 int bsscfgidx; 716 int err; 717 718 /* interface_create version 1 */ 719 memset(&iface_v1, 0, sizeof(iface_v1)); 720 iface_v1.ver = WL_INTERFACE_CREATE_VER_1; 721 iface_v1.flags = WL_INTERFACE_CREATE_AP | 722 WL_INTERFACE_MAC_USE; 723 724 brcmf_set_vif_sta_macaddr(ifp, iface_v1.mac_addr); 725 726 err = brcmf_fil_iovar_data_get(ifp, "interface_create", 727 &iface_v1, 728 sizeof(iface_v1)); 729 if (err) { 730 brcmf_info("failed to create interface(v1), err=%d\n", 731 err); 732 } else { 733 brcmf_dbg(INFO, "interface created(v1)\n"); 734 return 0; 735 } 736 737 /* interface_create version 2 */ 738 memset(&iface_v2, 0, sizeof(iface_v2)); 739 iface_v2.ver = WL_INTERFACE_CREATE_VER_2; 740 iface_v2.flags = WL_INTERFACE_MAC_USE; 741 iface_v2.iftype = WL_INTERFACE_CREATE_AP; 742 743 brcmf_set_vif_sta_macaddr(ifp, iface_v2.mac_addr); 744 745 err = brcmf_fil_iovar_data_get(ifp, "interface_create", 746 &iface_v2, 747 sizeof(iface_v2)); 748 if (err) { 749 brcmf_info("failed to create interface(v2), err=%d\n", 750 err); 751 } else { 752 brcmf_dbg(INFO, "interface created(v2)\n"); 753 return 0; 754 } 755 756 /* interface_create version 3+ */ 757 /* get supported version from firmware side */ 758 iface_create_ver = 0; 759 err = brcmf_fil_bsscfg_int_get(ifp, "interface_create", 760 &iface_create_ver); 761 if (err) { 762 brcmf_err("fail to get supported version, err=%d\n", err); 763 return -EOPNOTSUPP; 764 } 765 766 switch (iface_create_ver) { 767 case WL_INTERFACE_CREATE_VER_3: 768 memset(&iface_v3, 0, sizeof(iface_v3)); 769 iface_v3.ver = WL_INTERFACE_CREATE_VER_3; 770 iface_v3.flags = WL_INTERFACE_MAC_USE; 771 iface_v3.iftype = WL_INTERFACE_CREATE_AP; 772 brcmf_set_vif_sta_macaddr(ifp, iface_v3.mac_addr); 773 774 err = brcmf_fil_iovar_data_get(ifp, "interface_create", 775 &iface_v3, 776 sizeof(iface_v3)); 777 778 if (!err) 779 brcmf_dbg(INFO, "interface created(v3)\n"); 780 break; 781 default: 782 brcmf_err("not support interface create(v%d)\n", 783 iface_create_ver); 784 err = -EOPNOTSUPP; 785 break; 786 } 787 788 if (err) { 789 brcmf_info("Does not support interface_create (%d)\n", 790 err); 791 memset(&mbss_ssid_le, 0, sizeof(mbss_ssid_le)); 792 bsscfgidx = brcmf_get_first_free_bsscfgidx(ifp->drvr); 793 if (bsscfgidx < 0) 794 return bsscfgidx; 795 796 mbss_ssid_le.bsscfgidx = cpu_to_le32(bsscfgidx); 797 mbss_ssid_le.SSID_len = cpu_to_le32(5); 798 sprintf(mbss_ssid_le.SSID, "ssid%d", bsscfgidx); 799 800 err = brcmf_fil_bsscfg_data_set(ifp, "bsscfg:ssid", &mbss_ssid_le, 801 sizeof(mbss_ssid_le)); 802 803 if (err < 0) 804 bphy_err(drvr, "setting ssid failed %d\n", err); 805 } 806 807 return err; 808 } 809 810 /** 811 * brcmf_apsta_add_vif() - create a new AP or STA virtual interface 812 * 813 * @wiphy: wiphy device of new interface. 814 * @name: name of the new interface. 815 * @params: contains mac address for AP or STA device. 816 * @type: interface type. 817 */ 818 static 819 struct wireless_dev *brcmf_apsta_add_vif(struct wiphy *wiphy, const char *name, 820 struct vif_params *params, 821 enum nl80211_iftype type) 822 { 823 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy); 824 struct brcmf_if *ifp = netdev_priv(cfg_to_ndev(cfg)); 825 struct brcmf_pub *drvr = cfg->pub; 826 struct brcmf_cfg80211_vif *vif; 827 int err; 828 829 if (type != NL80211_IFTYPE_STATION && type != NL80211_IFTYPE_AP) 830 return ERR_PTR(-EINVAL); 831 832 if (brcmf_cfg80211_vif_event_armed(cfg)) 833 return ERR_PTR(-EBUSY); 834 835 brcmf_dbg(INFO, "Adding vif \"%s\"\n", name); 836 837 vif = brcmf_alloc_vif(cfg, type); 838 if (IS_ERR(vif)) 839 return (struct wireless_dev *)vif; 840 841 brcmf_cfg80211_arm_vif_event(cfg, vif); 842 843 if (type == NL80211_IFTYPE_STATION) 844 err = brcmf_cfg80211_request_sta_if(ifp, params->macaddr); 845 else 846 err = brcmf_cfg80211_request_ap_if(ifp); 847 if (err) { 848 brcmf_cfg80211_arm_vif_event(cfg, NULL); 849 goto fail; 850 } 851 852 /* wait for firmware event */ 853 err = brcmf_cfg80211_wait_vif_event(cfg, BRCMF_E_IF_ADD, 854 BRCMF_VIF_EVENT_TIMEOUT); 855 brcmf_cfg80211_arm_vif_event(cfg, NULL); 856 if (!err) { 857 bphy_err(drvr, "timeout occurred\n"); 858 err = -EIO; 859 goto fail; 860 } 861 862 /* interface created in firmware */ 863 ifp = vif->ifp; 864 if (!ifp) { 865 bphy_err(drvr, "no if pointer provided\n"); 866 err = -ENOENT; 867 goto fail; 868 } 869 870 strscpy(ifp->ndev->name, name, sizeof(ifp->ndev->name)); 871 err = brcmf_net_attach(ifp, true); 872 if (err) { 873 bphy_err(drvr, "Registering netdevice failed\n"); 874 free_netdev(ifp->ndev); 875 goto fail; 876 } 877 878 return &ifp->vif->wdev; 879 880 fail: 881 brcmf_free_vif(vif); 882 return ERR_PTR(err); 883 } 884 885 static bool brcmf_is_apmode(struct brcmf_cfg80211_vif *vif) 886 { 887 enum nl80211_iftype iftype; 888 889 iftype = vif->wdev.iftype; 890 return iftype == NL80211_IFTYPE_AP || iftype == NL80211_IFTYPE_P2P_GO; 891 } 892 893 static bool brcmf_is_ibssmode(struct brcmf_cfg80211_vif *vif) 894 { 895 return vif->wdev.iftype == NL80211_IFTYPE_ADHOC; 896 } 897 898 /** 899 * brcmf_mon_add_vif() - create monitor mode virtual interface 900 * 901 * @wiphy: wiphy device of new interface. 902 * @name: name of the new interface. 903 */ 904 static struct wireless_dev *brcmf_mon_add_vif(struct wiphy *wiphy, 905 const char *name) 906 { 907 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy); 908 struct brcmf_cfg80211_vif *vif; 909 struct net_device *ndev; 910 struct brcmf_if *ifp; 911 int err; 912 913 if (cfg->pub->mon_if) { 914 err = -EEXIST; 915 goto err_out; 916 } 917 918 vif = brcmf_alloc_vif(cfg, NL80211_IFTYPE_MONITOR); 919 if (IS_ERR(vif)) { 920 err = PTR_ERR(vif); 921 goto err_out; 922 } 923 924 ndev = alloc_netdev(sizeof(*ifp), name, NET_NAME_UNKNOWN, ether_setup); 925 if (!ndev) { 926 err = -ENOMEM; 927 goto err_free_vif; 928 } 929 ndev->type = ARPHRD_IEEE80211_RADIOTAP; 930 ndev->ieee80211_ptr = &vif->wdev; 931 ndev->needs_free_netdev = true; 932 ndev->priv_destructor = brcmf_cfg80211_free_netdev; 933 SET_NETDEV_DEV(ndev, wiphy_dev(cfg->wiphy)); 934 935 ifp = netdev_priv(ndev); 936 ifp->vif = vif; 937 ifp->ndev = ndev; 938 ifp->drvr = cfg->pub; 939 940 vif->ifp = ifp; 941 vif->wdev.netdev = ndev; 942 943 err = brcmf_net_mon_attach(ifp); 944 if (err) { 945 brcmf_err("Failed to attach %s device\n", ndev->name); 946 free_netdev(ndev); 947 goto err_free_vif; 948 } 949 950 cfg->pub->mon_if = ifp; 951 952 return &vif->wdev; 953 954 err_free_vif: 955 brcmf_free_vif(vif); 956 err_out: 957 return ERR_PTR(err); 958 } 959 960 static int brcmf_mon_del_vif(struct wiphy *wiphy, struct wireless_dev *wdev) 961 { 962 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy); 963 struct net_device *ndev = wdev->netdev; 964 965 ndev->netdev_ops->ndo_stop(ndev); 966 967 brcmf_net_detach(ndev, true); 968 969 cfg->pub->mon_if = NULL; 970 971 return 0; 972 } 973 974 static struct wireless_dev *brcmf_cfg80211_add_iface(struct wiphy *wiphy, 975 const char *name, 976 unsigned char name_assign_type, 977 enum nl80211_iftype type, 978 struct vif_params *params) 979 { 980 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy); 981 struct brcmf_pub *drvr = cfg->pub; 982 struct wireless_dev *wdev; 983 int err; 984 985 brcmf_dbg(TRACE, "enter: %s type %d\n", name, type); 986 err = brcmf_vif_add_validate(wiphy_to_cfg(wiphy), type); 987 if (err) { 988 bphy_err(drvr, "iface validation failed: err=%d\n", err); 989 return ERR_PTR(err); 990 } 991 switch (type) { 992 case NL80211_IFTYPE_ADHOC: 993 case NL80211_IFTYPE_AP_VLAN: 994 case NL80211_IFTYPE_WDS: 995 case NL80211_IFTYPE_MESH_POINT: 996 return ERR_PTR(-EOPNOTSUPP); 997 case NL80211_IFTYPE_MONITOR: 998 return brcmf_mon_add_vif(wiphy, name); 999 case NL80211_IFTYPE_STATION: 1000 case NL80211_IFTYPE_AP: 1001 wdev = brcmf_apsta_add_vif(wiphy, name, params, type); 1002 break; 1003 case NL80211_IFTYPE_P2P_CLIENT: 1004 case NL80211_IFTYPE_P2P_GO: 1005 case NL80211_IFTYPE_P2P_DEVICE: 1006 wdev = brcmf_p2p_add_vif(wiphy, name, name_assign_type, type, params); 1007 break; 1008 case NL80211_IFTYPE_UNSPECIFIED: 1009 default: 1010 return ERR_PTR(-EINVAL); 1011 } 1012 1013 if (IS_ERR(wdev)) 1014 bphy_err(drvr, "add iface %s type %d failed: err=%d\n", name, 1015 type, (int)PTR_ERR(wdev)); 1016 else 1017 brcmf_cfg80211_update_proto_addr_mode(wdev); 1018 1019 return wdev; 1020 } 1021 1022 static void brcmf_scan_config_mpc(struct brcmf_if *ifp, int mpc) 1023 { 1024 if (brcmf_feat_is_quirk_enabled(ifp, BRCMF_FEAT_QUIRK_NEED_MPC)) 1025 brcmf_set_mpc(ifp, mpc); 1026 } 1027 1028 void brcmf_set_mpc(struct brcmf_if *ifp, int mpc) 1029 { 1030 struct brcmf_pub *drvr = ifp->drvr; 1031 s32 err = 0; 1032 1033 if (check_vif_up(ifp->vif)) { 1034 err = brcmf_fil_iovar_int_set(ifp, "mpc", mpc); 1035 if (err) { 1036 bphy_err(drvr, "fail to set mpc\n"); 1037 return; 1038 } 1039 brcmf_dbg(INFO, "MPC : %d\n", mpc); 1040 } 1041 } 1042 1043 static void brcmf_scan_params_v2_to_v1(struct brcmf_scan_params_v2_le *params_v2_le, 1044 struct brcmf_scan_params_le *params_le) 1045 { 1046 size_t params_size; 1047 u32 ch; 1048 int n_channels, n_ssids; 1049 1050 memcpy(¶ms_le->ssid_le, ¶ms_v2_le->ssid_le, 1051 sizeof(params_le->ssid_le)); 1052 memcpy(¶ms_le->bssid, ¶ms_v2_le->bssid, 1053 sizeof(params_le->bssid)); 1054 1055 params_le->bss_type = params_v2_le->bss_type; 1056 params_le->scan_type = le32_to_cpu(params_v2_le->scan_type); 1057 params_le->nprobes = params_v2_le->nprobes; 1058 params_le->active_time = params_v2_le->active_time; 1059 params_le->passive_time = params_v2_le->passive_time; 1060 params_le->home_time = params_v2_le->home_time; 1061 params_le->channel_num = params_v2_le->channel_num; 1062 1063 ch = le32_to_cpu(params_v2_le->channel_num); 1064 n_channels = ch & BRCMF_SCAN_PARAMS_COUNT_MASK; 1065 n_ssids = ch >> BRCMF_SCAN_PARAMS_NSSID_SHIFT; 1066 1067 params_size = sizeof(u16) * n_channels; 1068 if (n_ssids > 0) { 1069 params_size = roundup(params_size, sizeof(u32)); 1070 params_size += sizeof(struct brcmf_ssid_le) * n_ssids; 1071 } 1072 1073 memcpy(¶ms_le->channel_list[0], 1074 ¶ms_v2_le->channel_list[0], params_size); 1075 } 1076 1077 static void brcmf_escan_prep(struct brcmf_cfg80211_info *cfg, 1078 struct brcmf_scan_params_v2_le *params_le, 1079 struct cfg80211_scan_request *request) 1080 { 1081 u32 n_ssids; 1082 u32 n_channels; 1083 s32 i; 1084 s32 offset; 1085 u16 chanspec; 1086 char *ptr; 1087 int length; 1088 struct brcmf_ssid_le ssid_le; 1089 1090 eth_broadcast_addr(params_le->bssid); 1091 1092 length = BRCMF_SCAN_PARAMS_V2_FIXED_SIZE; 1093 1094 params_le->version = cpu_to_le16(BRCMF_SCAN_PARAMS_VERSION_V2); 1095 params_le->bss_type = DOT11_BSSTYPE_ANY; 1096 params_le->scan_type = cpu_to_le32(BRCMF_SCANTYPE_ACTIVE); 1097 params_le->channel_num = 0; 1098 params_le->nprobes = cpu_to_le32(-1); 1099 params_le->active_time = cpu_to_le32(-1); 1100 params_le->passive_time = cpu_to_le32(-1); 1101 params_le->home_time = cpu_to_le32(-1); 1102 memset(¶ms_le->ssid_le, 0, sizeof(params_le->ssid_le)); 1103 1104 /* Scan abort */ 1105 if (!request) { 1106 length += sizeof(u16); 1107 params_le->channel_num = cpu_to_le32(1); 1108 params_le->channel_list[0] = cpu_to_le16(-1); 1109 params_le->length = cpu_to_le16(length); 1110 return; 1111 } 1112 1113 n_ssids = request->n_ssids; 1114 n_channels = request->n_channels; 1115 1116 /* Copy channel array if applicable */ 1117 brcmf_dbg(SCAN, "### List of channelspecs to scan ### %d\n", 1118 n_channels); 1119 if (n_channels > 0) { 1120 length += roundup(sizeof(u16) * n_channels, sizeof(u32)); 1121 for (i = 0; i < n_channels; i++) { 1122 chanspec = channel_to_chanspec(&cfg->d11inf, 1123 request->channels[i]); 1124 brcmf_dbg(SCAN, "Chan : %d, Channel spec: %x\n", 1125 request->channels[i]->hw_value, chanspec); 1126 params_le->channel_list[i] = cpu_to_le16(chanspec); 1127 } 1128 } else { 1129 brcmf_dbg(SCAN, "Scanning all channels\n"); 1130 } 1131 1132 /* Copy ssid array if applicable */ 1133 brcmf_dbg(SCAN, "### List of SSIDs to scan ### %d\n", n_ssids); 1134 if (n_ssids > 0) { 1135 offset = offsetof(struct brcmf_scan_params_v2_le, channel_list) + 1136 n_channels * sizeof(u16); 1137 offset = roundup(offset, sizeof(u32)); 1138 length += sizeof(ssid_le) * n_ssids, 1139 ptr = (char *)params_le + offset; 1140 for (i = 0; i < n_ssids; i++) { 1141 memset(&ssid_le, 0, sizeof(ssid_le)); 1142 ssid_le.SSID_len = 1143 cpu_to_le32(request->ssids[i].ssid_len); 1144 memcpy(ssid_le.SSID, request->ssids[i].ssid, 1145 request->ssids[i].ssid_len); 1146 if (!ssid_le.SSID_len) 1147 brcmf_dbg(SCAN, "%d: Broadcast scan\n", i); 1148 else 1149 brcmf_dbg(SCAN, "%d: scan for %.32s size=%d\n", 1150 i, ssid_le.SSID, ssid_le.SSID_len); 1151 memcpy(ptr, &ssid_le, sizeof(ssid_le)); 1152 ptr += sizeof(ssid_le); 1153 } 1154 } else { 1155 brcmf_dbg(SCAN, "Performing passive scan\n"); 1156 params_le->scan_type = cpu_to_le32(BRCMF_SCANTYPE_PASSIVE); 1157 } 1158 params_le->length = cpu_to_le16(length); 1159 /* Adding mask to channel numbers */ 1160 params_le->channel_num = 1161 cpu_to_le32((n_ssids << BRCMF_SCAN_PARAMS_NSSID_SHIFT) | 1162 (n_channels & BRCMF_SCAN_PARAMS_COUNT_MASK)); 1163 } 1164 1165 s32 brcmf_notify_escan_complete(struct brcmf_cfg80211_info *cfg, 1166 struct brcmf_if *ifp, bool aborted, 1167 bool fw_abort) 1168 { 1169 struct brcmf_pub *drvr = cfg->pub; 1170 struct brcmf_scan_params_v2_le params_v2_le; 1171 struct cfg80211_scan_request *scan_request; 1172 u64 reqid; 1173 u32 bucket; 1174 s32 err = 0; 1175 1176 brcmf_dbg(SCAN, "Enter\n"); 1177 1178 /* clear scan request, because the FW abort can cause a second call */ 1179 /* to this functon and might cause a double cfg80211_scan_done */ 1180 scan_request = cfg->scan_request; 1181 cfg->scan_request = NULL; 1182 1183 timer_delete_sync(&cfg->escan_timeout); 1184 1185 if (fw_abort) { 1186 /* Do a scan abort to stop the driver's scan engine */ 1187 brcmf_dbg(SCAN, "ABORT scan in firmware\n"); 1188 1189 brcmf_escan_prep(cfg, ¶ms_v2_le, NULL); 1190 1191 /* E-Scan (or anyother type) can be aborted by SCAN */ 1192 if (brcmf_feat_is_enabled(ifp, BRCMF_FEAT_SCAN_V2)) { 1193 err = brcmf_fil_cmd_data_set(ifp, BRCMF_C_SCAN, 1194 ¶ms_v2_le, 1195 sizeof(params_v2_le)); 1196 } else { 1197 struct brcmf_scan_params_le params_le; 1198 1199 brcmf_scan_params_v2_to_v1(¶ms_v2_le, ¶ms_le); 1200 err = brcmf_fil_cmd_data_set(ifp, BRCMF_C_SCAN, 1201 ¶ms_le, 1202 sizeof(params_le)); 1203 } 1204 1205 if (err) 1206 bphy_err(drvr, "Scan abort failed\n"); 1207 } 1208 1209 brcmf_scan_config_mpc(ifp, 1); 1210 1211 /* 1212 * e-scan can be initiated internally 1213 * which takes precedence. 1214 */ 1215 if (cfg->int_escan_map) { 1216 brcmf_dbg(SCAN, "scheduled scan completed (%x)\n", 1217 cfg->int_escan_map); 1218 while (cfg->int_escan_map) { 1219 bucket = __ffs(cfg->int_escan_map); 1220 cfg->int_escan_map &= ~BIT(bucket); 1221 reqid = brcmf_pno_find_reqid_by_bucket(cfg->pno, 1222 bucket); 1223 if (!aborted) { 1224 brcmf_dbg(SCAN, "report results: reqid=%llu\n", 1225 reqid); 1226 cfg80211_sched_scan_results(cfg_to_wiphy(cfg), 1227 reqid); 1228 } 1229 } 1230 } else if (scan_request) { 1231 struct cfg80211_scan_info info = { 1232 .aborted = aborted, 1233 }; 1234 1235 brcmf_dbg(SCAN, "ESCAN Completed scan: %s\n", 1236 aborted ? "Aborted" : "Done"); 1237 cfg80211_scan_done(scan_request, &info); 1238 } 1239 if (!test_and_clear_bit(BRCMF_SCAN_STATUS_BUSY, &cfg->scan_status)) 1240 brcmf_dbg(SCAN, "Scan complete, probably P2P scan\n"); 1241 1242 return err; 1243 } 1244 1245 static int brcmf_cfg80211_del_apsta_iface(struct wiphy *wiphy, 1246 struct wireless_dev *wdev) 1247 { 1248 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy); 1249 struct net_device *ndev = wdev->netdev; 1250 struct brcmf_if *ifp = netdev_priv(ndev); 1251 struct brcmf_pub *drvr = cfg->pub; 1252 int ret; 1253 int err; 1254 1255 brcmf_cfg80211_arm_vif_event(cfg, ifp->vif); 1256 1257 err = brcmf_fil_bsscfg_data_set(ifp, "interface_remove", NULL, 0); 1258 if (err) { 1259 bphy_err(drvr, "interface_remove failed %d\n", err); 1260 goto err_unarm; 1261 } 1262 1263 /* wait for firmware event */ 1264 ret = brcmf_cfg80211_wait_vif_event(cfg, BRCMF_E_IF_DEL, 1265 BRCMF_VIF_EVENT_TIMEOUT); 1266 if (!ret) { 1267 bphy_err(drvr, "timeout occurred\n"); 1268 err = -EIO; 1269 goto err_unarm; 1270 } 1271 1272 brcmf_remove_interface(ifp, true); 1273 1274 err_unarm: 1275 brcmf_cfg80211_arm_vif_event(cfg, NULL); 1276 return err; 1277 } 1278 1279 static 1280 int brcmf_cfg80211_del_iface(struct wiphy *wiphy, struct wireless_dev *wdev) 1281 { 1282 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy); 1283 struct net_device *ndev = wdev->netdev; 1284 1285 if (ndev && ndev == cfg_to_ndev(cfg)) 1286 return -ENOTSUPP; 1287 1288 /* vif event pending in firmware */ 1289 if (brcmf_cfg80211_vif_event_armed(cfg)) 1290 return -EBUSY; 1291 1292 if (ndev) { 1293 if (test_bit(BRCMF_SCAN_STATUS_BUSY, &cfg->scan_status) && 1294 cfg->escan_info.ifp == netdev_priv(ndev)) 1295 brcmf_notify_escan_complete(cfg, netdev_priv(ndev), 1296 true, true); 1297 1298 brcmf_fil_iovar_int_set(netdev_priv(ndev), "mpc", 1); 1299 } 1300 1301 switch (wdev->iftype) { 1302 case NL80211_IFTYPE_ADHOC: 1303 case NL80211_IFTYPE_AP_VLAN: 1304 case NL80211_IFTYPE_WDS: 1305 case NL80211_IFTYPE_MESH_POINT: 1306 return -EOPNOTSUPP; 1307 case NL80211_IFTYPE_MONITOR: 1308 return brcmf_mon_del_vif(wiphy, wdev); 1309 case NL80211_IFTYPE_STATION: 1310 case NL80211_IFTYPE_AP: 1311 return brcmf_cfg80211_del_apsta_iface(wiphy, wdev); 1312 case NL80211_IFTYPE_P2P_CLIENT: 1313 case NL80211_IFTYPE_P2P_GO: 1314 case NL80211_IFTYPE_P2P_DEVICE: 1315 return brcmf_p2p_del_vif(wiphy, wdev); 1316 case NL80211_IFTYPE_UNSPECIFIED: 1317 default: 1318 return -EINVAL; 1319 } 1320 return -EOPNOTSUPP; 1321 } 1322 1323 static s32 1324 brcmf_cfg80211_change_iface(struct wiphy *wiphy, struct net_device *ndev, 1325 enum nl80211_iftype type, 1326 struct vif_params *params) 1327 { 1328 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy); 1329 struct brcmf_if *ifp = netdev_priv(ndev); 1330 struct brcmf_cfg80211_vif *vif = ifp->vif; 1331 struct brcmf_pub *drvr = cfg->pub; 1332 s32 infra = 0; 1333 s32 ap = 0; 1334 s32 err = 0; 1335 1336 brcmf_dbg(TRACE, "Enter, bsscfgidx=%d, type=%d\n", ifp->bsscfgidx, 1337 type); 1338 1339 /* WAR: There are a number of p2p interface related problems which 1340 * need to be handled initially (before doing the validate). 1341 * wpa_supplicant tends to do iface changes on p2p device/client/go 1342 * which are not always possible/allowed. However we need to return 1343 * OK otherwise the wpa_supplicant wont start. The situation differs 1344 * on configuration and setup (p2pon=1 module param). The first check 1345 * is to see if the request is a change to station for p2p iface. 1346 */ 1347 if ((type == NL80211_IFTYPE_STATION) && 1348 ((vif->wdev.iftype == NL80211_IFTYPE_P2P_CLIENT) || 1349 (vif->wdev.iftype == NL80211_IFTYPE_P2P_GO) || 1350 (vif->wdev.iftype == NL80211_IFTYPE_P2P_DEVICE))) { 1351 brcmf_dbg(TRACE, "Ignoring cmd for p2p if\n"); 1352 /* Now depending on whether module param p2pon=1 was used the 1353 * response needs to be either 0 or EOPNOTSUPP. The reason is 1354 * that if p2pon=1 is used, but a newer supplicant is used then 1355 * we should return an error, as this combination wont work. 1356 * In other situations 0 is returned and supplicant will start 1357 * normally. It will give a trace in cfg80211, but it is the 1358 * only way to get it working. Unfortunately this will result 1359 * in situation where we wont support new supplicant in 1360 * combination with module param p2pon=1, but that is the way 1361 * it is. If the user tries this then unloading of driver might 1362 * fail/lock. 1363 */ 1364 if (cfg->p2p.p2pdev_dynamically) 1365 return -EOPNOTSUPP; 1366 else 1367 return 0; 1368 } 1369 err = brcmf_vif_change_validate(wiphy_to_cfg(wiphy), vif, type); 1370 if (err) { 1371 bphy_err(drvr, "iface validation failed: err=%d\n", err); 1372 return err; 1373 } 1374 switch (type) { 1375 case NL80211_IFTYPE_MONITOR: 1376 case NL80211_IFTYPE_WDS: 1377 bphy_err(drvr, "type (%d) : currently we do not support this type\n", 1378 type); 1379 return -EOPNOTSUPP; 1380 case NL80211_IFTYPE_ADHOC: 1381 infra = 0; 1382 break; 1383 case NL80211_IFTYPE_STATION: 1384 infra = 1; 1385 break; 1386 case NL80211_IFTYPE_AP: 1387 case NL80211_IFTYPE_P2P_GO: 1388 ap = 1; 1389 break; 1390 default: 1391 err = -EINVAL; 1392 goto done; 1393 } 1394 1395 if (ap) { 1396 if (type == NL80211_IFTYPE_P2P_GO) { 1397 brcmf_dbg(INFO, "IF Type = P2P GO\n"); 1398 err = brcmf_p2p_ifchange(cfg, BRCMF_FIL_P2P_IF_GO); 1399 } 1400 if (!err) { 1401 brcmf_dbg(INFO, "IF Type = AP\n"); 1402 } 1403 } else { 1404 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_INFRA, infra); 1405 if (err) { 1406 bphy_err(drvr, "WLC_SET_INFRA error (%d)\n", err); 1407 err = -EAGAIN; 1408 goto done; 1409 } 1410 brcmf_dbg(INFO, "IF Type = %s\n", brcmf_is_ibssmode(vif) ? 1411 "Adhoc" : "Infra"); 1412 } 1413 ndev->ieee80211_ptr->iftype = type; 1414 1415 brcmf_cfg80211_update_proto_addr_mode(&vif->wdev); 1416 1417 done: 1418 brcmf_dbg(TRACE, "Exit\n"); 1419 1420 return err; 1421 } 1422 1423 static s32 1424 brcmf_run_escan(struct brcmf_cfg80211_info *cfg, struct brcmf_if *ifp, 1425 struct cfg80211_scan_request *request) 1426 { 1427 struct brcmf_pub *drvr = cfg->pub; 1428 s32 params_size = BRCMF_SCAN_PARAMS_V2_FIXED_SIZE + 1429 offsetof(struct brcmf_escan_params_le, params_v2_le); 1430 struct brcmf_escan_params_le *params; 1431 s32 err = 0; 1432 1433 brcmf_dbg(SCAN, "E-SCAN START\n"); 1434 1435 if (request != NULL) { 1436 /* Allocate space for populating ssids in struct */ 1437 params_size += sizeof(u32) * ((request->n_channels + 1) / 2); 1438 1439 /* Allocate space for populating ssids in struct */ 1440 params_size += sizeof(struct brcmf_ssid_le) * request->n_ssids; 1441 } 1442 1443 params = kzalloc(params_size, GFP_KERNEL); 1444 if (!params) { 1445 err = -ENOMEM; 1446 goto exit; 1447 } 1448 BUG_ON(params_size + sizeof("escan") >= BRCMF_DCMD_MEDLEN); 1449 brcmf_escan_prep(cfg, ¶ms->params_v2_le, request); 1450 1451 params->version = cpu_to_le32(BRCMF_ESCAN_REQ_VERSION_V2); 1452 1453 if (!brcmf_feat_is_enabled(ifp, BRCMF_FEAT_SCAN_V2)) { 1454 struct brcmf_escan_params_le *params_v1; 1455 1456 params_size -= BRCMF_SCAN_PARAMS_V2_FIXED_SIZE; 1457 params_size += BRCMF_SCAN_PARAMS_FIXED_SIZE; 1458 params_v1 = kzalloc(params_size, GFP_KERNEL); 1459 if (!params_v1) { 1460 err = -ENOMEM; 1461 goto exit_params; 1462 } 1463 params_v1->version = cpu_to_le32(BRCMF_ESCAN_REQ_VERSION); 1464 brcmf_scan_params_v2_to_v1(¶ms->params_v2_le, ¶ms_v1->params_le); 1465 kfree(params); 1466 params = params_v1; 1467 } 1468 1469 params->action = cpu_to_le16(WL_ESCAN_ACTION_START); 1470 params->sync_id = cpu_to_le16(0x1234); 1471 1472 err = brcmf_fil_iovar_data_set(ifp, "escan", params, params_size); 1473 if (err) { 1474 if (err == -EBUSY) 1475 brcmf_dbg(INFO, "system busy : escan canceled\n"); 1476 else 1477 bphy_err(drvr, "error (%d)\n", err); 1478 } 1479 1480 exit_params: 1481 kfree(params); 1482 exit: 1483 return err; 1484 } 1485 1486 static s32 1487 brcmf_do_escan(struct brcmf_if *ifp, struct cfg80211_scan_request *request) 1488 { 1489 struct brcmf_cfg80211_info *cfg = ifp->drvr->config; 1490 s32 err; 1491 struct brcmf_scan_results *results; 1492 struct escan_info *escan = &cfg->escan_info; 1493 1494 brcmf_dbg(SCAN, "Enter\n"); 1495 escan->ifp = ifp; 1496 escan->wiphy = cfg->wiphy; 1497 escan->escan_state = WL_ESCAN_STATE_SCANNING; 1498 1499 brcmf_scan_config_mpc(ifp, 0); 1500 results = (struct brcmf_scan_results *)cfg->escan_info.escan_buf; 1501 results->version = 0; 1502 results->count = 0; 1503 results->buflen = WL_ESCAN_RESULTS_FIXED_SIZE; 1504 1505 err = escan->run(cfg, ifp, request); 1506 if (err) 1507 brcmf_scan_config_mpc(ifp, 1); 1508 return err; 1509 } 1510 1511 static s32 1512 brcmf_cfg80211_scan(struct wiphy *wiphy, struct cfg80211_scan_request *request) 1513 { 1514 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy); 1515 struct brcmf_pub *drvr = cfg->pub; 1516 struct brcmf_cfg80211_vif *vif; 1517 s32 err = 0; 1518 1519 brcmf_dbg(TRACE, "Enter\n"); 1520 vif = container_of(request->wdev, struct brcmf_cfg80211_vif, wdev); 1521 if (!check_vif_up(vif)) 1522 return -EIO; 1523 1524 if (test_bit(BRCMF_SCAN_STATUS_BUSY, &cfg->scan_status)) { 1525 bphy_err(drvr, "Scanning already: status (%lu)\n", 1526 cfg->scan_status); 1527 return -EAGAIN; 1528 } 1529 if (test_bit(BRCMF_SCAN_STATUS_ABORT, &cfg->scan_status)) { 1530 bphy_err(drvr, "Scanning being aborted: status (%lu)\n", 1531 cfg->scan_status); 1532 return -EAGAIN; 1533 } 1534 if (test_bit(BRCMF_SCAN_STATUS_SUPPRESS, &cfg->scan_status)) { 1535 bphy_err(drvr, "Scanning suppressed: status (%lu)\n", 1536 cfg->scan_status); 1537 return -EAGAIN; 1538 } 1539 if (test_bit(BRCMF_VIF_STATUS_CONNECTING, &vif->sme_state)) { 1540 bphy_err(drvr, "Connecting: status (%lu)\n", vif->sme_state); 1541 return -EAGAIN; 1542 } 1543 1544 /* If scan req comes for p2p0, send it over primary I/F */ 1545 if (vif == cfg->p2p.bss_idx[P2PAPI_BSSCFG_DEVICE].vif) 1546 vif = cfg->p2p.bss_idx[P2PAPI_BSSCFG_PRIMARY].vif; 1547 1548 brcmf_dbg(SCAN, "START ESCAN\n"); 1549 1550 cfg->scan_request = request; 1551 set_bit(BRCMF_SCAN_STATUS_BUSY, &cfg->scan_status); 1552 1553 cfg->escan_info.run = brcmf_run_escan; 1554 err = brcmf_p2p_scan_prep(wiphy, request, vif); 1555 if (err) 1556 goto scan_out; 1557 1558 err = brcmf_vif_set_mgmt_ie(vif, BRCMF_VNDR_IE_PRBREQ_FLAG, 1559 request->ie, request->ie_len); 1560 if (err) 1561 goto scan_out; 1562 1563 err = brcmf_do_escan(vif->ifp, request); 1564 if (err) 1565 goto scan_out; 1566 1567 /* Arm scan timeout timer */ 1568 mod_timer(&cfg->escan_timeout, 1569 jiffies + msecs_to_jiffies(BRCMF_ESCAN_TIMER_INTERVAL_MS)); 1570 1571 return 0; 1572 1573 scan_out: 1574 bphy_err(drvr, "scan error (%d)\n", err); 1575 clear_bit(BRCMF_SCAN_STATUS_BUSY, &cfg->scan_status); 1576 cfg->scan_request = NULL; 1577 return err; 1578 } 1579 1580 static s32 brcmf_set_rts(struct net_device *ndev, u32 rts_threshold) 1581 { 1582 struct brcmf_if *ifp = netdev_priv(ndev); 1583 struct brcmf_pub *drvr = ifp->drvr; 1584 s32 err = 0; 1585 1586 err = brcmf_fil_iovar_int_set(ifp, "rtsthresh", rts_threshold); 1587 if (err) 1588 bphy_err(drvr, "Error (%d)\n", err); 1589 1590 return err; 1591 } 1592 1593 static s32 brcmf_set_frag(struct net_device *ndev, u32 frag_threshold) 1594 { 1595 struct brcmf_if *ifp = netdev_priv(ndev); 1596 struct brcmf_pub *drvr = ifp->drvr; 1597 s32 err = 0; 1598 1599 err = brcmf_fil_iovar_int_set(ifp, "fragthresh", 1600 frag_threshold); 1601 if (err) 1602 bphy_err(drvr, "Error (%d)\n", err); 1603 1604 return err; 1605 } 1606 1607 static s32 brcmf_set_retry(struct net_device *ndev, u32 retry, bool l) 1608 { 1609 struct brcmf_if *ifp = netdev_priv(ndev); 1610 struct brcmf_pub *drvr = ifp->drvr; 1611 s32 err = 0; 1612 u32 cmd = (l ? BRCMF_C_SET_LRL : BRCMF_C_SET_SRL); 1613 1614 err = brcmf_fil_cmd_int_set(ifp, cmd, retry); 1615 if (err) { 1616 bphy_err(drvr, "cmd (%d) , error (%d)\n", cmd, err); 1617 return err; 1618 } 1619 return err; 1620 } 1621 1622 static s32 brcmf_cfg80211_set_wiphy_params(struct wiphy *wiphy, u32 changed) 1623 { 1624 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy); 1625 struct net_device *ndev = cfg_to_ndev(cfg); 1626 struct brcmf_if *ifp = netdev_priv(ndev); 1627 s32 err = 0; 1628 1629 brcmf_dbg(TRACE, "Enter\n"); 1630 if (!check_vif_up(ifp->vif)) 1631 return -EIO; 1632 1633 if (changed & WIPHY_PARAM_RTS_THRESHOLD && 1634 (cfg->conf->rts_threshold != wiphy->rts_threshold)) { 1635 cfg->conf->rts_threshold = wiphy->rts_threshold; 1636 err = brcmf_set_rts(ndev, cfg->conf->rts_threshold); 1637 if (!err) 1638 goto done; 1639 } 1640 if (changed & WIPHY_PARAM_FRAG_THRESHOLD && 1641 (cfg->conf->frag_threshold != wiphy->frag_threshold)) { 1642 cfg->conf->frag_threshold = wiphy->frag_threshold; 1643 err = brcmf_set_frag(ndev, cfg->conf->frag_threshold); 1644 if (!err) 1645 goto done; 1646 } 1647 if (changed & WIPHY_PARAM_RETRY_LONG 1648 && (cfg->conf->retry_long != wiphy->retry_long)) { 1649 cfg->conf->retry_long = wiphy->retry_long; 1650 err = brcmf_set_retry(ndev, cfg->conf->retry_long, true); 1651 if (!err) 1652 goto done; 1653 } 1654 if (changed & WIPHY_PARAM_RETRY_SHORT 1655 && (cfg->conf->retry_short != wiphy->retry_short)) { 1656 cfg->conf->retry_short = wiphy->retry_short; 1657 err = brcmf_set_retry(ndev, cfg->conf->retry_short, false); 1658 if (!err) 1659 goto done; 1660 } 1661 1662 done: 1663 brcmf_dbg(TRACE, "Exit\n"); 1664 return err; 1665 } 1666 1667 static void brcmf_init_prof(struct brcmf_cfg80211_profile *prof) 1668 { 1669 memset(prof, 0, sizeof(*prof)); 1670 } 1671 1672 static u16 brcmf_map_fw_linkdown_reason(const struct brcmf_event_msg *e) 1673 { 1674 u16 reason; 1675 1676 switch (e->event_code) { 1677 case BRCMF_E_DEAUTH: 1678 case BRCMF_E_DEAUTH_IND: 1679 case BRCMF_E_DISASSOC_IND: 1680 reason = e->reason; 1681 break; 1682 case BRCMF_E_LINK: 1683 default: 1684 reason = 0; 1685 break; 1686 } 1687 return reason; 1688 } 1689 1690 int brcmf_set_wsec(struct brcmf_if *ifp, const u8 *key, u16 key_len, u16 flags) 1691 { 1692 struct brcmf_pub *drvr = ifp->drvr; 1693 struct brcmf_wsec_pmk_le pmk; 1694 int err; 1695 1696 if (key_len > sizeof(pmk.key)) { 1697 bphy_err(drvr, "key must be less than %zu bytes\n", 1698 sizeof(pmk.key)); 1699 return -EINVAL; 1700 } 1701 1702 memset(&pmk, 0, sizeof(pmk)); 1703 1704 /* pass key material directly */ 1705 pmk.key_len = cpu_to_le16(key_len); 1706 pmk.flags = cpu_to_le16(flags); 1707 memcpy(pmk.key, key, key_len); 1708 1709 /* store key material in firmware */ 1710 err = brcmf_fil_cmd_data_set(ifp, BRCMF_C_SET_WSEC_PMK, 1711 &pmk, sizeof(pmk)); 1712 if (err < 0) 1713 bphy_err(drvr, "failed to change PSK in firmware (len=%u)\n", 1714 key_len); 1715 1716 return err; 1717 } 1718 BRCMF_EXPORT_SYMBOL_GPL(brcmf_set_wsec); 1719 1720 static int brcmf_set_pmk(struct brcmf_if *ifp, const u8 *pmk_data, u16 pmk_len) 1721 { 1722 return brcmf_set_wsec(ifp, pmk_data, pmk_len, 0); 1723 } 1724 1725 static void brcmf_link_down(struct brcmf_cfg80211_vif *vif, u16 reason, 1726 bool locally_generated) 1727 { 1728 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(vif->wdev.wiphy); 1729 struct brcmf_pub *drvr = cfg->pub; 1730 bool bus_up = drvr->bus_if->state == BRCMF_BUS_UP; 1731 s32 err = 0; 1732 1733 brcmf_dbg(TRACE, "Enter\n"); 1734 1735 if (test_and_clear_bit(BRCMF_VIF_STATUS_CONNECTED, &vif->sme_state)) { 1736 if (bus_up) { 1737 brcmf_dbg(INFO, "Call WLC_DISASSOC to stop excess roaming\n"); 1738 err = brcmf_fil_cmd_data_set(vif->ifp, 1739 BRCMF_C_DISASSOC, NULL, 0); 1740 if (err) 1741 bphy_err(drvr, "WLC_DISASSOC failed (%d)\n", 1742 err); 1743 } 1744 1745 if ((vif->wdev.iftype == NL80211_IFTYPE_STATION) || 1746 (vif->wdev.iftype == NL80211_IFTYPE_P2P_CLIENT)) 1747 cfg80211_disconnected(vif->wdev.netdev, reason, NULL, 0, 1748 locally_generated, GFP_KERNEL); 1749 } 1750 clear_bit(BRCMF_VIF_STATUS_CONNECTING, &vif->sme_state); 1751 clear_bit(BRCMF_VIF_STATUS_EAP_SUCCESS, &vif->sme_state); 1752 clear_bit(BRCMF_VIF_STATUS_ASSOC_SUCCESS, &vif->sme_state); 1753 clear_bit(BRCMF_SCAN_STATUS_SUPPRESS, &cfg->scan_status); 1754 brcmf_btcoex_set_mode(vif, BRCMF_BTCOEX_ENABLED, 0); 1755 if (vif->profile.use_fwsup != BRCMF_PROFILE_FWSUP_NONE) { 1756 if (bus_up) 1757 brcmf_set_pmk(vif->ifp, NULL, 0); 1758 vif->profile.use_fwsup = BRCMF_PROFILE_FWSUP_NONE; 1759 } 1760 brcmf_dbg(TRACE, "Exit\n"); 1761 } 1762 1763 static s32 1764 brcmf_cfg80211_join_ibss(struct wiphy *wiphy, struct net_device *ndev, 1765 struct cfg80211_ibss_params *params) 1766 { 1767 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy); 1768 struct brcmf_if *ifp = netdev_priv(ndev); 1769 struct brcmf_cfg80211_profile *profile = &ifp->vif->profile; 1770 struct brcmf_pub *drvr = cfg->pub; 1771 struct brcmf_join_params join_params; 1772 size_t join_params_size = 0; 1773 s32 err = 0; 1774 s32 wsec = 0; 1775 s32 bcnprd; 1776 u16 chanspec; 1777 u32 ssid_len; 1778 1779 brcmf_dbg(TRACE, "Enter\n"); 1780 if (!check_vif_up(ifp->vif)) 1781 return -EIO; 1782 1783 if (params->ssid) 1784 brcmf_dbg(CONN, "SSID: %s\n", params->ssid); 1785 else { 1786 brcmf_dbg(CONN, "SSID: NULL, Not supported\n"); 1787 return -EOPNOTSUPP; 1788 } 1789 1790 set_bit(BRCMF_VIF_STATUS_CONNECTING, &ifp->vif->sme_state); 1791 1792 if (params->bssid) 1793 brcmf_dbg(CONN, "BSSID: %pM\n", params->bssid); 1794 else 1795 brcmf_dbg(CONN, "No BSSID specified\n"); 1796 1797 if (params->chandef.chan) 1798 brcmf_dbg(CONN, "channel: %d\n", 1799 params->chandef.chan->center_freq); 1800 else 1801 brcmf_dbg(CONN, "no channel specified\n"); 1802 1803 if (params->channel_fixed) 1804 brcmf_dbg(CONN, "fixed channel required\n"); 1805 else 1806 brcmf_dbg(CONN, "no fixed channel required\n"); 1807 1808 if (params->ie && params->ie_len) 1809 brcmf_dbg(CONN, "ie len: %d\n", params->ie_len); 1810 else 1811 brcmf_dbg(CONN, "no ie specified\n"); 1812 1813 if (params->beacon_interval) 1814 brcmf_dbg(CONN, "beacon interval: %d\n", 1815 params->beacon_interval); 1816 else 1817 brcmf_dbg(CONN, "no beacon interval specified\n"); 1818 1819 if (params->basic_rates) 1820 brcmf_dbg(CONN, "basic rates: %08X\n", params->basic_rates); 1821 else 1822 brcmf_dbg(CONN, "no basic rates specified\n"); 1823 1824 if (params->privacy) 1825 brcmf_dbg(CONN, "privacy required\n"); 1826 else 1827 brcmf_dbg(CONN, "no privacy required\n"); 1828 1829 /* Configure Privacy for starter */ 1830 if (params->privacy) 1831 wsec |= WEP_ENABLED; 1832 1833 err = brcmf_fil_iovar_int_set(ifp, "wsec", wsec); 1834 if (err) { 1835 bphy_err(drvr, "wsec failed (%d)\n", err); 1836 goto done; 1837 } 1838 1839 /* Configure Beacon Interval for starter */ 1840 if (params->beacon_interval) 1841 bcnprd = params->beacon_interval; 1842 else 1843 bcnprd = 100; 1844 1845 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_BCNPRD, bcnprd); 1846 if (err) { 1847 bphy_err(drvr, "WLC_SET_BCNPRD failed (%d)\n", err); 1848 goto done; 1849 } 1850 1851 /* Configure required join parameter */ 1852 memset(&join_params, 0, sizeof(struct brcmf_join_params)); 1853 1854 /* SSID */ 1855 ssid_len = min_t(u32, params->ssid_len, IEEE80211_MAX_SSID_LEN); 1856 memcpy(join_params.ssid_le.SSID, params->ssid, ssid_len); 1857 join_params.ssid_le.SSID_len = cpu_to_le32(ssid_len); 1858 join_params_size = sizeof(join_params.ssid_le); 1859 1860 /* BSSID */ 1861 if (params->bssid) { 1862 memcpy(join_params.params_le.bssid, params->bssid, ETH_ALEN); 1863 join_params_size += BRCMF_ASSOC_PARAMS_FIXED_SIZE; 1864 memcpy(profile->bssid, params->bssid, ETH_ALEN); 1865 } else { 1866 eth_broadcast_addr(join_params.params_le.bssid); 1867 eth_zero_addr(profile->bssid); 1868 } 1869 1870 /* Channel */ 1871 if (params->chandef.chan) { 1872 u32 target_channel; 1873 1874 cfg->channel = 1875 ieee80211_frequency_to_channel( 1876 params->chandef.chan->center_freq); 1877 if (params->channel_fixed) { 1878 /* adding chanspec */ 1879 chanspec = chandef_to_chanspec(&cfg->d11inf, 1880 ¶ms->chandef); 1881 join_params.params_le.chanspec_list[0] = 1882 cpu_to_le16(chanspec); 1883 join_params.params_le.chanspec_num = cpu_to_le32(1); 1884 join_params_size += sizeof(join_params.params_le); 1885 } 1886 1887 /* set channel for starter */ 1888 target_channel = cfg->channel; 1889 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_CHANNEL, 1890 target_channel); 1891 if (err) { 1892 bphy_err(drvr, "WLC_SET_CHANNEL failed (%d)\n", err); 1893 goto done; 1894 } 1895 } else 1896 cfg->channel = 0; 1897 1898 cfg->ibss_starter = false; 1899 1900 1901 err = brcmf_fil_cmd_data_set(ifp, BRCMF_C_SET_SSID, 1902 &join_params, join_params_size); 1903 if (err) { 1904 bphy_err(drvr, "WLC_SET_SSID failed (%d)\n", err); 1905 goto done; 1906 } 1907 1908 done: 1909 if (err) 1910 clear_bit(BRCMF_VIF_STATUS_CONNECTING, &ifp->vif->sme_state); 1911 brcmf_dbg(TRACE, "Exit\n"); 1912 return err; 1913 } 1914 1915 static s32 1916 brcmf_cfg80211_leave_ibss(struct wiphy *wiphy, struct net_device *ndev) 1917 { 1918 struct brcmf_if *ifp = netdev_priv(ndev); 1919 1920 brcmf_dbg(TRACE, "Enter\n"); 1921 if (!check_vif_up(ifp->vif)) { 1922 /* When driver is being unloaded, it can end up here. If an 1923 * error is returned then later on a debug trace in the wireless 1924 * core module will be printed. To avoid this 0 is returned. 1925 */ 1926 return 0; 1927 } 1928 1929 brcmf_link_down(ifp->vif, WLAN_REASON_DEAUTH_LEAVING, true); 1930 brcmf_net_setcarrier(ifp, false); 1931 1932 brcmf_dbg(TRACE, "Exit\n"); 1933 1934 return 0; 1935 } 1936 1937 static s32 brcmf_set_wpa_version(struct net_device *ndev, 1938 struct cfg80211_connect_params *sme) 1939 { 1940 struct brcmf_if *ifp = netdev_priv(ndev); 1941 struct brcmf_cfg80211_profile *profile = ndev_to_prof(ndev); 1942 struct brcmf_pub *drvr = ifp->drvr; 1943 struct brcmf_cfg80211_security *sec; 1944 s32 val = 0; 1945 s32 err = 0; 1946 1947 if (sme->crypto.wpa_versions & NL80211_WPA_VERSION_1) 1948 val = WPA_AUTH_PSK | WPA_AUTH_UNSPECIFIED; 1949 else if (sme->crypto.wpa_versions & NL80211_WPA_VERSION_2) 1950 val = WPA2_AUTH_PSK | WPA2_AUTH_UNSPECIFIED; 1951 else if (sme->crypto.wpa_versions & NL80211_WPA_VERSION_3) 1952 val = WPA3_AUTH_SAE_PSK; 1953 else 1954 val = WPA_AUTH_DISABLED; 1955 brcmf_dbg(CONN, "setting wpa_auth to 0x%0x\n", val); 1956 err = brcmf_fil_bsscfg_int_set(ifp, "wpa_auth", val); 1957 if (err) { 1958 bphy_err(drvr, "set wpa_auth failed (%d)\n", err); 1959 return err; 1960 } 1961 sec = &profile->sec; 1962 sec->wpa_versions = sme->crypto.wpa_versions; 1963 return err; 1964 } 1965 1966 static s32 brcmf_set_auth_type(struct net_device *ndev, 1967 struct cfg80211_connect_params *sme) 1968 { 1969 struct brcmf_if *ifp = netdev_priv(ndev); 1970 struct brcmf_cfg80211_profile *profile = ndev_to_prof(ndev); 1971 struct brcmf_pub *drvr = ifp->drvr; 1972 struct brcmf_cfg80211_security *sec; 1973 s32 val = 0; 1974 s32 err = 0; 1975 1976 switch (sme->auth_type) { 1977 case NL80211_AUTHTYPE_OPEN_SYSTEM: 1978 val = 0; 1979 brcmf_dbg(CONN, "open system\n"); 1980 break; 1981 case NL80211_AUTHTYPE_SHARED_KEY: 1982 val = 1; 1983 brcmf_dbg(CONN, "shared key\n"); 1984 break; 1985 case NL80211_AUTHTYPE_SAE: 1986 val = 3; 1987 brcmf_dbg(CONN, "SAE authentication\n"); 1988 break; 1989 default: 1990 val = 2; 1991 brcmf_dbg(CONN, "automatic, auth type (%d)\n", sme->auth_type); 1992 break; 1993 } 1994 1995 err = brcmf_fil_bsscfg_int_set(ifp, "auth", val); 1996 if (err) { 1997 bphy_err(drvr, "set auth failed (%d)\n", err); 1998 return err; 1999 } 2000 sec = &profile->sec; 2001 sec->auth_type = sme->auth_type; 2002 return err; 2003 } 2004 2005 static s32 2006 brcmf_set_wsec_mode(struct net_device *ndev, 2007 struct cfg80211_connect_params *sme) 2008 { 2009 struct brcmf_if *ifp = netdev_priv(ndev); 2010 struct brcmf_cfg80211_profile *profile = ndev_to_prof(ndev); 2011 struct brcmf_pub *drvr = ifp->drvr; 2012 struct brcmf_cfg80211_security *sec; 2013 s32 pval = 0; 2014 s32 gval = 0; 2015 s32 wsec; 2016 s32 err = 0; 2017 2018 if (sme->crypto.n_ciphers_pairwise) { 2019 switch (sme->crypto.ciphers_pairwise[0]) { 2020 case WLAN_CIPHER_SUITE_WEP40: 2021 case WLAN_CIPHER_SUITE_WEP104: 2022 pval = WEP_ENABLED; 2023 break; 2024 case WLAN_CIPHER_SUITE_TKIP: 2025 pval = TKIP_ENABLED; 2026 break; 2027 case WLAN_CIPHER_SUITE_CCMP: 2028 pval = AES_ENABLED; 2029 break; 2030 case WLAN_CIPHER_SUITE_AES_CMAC: 2031 pval = AES_ENABLED; 2032 break; 2033 default: 2034 bphy_err(drvr, "invalid cipher pairwise (%d)\n", 2035 sme->crypto.ciphers_pairwise[0]); 2036 return -EINVAL; 2037 } 2038 } 2039 if (sme->crypto.cipher_group) { 2040 switch (sme->crypto.cipher_group) { 2041 case WLAN_CIPHER_SUITE_WEP40: 2042 case WLAN_CIPHER_SUITE_WEP104: 2043 gval = WEP_ENABLED; 2044 break; 2045 case WLAN_CIPHER_SUITE_TKIP: 2046 gval = TKIP_ENABLED; 2047 break; 2048 case WLAN_CIPHER_SUITE_CCMP: 2049 gval = AES_ENABLED; 2050 break; 2051 case WLAN_CIPHER_SUITE_AES_CMAC: 2052 gval = AES_ENABLED; 2053 break; 2054 default: 2055 bphy_err(drvr, "invalid cipher group (%d)\n", 2056 sme->crypto.cipher_group); 2057 return -EINVAL; 2058 } 2059 } 2060 2061 brcmf_dbg(CONN, "pval (%d) gval (%d)\n", pval, gval); 2062 /* In case of privacy, but no security and WPS then simulate */ 2063 /* setting AES. WPS-2.0 allows no security */ 2064 if (brcmf_find_wpsie(sme->ie, sme->ie_len) && !pval && !gval && 2065 sme->privacy) 2066 pval = AES_ENABLED; 2067 2068 wsec = pval | gval; 2069 err = brcmf_fil_bsscfg_int_set(ifp, "wsec", wsec); 2070 if (err) { 2071 bphy_err(drvr, "error (%d)\n", err); 2072 return err; 2073 } 2074 2075 sec = &profile->sec; 2076 sec->cipher_pairwise = sme->crypto.ciphers_pairwise[0]; 2077 sec->cipher_group = sme->crypto.cipher_group; 2078 2079 return err; 2080 } 2081 2082 static s32 2083 brcmf_set_key_mgmt(struct net_device *ndev, struct cfg80211_connect_params *sme) 2084 { 2085 struct brcmf_if *ifp = netdev_priv(ndev); 2086 struct brcmf_cfg80211_profile *profile = &ifp->vif->profile; 2087 struct brcmf_pub *drvr = ifp->drvr; 2088 s32 val; 2089 s32 err; 2090 const struct brcmf_tlv *rsn_ie; 2091 const u8 *ie; 2092 u32 ie_len; 2093 u32 offset; 2094 u16 rsn_cap; 2095 u32 mfp; 2096 u16 count; 2097 2098 profile->use_fwsup = BRCMF_PROFILE_FWSUP_NONE; 2099 profile->is_ft = false; 2100 2101 if (!sme->crypto.n_akm_suites) 2102 return 0; 2103 2104 err = brcmf_fil_bsscfg_int_get(netdev_priv(ndev), "wpa_auth", &val); 2105 if (err) { 2106 bphy_err(drvr, "could not get wpa_auth (%d)\n", err); 2107 return err; 2108 } 2109 if (val & (WPA_AUTH_PSK | WPA_AUTH_UNSPECIFIED)) { 2110 switch (sme->crypto.akm_suites[0]) { 2111 case WLAN_AKM_SUITE_8021X: 2112 val = WPA_AUTH_UNSPECIFIED; 2113 if (sme->want_1x) 2114 profile->use_fwsup = BRCMF_PROFILE_FWSUP_1X; 2115 break; 2116 case WLAN_AKM_SUITE_PSK: 2117 val = WPA_AUTH_PSK; 2118 break; 2119 default: 2120 bphy_err(drvr, "invalid akm suite (%d)\n", 2121 sme->crypto.akm_suites[0]); 2122 return -EINVAL; 2123 } 2124 } else if (val & (WPA2_AUTH_PSK | WPA2_AUTH_UNSPECIFIED)) { 2125 switch (sme->crypto.akm_suites[0]) { 2126 case WLAN_AKM_SUITE_8021X: 2127 val = WPA2_AUTH_UNSPECIFIED; 2128 if (sme->want_1x) 2129 profile->use_fwsup = BRCMF_PROFILE_FWSUP_1X; 2130 break; 2131 case WLAN_AKM_SUITE_8021X_SHA256: 2132 val = WPA2_AUTH_1X_SHA256; 2133 if (sme->want_1x) 2134 profile->use_fwsup = BRCMF_PROFILE_FWSUP_1X; 2135 break; 2136 case WLAN_AKM_SUITE_PSK_SHA256: 2137 val = WPA2_AUTH_PSK_SHA256; 2138 break; 2139 case WLAN_AKM_SUITE_PSK: 2140 val = WPA2_AUTH_PSK; 2141 break; 2142 case WLAN_AKM_SUITE_FT_8021X: 2143 val = WPA2_AUTH_UNSPECIFIED | WPA2_AUTH_FT; 2144 profile->is_ft = true; 2145 if (sme->want_1x) 2146 profile->use_fwsup = BRCMF_PROFILE_FWSUP_1X; 2147 break; 2148 case WLAN_AKM_SUITE_FT_PSK: 2149 val = WPA2_AUTH_PSK | WPA2_AUTH_FT; 2150 profile->is_ft = true; 2151 break; 2152 default: 2153 bphy_err(drvr, "invalid akm suite (%d)\n", 2154 sme->crypto.akm_suites[0]); 2155 return -EINVAL; 2156 } 2157 } else if (val & WPA3_AUTH_SAE_PSK) { 2158 switch (sme->crypto.akm_suites[0]) { 2159 case WLAN_AKM_SUITE_SAE: 2160 val = WPA3_AUTH_SAE_PSK; 2161 if (sme->crypto.sae_pwd) { 2162 brcmf_dbg(INFO, "using SAE offload\n"); 2163 profile->use_fwsup = BRCMF_PROFILE_FWSUP_SAE; 2164 } 2165 break; 2166 case WLAN_AKM_SUITE_FT_OVER_SAE: 2167 val = WPA3_AUTH_SAE_PSK | WPA2_AUTH_FT; 2168 profile->is_ft = true; 2169 if (sme->crypto.sae_pwd) { 2170 brcmf_dbg(INFO, "using SAE offload\n"); 2171 profile->use_fwsup = BRCMF_PROFILE_FWSUP_SAE; 2172 } 2173 break; 2174 default: 2175 bphy_err(drvr, "invalid akm suite (%d)\n", 2176 sme->crypto.akm_suites[0]); 2177 return -EINVAL; 2178 } 2179 } 2180 2181 if (profile->use_fwsup == BRCMF_PROFILE_FWSUP_1X) 2182 brcmf_dbg(INFO, "using 1X offload\n"); 2183 2184 if (!brcmf_feat_is_enabled(ifp, BRCMF_FEAT_MFP)) 2185 goto skip_mfp_config; 2186 /* The MFP mode (1 or 2) needs to be determined, parse IEs. The 2187 * IE will not be verified, just a quick search for MFP config 2188 */ 2189 rsn_ie = brcmf_parse_tlvs((const u8 *)sme->ie, sme->ie_len, 2190 WLAN_EID_RSN); 2191 if (!rsn_ie) 2192 goto skip_mfp_config; 2193 ie = (const u8 *)rsn_ie; 2194 ie_len = rsn_ie->len + TLV_HDR_LEN; 2195 /* Skip unicast suite */ 2196 offset = TLV_HDR_LEN + WPA_IE_VERSION_LEN + WPA_IE_MIN_OUI_LEN; 2197 if (offset + WPA_IE_SUITE_COUNT_LEN >= ie_len) 2198 goto skip_mfp_config; 2199 /* Skip multicast suite */ 2200 count = ie[offset] + (ie[offset + 1] << 8); 2201 offset += WPA_IE_SUITE_COUNT_LEN + (count * WPA_IE_MIN_OUI_LEN); 2202 if (offset + WPA_IE_SUITE_COUNT_LEN >= ie_len) 2203 goto skip_mfp_config; 2204 /* Skip auth key management suite(s) */ 2205 count = ie[offset] + (ie[offset + 1] << 8); 2206 offset += WPA_IE_SUITE_COUNT_LEN + (count * WPA_IE_MIN_OUI_LEN); 2207 if (offset + WPA_IE_SUITE_COUNT_LEN > ie_len) 2208 goto skip_mfp_config; 2209 /* Ready to read capabilities */ 2210 mfp = BRCMF_MFP_NONE; 2211 rsn_cap = ie[offset] + (ie[offset + 1] << 8); 2212 if (rsn_cap & RSN_CAP_MFPR_MASK) 2213 mfp = BRCMF_MFP_REQUIRED; 2214 else if (rsn_cap & RSN_CAP_MFPC_MASK) 2215 mfp = BRCMF_MFP_CAPABLE; 2216 brcmf_fil_bsscfg_int_set(netdev_priv(ndev), "mfp", mfp); 2217 2218 skip_mfp_config: 2219 brcmf_dbg(CONN, "setting wpa_auth to %d\n", val); 2220 err = brcmf_fil_bsscfg_int_set(netdev_priv(ndev), "wpa_auth", val); 2221 if (err) { 2222 bphy_err(drvr, "could not set wpa_auth (%d)\n", err); 2223 return err; 2224 } 2225 2226 return err; 2227 } 2228 2229 static s32 2230 brcmf_set_sharedkey(struct net_device *ndev, 2231 struct cfg80211_connect_params *sme) 2232 { 2233 struct brcmf_if *ifp = netdev_priv(ndev); 2234 struct brcmf_pub *drvr = ifp->drvr; 2235 struct brcmf_cfg80211_profile *profile = ndev_to_prof(ndev); 2236 struct brcmf_cfg80211_security *sec; 2237 struct brcmf_wsec_key key; 2238 s32 val; 2239 s32 err = 0; 2240 2241 brcmf_dbg(CONN, "key len (%d)\n", sme->key_len); 2242 2243 if (sme->key_len == 0) 2244 return 0; 2245 2246 sec = &profile->sec; 2247 brcmf_dbg(CONN, "wpa_versions 0x%x cipher_pairwise 0x%x\n", 2248 sec->wpa_versions, sec->cipher_pairwise); 2249 2250 if (sec->wpa_versions & (NL80211_WPA_VERSION_1 | NL80211_WPA_VERSION_2 | 2251 NL80211_WPA_VERSION_3)) 2252 return 0; 2253 2254 if (!(sec->cipher_pairwise & 2255 (WLAN_CIPHER_SUITE_WEP40 | WLAN_CIPHER_SUITE_WEP104))) 2256 return 0; 2257 2258 memset(&key, 0, sizeof(key)); 2259 key.len = (u32) sme->key_len; 2260 key.index = (u32) sme->key_idx; 2261 if (key.len > sizeof(key.data)) { 2262 bphy_err(drvr, "Too long key length (%u)\n", key.len); 2263 return -EINVAL; 2264 } 2265 memcpy(key.data, sme->key, key.len); 2266 key.flags = BRCMF_PRIMARY_KEY; 2267 switch (sec->cipher_pairwise) { 2268 case WLAN_CIPHER_SUITE_WEP40: 2269 key.algo = CRYPTO_ALGO_WEP1; 2270 break; 2271 case WLAN_CIPHER_SUITE_WEP104: 2272 key.algo = CRYPTO_ALGO_WEP128; 2273 break; 2274 default: 2275 bphy_err(drvr, "Invalid algorithm (%d)\n", 2276 sme->crypto.ciphers_pairwise[0]); 2277 return -EINVAL; 2278 } 2279 /* Set the new key/index */ 2280 brcmf_dbg(CONN, "key length (%d) key index (%d) algo (%d)\n", 2281 key.len, key.index, key.algo); 2282 brcmf_dbg(CONN, "key \"%s\"\n", key.data); 2283 err = send_key_to_dongle(ifp, &key); 2284 if (err) 2285 return err; 2286 2287 if (sec->auth_type == NL80211_AUTHTYPE_SHARED_KEY) { 2288 brcmf_dbg(CONN, "set auth_type to shared key\n"); 2289 val = WL_AUTH_SHARED_KEY; /* shared key */ 2290 err = brcmf_fil_bsscfg_int_set(ifp, "auth", val); 2291 if (err) 2292 bphy_err(drvr, "set auth failed (%d)\n", err); 2293 } 2294 return err; 2295 } 2296 2297 static 2298 enum nl80211_auth_type brcmf_war_auth_type(struct brcmf_if *ifp, 2299 enum nl80211_auth_type type) 2300 { 2301 if (type == NL80211_AUTHTYPE_AUTOMATIC && 2302 brcmf_feat_is_quirk_enabled(ifp, BRCMF_FEAT_QUIRK_AUTO_AUTH)) { 2303 brcmf_dbg(CONN, "WAR: use OPEN instead of AUTO\n"); 2304 type = NL80211_AUTHTYPE_OPEN_SYSTEM; 2305 } 2306 return type; 2307 } 2308 2309 static void brcmf_set_join_pref(struct brcmf_if *ifp, 2310 struct cfg80211_bss_selection *bss_select) 2311 { 2312 struct brcmf_pub *drvr = ifp->drvr; 2313 struct brcmf_join_pref_params join_pref_params[2]; 2314 enum nl80211_band band; 2315 int err, i = 0; 2316 2317 join_pref_params[i].len = 2; 2318 join_pref_params[i].rssi_gain = 0; 2319 2320 if (bss_select->behaviour != NL80211_BSS_SELECT_ATTR_BAND_PREF) 2321 brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_ASSOC_PREFER, WLC_BAND_AUTO); 2322 2323 switch (bss_select->behaviour) { 2324 case __NL80211_BSS_SELECT_ATTR_INVALID: 2325 brcmf_c_set_joinpref_default(ifp); 2326 return; 2327 case NL80211_BSS_SELECT_ATTR_BAND_PREF: 2328 join_pref_params[i].type = BRCMF_JOIN_PREF_BAND; 2329 band = bss_select->param.band_pref; 2330 join_pref_params[i].band = nl80211_band_to_fwil(band); 2331 i++; 2332 break; 2333 case NL80211_BSS_SELECT_ATTR_RSSI_ADJUST: 2334 join_pref_params[i].type = BRCMF_JOIN_PREF_RSSI_DELTA; 2335 band = bss_select->param.adjust.band; 2336 join_pref_params[i].band = nl80211_band_to_fwil(band); 2337 join_pref_params[i].rssi_gain = bss_select->param.adjust.delta; 2338 i++; 2339 break; 2340 case NL80211_BSS_SELECT_ATTR_RSSI: 2341 default: 2342 break; 2343 } 2344 join_pref_params[i].type = BRCMF_JOIN_PREF_RSSI; 2345 join_pref_params[i].len = 2; 2346 join_pref_params[i].rssi_gain = 0; 2347 join_pref_params[i].band = 0; 2348 err = brcmf_fil_iovar_data_set(ifp, "join_pref", join_pref_params, 2349 sizeof(join_pref_params)); 2350 if (err) 2351 bphy_err(drvr, "Set join_pref error (%d)\n", err); 2352 } 2353 2354 static s32 2355 brcmf_cfg80211_connect(struct wiphy *wiphy, struct net_device *ndev, 2356 struct cfg80211_connect_params *sme) 2357 { 2358 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy); 2359 struct brcmf_if *ifp = netdev_priv(ndev); 2360 struct brcmf_cfg80211_profile *profile = &ifp->vif->profile; 2361 struct ieee80211_channel *chan = sme->channel; 2362 struct brcmf_pub *drvr = ifp->drvr; 2363 struct brcmf_join_params join_params; 2364 size_t join_params_size; 2365 const struct brcmf_tlv *rsn_ie; 2366 const struct brcmf_vs_tlv *wpa_ie; 2367 const void *ie; 2368 u32 ie_len; 2369 struct brcmf_ext_join_params_le *ext_join_params; 2370 u16 chanspec; 2371 s32 err = 0; 2372 u32 ssid_len; 2373 2374 brcmf_dbg(TRACE, "Enter\n"); 2375 if (!check_vif_up(ifp->vif)) 2376 return -EIO; 2377 2378 if (!sme->ssid) { 2379 bphy_err(drvr, "Invalid ssid\n"); 2380 return -EOPNOTSUPP; 2381 } 2382 2383 if (sme->channel_hint) 2384 chan = sme->channel_hint; 2385 2386 if (sme->bssid_hint) 2387 sme->bssid = sme->bssid_hint; 2388 2389 if (ifp->vif == cfg->p2p.bss_idx[P2PAPI_BSSCFG_PRIMARY].vif) { 2390 /* A normal (non P2P) connection request setup. */ 2391 ie = NULL; 2392 ie_len = 0; 2393 /* find the WPA_IE */ 2394 wpa_ie = brcmf_find_wpaie((u8 *)sme->ie, sme->ie_len); 2395 if (wpa_ie) { 2396 ie = wpa_ie; 2397 ie_len = wpa_ie->len + TLV_HDR_LEN; 2398 } else { 2399 /* find the RSN_IE */ 2400 rsn_ie = brcmf_parse_tlvs((const u8 *)sme->ie, 2401 sme->ie_len, 2402 WLAN_EID_RSN); 2403 if (rsn_ie) { 2404 ie = rsn_ie; 2405 ie_len = rsn_ie->len + TLV_HDR_LEN; 2406 } 2407 } 2408 brcmf_fil_iovar_data_set(ifp, "wpaie", ie, ie_len); 2409 } 2410 2411 err = brcmf_vif_set_mgmt_ie(ifp->vif, BRCMF_VNDR_IE_ASSOCREQ_FLAG, 2412 sme->ie, sme->ie_len); 2413 if (err) 2414 bphy_err(drvr, "Set Assoc REQ IE Failed\n"); 2415 else 2416 brcmf_dbg(TRACE, "Applied Vndr IEs for Assoc request\n"); 2417 2418 set_bit(BRCMF_VIF_STATUS_CONNECTING, &ifp->vif->sme_state); 2419 2420 if (chan) { 2421 cfg->channel = 2422 ieee80211_frequency_to_channel(chan->center_freq); 2423 chanspec = channel_to_chanspec(&cfg->d11inf, chan); 2424 brcmf_dbg(CONN, "channel=%d, center_req=%d, chanspec=0x%04x\n", 2425 cfg->channel, chan->center_freq, chanspec); 2426 } else { 2427 cfg->channel = 0; 2428 chanspec = 0; 2429 } 2430 2431 brcmf_dbg(INFO, "ie (%p), ie_len (%zd)\n", sme->ie, sme->ie_len); 2432 2433 err = brcmf_set_wpa_version(ndev, sme); 2434 if (err) { 2435 bphy_err(drvr, "wl_set_wpa_version failed (%d)\n", err); 2436 goto done; 2437 } 2438 2439 sme->auth_type = brcmf_war_auth_type(ifp, sme->auth_type); 2440 err = brcmf_set_auth_type(ndev, sme); 2441 if (err) { 2442 bphy_err(drvr, "wl_set_auth_type failed (%d)\n", err); 2443 goto done; 2444 } 2445 2446 err = brcmf_set_wsec_mode(ndev, sme); 2447 if (err) { 2448 bphy_err(drvr, "wl_set_set_cipher failed (%d)\n", err); 2449 goto done; 2450 } 2451 2452 err = brcmf_set_key_mgmt(ndev, sme); 2453 if (err) { 2454 bphy_err(drvr, "wl_set_key_mgmt failed (%d)\n", err); 2455 goto done; 2456 } 2457 2458 err = brcmf_set_sharedkey(ndev, sme); 2459 if (err) { 2460 bphy_err(drvr, "brcmf_set_sharedkey failed (%d)\n", err); 2461 goto done; 2462 } 2463 2464 if (sme->crypto.psk && 2465 profile->use_fwsup != BRCMF_PROFILE_FWSUP_SAE) { 2466 if (WARN_ON(profile->use_fwsup != BRCMF_PROFILE_FWSUP_NONE)) { 2467 err = -EINVAL; 2468 goto done; 2469 } 2470 brcmf_dbg(INFO, "using PSK offload\n"); 2471 profile->use_fwsup = BRCMF_PROFILE_FWSUP_PSK; 2472 } 2473 2474 if (profile->use_fwsup != BRCMF_PROFILE_FWSUP_NONE) { 2475 /* enable firmware supplicant for this interface */ 2476 err = brcmf_fil_iovar_int_set(ifp, "sup_wpa", 1); 2477 if (err < 0) { 2478 bphy_err(drvr, "failed to enable fw supplicant\n"); 2479 goto done; 2480 } 2481 } 2482 2483 if (profile->use_fwsup == BRCMF_PROFILE_FWSUP_PSK) 2484 err = brcmf_set_pmk(ifp, sme->crypto.psk, 2485 BRCMF_WSEC_MAX_PSK_LEN); 2486 else if (profile->use_fwsup == BRCMF_PROFILE_FWSUP_SAE) { 2487 /* clean up user-space RSNE */ 2488 err = brcmf_fil_iovar_data_set(ifp, "wpaie", NULL, 0); 2489 if (err) { 2490 bphy_err(drvr, "failed to clean up user-space RSNE\n"); 2491 goto done; 2492 } 2493 err = brcmf_fwvid_set_sae_password(ifp, &sme->crypto); 2494 if (!err && sme->crypto.psk) 2495 err = brcmf_set_pmk(ifp, sme->crypto.psk, 2496 BRCMF_WSEC_MAX_PSK_LEN); 2497 } 2498 if (err) 2499 goto done; 2500 2501 /* Join with specific BSSID and cached SSID 2502 * If SSID is zero join based on BSSID only 2503 */ 2504 join_params_size = offsetof(struct brcmf_ext_join_params_le, assoc_le) + 2505 offsetof(struct brcmf_assoc_params_le, chanspec_list); 2506 if (cfg->channel) 2507 join_params_size += sizeof(u16); 2508 ext_join_params = kzalloc(sizeof(*ext_join_params), GFP_KERNEL); 2509 if (ext_join_params == NULL) { 2510 err = -ENOMEM; 2511 goto done; 2512 } 2513 ssid_len = min_t(u32, sme->ssid_len, IEEE80211_MAX_SSID_LEN); 2514 ext_join_params->ssid_le.SSID_len = cpu_to_le32(ssid_len); 2515 memcpy(&ext_join_params->ssid_le.SSID, sme->ssid, ssid_len); 2516 if (ssid_len < IEEE80211_MAX_SSID_LEN) 2517 brcmf_dbg(CONN, "SSID \"%s\", len (%d)\n", 2518 ext_join_params->ssid_le.SSID, ssid_len); 2519 2520 /* Set up join scan parameters */ 2521 ext_join_params->scan_le.scan_type = -1; 2522 ext_join_params->scan_le.home_time = cpu_to_le32(-1); 2523 2524 if (sme->bssid) 2525 memcpy(&ext_join_params->assoc_le.bssid, sme->bssid, ETH_ALEN); 2526 else 2527 eth_broadcast_addr(ext_join_params->assoc_le.bssid); 2528 2529 if (cfg->channel) { 2530 ext_join_params->assoc_le.chanspec_num = cpu_to_le32(1); 2531 2532 ext_join_params->assoc_le.chanspec_list[0] = 2533 cpu_to_le16(chanspec); 2534 /* Increase dwell time to receive probe response or detect 2535 * beacon from target AP at a noisy air only during connect 2536 * command. 2537 */ 2538 ext_join_params->scan_le.active_time = 2539 cpu_to_le32(BRCMF_SCAN_JOIN_ACTIVE_DWELL_TIME_MS); 2540 ext_join_params->scan_le.passive_time = 2541 cpu_to_le32(BRCMF_SCAN_JOIN_PASSIVE_DWELL_TIME_MS); 2542 /* To sync with presence period of VSDB GO send probe request 2543 * more frequently. Probe request will be stopped when it gets 2544 * probe response from target AP/GO. 2545 */ 2546 ext_join_params->scan_le.nprobes = 2547 cpu_to_le32(BRCMF_SCAN_JOIN_ACTIVE_DWELL_TIME_MS / 2548 BRCMF_SCAN_JOIN_PROBE_INTERVAL_MS); 2549 } else { 2550 ext_join_params->scan_le.active_time = cpu_to_le32(-1); 2551 ext_join_params->scan_le.passive_time = cpu_to_le32(-1); 2552 ext_join_params->scan_le.nprobes = cpu_to_le32(-1); 2553 } 2554 2555 brcmf_set_join_pref(ifp, &sme->bss_select); 2556 2557 err = brcmf_fil_bsscfg_data_set(ifp, "join", ext_join_params, 2558 join_params_size); 2559 kfree(ext_join_params); 2560 if (!err) 2561 /* This is it. join command worked, we are done */ 2562 goto done; 2563 2564 /* join command failed, fallback to set ssid */ 2565 memset(&join_params, 0, sizeof(join_params)); 2566 join_params_size = sizeof(join_params.ssid_le); 2567 2568 memcpy(&join_params.ssid_le.SSID, sme->ssid, ssid_len); 2569 join_params.ssid_le.SSID_len = cpu_to_le32(ssid_len); 2570 2571 if (sme->bssid) 2572 memcpy(join_params.params_le.bssid, sme->bssid, ETH_ALEN); 2573 else 2574 eth_broadcast_addr(join_params.params_le.bssid); 2575 2576 if (cfg->channel) { 2577 join_params.params_le.chanspec_list[0] = cpu_to_le16(chanspec); 2578 join_params.params_le.chanspec_num = cpu_to_le32(1); 2579 join_params_size += sizeof(join_params.params_le); 2580 } 2581 err = brcmf_fil_cmd_data_set(ifp, BRCMF_C_SET_SSID, 2582 &join_params, join_params_size); 2583 if (err) 2584 bphy_err(drvr, "BRCMF_C_SET_SSID failed (%d)\n", err); 2585 2586 done: 2587 if (err) 2588 clear_bit(BRCMF_VIF_STATUS_CONNECTING, &ifp->vif->sme_state); 2589 brcmf_dbg(TRACE, "Exit\n"); 2590 return err; 2591 } 2592 2593 static s32 2594 brcmf_cfg80211_disconnect(struct wiphy *wiphy, struct net_device *ndev, 2595 u16 reason_code) 2596 { 2597 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy); 2598 struct brcmf_if *ifp = netdev_priv(ndev); 2599 struct brcmf_cfg80211_profile *profile = &ifp->vif->profile; 2600 struct brcmf_pub *drvr = cfg->pub; 2601 struct brcmf_scb_val_le scbval; 2602 s32 err = 0; 2603 2604 brcmf_dbg(TRACE, "Enter. Reason code = %d\n", reason_code); 2605 if (!check_vif_up(ifp->vif)) 2606 return -EIO; 2607 2608 clear_bit(BRCMF_VIF_STATUS_CONNECTED, &ifp->vif->sme_state); 2609 clear_bit(BRCMF_VIF_STATUS_CONNECTING, &ifp->vif->sme_state); 2610 clear_bit(BRCMF_VIF_STATUS_EAP_SUCCESS, &ifp->vif->sme_state); 2611 clear_bit(BRCMF_VIF_STATUS_ASSOC_SUCCESS, &ifp->vif->sme_state); 2612 cfg80211_disconnected(ndev, reason_code, NULL, 0, true, GFP_KERNEL); 2613 2614 memcpy(&scbval.ea, &profile->bssid, ETH_ALEN); 2615 scbval.val = cpu_to_le32(reason_code); 2616 err = brcmf_fil_cmd_data_set(ifp, BRCMF_C_DISASSOC, 2617 &scbval, sizeof(scbval)); 2618 if (err) 2619 bphy_err(drvr, "error (%d)\n", err); 2620 2621 brcmf_dbg(TRACE, "Exit\n"); 2622 return err; 2623 } 2624 2625 static s32 2626 brcmf_cfg80211_set_tx_power(struct wiphy *wiphy, struct wireless_dev *wdev, 2627 enum nl80211_tx_power_setting type, s32 mbm) 2628 { 2629 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy); 2630 struct net_device *ndev = cfg_to_ndev(cfg); 2631 struct brcmf_if *ifp = netdev_priv(ndev); 2632 struct brcmf_pub *drvr = cfg->pub; 2633 s32 err; 2634 s32 disable; 2635 u32 qdbm = 127; 2636 2637 brcmf_dbg(TRACE, "Enter %d %d\n", type, mbm); 2638 if (!check_vif_up(ifp->vif)) 2639 return -EIO; 2640 2641 switch (type) { 2642 case NL80211_TX_POWER_AUTOMATIC: 2643 break; 2644 case NL80211_TX_POWER_LIMITED: 2645 case NL80211_TX_POWER_FIXED: 2646 if (mbm < 0) { 2647 bphy_err(drvr, "TX_POWER_FIXED - dbm is negative\n"); 2648 err = -EINVAL; 2649 goto done; 2650 } 2651 qdbm = MBM_TO_DBM(4 * mbm); 2652 if (qdbm > 127) 2653 qdbm = 127; 2654 qdbm |= WL_TXPWR_OVERRIDE; 2655 break; 2656 default: 2657 bphy_err(drvr, "Unsupported type %d\n", type); 2658 err = -EINVAL; 2659 goto done; 2660 } 2661 /* Make sure radio is off or on as far as software is concerned */ 2662 disable = WL_RADIO_SW_DISABLE << 16; 2663 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_RADIO, disable); 2664 if (err) 2665 bphy_err(drvr, "WLC_SET_RADIO error (%d)\n", err); 2666 2667 err = brcmf_fil_iovar_int_set(ifp, "qtxpower", qdbm); 2668 if (err) 2669 bphy_err(drvr, "qtxpower error (%d)\n", err); 2670 2671 done: 2672 brcmf_dbg(TRACE, "Exit %d (qdbm)\n", qdbm & ~WL_TXPWR_OVERRIDE); 2673 return err; 2674 } 2675 2676 static s32 2677 brcmf_cfg80211_get_tx_power(struct wiphy *wiphy, struct wireless_dev *wdev, 2678 s32 *dbm) 2679 { 2680 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy); 2681 struct brcmf_cfg80211_vif *vif = wdev_to_vif(wdev); 2682 struct brcmf_pub *drvr = cfg->pub; 2683 s32 qdbm = 0; 2684 s32 err; 2685 2686 brcmf_dbg(TRACE, "Enter\n"); 2687 if (!check_vif_up(vif)) 2688 return -EIO; 2689 2690 err = brcmf_fil_iovar_int_get(vif->ifp, "qtxpower", &qdbm); 2691 if (err) { 2692 bphy_err(drvr, "error (%d)\n", err); 2693 goto done; 2694 } 2695 *dbm = (qdbm & ~WL_TXPWR_OVERRIDE) / 4; 2696 2697 done: 2698 brcmf_dbg(TRACE, "Exit (0x%x %d)\n", qdbm, *dbm); 2699 return err; 2700 } 2701 2702 static s32 2703 brcmf_cfg80211_config_default_key(struct wiphy *wiphy, struct net_device *ndev, 2704 int link_id, u8 key_idx, bool unicast, 2705 bool multicast) 2706 { 2707 struct brcmf_if *ifp = netdev_priv(ndev); 2708 struct brcmf_pub *drvr = ifp->drvr; 2709 u32 index; 2710 u32 wsec; 2711 s32 err = 0; 2712 2713 brcmf_dbg(TRACE, "Enter\n"); 2714 brcmf_dbg(CONN, "key index (%d)\n", key_idx); 2715 if (!check_vif_up(ifp->vif)) 2716 return -EIO; 2717 2718 err = brcmf_fil_bsscfg_int_get(ifp, "wsec", &wsec); 2719 if (err) { 2720 bphy_err(drvr, "WLC_GET_WSEC error (%d)\n", err); 2721 goto done; 2722 } 2723 2724 if (wsec & WEP_ENABLED) { 2725 /* Just select a new current key */ 2726 index = key_idx; 2727 err = brcmf_fil_cmd_int_set(ifp, 2728 BRCMF_C_SET_KEY_PRIMARY, index); 2729 if (err) 2730 bphy_err(drvr, "error (%d)\n", err); 2731 } 2732 done: 2733 brcmf_dbg(TRACE, "Exit\n"); 2734 return err; 2735 } 2736 2737 static s32 2738 brcmf_cfg80211_del_key(struct wiphy *wiphy, struct net_device *ndev, 2739 int link_id, u8 key_idx, bool pairwise, 2740 const u8 *mac_addr) 2741 { 2742 struct brcmf_if *ifp = netdev_priv(ndev); 2743 struct brcmf_wsec_key *key; 2744 s32 err; 2745 2746 brcmf_dbg(TRACE, "Enter\n"); 2747 brcmf_dbg(CONN, "key index (%d)\n", key_idx); 2748 2749 if (!check_vif_up(ifp->vif)) 2750 return -EIO; 2751 2752 if (key_idx >= BRCMF_MAX_DEFAULT_KEYS) { 2753 /* we ignore this key index in this case */ 2754 return -EINVAL; 2755 } 2756 2757 key = &ifp->vif->profile.key[key_idx]; 2758 2759 if (key->algo == CRYPTO_ALGO_OFF) { 2760 brcmf_dbg(CONN, "Ignore clearing of (never configured) key\n"); 2761 return -EINVAL; 2762 } 2763 2764 memset(key, 0, sizeof(*key)); 2765 key->index = (u32)key_idx; 2766 key->flags = BRCMF_PRIMARY_KEY; 2767 2768 /* Clear the key/index */ 2769 err = send_key_to_dongle(ifp, key); 2770 2771 brcmf_dbg(TRACE, "Exit\n"); 2772 return err; 2773 } 2774 2775 static s32 2776 brcmf_cfg80211_add_key(struct wiphy *wiphy, struct net_device *ndev, 2777 int link_id, u8 key_idx, bool pairwise, 2778 const u8 *mac_addr, struct key_params *params) 2779 { 2780 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy); 2781 struct brcmf_if *ifp = netdev_priv(ndev); 2782 struct brcmf_pub *drvr = cfg->pub; 2783 struct brcmf_wsec_key *key; 2784 s32 val; 2785 s32 wsec; 2786 s32 err; 2787 u8 keybuf[8]; 2788 bool ext_key; 2789 2790 brcmf_dbg(TRACE, "Enter\n"); 2791 brcmf_dbg(CONN, "key index (%d)\n", key_idx); 2792 if (!check_vif_up(ifp->vif)) 2793 return -EIO; 2794 2795 if (key_idx >= BRCMF_MAX_DEFAULT_KEYS) { 2796 /* we ignore this key index in this case */ 2797 bphy_err(drvr, "invalid key index (%d)\n", key_idx); 2798 return -EINVAL; 2799 } 2800 2801 if (params->key_len == 0) 2802 return brcmf_cfg80211_del_key(wiphy, ndev, -1, key_idx, 2803 pairwise, mac_addr); 2804 2805 if (params->key_len > sizeof(key->data)) { 2806 bphy_err(drvr, "Too long key length (%u)\n", params->key_len); 2807 return -EINVAL; 2808 } 2809 2810 ext_key = false; 2811 if (mac_addr && (params->cipher != WLAN_CIPHER_SUITE_WEP40) && 2812 (params->cipher != WLAN_CIPHER_SUITE_WEP104)) { 2813 brcmf_dbg(TRACE, "Ext key, mac %pM", mac_addr); 2814 ext_key = true; 2815 } 2816 2817 key = &ifp->vif->profile.key[key_idx]; 2818 memset(key, 0, sizeof(*key)); 2819 if ((ext_key) && (!is_multicast_ether_addr(mac_addr))) 2820 memcpy((char *)&key->ea, (void *)mac_addr, ETH_ALEN); 2821 key->len = params->key_len; 2822 key->index = key_idx; 2823 memcpy(key->data, params->key, key->len); 2824 if (!ext_key) 2825 key->flags = BRCMF_PRIMARY_KEY; 2826 2827 if (params->seq && params->seq_len == 6) { 2828 /* rx iv */ 2829 u8 *ivptr; 2830 2831 ivptr = (u8 *)params->seq; 2832 key->rxiv.hi = (ivptr[5] << 24) | (ivptr[4] << 16) | 2833 (ivptr[3] << 8) | ivptr[2]; 2834 key->rxiv.lo = (ivptr[1] << 8) | ivptr[0]; 2835 key->iv_initialized = true; 2836 } 2837 2838 switch (params->cipher) { 2839 case WLAN_CIPHER_SUITE_WEP40: 2840 key->algo = CRYPTO_ALGO_WEP1; 2841 val = WEP_ENABLED; 2842 brcmf_dbg(CONN, "WLAN_CIPHER_SUITE_WEP40\n"); 2843 break; 2844 case WLAN_CIPHER_SUITE_WEP104: 2845 key->algo = CRYPTO_ALGO_WEP128; 2846 val = WEP_ENABLED; 2847 brcmf_dbg(CONN, "WLAN_CIPHER_SUITE_WEP104\n"); 2848 break; 2849 case WLAN_CIPHER_SUITE_TKIP: 2850 if (!brcmf_is_apmode(ifp->vif)) { 2851 brcmf_dbg(CONN, "Swapping RX/TX MIC key\n"); 2852 memcpy(keybuf, &key->data[24], sizeof(keybuf)); 2853 memcpy(&key->data[24], &key->data[16], sizeof(keybuf)); 2854 memcpy(&key->data[16], keybuf, sizeof(keybuf)); 2855 } 2856 key->algo = CRYPTO_ALGO_TKIP; 2857 val = TKIP_ENABLED; 2858 brcmf_dbg(CONN, "WLAN_CIPHER_SUITE_TKIP\n"); 2859 break; 2860 case WLAN_CIPHER_SUITE_AES_CMAC: 2861 key->algo = CRYPTO_ALGO_AES_CCM; 2862 val = AES_ENABLED; 2863 brcmf_dbg(CONN, "WLAN_CIPHER_SUITE_AES_CMAC\n"); 2864 break; 2865 case WLAN_CIPHER_SUITE_CCMP: 2866 key->algo = CRYPTO_ALGO_AES_CCM; 2867 val = AES_ENABLED; 2868 brcmf_dbg(CONN, "WLAN_CIPHER_SUITE_CCMP\n"); 2869 break; 2870 default: 2871 bphy_err(drvr, "Invalid cipher (0x%x)\n", params->cipher); 2872 err = -EINVAL; 2873 goto done; 2874 } 2875 2876 err = send_key_to_dongle(ifp, key); 2877 if (ext_key || err) 2878 goto done; 2879 2880 err = brcmf_fil_bsscfg_int_get(ifp, "wsec", &wsec); 2881 if (err) { 2882 bphy_err(drvr, "get wsec error (%d)\n", err); 2883 goto done; 2884 } 2885 wsec |= val; 2886 err = brcmf_fil_bsscfg_int_set(ifp, "wsec", wsec); 2887 if (err) { 2888 bphy_err(drvr, "set wsec error (%d)\n", err); 2889 goto done; 2890 } 2891 2892 done: 2893 brcmf_dbg(TRACE, "Exit\n"); 2894 return err; 2895 } 2896 2897 static s32 2898 brcmf_cfg80211_get_key(struct wiphy *wiphy, struct net_device *ndev, 2899 int link_id, u8 key_idx, bool pairwise, 2900 const u8 *mac_addr, void *cookie, 2901 void (*callback)(void *cookie, 2902 struct key_params *params)) 2903 { 2904 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy); 2905 struct key_params params; 2906 struct brcmf_if *ifp = netdev_priv(ndev); 2907 struct brcmf_cfg80211_profile *profile = &ifp->vif->profile; 2908 struct brcmf_pub *drvr = cfg->pub; 2909 struct brcmf_cfg80211_security *sec; 2910 s32 wsec; 2911 s32 err = 0; 2912 2913 brcmf_dbg(TRACE, "Enter\n"); 2914 brcmf_dbg(CONN, "key index (%d)\n", key_idx); 2915 if (!check_vif_up(ifp->vif)) 2916 return -EIO; 2917 2918 memset(¶ms, 0, sizeof(params)); 2919 2920 err = brcmf_fil_bsscfg_int_get(ifp, "wsec", &wsec); 2921 if (err) { 2922 bphy_err(drvr, "WLC_GET_WSEC error (%d)\n", err); 2923 /* Ignore this error, may happen during DISASSOC */ 2924 err = -EAGAIN; 2925 goto done; 2926 } 2927 if (wsec & WEP_ENABLED) { 2928 sec = &profile->sec; 2929 if (sec->cipher_pairwise & WLAN_CIPHER_SUITE_WEP40) { 2930 params.cipher = WLAN_CIPHER_SUITE_WEP40; 2931 brcmf_dbg(CONN, "WLAN_CIPHER_SUITE_WEP40\n"); 2932 } else if (sec->cipher_pairwise & WLAN_CIPHER_SUITE_WEP104) { 2933 params.cipher = WLAN_CIPHER_SUITE_WEP104; 2934 brcmf_dbg(CONN, "WLAN_CIPHER_SUITE_WEP104\n"); 2935 } 2936 } else if (wsec & TKIP_ENABLED) { 2937 params.cipher = WLAN_CIPHER_SUITE_TKIP; 2938 brcmf_dbg(CONN, "WLAN_CIPHER_SUITE_TKIP\n"); 2939 } else if (wsec & AES_ENABLED) { 2940 params.cipher = WLAN_CIPHER_SUITE_AES_CMAC; 2941 brcmf_dbg(CONN, "WLAN_CIPHER_SUITE_AES_CMAC\n"); 2942 } else { 2943 bphy_err(drvr, "Invalid algo (0x%x)\n", wsec); 2944 err = -EINVAL; 2945 goto done; 2946 } 2947 callback(cookie, ¶ms); 2948 2949 done: 2950 brcmf_dbg(TRACE, "Exit\n"); 2951 return err; 2952 } 2953 2954 static s32 2955 brcmf_cfg80211_config_default_mgmt_key(struct wiphy *wiphy, 2956 struct net_device *ndev, int link_id, 2957 u8 key_idx) 2958 { 2959 struct brcmf_if *ifp = netdev_priv(ndev); 2960 2961 brcmf_dbg(TRACE, "Enter key_idx %d\n", key_idx); 2962 2963 if (brcmf_feat_is_enabled(ifp, BRCMF_FEAT_MFP)) 2964 return 0; 2965 2966 brcmf_dbg(INFO, "Not supported\n"); 2967 2968 return -EOPNOTSUPP; 2969 } 2970 2971 static void 2972 brcmf_cfg80211_reconfigure_wep(struct brcmf_if *ifp) 2973 { 2974 struct brcmf_pub *drvr = ifp->drvr; 2975 s32 err; 2976 u8 key_idx; 2977 struct brcmf_wsec_key *key; 2978 s32 wsec; 2979 2980 for (key_idx = 0; key_idx < BRCMF_MAX_DEFAULT_KEYS; key_idx++) { 2981 key = &ifp->vif->profile.key[key_idx]; 2982 if ((key->algo == CRYPTO_ALGO_WEP1) || 2983 (key->algo == CRYPTO_ALGO_WEP128)) 2984 break; 2985 } 2986 if (key_idx == BRCMF_MAX_DEFAULT_KEYS) 2987 return; 2988 2989 err = send_key_to_dongle(ifp, key); 2990 if (err) { 2991 bphy_err(drvr, "Setting WEP key failed (%d)\n", err); 2992 return; 2993 } 2994 err = brcmf_fil_bsscfg_int_get(ifp, "wsec", &wsec); 2995 if (err) { 2996 bphy_err(drvr, "get wsec error (%d)\n", err); 2997 return; 2998 } 2999 wsec |= WEP_ENABLED; 3000 err = brcmf_fil_bsscfg_int_set(ifp, "wsec", wsec); 3001 if (err) 3002 bphy_err(drvr, "set wsec error (%d)\n", err); 3003 } 3004 3005 static void brcmf_convert_sta_flags(u32 fw_sta_flags, struct station_info *si) 3006 { 3007 struct nl80211_sta_flag_update *sfu; 3008 3009 brcmf_dbg(TRACE, "flags %08x\n", fw_sta_flags); 3010 si->filled |= BIT_ULL(NL80211_STA_INFO_STA_FLAGS); 3011 sfu = &si->sta_flags; 3012 sfu->mask = BIT(NL80211_STA_FLAG_WME) | 3013 BIT(NL80211_STA_FLAG_AUTHENTICATED) | 3014 BIT(NL80211_STA_FLAG_ASSOCIATED) | 3015 BIT(NL80211_STA_FLAG_AUTHORIZED); 3016 if (fw_sta_flags & BRCMF_STA_WME) 3017 sfu->set |= BIT(NL80211_STA_FLAG_WME); 3018 if (fw_sta_flags & BRCMF_STA_AUTHE) 3019 sfu->set |= BIT(NL80211_STA_FLAG_AUTHENTICATED); 3020 if (fw_sta_flags & BRCMF_STA_ASSOC) 3021 sfu->set |= BIT(NL80211_STA_FLAG_ASSOCIATED); 3022 if (fw_sta_flags & BRCMF_STA_AUTHO) 3023 sfu->set |= BIT(NL80211_STA_FLAG_AUTHORIZED); 3024 } 3025 3026 static void brcmf_fill_bss_param(struct brcmf_if *ifp, struct station_info *si) 3027 { 3028 struct brcmf_pub *drvr = ifp->drvr; 3029 struct { 3030 __le32 len; 3031 struct brcmf_bss_info_le bss_le; 3032 } *buf; 3033 u16 capability; 3034 int err; 3035 3036 buf = kzalloc(WL_BSS_INFO_MAX, GFP_KERNEL); 3037 if (!buf) 3038 return; 3039 3040 buf->len = cpu_to_le32(WL_BSS_INFO_MAX); 3041 err = brcmf_fil_cmd_data_get(ifp, BRCMF_C_GET_BSS_INFO, buf, 3042 WL_BSS_INFO_MAX); 3043 if (err) { 3044 bphy_err(drvr, "Failed to get bss info (%d)\n", err); 3045 goto out_kfree; 3046 } 3047 si->filled |= BIT_ULL(NL80211_STA_INFO_BSS_PARAM); 3048 si->bss_param.beacon_interval = le16_to_cpu(buf->bss_le.beacon_period); 3049 si->bss_param.dtim_period = buf->bss_le.dtim_period; 3050 capability = le16_to_cpu(buf->bss_le.capability); 3051 if (capability & IEEE80211_HT_STBC_PARAM_DUAL_CTS_PROT) 3052 si->bss_param.flags |= BSS_PARAM_FLAGS_CTS_PROT; 3053 if (capability & WLAN_CAPABILITY_SHORT_PREAMBLE) 3054 si->bss_param.flags |= BSS_PARAM_FLAGS_SHORT_PREAMBLE; 3055 if (capability & WLAN_CAPABILITY_SHORT_SLOT_TIME) 3056 si->bss_param.flags |= BSS_PARAM_FLAGS_SHORT_SLOT_TIME; 3057 3058 out_kfree: 3059 kfree(buf); 3060 } 3061 3062 static s32 3063 brcmf_cfg80211_get_station_ibss(struct brcmf_if *ifp, 3064 struct station_info *sinfo) 3065 { 3066 struct brcmf_pub *drvr = ifp->drvr; 3067 struct brcmf_scb_val_le scbval; 3068 struct brcmf_pktcnt_le pktcnt; 3069 s32 err; 3070 u32 rate = 0; 3071 u32 rssi; 3072 3073 /* Get the current tx rate */ 3074 err = brcmf_fil_cmd_int_get(ifp, BRCMF_C_GET_RATE, &rate); 3075 if (err < 0) { 3076 bphy_err(drvr, "BRCMF_C_GET_RATE error (%d)\n", err); 3077 return err; 3078 } 3079 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_TX_BITRATE); 3080 sinfo->txrate.legacy = rate * 5; 3081 3082 memset(&scbval, 0, sizeof(scbval)); 3083 err = brcmf_fil_cmd_data_get(ifp, BRCMF_C_GET_RSSI, &scbval, 3084 sizeof(scbval)); 3085 if (err) { 3086 bphy_err(drvr, "BRCMF_C_GET_RSSI error (%d)\n", err); 3087 return err; 3088 } 3089 rssi = le32_to_cpu(scbval.val); 3090 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_SIGNAL); 3091 sinfo->signal = rssi; 3092 3093 err = brcmf_fil_cmd_data_get(ifp, BRCMF_C_GET_GET_PKTCNTS, &pktcnt, 3094 sizeof(pktcnt)); 3095 if (err) { 3096 bphy_err(drvr, "BRCMF_C_GET_GET_PKTCNTS error (%d)\n", err); 3097 return err; 3098 } 3099 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_RX_PACKETS) | 3100 BIT_ULL(NL80211_STA_INFO_RX_DROP_MISC) | 3101 BIT_ULL(NL80211_STA_INFO_TX_PACKETS) | 3102 BIT_ULL(NL80211_STA_INFO_TX_FAILED); 3103 sinfo->rx_packets = le32_to_cpu(pktcnt.rx_good_pkt); 3104 sinfo->rx_dropped_misc = le32_to_cpu(pktcnt.rx_bad_pkt); 3105 sinfo->tx_packets = le32_to_cpu(pktcnt.tx_good_pkt); 3106 sinfo->tx_failed = le32_to_cpu(pktcnt.tx_bad_pkt); 3107 3108 return 0; 3109 } 3110 3111 static s32 3112 brcmf_cfg80211_get_station(struct wiphy *wiphy, struct net_device *ndev, 3113 const u8 *mac, struct station_info *sinfo) 3114 { 3115 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy); 3116 struct brcmf_if *ifp = netdev_priv(ndev); 3117 struct brcmf_pub *drvr = cfg->pub; 3118 struct brcmf_scb_val_le scb_val; 3119 s32 err = 0; 3120 struct brcmf_sta_info_le sta_info_le; 3121 u32 sta_flags; 3122 u32 is_tdls_peer; 3123 s32 total_rssi_avg = 0; 3124 s32 total_rssi = 0; 3125 s32 count_rssi = 0; 3126 int rssi; 3127 u32 i; 3128 3129 brcmf_dbg(TRACE, "Enter, MAC %pM\n", mac); 3130 if (!check_vif_up(ifp->vif)) 3131 return -EIO; 3132 3133 if (brcmf_is_ibssmode(ifp->vif)) 3134 return brcmf_cfg80211_get_station_ibss(ifp, sinfo); 3135 3136 memset(&sta_info_le, 0, sizeof(sta_info_le)); 3137 memcpy(&sta_info_le, mac, ETH_ALEN); 3138 err = brcmf_fil_iovar_data_get(ifp, "tdls_sta_info", 3139 &sta_info_le, 3140 sizeof(sta_info_le)); 3141 is_tdls_peer = !err; 3142 if (err) { 3143 err = brcmf_fil_iovar_data_get(ifp, "sta_info", 3144 &sta_info_le, 3145 sizeof(sta_info_le)); 3146 if (err < 0) { 3147 bphy_err(drvr, "GET STA INFO failed, %d\n", err); 3148 goto done; 3149 } 3150 } 3151 brcmf_dbg(TRACE, "version %d\n", le16_to_cpu(sta_info_le.ver)); 3152 sinfo->filled = BIT_ULL(NL80211_STA_INFO_INACTIVE_TIME); 3153 sinfo->inactive_time = le32_to_cpu(sta_info_le.idle) * 1000; 3154 sta_flags = le32_to_cpu(sta_info_le.flags); 3155 brcmf_convert_sta_flags(sta_flags, sinfo); 3156 sinfo->sta_flags.mask |= BIT(NL80211_STA_FLAG_TDLS_PEER); 3157 if (is_tdls_peer) 3158 sinfo->sta_flags.set |= BIT(NL80211_STA_FLAG_TDLS_PEER); 3159 else 3160 sinfo->sta_flags.set &= ~BIT(NL80211_STA_FLAG_TDLS_PEER); 3161 if (sta_flags & BRCMF_STA_ASSOC) { 3162 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_CONNECTED_TIME); 3163 sinfo->connected_time = le32_to_cpu(sta_info_le.in); 3164 brcmf_fill_bss_param(ifp, sinfo); 3165 } 3166 if (sta_flags & BRCMF_STA_SCBSTATS) { 3167 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_TX_FAILED); 3168 sinfo->tx_failed = le32_to_cpu(sta_info_le.tx_failures); 3169 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_TX_PACKETS); 3170 sinfo->tx_packets = le32_to_cpu(sta_info_le.tx_pkts); 3171 sinfo->tx_packets += le32_to_cpu(sta_info_le.tx_mcast_pkts); 3172 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_RX_PACKETS); 3173 sinfo->rx_packets = le32_to_cpu(sta_info_le.rx_ucast_pkts); 3174 sinfo->rx_packets += le32_to_cpu(sta_info_le.rx_mcast_pkts); 3175 if (sinfo->tx_packets) { 3176 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_TX_BITRATE); 3177 sinfo->txrate.legacy = 3178 le32_to_cpu(sta_info_le.tx_rate) / 100; 3179 } 3180 if (sinfo->rx_packets) { 3181 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_RX_BITRATE); 3182 sinfo->rxrate.legacy = 3183 le32_to_cpu(sta_info_le.rx_rate) / 100; 3184 } 3185 if (le16_to_cpu(sta_info_le.ver) >= 4) { 3186 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_TX_BYTES); 3187 sinfo->tx_bytes = le64_to_cpu(sta_info_le.tx_tot_bytes); 3188 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_RX_BYTES); 3189 sinfo->rx_bytes = le64_to_cpu(sta_info_le.rx_tot_bytes); 3190 } 3191 for (i = 0; i < BRCMF_ANT_MAX; i++) { 3192 if (sta_info_le.rssi[i] == 0 || 3193 sta_info_le.rx_lastpkt_rssi[i] == 0) 3194 continue; 3195 sinfo->chains |= BIT(count_rssi); 3196 sinfo->chain_signal[count_rssi] = 3197 sta_info_le.rx_lastpkt_rssi[i]; 3198 sinfo->chain_signal_avg[count_rssi] = 3199 sta_info_le.rssi[i]; 3200 total_rssi += sta_info_le.rx_lastpkt_rssi[i]; 3201 total_rssi_avg += sta_info_le.rssi[i]; 3202 count_rssi++; 3203 } 3204 if (count_rssi) { 3205 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_SIGNAL); 3206 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_SIGNAL_AVG); 3207 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_CHAIN_SIGNAL); 3208 sinfo->filled |= 3209 BIT_ULL(NL80211_STA_INFO_CHAIN_SIGNAL_AVG); 3210 sinfo->signal = total_rssi / count_rssi; 3211 sinfo->signal_avg = total_rssi_avg / count_rssi; 3212 } else if (test_bit(BRCMF_VIF_STATUS_CONNECTED, 3213 &ifp->vif->sme_state)) { 3214 memset(&scb_val, 0, sizeof(scb_val)); 3215 err = brcmf_fil_cmd_data_get(ifp, BRCMF_C_GET_RSSI, 3216 &scb_val, sizeof(scb_val)); 3217 if (err) { 3218 bphy_err(drvr, "Could not get rssi (%d)\n", 3219 err); 3220 goto done; 3221 } else { 3222 rssi = le32_to_cpu(scb_val.val); 3223 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_SIGNAL); 3224 sinfo->signal = rssi; 3225 brcmf_dbg(CONN, "RSSI %d dBm\n", rssi); 3226 } 3227 } 3228 } 3229 done: 3230 brcmf_dbg(TRACE, "Exit\n"); 3231 return err; 3232 } 3233 3234 static int 3235 brcmf_cfg80211_dump_station(struct wiphy *wiphy, struct net_device *ndev, 3236 int idx, u8 *mac, struct station_info *sinfo) 3237 { 3238 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy); 3239 struct brcmf_if *ifp = netdev_priv(ndev); 3240 struct brcmf_pub *drvr = cfg->pub; 3241 s32 err; 3242 3243 brcmf_dbg(TRACE, "Enter, idx %d\n", idx); 3244 3245 if (idx == 0) { 3246 cfg->assoclist.count = cpu_to_le32(BRCMF_MAX_ASSOCLIST); 3247 err = brcmf_fil_cmd_data_get(ifp, BRCMF_C_GET_ASSOCLIST, 3248 &cfg->assoclist, 3249 sizeof(cfg->assoclist)); 3250 if (err) { 3251 /* GET_ASSOCLIST unsupported by firmware of older chips */ 3252 if (err == -EBADE) 3253 bphy_info_once(drvr, "BRCMF_C_GET_ASSOCLIST unsupported\n"); 3254 else 3255 bphy_err(drvr, "BRCMF_C_GET_ASSOCLIST failed, err=%d\n", 3256 err); 3257 3258 cfg->assoclist.count = 0; 3259 return -EOPNOTSUPP; 3260 } 3261 } 3262 if (idx < le32_to_cpu(cfg->assoclist.count)) { 3263 memcpy(mac, cfg->assoclist.mac[idx], ETH_ALEN); 3264 return brcmf_cfg80211_get_station(wiphy, ndev, mac, sinfo); 3265 } 3266 return -ENOENT; 3267 } 3268 3269 static s32 3270 brcmf_cfg80211_set_power_mgmt(struct wiphy *wiphy, struct net_device *ndev, 3271 bool enabled, s32 timeout) 3272 { 3273 s32 pm; 3274 s32 err = 0; 3275 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy); 3276 struct brcmf_if *ifp = netdev_priv(ndev); 3277 struct brcmf_pub *drvr = cfg->pub; 3278 3279 brcmf_dbg(TRACE, "Enter\n"); 3280 3281 /* 3282 * Powersave enable/disable request is coming from the 3283 * cfg80211 even before the interface is up. In that 3284 * scenario, driver will be storing the power save 3285 * preference in cfg struct to apply this to 3286 * FW later while initializing the dongle 3287 */ 3288 cfg->pwr_save = enabled; 3289 if (!check_vif_up(ifp->vif)) { 3290 3291 brcmf_dbg(INFO, "Device is not ready, storing the value in cfg_info struct\n"); 3292 goto done; 3293 } 3294 3295 pm = enabled ? PM_FAST : PM_OFF; 3296 /* Do not enable the power save after assoc if it is a p2p interface */ 3297 if (ifp->vif->wdev.iftype == NL80211_IFTYPE_P2P_CLIENT) { 3298 brcmf_dbg(INFO, "Do not enable power save for P2P clients\n"); 3299 pm = PM_OFF; 3300 } 3301 brcmf_dbg(INFO, "power save %s\n", (pm ? "enabled" : "disabled")); 3302 3303 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_PM, pm); 3304 if (err) { 3305 if (err == -ENODEV) 3306 bphy_err(drvr, "net_device is not ready yet\n"); 3307 else 3308 bphy_err(drvr, "error (%d)\n", err); 3309 } 3310 3311 err = brcmf_fil_iovar_int_set(ifp, "pm2_sleep_ret", 3312 min_t(u32, timeout, BRCMF_PS_MAX_TIMEOUT_MS)); 3313 if (err) 3314 bphy_err(drvr, "Unable to set pm timeout, (%d)\n", err); 3315 3316 done: 3317 brcmf_dbg(TRACE, "Exit\n"); 3318 return err; 3319 } 3320 3321 static s32 brcmf_inform_single_bss(struct brcmf_cfg80211_info *cfg, 3322 struct brcmf_bss_info_le *bi) 3323 { 3324 struct wiphy *wiphy = cfg_to_wiphy(cfg); 3325 struct brcmf_pub *drvr = cfg->pub; 3326 struct cfg80211_bss *bss; 3327 enum nl80211_band band; 3328 struct brcmu_chan ch; 3329 u16 channel; 3330 u32 freq; 3331 u16 notify_capability; 3332 u16 notify_interval; 3333 u8 *notify_ie; 3334 size_t notify_ielen; 3335 struct cfg80211_inform_bss bss_data = {}; 3336 3337 if (le32_to_cpu(bi->length) > WL_BSS_INFO_MAX) { 3338 bphy_err(drvr, "Bss info is larger than buffer. Discarding\n"); 3339 return -EINVAL; 3340 } 3341 3342 if (!bi->ctl_ch) { 3343 ch.chspec = le16_to_cpu(bi->chanspec); 3344 cfg->d11inf.decchspec(&ch); 3345 bi->ctl_ch = ch.control_ch_num; 3346 } 3347 channel = bi->ctl_ch; 3348 3349 if (channel <= CH_MAX_2G_CHANNEL) 3350 band = NL80211_BAND_2GHZ; 3351 else 3352 band = NL80211_BAND_5GHZ; 3353 3354 freq = ieee80211_channel_to_frequency(channel, band); 3355 bss_data.chan = ieee80211_get_channel(wiphy, freq); 3356 bss_data.boottime_ns = ktime_to_ns(ktime_get_boottime()); 3357 3358 notify_capability = le16_to_cpu(bi->capability); 3359 notify_interval = le16_to_cpu(bi->beacon_period); 3360 notify_ie = (u8 *)bi + le16_to_cpu(bi->ie_offset); 3361 notify_ielen = le32_to_cpu(bi->ie_length); 3362 bss_data.signal = (s16)le16_to_cpu(bi->RSSI) * 100; 3363 3364 brcmf_dbg(CONN, "bssid: %pM\n", bi->BSSID); 3365 brcmf_dbg(CONN, "Channel: %d(%d)\n", channel, freq); 3366 brcmf_dbg(CONN, "Capability: %X\n", notify_capability); 3367 brcmf_dbg(CONN, "Beacon interval: %d\n", notify_interval); 3368 brcmf_dbg(CONN, "Signal: %d\n", bss_data.signal); 3369 3370 bss = cfg80211_inform_bss_data(wiphy, &bss_data, 3371 CFG80211_BSS_FTYPE_UNKNOWN, 3372 (const u8 *)bi->BSSID, 3373 0, notify_capability, 3374 notify_interval, notify_ie, 3375 notify_ielen, GFP_KERNEL); 3376 3377 if (!bss) 3378 return -ENOMEM; 3379 3380 cfg80211_put_bss(wiphy, bss); 3381 3382 return 0; 3383 } 3384 3385 static struct brcmf_bss_info_le * 3386 next_bss_le(struct brcmf_scan_results *list, struct brcmf_bss_info_le *bss) 3387 { 3388 if (bss == NULL) 3389 return list->bss_info_le; 3390 return (struct brcmf_bss_info_le *)((unsigned long)bss + 3391 le32_to_cpu(bss->length)); 3392 } 3393 3394 static s32 brcmf_inform_bss(struct brcmf_cfg80211_info *cfg) 3395 { 3396 struct brcmf_pub *drvr = cfg->pub; 3397 struct brcmf_scan_results *bss_list; 3398 struct brcmf_bss_info_le *bi = NULL; /* must be initialized */ 3399 s32 err = 0; 3400 int i; 3401 3402 bss_list = (struct brcmf_scan_results *)cfg->escan_info.escan_buf; 3403 if (bss_list->count != 0 && 3404 bss_list->version != BRCMF_BSS_INFO_VERSION) { 3405 bphy_err(drvr, "Version %d != WL_BSS_INFO_VERSION\n", 3406 bss_list->version); 3407 return -EOPNOTSUPP; 3408 } 3409 brcmf_dbg(SCAN, "scanned AP count (%d)\n", bss_list->count); 3410 for (i = 0; i < bss_list->count; i++) { 3411 bi = next_bss_le(bss_list, bi); 3412 err = brcmf_inform_single_bss(cfg, bi); 3413 if (err) 3414 break; 3415 } 3416 return err; 3417 } 3418 3419 static s32 brcmf_inform_ibss(struct brcmf_cfg80211_info *cfg, 3420 struct net_device *ndev, const u8 *bssid) 3421 { 3422 struct wiphy *wiphy = cfg_to_wiphy(cfg); 3423 struct brcmf_pub *drvr = cfg->pub; 3424 struct ieee80211_channel *notify_channel; 3425 struct brcmf_bss_info_le *bi = NULL; 3426 struct ieee80211_supported_band *band; 3427 struct cfg80211_bss *bss; 3428 struct brcmu_chan ch; 3429 u8 *buf = NULL; 3430 s32 err = 0; 3431 u32 freq; 3432 u16 notify_capability; 3433 u16 notify_interval; 3434 u8 *notify_ie; 3435 size_t notify_ielen; 3436 s32 notify_signal; 3437 3438 brcmf_dbg(TRACE, "Enter\n"); 3439 3440 buf = kzalloc(WL_BSS_INFO_MAX, GFP_KERNEL); 3441 if (buf == NULL) { 3442 err = -ENOMEM; 3443 goto CleanUp; 3444 } 3445 3446 *(__le32 *)buf = cpu_to_le32(WL_BSS_INFO_MAX); 3447 3448 err = brcmf_fil_cmd_data_get(netdev_priv(ndev), BRCMF_C_GET_BSS_INFO, 3449 buf, WL_BSS_INFO_MAX); 3450 if (err) { 3451 bphy_err(drvr, "WLC_GET_BSS_INFO failed: %d\n", err); 3452 goto CleanUp; 3453 } 3454 3455 bi = (struct brcmf_bss_info_le *)(buf + 4); 3456 3457 ch.chspec = le16_to_cpu(bi->chanspec); 3458 cfg->d11inf.decchspec(&ch); 3459 3460 if (ch.band == BRCMU_CHAN_BAND_2G) 3461 band = wiphy->bands[NL80211_BAND_2GHZ]; 3462 else 3463 band = wiphy->bands[NL80211_BAND_5GHZ]; 3464 3465 freq = ieee80211_channel_to_frequency(ch.control_ch_num, band->band); 3466 cfg->channel = freq; 3467 notify_channel = ieee80211_get_channel(wiphy, freq); 3468 3469 notify_capability = le16_to_cpu(bi->capability); 3470 notify_interval = le16_to_cpu(bi->beacon_period); 3471 notify_ie = (u8 *)bi + le16_to_cpu(bi->ie_offset); 3472 notify_ielen = le32_to_cpu(bi->ie_length); 3473 notify_signal = (s16)le16_to_cpu(bi->RSSI) * 100; 3474 3475 brcmf_dbg(CONN, "channel: %d(%d)\n", ch.control_ch_num, freq); 3476 brcmf_dbg(CONN, "capability: %X\n", notify_capability); 3477 brcmf_dbg(CONN, "beacon interval: %d\n", notify_interval); 3478 brcmf_dbg(CONN, "signal: %d\n", notify_signal); 3479 3480 bss = cfg80211_inform_bss(wiphy, notify_channel, 3481 CFG80211_BSS_FTYPE_UNKNOWN, bssid, 0, 3482 notify_capability, notify_interval, 3483 notify_ie, notify_ielen, notify_signal, 3484 GFP_KERNEL); 3485 3486 if (!bss) { 3487 err = -ENOMEM; 3488 goto CleanUp; 3489 } 3490 3491 cfg80211_put_bss(wiphy, bss); 3492 3493 CleanUp: 3494 3495 kfree(buf); 3496 3497 brcmf_dbg(TRACE, "Exit\n"); 3498 3499 return err; 3500 } 3501 3502 static s32 brcmf_update_bss_info(struct brcmf_cfg80211_info *cfg, 3503 struct brcmf_if *ifp) 3504 { 3505 struct brcmf_pub *drvr = cfg->pub; 3506 struct brcmf_bss_info_le *bi = NULL; 3507 s32 err = 0; 3508 3509 brcmf_dbg(TRACE, "Enter\n"); 3510 if (brcmf_is_ibssmode(ifp->vif)) 3511 return err; 3512 3513 *(__le32 *)cfg->extra_buf = cpu_to_le32(WL_EXTRA_BUF_MAX); 3514 err = brcmf_fil_cmd_data_get(ifp, BRCMF_C_GET_BSS_INFO, 3515 cfg->extra_buf, WL_EXTRA_BUF_MAX); 3516 if (err) { 3517 bphy_err(drvr, "Could not get bss info %d\n", err); 3518 goto update_bss_info_out; 3519 } 3520 bi = (struct brcmf_bss_info_le *)(cfg->extra_buf + 4); 3521 err = brcmf_inform_single_bss(cfg, bi); 3522 3523 update_bss_info_out: 3524 brcmf_dbg(TRACE, "Exit"); 3525 return err; 3526 } 3527 3528 void brcmf_abort_scanning(struct brcmf_cfg80211_info *cfg) 3529 { 3530 struct escan_info *escan = &cfg->escan_info; 3531 3532 set_bit(BRCMF_SCAN_STATUS_ABORT, &cfg->scan_status); 3533 if (cfg->int_escan_map || cfg->scan_request) { 3534 escan->escan_state = WL_ESCAN_STATE_IDLE; 3535 brcmf_notify_escan_complete(cfg, escan->ifp, true, true); 3536 } 3537 clear_bit(BRCMF_SCAN_STATUS_BUSY, &cfg->scan_status); 3538 clear_bit(BRCMF_SCAN_STATUS_ABORT, &cfg->scan_status); 3539 } 3540 3541 static void brcmf_cfg80211_escan_timeout_worker(struct work_struct *work) 3542 { 3543 struct brcmf_cfg80211_info *cfg = 3544 container_of(work, struct brcmf_cfg80211_info, 3545 escan_timeout_work); 3546 3547 brcmf_inform_bss(cfg); 3548 brcmf_notify_escan_complete(cfg, cfg->escan_info.ifp, true, true); 3549 } 3550 3551 static void brcmf_escan_timeout(struct timer_list *t) 3552 { 3553 struct brcmf_cfg80211_info *cfg = 3554 from_timer(cfg, t, escan_timeout); 3555 struct brcmf_pub *drvr = cfg->pub; 3556 3557 if (cfg->int_escan_map || cfg->scan_request) { 3558 bphy_err(drvr, "timer expired\n"); 3559 schedule_work(&cfg->escan_timeout_work); 3560 } 3561 } 3562 3563 static s32 3564 brcmf_compare_update_same_bss(struct brcmf_cfg80211_info *cfg, 3565 struct brcmf_bss_info_le *bss, 3566 struct brcmf_bss_info_le *bss_info_le) 3567 { 3568 struct brcmu_chan ch_bss, ch_bss_info_le; 3569 3570 ch_bss.chspec = le16_to_cpu(bss->chanspec); 3571 cfg->d11inf.decchspec(&ch_bss); 3572 ch_bss_info_le.chspec = le16_to_cpu(bss_info_le->chanspec); 3573 cfg->d11inf.decchspec(&ch_bss_info_le); 3574 3575 if (!memcmp(&bss_info_le->BSSID, &bss->BSSID, ETH_ALEN) && 3576 ch_bss.band == ch_bss_info_le.band && 3577 bss_info_le->SSID_len == bss->SSID_len && 3578 !memcmp(bss_info_le->SSID, bss->SSID, bss_info_le->SSID_len)) { 3579 if ((bss->flags & BRCMF_BSS_RSSI_ON_CHANNEL) == 3580 (bss_info_le->flags & BRCMF_BSS_RSSI_ON_CHANNEL)) { 3581 s16 bss_rssi = le16_to_cpu(bss->RSSI); 3582 s16 bss_info_rssi = le16_to_cpu(bss_info_le->RSSI); 3583 3584 /* preserve max RSSI if the measurements are 3585 * both on-channel or both off-channel 3586 */ 3587 if (bss_info_rssi > bss_rssi) 3588 bss->RSSI = bss_info_le->RSSI; 3589 } else if ((bss->flags & BRCMF_BSS_RSSI_ON_CHANNEL) && 3590 (bss_info_le->flags & BRCMF_BSS_RSSI_ON_CHANNEL) == 0) { 3591 /* preserve the on-channel rssi measurement 3592 * if the new measurement is off channel 3593 */ 3594 bss->RSSI = bss_info_le->RSSI; 3595 bss->flags |= BRCMF_BSS_RSSI_ON_CHANNEL; 3596 } 3597 return 1; 3598 } 3599 return 0; 3600 } 3601 3602 static s32 3603 brcmf_cfg80211_escan_handler(struct brcmf_if *ifp, 3604 const struct brcmf_event_msg *e, void *data) 3605 { 3606 struct brcmf_pub *drvr = ifp->drvr; 3607 struct brcmf_cfg80211_info *cfg = drvr->config; 3608 s32 status; 3609 struct brcmf_escan_result_le *escan_result_le; 3610 u32 escan_buflen; 3611 struct brcmf_bss_info_le *bss_info_le; 3612 struct brcmf_bss_info_le *bss = NULL; 3613 u32 bi_length; 3614 struct brcmf_scan_results *list; 3615 u32 i; 3616 bool aborted; 3617 3618 status = e->status; 3619 3620 if (status == BRCMF_E_STATUS_ABORT) 3621 goto exit; 3622 3623 if (!test_bit(BRCMF_SCAN_STATUS_BUSY, &cfg->scan_status)) { 3624 bphy_err(drvr, "scan not ready, bsscfgidx=%d\n", 3625 ifp->bsscfgidx); 3626 return -EPERM; 3627 } 3628 3629 if (status == BRCMF_E_STATUS_PARTIAL) { 3630 brcmf_dbg(SCAN, "ESCAN Partial result\n"); 3631 if (e->datalen < sizeof(*escan_result_le)) { 3632 bphy_err(drvr, "invalid event data length\n"); 3633 goto exit; 3634 } 3635 escan_result_le = (struct brcmf_escan_result_le *) data; 3636 if (!escan_result_le) { 3637 bphy_err(drvr, "Invalid escan result (NULL pointer)\n"); 3638 goto exit; 3639 } 3640 escan_buflen = le32_to_cpu(escan_result_le->buflen); 3641 if (escan_buflen > BRCMF_ESCAN_BUF_SIZE || 3642 escan_buflen > e->datalen || 3643 escan_buflen < sizeof(*escan_result_le)) { 3644 bphy_err(drvr, "Invalid escan buffer length: %d\n", 3645 escan_buflen); 3646 goto exit; 3647 } 3648 if (le16_to_cpu(escan_result_le->bss_count) != 1) { 3649 bphy_err(drvr, "Invalid bss_count %d: ignoring\n", 3650 escan_result_le->bss_count); 3651 goto exit; 3652 } 3653 bss_info_le = &escan_result_le->bss_info_le; 3654 3655 if (brcmf_p2p_scan_finding_common_channel(cfg, bss_info_le)) 3656 goto exit; 3657 3658 if (!cfg->int_escan_map && !cfg->scan_request) { 3659 brcmf_dbg(SCAN, "result without cfg80211 request\n"); 3660 goto exit; 3661 } 3662 3663 bi_length = le32_to_cpu(bss_info_le->length); 3664 if (bi_length != escan_buflen - WL_ESCAN_RESULTS_FIXED_SIZE) { 3665 bphy_err(drvr, "Ignoring invalid bss_info length: %d\n", 3666 bi_length); 3667 goto exit; 3668 } 3669 3670 if (!(cfg_to_wiphy(cfg)->interface_modes & 3671 BIT(NL80211_IFTYPE_ADHOC))) { 3672 if (le16_to_cpu(bss_info_le->capability) & 3673 WLAN_CAPABILITY_IBSS) { 3674 bphy_err(drvr, "Ignoring IBSS result\n"); 3675 goto exit; 3676 } 3677 } 3678 3679 list = (struct brcmf_scan_results *) 3680 cfg->escan_info.escan_buf; 3681 if (bi_length > BRCMF_ESCAN_BUF_SIZE - list->buflen) { 3682 bphy_err(drvr, "Buffer is too small: ignoring\n"); 3683 goto exit; 3684 } 3685 3686 for (i = 0; i < list->count; i++) { 3687 bss = bss ? (struct brcmf_bss_info_le *) 3688 ((unsigned char *)bss + 3689 le32_to_cpu(bss->length)) : list->bss_info_le; 3690 if (brcmf_compare_update_same_bss(cfg, bss, 3691 bss_info_le)) 3692 goto exit; 3693 } 3694 memcpy(&cfg->escan_info.escan_buf[list->buflen], bss_info_le, 3695 bi_length); 3696 list->version = le32_to_cpu(bss_info_le->version); 3697 list->buflen += bi_length; 3698 list->count++; 3699 } else { 3700 cfg->escan_info.escan_state = WL_ESCAN_STATE_IDLE; 3701 if (brcmf_p2p_scan_finding_common_channel(cfg, NULL)) 3702 goto exit; 3703 if (cfg->int_escan_map || cfg->scan_request) { 3704 brcmf_inform_bss(cfg); 3705 aborted = status != BRCMF_E_STATUS_SUCCESS; 3706 brcmf_notify_escan_complete(cfg, ifp, aborted, false); 3707 } else 3708 brcmf_dbg(SCAN, "Ignored scan complete result 0x%x\n", 3709 status); 3710 } 3711 exit: 3712 return 0; 3713 } 3714 3715 static void brcmf_init_escan(struct brcmf_cfg80211_info *cfg) 3716 { 3717 brcmf_fweh_register(cfg->pub, BRCMF_E_ESCAN_RESULT, 3718 brcmf_cfg80211_escan_handler); 3719 cfg->escan_info.escan_state = WL_ESCAN_STATE_IDLE; 3720 /* Init scan_timeout timer */ 3721 timer_setup(&cfg->escan_timeout, brcmf_escan_timeout, 0); 3722 INIT_WORK(&cfg->escan_timeout_work, 3723 brcmf_cfg80211_escan_timeout_worker); 3724 } 3725 3726 static struct cfg80211_scan_request * 3727 brcmf_alloc_internal_escan_request(struct wiphy *wiphy, u32 n_netinfo) { 3728 struct cfg80211_scan_request *req; 3729 size_t req_size; 3730 3731 req_size = sizeof(*req) + 3732 n_netinfo * sizeof(req->channels[0]) + 3733 n_netinfo * sizeof(*req->ssids); 3734 3735 req = kzalloc(req_size, GFP_KERNEL); 3736 if (req) { 3737 req->wiphy = wiphy; 3738 req->ssids = (void *)(&req->channels[0]) + 3739 n_netinfo * sizeof(req->channels[0]); 3740 } 3741 return req; 3742 } 3743 3744 static int brcmf_internal_escan_add_info(struct cfg80211_scan_request *req, 3745 u8 *ssid, u8 ssid_len, u8 channel) 3746 { 3747 struct ieee80211_channel *chan; 3748 enum nl80211_band band; 3749 int freq, i; 3750 3751 if (channel <= CH_MAX_2G_CHANNEL) 3752 band = NL80211_BAND_2GHZ; 3753 else 3754 band = NL80211_BAND_5GHZ; 3755 3756 freq = ieee80211_channel_to_frequency(channel, band); 3757 if (!freq) 3758 return -EINVAL; 3759 3760 chan = ieee80211_get_channel(req->wiphy, freq); 3761 if (!chan) 3762 return -EINVAL; 3763 3764 for (i = 0; i < req->n_channels; i++) { 3765 if (req->channels[i] == chan) 3766 break; 3767 } 3768 if (i == req->n_channels) { 3769 req->n_channels++; 3770 req->channels[i] = chan; 3771 } 3772 3773 for (i = 0; i < req->n_ssids; i++) { 3774 if (req->ssids[i].ssid_len == ssid_len && 3775 !memcmp(req->ssids[i].ssid, ssid, ssid_len)) 3776 break; 3777 } 3778 if (i == req->n_ssids) { 3779 memcpy(req->ssids[req->n_ssids].ssid, ssid, ssid_len); 3780 req->ssids[req->n_ssids++].ssid_len = ssid_len; 3781 } 3782 return 0; 3783 } 3784 3785 static int brcmf_start_internal_escan(struct brcmf_if *ifp, u32 fwmap, 3786 struct cfg80211_scan_request *request) 3787 { 3788 struct brcmf_cfg80211_info *cfg = ifp->drvr->config; 3789 int err; 3790 3791 if (test_bit(BRCMF_SCAN_STATUS_BUSY, &cfg->scan_status)) { 3792 if (cfg->int_escan_map) 3793 brcmf_dbg(SCAN, "aborting internal scan: map=%u\n", 3794 cfg->int_escan_map); 3795 /* Abort any on-going scan */ 3796 brcmf_abort_scanning(cfg); 3797 } 3798 3799 brcmf_dbg(SCAN, "start internal scan: map=%u\n", fwmap); 3800 set_bit(BRCMF_SCAN_STATUS_BUSY, &cfg->scan_status); 3801 cfg->escan_info.run = brcmf_run_escan; 3802 err = brcmf_do_escan(ifp, request); 3803 if (err) { 3804 clear_bit(BRCMF_SCAN_STATUS_BUSY, &cfg->scan_status); 3805 return err; 3806 } 3807 cfg->int_escan_map = fwmap; 3808 return 0; 3809 } 3810 3811 static struct brcmf_pno_net_info_le * 3812 brcmf_get_netinfo_array(struct brcmf_pno_scanresults_le *pfn_v1) 3813 { 3814 struct brcmf_pno_scanresults_v2_le *pfn_v2; 3815 struct brcmf_pno_net_info_le *netinfo; 3816 3817 switch (pfn_v1->version) { 3818 default: 3819 WARN_ON(1); 3820 fallthrough; 3821 case cpu_to_le32(1): 3822 netinfo = (struct brcmf_pno_net_info_le *)(pfn_v1 + 1); 3823 break; 3824 case cpu_to_le32(2): 3825 pfn_v2 = (struct brcmf_pno_scanresults_v2_le *)pfn_v1; 3826 netinfo = (struct brcmf_pno_net_info_le *)(pfn_v2 + 1); 3827 break; 3828 } 3829 3830 return netinfo; 3831 } 3832 3833 /* PFN result doesn't have all the info which are required by the supplicant 3834 * (For e.g IEs) Do a target Escan so that sched scan results are reported 3835 * via wl_inform_single_bss in the required format. Escan does require the 3836 * scan request in the form of cfg80211_scan_request. For timebeing, create 3837 * cfg80211_scan_request one out of the received PNO event. 3838 */ 3839 static s32 3840 brcmf_notify_sched_scan_results(struct brcmf_if *ifp, 3841 const struct brcmf_event_msg *e, void *data) 3842 { 3843 struct brcmf_pub *drvr = ifp->drvr; 3844 struct brcmf_cfg80211_info *cfg = drvr->config; 3845 struct brcmf_pno_net_info_le *netinfo, *netinfo_start; 3846 struct cfg80211_scan_request *request = NULL; 3847 struct wiphy *wiphy = cfg_to_wiphy(cfg); 3848 int i, err = 0; 3849 struct brcmf_pno_scanresults_le *pfn_result; 3850 u32 bucket_map; 3851 u32 result_count; 3852 u32 status; 3853 u32 datalen; 3854 3855 brcmf_dbg(SCAN, "Enter\n"); 3856 3857 if (e->datalen < (sizeof(*pfn_result) + sizeof(*netinfo))) { 3858 brcmf_dbg(SCAN, "Event data to small. Ignore\n"); 3859 return 0; 3860 } 3861 3862 if (e->event_code == BRCMF_E_PFN_NET_LOST) { 3863 brcmf_dbg(SCAN, "PFN NET LOST event. Do Nothing\n"); 3864 return 0; 3865 } 3866 3867 pfn_result = (struct brcmf_pno_scanresults_le *)data; 3868 result_count = le32_to_cpu(pfn_result->count); 3869 status = le32_to_cpu(pfn_result->status); 3870 3871 /* PFN event is limited to fit 512 bytes so we may get 3872 * multiple NET_FOUND events. For now place a warning here. 3873 */ 3874 WARN_ON(status != BRCMF_PNO_SCAN_COMPLETE); 3875 brcmf_dbg(SCAN, "PFN NET FOUND event. count: %d\n", result_count); 3876 if (!result_count) { 3877 bphy_err(drvr, "FALSE PNO Event. (pfn_count == 0)\n"); 3878 goto out_err; 3879 } 3880 3881 netinfo_start = brcmf_get_netinfo_array(pfn_result); 3882 datalen = e->datalen - ((void *)netinfo_start - (void *)pfn_result); 3883 if (datalen < result_count * sizeof(*netinfo)) { 3884 bphy_err(drvr, "insufficient event data\n"); 3885 goto out_err; 3886 } 3887 3888 request = brcmf_alloc_internal_escan_request(wiphy, 3889 result_count); 3890 if (!request) { 3891 err = -ENOMEM; 3892 goto out_err; 3893 } 3894 3895 bucket_map = 0; 3896 for (i = 0; i < result_count; i++) { 3897 netinfo = &netinfo_start[i]; 3898 3899 if (netinfo->SSID_len > IEEE80211_MAX_SSID_LEN) 3900 netinfo->SSID_len = IEEE80211_MAX_SSID_LEN; 3901 brcmf_dbg(SCAN, "SSID:%.32s Channel:%d\n", 3902 netinfo->SSID, netinfo->channel); 3903 bucket_map |= brcmf_pno_get_bucket_map(cfg->pno, netinfo); 3904 err = brcmf_internal_escan_add_info(request, 3905 netinfo->SSID, 3906 netinfo->SSID_len, 3907 netinfo->channel); 3908 if (err) 3909 goto out_err; 3910 } 3911 3912 if (!bucket_map) 3913 goto free_req; 3914 3915 err = brcmf_start_internal_escan(ifp, bucket_map, request); 3916 if (!err) 3917 goto free_req; 3918 3919 out_err: 3920 cfg80211_sched_scan_stopped(wiphy, 0); 3921 free_req: 3922 kfree(request); 3923 return err; 3924 } 3925 3926 static int 3927 brcmf_cfg80211_sched_scan_start(struct wiphy *wiphy, 3928 struct net_device *ndev, 3929 struct cfg80211_sched_scan_request *req) 3930 { 3931 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy); 3932 struct brcmf_if *ifp = netdev_priv(ndev); 3933 struct brcmf_pub *drvr = cfg->pub; 3934 3935 brcmf_dbg(SCAN, "Enter: n_match_sets=%d n_ssids=%d\n", 3936 req->n_match_sets, req->n_ssids); 3937 3938 if (test_bit(BRCMF_SCAN_STATUS_SUPPRESS, &cfg->scan_status)) { 3939 bphy_err(drvr, "Scanning suppressed: status=%lu\n", 3940 cfg->scan_status); 3941 return -EAGAIN; 3942 } 3943 3944 if (req->n_match_sets <= 0) { 3945 brcmf_dbg(SCAN, "invalid number of matchsets specified: %d\n", 3946 req->n_match_sets); 3947 return -EINVAL; 3948 } 3949 3950 return brcmf_pno_start_sched_scan(ifp, req); 3951 } 3952 3953 static int brcmf_cfg80211_sched_scan_stop(struct wiphy *wiphy, 3954 struct net_device *ndev, u64 reqid) 3955 { 3956 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy); 3957 struct brcmf_if *ifp = netdev_priv(ndev); 3958 3959 brcmf_dbg(SCAN, "enter\n"); 3960 brcmf_pno_stop_sched_scan(ifp, reqid); 3961 if (cfg->int_escan_map) 3962 brcmf_notify_escan_complete(cfg, ifp, true, true); 3963 return 0; 3964 } 3965 3966 static __always_inline void brcmf_delay(u32 ms) 3967 { 3968 if (ms < 1000 / HZ) { 3969 cond_resched(); 3970 mdelay(ms); 3971 } else { 3972 msleep(ms); 3973 } 3974 } 3975 3976 static s32 brcmf_config_wowl_pattern(struct brcmf_if *ifp, u8 cmd[4], 3977 u8 *pattern, u32 patternsize, u8 *mask, 3978 u32 packet_offset) 3979 { 3980 struct brcmf_fil_wowl_pattern_le *filter; 3981 u32 masksize; 3982 u32 patternoffset; 3983 u8 *buf; 3984 u32 bufsize; 3985 s32 ret; 3986 3987 masksize = (patternsize + 7) / 8; 3988 patternoffset = sizeof(*filter) - sizeof(filter->cmd) + masksize; 3989 3990 bufsize = sizeof(*filter) + patternsize + masksize; 3991 buf = kzalloc(bufsize, GFP_KERNEL); 3992 if (!buf) 3993 return -ENOMEM; 3994 filter = (struct brcmf_fil_wowl_pattern_le *)buf; 3995 3996 memcpy(filter->cmd, cmd, 4); 3997 filter->masksize = cpu_to_le32(masksize); 3998 filter->offset = cpu_to_le32(packet_offset); 3999 filter->patternoffset = cpu_to_le32(patternoffset); 4000 filter->patternsize = cpu_to_le32(patternsize); 4001 filter->type = cpu_to_le32(BRCMF_WOWL_PATTERN_TYPE_BITMAP); 4002 4003 if ((mask) && (masksize)) 4004 memcpy(buf + sizeof(*filter), mask, masksize); 4005 if ((pattern) && (patternsize)) 4006 memcpy(buf + sizeof(*filter) + masksize, pattern, patternsize); 4007 4008 ret = brcmf_fil_iovar_data_set(ifp, "wowl_pattern", buf, bufsize); 4009 4010 kfree(buf); 4011 return ret; 4012 } 4013 4014 static s32 4015 brcmf_wowl_nd_results(struct brcmf_if *ifp, const struct brcmf_event_msg *e, 4016 void *data) 4017 { 4018 struct brcmf_pub *drvr = ifp->drvr; 4019 struct brcmf_cfg80211_info *cfg = drvr->config; 4020 struct brcmf_pno_scanresults_le *pfn_result; 4021 struct brcmf_pno_net_info_le *netinfo; 4022 4023 brcmf_dbg(SCAN, "Enter\n"); 4024 4025 if (e->datalen < (sizeof(*pfn_result) + sizeof(*netinfo))) { 4026 brcmf_dbg(SCAN, "Event data to small. Ignore\n"); 4027 return 0; 4028 } 4029 4030 pfn_result = (struct brcmf_pno_scanresults_le *)data; 4031 4032 if (e->event_code == BRCMF_E_PFN_NET_LOST) { 4033 brcmf_dbg(SCAN, "PFN NET LOST event. Ignore\n"); 4034 return 0; 4035 } 4036 4037 if (le32_to_cpu(pfn_result->count) < 1) { 4038 bphy_err(drvr, "Invalid result count, expected 1 (%d)\n", 4039 le32_to_cpu(pfn_result->count)); 4040 return -EINVAL; 4041 } 4042 4043 netinfo = brcmf_get_netinfo_array(pfn_result); 4044 if (netinfo->SSID_len > IEEE80211_MAX_SSID_LEN) 4045 netinfo->SSID_len = IEEE80211_MAX_SSID_LEN; 4046 memcpy(cfg->wowl.nd->ssid.ssid, netinfo->SSID, netinfo->SSID_len); 4047 cfg->wowl.nd->ssid.ssid_len = netinfo->SSID_len; 4048 cfg->wowl.nd->n_channels = 1; 4049 cfg->wowl.nd->channels[0] = 4050 ieee80211_channel_to_frequency(netinfo->channel, 4051 netinfo->channel <= CH_MAX_2G_CHANNEL ? 4052 NL80211_BAND_2GHZ : NL80211_BAND_5GHZ); 4053 cfg->wowl.nd_info->n_matches = 1; 4054 cfg->wowl.nd_info->matches[0] = cfg->wowl.nd; 4055 4056 /* Inform (the resume task) that the net detect information was recvd */ 4057 cfg->wowl.nd_data_completed = true; 4058 wake_up(&cfg->wowl.nd_data_wait); 4059 4060 return 0; 4061 } 4062 4063 #ifdef CONFIG_PM 4064 4065 static void brcmf_report_wowl_wakeind(struct wiphy *wiphy, struct brcmf_if *ifp) 4066 { 4067 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy); 4068 struct brcmf_pub *drvr = cfg->pub; 4069 struct brcmf_wowl_wakeind_le wake_ind_le; 4070 struct cfg80211_wowlan_wakeup wakeup_data; 4071 struct cfg80211_wowlan_wakeup *wakeup; 4072 u32 wakeind; 4073 s32 err; 4074 long time_left; 4075 4076 err = brcmf_fil_iovar_data_get(ifp, "wowl_wakeind", &wake_ind_le, 4077 sizeof(wake_ind_le)); 4078 if (err) { 4079 bphy_err(drvr, "Get wowl_wakeind failed, err = %d\n", err); 4080 return; 4081 } 4082 4083 wakeind = le32_to_cpu(wake_ind_le.ucode_wakeind); 4084 if (wakeind & (BRCMF_WOWL_MAGIC | BRCMF_WOWL_DIS | BRCMF_WOWL_BCN | 4085 BRCMF_WOWL_RETR | BRCMF_WOWL_NET | 4086 BRCMF_WOWL_PFN_FOUND)) { 4087 wakeup = &wakeup_data; 4088 memset(&wakeup_data, 0, sizeof(wakeup_data)); 4089 wakeup_data.pattern_idx = -1; 4090 4091 if (wakeind & BRCMF_WOWL_MAGIC) { 4092 brcmf_dbg(INFO, "WOWL Wake indicator: BRCMF_WOWL_MAGIC\n"); 4093 wakeup_data.magic_pkt = true; 4094 } 4095 if (wakeind & BRCMF_WOWL_DIS) { 4096 brcmf_dbg(INFO, "WOWL Wake indicator: BRCMF_WOWL_DIS\n"); 4097 wakeup_data.disconnect = true; 4098 } 4099 if (wakeind & BRCMF_WOWL_BCN) { 4100 brcmf_dbg(INFO, "WOWL Wake indicator: BRCMF_WOWL_BCN\n"); 4101 wakeup_data.disconnect = true; 4102 } 4103 if (wakeind & BRCMF_WOWL_RETR) { 4104 brcmf_dbg(INFO, "WOWL Wake indicator: BRCMF_WOWL_RETR\n"); 4105 wakeup_data.disconnect = true; 4106 } 4107 if (wakeind & BRCMF_WOWL_NET) { 4108 brcmf_dbg(INFO, "WOWL Wake indicator: BRCMF_WOWL_NET\n"); 4109 /* For now always map to pattern 0, no API to get 4110 * correct information available at the moment. 4111 */ 4112 wakeup_data.pattern_idx = 0; 4113 } 4114 if (wakeind & BRCMF_WOWL_PFN_FOUND) { 4115 brcmf_dbg(INFO, "WOWL Wake indicator: BRCMF_WOWL_PFN_FOUND\n"); 4116 time_left = wait_event_timeout(cfg->wowl.nd_data_wait, 4117 cfg->wowl.nd_data_completed, 4118 BRCMF_ND_INFO_TIMEOUT); 4119 if (!time_left) 4120 bphy_err(drvr, "No result for wowl net detect\n"); 4121 else 4122 wakeup_data.net_detect = cfg->wowl.nd_info; 4123 } 4124 if (wakeind & BRCMF_WOWL_GTK_FAILURE) { 4125 brcmf_dbg(INFO, "WOWL Wake indicator: BRCMF_WOWL_GTK_FAILURE\n"); 4126 wakeup_data.gtk_rekey_failure = true; 4127 } 4128 } else { 4129 wakeup = NULL; 4130 } 4131 cfg80211_report_wowlan_wakeup(&ifp->vif->wdev, wakeup, GFP_KERNEL); 4132 } 4133 4134 #else 4135 4136 static void brcmf_report_wowl_wakeind(struct wiphy *wiphy, struct brcmf_if *ifp) 4137 { 4138 } 4139 4140 #endif /* CONFIG_PM */ 4141 4142 static s32 brcmf_cfg80211_resume(struct wiphy *wiphy) 4143 { 4144 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy); 4145 struct net_device *ndev = cfg_to_ndev(cfg); 4146 struct brcmf_if *ifp = netdev_priv(ndev); 4147 4148 brcmf_dbg(TRACE, "Enter\n"); 4149 4150 if (cfg->wowl.active) { 4151 brcmf_report_wowl_wakeind(wiphy, ifp); 4152 brcmf_fil_iovar_int_set(ifp, "wowl_clear", 0); 4153 brcmf_config_wowl_pattern(ifp, "clr", NULL, 0, NULL, 0); 4154 if (!brcmf_feat_is_enabled(ifp, BRCMF_FEAT_WOWL_ARP_ND)) 4155 brcmf_configure_arp_nd_offload(ifp, true); 4156 brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_PM, 4157 cfg->wowl.pre_pmmode); 4158 cfg->wowl.active = false; 4159 if (cfg->wowl.nd_enabled) { 4160 brcmf_cfg80211_sched_scan_stop(cfg->wiphy, ifp->ndev, 0); 4161 brcmf_fweh_unregister(cfg->pub, BRCMF_E_PFN_NET_FOUND); 4162 brcmf_fweh_register(cfg->pub, BRCMF_E_PFN_NET_FOUND, 4163 brcmf_notify_sched_scan_results); 4164 cfg->wowl.nd_enabled = false; 4165 } 4166 } 4167 return 0; 4168 } 4169 4170 static void brcmf_configure_wowl(struct brcmf_cfg80211_info *cfg, 4171 struct brcmf_if *ifp, 4172 struct cfg80211_wowlan *wowl) 4173 { 4174 u32 wowl_config; 4175 struct brcmf_wowl_wakeind_le wowl_wakeind; 4176 u32 i; 4177 4178 brcmf_dbg(TRACE, "Suspend, wowl config.\n"); 4179 4180 if (!brcmf_feat_is_enabled(ifp, BRCMF_FEAT_WOWL_ARP_ND)) 4181 brcmf_configure_arp_nd_offload(ifp, false); 4182 brcmf_fil_cmd_int_get(ifp, BRCMF_C_GET_PM, &cfg->wowl.pre_pmmode); 4183 brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_PM, PM_MAX); 4184 4185 wowl_config = 0; 4186 if (wowl->disconnect) 4187 wowl_config = BRCMF_WOWL_DIS | BRCMF_WOWL_BCN | BRCMF_WOWL_RETR; 4188 if (wowl->magic_pkt) 4189 wowl_config |= BRCMF_WOWL_MAGIC; 4190 if ((wowl->patterns) && (wowl->n_patterns)) { 4191 wowl_config |= BRCMF_WOWL_NET; 4192 for (i = 0; i < wowl->n_patterns; i++) { 4193 brcmf_config_wowl_pattern(ifp, "add", 4194 (u8 *)wowl->patterns[i].pattern, 4195 wowl->patterns[i].pattern_len, 4196 (u8 *)wowl->patterns[i].mask, 4197 wowl->patterns[i].pkt_offset); 4198 } 4199 } 4200 if (wowl->nd_config) { 4201 brcmf_cfg80211_sched_scan_start(cfg->wiphy, ifp->ndev, 4202 wowl->nd_config); 4203 wowl_config |= BRCMF_WOWL_PFN_FOUND; 4204 4205 cfg->wowl.nd_data_completed = false; 4206 cfg->wowl.nd_enabled = true; 4207 /* Now reroute the event for PFN to the wowl function. */ 4208 brcmf_fweh_unregister(cfg->pub, BRCMF_E_PFN_NET_FOUND); 4209 brcmf_fweh_register(cfg->pub, BRCMF_E_PFN_NET_FOUND, 4210 brcmf_wowl_nd_results); 4211 } 4212 if (wowl->gtk_rekey_failure) 4213 wowl_config |= BRCMF_WOWL_GTK_FAILURE; 4214 if (!test_bit(BRCMF_VIF_STATUS_CONNECTED, &ifp->vif->sme_state)) 4215 wowl_config |= BRCMF_WOWL_UNASSOC; 4216 4217 memcpy(&wowl_wakeind, "clear", 6); 4218 brcmf_fil_iovar_data_set(ifp, "wowl_wakeind", &wowl_wakeind, 4219 sizeof(wowl_wakeind)); 4220 brcmf_fil_iovar_int_set(ifp, "wowl", wowl_config); 4221 brcmf_fil_iovar_int_set(ifp, "wowl_activate", 1); 4222 brcmf_bus_wowl_config(cfg->pub->bus_if, true); 4223 cfg->wowl.active = true; 4224 } 4225 4226 static int brcmf_keepalive_start(struct brcmf_if *ifp, unsigned int interval) 4227 { 4228 struct brcmf_mkeep_alive_pkt_le kalive = {0}; 4229 int ret = 0; 4230 4231 /* Configure Null function/data keepalive */ 4232 kalive.version = cpu_to_le16(1); 4233 kalive.period_msec = cpu_to_le32(interval * MSEC_PER_SEC); 4234 kalive.len_bytes = cpu_to_le16(0); 4235 kalive.keep_alive_id = 0; 4236 4237 ret = brcmf_fil_iovar_data_set(ifp, "mkeep_alive", &kalive, sizeof(kalive)); 4238 if (ret) 4239 brcmf_err("keep-alive packet config failed, ret=%d\n", ret); 4240 4241 return ret; 4242 } 4243 4244 static s32 brcmf_cfg80211_suspend(struct wiphy *wiphy, 4245 struct cfg80211_wowlan *wowl) 4246 { 4247 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy); 4248 struct net_device *ndev = cfg_to_ndev(cfg); 4249 struct brcmf_if *ifp = netdev_priv(ndev); 4250 struct brcmf_cfg80211_vif *vif; 4251 4252 brcmf_dbg(TRACE, "Enter\n"); 4253 4254 /* if the primary net_device is not READY there is nothing 4255 * we can do but pray resume goes smoothly. 4256 */ 4257 if (!check_vif_up(ifp->vif)) 4258 goto exit; 4259 4260 /* Stop scheduled scan */ 4261 if (brcmf_feat_is_enabled(ifp, BRCMF_FEAT_PNO)) 4262 brcmf_cfg80211_sched_scan_stop(wiphy, ndev, 0); 4263 4264 /* end any scanning */ 4265 if (test_bit(BRCMF_SCAN_STATUS_BUSY, &cfg->scan_status)) 4266 brcmf_abort_scanning(cfg); 4267 4268 if (wowl == NULL) { 4269 brcmf_bus_wowl_config(cfg->pub->bus_if, false); 4270 list_for_each_entry(vif, &cfg->vif_list, list) { 4271 if (!test_bit(BRCMF_VIF_STATUS_READY, &vif->sme_state)) 4272 continue; 4273 /* While going to suspend if associated with AP 4274 * disassociate from AP to save power while system is 4275 * in suspended state 4276 */ 4277 brcmf_link_down(vif, WLAN_REASON_UNSPECIFIED, true); 4278 /* Make sure WPA_Supplicant receives all the event 4279 * generated due to DISASSOC call to the fw to keep 4280 * the state fw and WPA_Supplicant state consistent 4281 */ 4282 brcmf_delay(500); 4283 } 4284 /* Configure MPC */ 4285 brcmf_set_mpc(ifp, 1); 4286 4287 } else { 4288 /* Configure WOWL paramaters */ 4289 brcmf_configure_wowl(cfg, ifp, wowl); 4290 4291 /* Prevent disassociation due to inactivity with keep-alive */ 4292 brcmf_keepalive_start(ifp, 30); 4293 } 4294 4295 exit: 4296 brcmf_dbg(TRACE, "Exit\n"); 4297 /* clear any scanning activity */ 4298 cfg->scan_status = 0; 4299 return 0; 4300 } 4301 4302 static s32 4303 brcmf_pmksa_v3_op(struct brcmf_if *ifp, struct cfg80211_pmksa *pmksa, 4304 bool alive) 4305 { 4306 struct brcmf_pmk_op_v3_le *pmk_op; 4307 int length = offsetof(struct brcmf_pmk_op_v3_le, pmk); 4308 int ret; 4309 4310 pmk_op = kzalloc(sizeof(*pmk_op), GFP_KERNEL); 4311 if (!pmk_op) 4312 return -ENOMEM; 4313 4314 pmk_op->version = cpu_to_le16(BRCMF_PMKSA_VER_3); 4315 4316 if (!pmksa) { 4317 /* Flush operation, operate on entire list */ 4318 pmk_op->count = cpu_to_le16(0); 4319 } else { 4320 /* Single PMK operation */ 4321 pmk_op->count = cpu_to_le16(1); 4322 length += sizeof(struct brcmf_pmksa_v3); 4323 if (pmksa->bssid) 4324 memcpy(pmk_op->pmk[0].bssid, pmksa->bssid, ETH_ALEN); 4325 if (pmksa->pmkid) { 4326 memcpy(pmk_op->pmk[0].pmkid, pmksa->pmkid, WLAN_PMKID_LEN); 4327 pmk_op->pmk[0].pmkid_len = WLAN_PMKID_LEN; 4328 } 4329 if (pmksa->ssid && pmksa->ssid_len) { 4330 memcpy(pmk_op->pmk[0].ssid.SSID, pmksa->ssid, pmksa->ssid_len); 4331 pmk_op->pmk[0].ssid.SSID_len = pmksa->ssid_len; 4332 } 4333 pmk_op->pmk[0].time_left = cpu_to_le32(alive ? BRCMF_PMKSA_NO_EXPIRY : 0); 4334 } 4335 4336 pmk_op->length = cpu_to_le16(length); 4337 4338 ret = brcmf_fil_iovar_data_set(ifp, "pmkid_info", pmk_op, sizeof(*pmk_op)); 4339 kfree(pmk_op); 4340 return ret; 4341 } 4342 4343 static __used s32 4344 brcmf_update_pmklist(struct brcmf_cfg80211_info *cfg, struct brcmf_if *ifp) 4345 { 4346 struct brcmf_pmk_list_le *pmk_list; 4347 int i; 4348 u32 npmk; 4349 4350 pmk_list = &cfg->pmk_list; 4351 npmk = le32_to_cpu(pmk_list->npmk); 4352 4353 brcmf_dbg(CONN, "No of elements %d\n", npmk); 4354 for (i = 0; i < npmk; i++) 4355 brcmf_dbg(CONN, "PMK[%d]: %pM\n", i, &pmk_list->pmk[i].bssid); 4356 4357 return brcmf_fil_iovar_data_set(ifp, "pmkid_info", pmk_list, 4358 sizeof(*pmk_list)); 4359 } 4360 4361 static s32 4362 brcmf_cfg80211_set_pmksa(struct wiphy *wiphy, struct net_device *ndev, 4363 struct cfg80211_pmksa *pmksa) 4364 { 4365 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy); 4366 struct brcmf_if *ifp = netdev_priv(ndev); 4367 struct brcmf_pmksa *pmk = &cfg->pmk_list.pmk[0]; 4368 struct brcmf_pub *drvr = cfg->pub; 4369 s32 err; 4370 u32 npmk, i; 4371 4372 brcmf_dbg(TRACE, "Enter\n"); 4373 if (!check_vif_up(ifp->vif)) 4374 return -EIO; 4375 4376 brcmf_dbg(CONN, "set_pmksa - PMK bssid: %pM =\n", pmksa->bssid); 4377 brcmf_dbg(CONN, "%*ph\n", WLAN_PMKID_LEN, pmksa->pmkid); 4378 4379 if (brcmf_feat_is_enabled(ifp, BRCMF_FEAT_PMKID_V3)) 4380 return brcmf_pmksa_v3_op(ifp, pmksa, true); 4381 4382 /* TODO: implement PMKID_V2 */ 4383 4384 npmk = le32_to_cpu(cfg->pmk_list.npmk); 4385 for (i = 0; i < npmk; i++) 4386 if (!memcmp(pmksa->bssid, pmk[i].bssid, ETH_ALEN)) 4387 break; 4388 if (i < BRCMF_MAXPMKID) { 4389 memcpy(pmk[i].bssid, pmksa->bssid, ETH_ALEN); 4390 memcpy(pmk[i].pmkid, pmksa->pmkid, WLAN_PMKID_LEN); 4391 if (i == npmk) { 4392 npmk++; 4393 cfg->pmk_list.npmk = cpu_to_le32(npmk); 4394 } 4395 } else { 4396 bphy_err(drvr, "Too many PMKSA entries cached %d\n", npmk); 4397 return -EINVAL; 4398 } 4399 4400 err = brcmf_update_pmklist(cfg, ifp); 4401 4402 brcmf_dbg(TRACE, "Exit\n"); 4403 return err; 4404 } 4405 4406 static s32 4407 brcmf_cfg80211_del_pmksa(struct wiphy *wiphy, struct net_device *ndev, 4408 struct cfg80211_pmksa *pmksa) 4409 { 4410 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy); 4411 struct brcmf_if *ifp = netdev_priv(ndev); 4412 struct brcmf_pmksa *pmk = &cfg->pmk_list.pmk[0]; 4413 struct brcmf_pub *drvr = cfg->pub; 4414 s32 err; 4415 u32 npmk, i; 4416 4417 brcmf_dbg(TRACE, "Enter\n"); 4418 if (!check_vif_up(ifp->vif)) 4419 return -EIO; 4420 4421 brcmf_dbg(CONN, "del_pmksa - PMK bssid = %pM\n", pmksa->bssid); 4422 4423 if (brcmf_feat_is_enabled(ifp, BRCMF_FEAT_PMKID_V3)) 4424 return brcmf_pmksa_v3_op(ifp, pmksa, false); 4425 4426 /* TODO: implement PMKID_V2 */ 4427 4428 npmk = le32_to_cpu(cfg->pmk_list.npmk); 4429 for (i = 0; i < npmk; i++) 4430 if (!memcmp(pmksa->bssid, pmk[i].bssid, ETH_ALEN)) 4431 break; 4432 4433 if ((npmk > 0) && (i < npmk)) { 4434 for (; i < (npmk - 1); i++) { 4435 memcpy(&pmk[i].bssid, &pmk[i + 1].bssid, ETH_ALEN); 4436 memcpy(&pmk[i].pmkid, &pmk[i + 1].pmkid, 4437 WLAN_PMKID_LEN); 4438 } 4439 memset(&pmk[i], 0, sizeof(*pmk)); 4440 cfg->pmk_list.npmk = cpu_to_le32(npmk - 1); 4441 } else { 4442 bphy_err(drvr, "Cache entry not found\n"); 4443 return -EINVAL; 4444 } 4445 4446 err = brcmf_update_pmklist(cfg, ifp); 4447 4448 brcmf_dbg(TRACE, "Exit\n"); 4449 return err; 4450 4451 } 4452 4453 static s32 4454 brcmf_cfg80211_flush_pmksa(struct wiphy *wiphy, struct net_device *ndev) 4455 { 4456 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy); 4457 struct brcmf_if *ifp = netdev_priv(ndev); 4458 s32 err; 4459 4460 brcmf_dbg(TRACE, "Enter\n"); 4461 if (!check_vif_up(ifp->vif)) 4462 return -EIO; 4463 4464 if (brcmf_feat_is_enabled(ifp, BRCMF_FEAT_PMKID_V3)) 4465 return brcmf_pmksa_v3_op(ifp, NULL, false); 4466 4467 /* TODO: implement PMKID_V2 */ 4468 4469 memset(&cfg->pmk_list, 0, sizeof(cfg->pmk_list)); 4470 err = brcmf_update_pmklist(cfg, ifp); 4471 4472 brcmf_dbg(TRACE, "Exit\n"); 4473 return err; 4474 4475 } 4476 4477 static s32 brcmf_configure_opensecurity(struct brcmf_if *ifp) 4478 { 4479 struct brcmf_pub *drvr = ifp->drvr; 4480 s32 err; 4481 s32 wpa_val; 4482 4483 /* set auth */ 4484 err = brcmf_fil_bsscfg_int_set(ifp, "auth", 0); 4485 if (err < 0) { 4486 bphy_err(drvr, "auth error %d\n", err); 4487 return err; 4488 } 4489 /* set wsec */ 4490 err = brcmf_fil_bsscfg_int_set(ifp, "wsec", 0); 4491 if (err < 0) { 4492 bphy_err(drvr, "wsec error %d\n", err); 4493 return err; 4494 } 4495 /* set upper-layer auth */ 4496 if (brcmf_is_ibssmode(ifp->vif)) 4497 wpa_val = WPA_AUTH_NONE; 4498 else 4499 wpa_val = WPA_AUTH_DISABLED; 4500 err = brcmf_fil_bsscfg_int_set(ifp, "wpa_auth", wpa_val); 4501 if (err < 0) { 4502 bphy_err(drvr, "wpa_auth error %d\n", err); 4503 return err; 4504 } 4505 4506 return 0; 4507 } 4508 4509 static bool brcmf_valid_wpa_oui(u8 *oui, bool is_rsn_ie) 4510 { 4511 if (is_rsn_ie) 4512 return (memcmp(oui, RSN_OUI, TLV_OUI_LEN) == 0); 4513 4514 return (memcmp(oui, WPA_OUI, TLV_OUI_LEN) == 0); 4515 } 4516 4517 static s32 4518 brcmf_configure_wpaie(struct brcmf_if *ifp, 4519 const struct brcmf_vs_tlv *wpa_ie, 4520 bool is_rsn_ie) 4521 { 4522 struct brcmf_pub *drvr = ifp->drvr; 4523 u32 auth = 0; /* d11 open authentication */ 4524 u16 count; 4525 s32 err = 0; 4526 s32 len; 4527 u32 i; 4528 u32 wsec; 4529 u32 pval = 0; 4530 u32 gval = 0; 4531 u32 wpa_auth = 0; 4532 u32 offset; 4533 u8 *data; 4534 u16 rsn_cap; 4535 u32 wme_bss_disable; 4536 u32 mfp; 4537 4538 brcmf_dbg(TRACE, "Enter\n"); 4539 if (wpa_ie == NULL) 4540 goto exit; 4541 4542 len = wpa_ie->len + TLV_HDR_LEN; 4543 data = (u8 *)wpa_ie; 4544 offset = TLV_HDR_LEN; 4545 if (!is_rsn_ie) 4546 offset += VS_IE_FIXED_HDR_LEN; 4547 else 4548 offset += WPA_IE_VERSION_LEN; 4549 4550 /* check for multicast cipher suite */ 4551 if (offset + WPA_IE_MIN_OUI_LEN > len) { 4552 err = -EINVAL; 4553 bphy_err(drvr, "no multicast cipher suite\n"); 4554 goto exit; 4555 } 4556 4557 if (!brcmf_valid_wpa_oui(&data[offset], is_rsn_ie)) { 4558 err = -EINVAL; 4559 bphy_err(drvr, "invalid OUI\n"); 4560 goto exit; 4561 } 4562 offset += TLV_OUI_LEN; 4563 4564 /* pick up multicast cipher */ 4565 switch (data[offset]) { 4566 case WPA_CIPHER_NONE: 4567 gval = 0; 4568 break; 4569 case WPA_CIPHER_WEP_40: 4570 case WPA_CIPHER_WEP_104: 4571 gval = WEP_ENABLED; 4572 break; 4573 case WPA_CIPHER_TKIP: 4574 gval = TKIP_ENABLED; 4575 break; 4576 case WPA_CIPHER_AES_CCM: 4577 gval = AES_ENABLED; 4578 break; 4579 default: 4580 err = -EINVAL; 4581 bphy_err(drvr, "Invalid multi cast cipher info\n"); 4582 goto exit; 4583 } 4584 4585 offset++; 4586 /* walk thru unicast cipher list and pick up what we recognize */ 4587 count = data[offset] + (data[offset + 1] << 8); 4588 offset += WPA_IE_SUITE_COUNT_LEN; 4589 /* Check for unicast suite(s) */ 4590 if (offset + (WPA_IE_MIN_OUI_LEN * count) > len) { 4591 err = -EINVAL; 4592 bphy_err(drvr, "no unicast cipher suite\n"); 4593 goto exit; 4594 } 4595 for (i = 0; i < count; i++) { 4596 if (!brcmf_valid_wpa_oui(&data[offset], is_rsn_ie)) { 4597 err = -EINVAL; 4598 bphy_err(drvr, "invalid OUI\n"); 4599 goto exit; 4600 } 4601 offset += TLV_OUI_LEN; 4602 switch (data[offset]) { 4603 case WPA_CIPHER_NONE: 4604 break; 4605 case WPA_CIPHER_WEP_40: 4606 case WPA_CIPHER_WEP_104: 4607 pval |= WEP_ENABLED; 4608 break; 4609 case WPA_CIPHER_TKIP: 4610 pval |= TKIP_ENABLED; 4611 break; 4612 case WPA_CIPHER_AES_CCM: 4613 pval |= AES_ENABLED; 4614 break; 4615 default: 4616 bphy_err(drvr, "Invalid unicast security info\n"); 4617 } 4618 offset++; 4619 } 4620 /* walk thru auth management suite list and pick up what we recognize */ 4621 count = data[offset] + (data[offset + 1] << 8); 4622 offset += WPA_IE_SUITE_COUNT_LEN; 4623 /* Check for auth key management suite(s) */ 4624 if (offset + (WPA_IE_MIN_OUI_LEN * count) > len) { 4625 err = -EINVAL; 4626 bphy_err(drvr, "no auth key mgmt suite\n"); 4627 goto exit; 4628 } 4629 for (i = 0; i < count; i++) { 4630 if (!brcmf_valid_wpa_oui(&data[offset], is_rsn_ie)) { 4631 err = -EINVAL; 4632 bphy_err(drvr, "invalid OUI\n"); 4633 goto exit; 4634 } 4635 offset += TLV_OUI_LEN; 4636 switch (data[offset]) { 4637 case RSN_AKM_NONE: 4638 brcmf_dbg(TRACE, "RSN_AKM_NONE\n"); 4639 wpa_auth |= WPA_AUTH_NONE; 4640 break; 4641 case RSN_AKM_UNSPECIFIED: 4642 brcmf_dbg(TRACE, "RSN_AKM_UNSPECIFIED\n"); 4643 is_rsn_ie ? (wpa_auth |= WPA2_AUTH_UNSPECIFIED) : 4644 (wpa_auth |= WPA_AUTH_UNSPECIFIED); 4645 break; 4646 case RSN_AKM_PSK: 4647 brcmf_dbg(TRACE, "RSN_AKM_PSK\n"); 4648 is_rsn_ie ? (wpa_auth |= WPA2_AUTH_PSK) : 4649 (wpa_auth |= WPA_AUTH_PSK); 4650 break; 4651 case RSN_AKM_SHA256_PSK: 4652 brcmf_dbg(TRACE, "RSN_AKM_MFP_PSK\n"); 4653 wpa_auth |= WPA2_AUTH_PSK_SHA256; 4654 break; 4655 case RSN_AKM_SHA256_1X: 4656 brcmf_dbg(TRACE, "RSN_AKM_MFP_1X\n"); 4657 wpa_auth |= WPA2_AUTH_1X_SHA256; 4658 break; 4659 case RSN_AKM_SAE: 4660 brcmf_dbg(TRACE, "RSN_AKM_SAE\n"); 4661 wpa_auth |= WPA3_AUTH_SAE_PSK; 4662 break; 4663 default: 4664 bphy_err(drvr, "Invalid key mgmt info\n"); 4665 } 4666 offset++; 4667 } 4668 4669 mfp = BRCMF_MFP_NONE; 4670 if (is_rsn_ie) { 4671 wme_bss_disable = 1; 4672 if ((offset + RSN_CAP_LEN) <= len) { 4673 rsn_cap = data[offset] + (data[offset + 1] << 8); 4674 if (rsn_cap & RSN_CAP_PTK_REPLAY_CNTR_MASK) 4675 wme_bss_disable = 0; 4676 if (rsn_cap & RSN_CAP_MFPR_MASK) { 4677 brcmf_dbg(TRACE, "MFP Required\n"); 4678 mfp = BRCMF_MFP_REQUIRED; 4679 /* Firmware only supports mfp required in 4680 * combination with WPA2_AUTH_PSK_SHA256, 4681 * WPA2_AUTH_1X_SHA256, or WPA3_AUTH_SAE_PSK. 4682 */ 4683 if (!(wpa_auth & (WPA2_AUTH_PSK_SHA256 | 4684 WPA2_AUTH_1X_SHA256 | 4685 WPA3_AUTH_SAE_PSK))) { 4686 err = -EINVAL; 4687 goto exit; 4688 } 4689 /* Firmware has requirement that WPA2_AUTH_PSK/ 4690 * WPA2_AUTH_UNSPECIFIED be set, if SHA256 OUI 4691 * is to be included in the rsn ie. 4692 */ 4693 if (wpa_auth & WPA2_AUTH_PSK_SHA256) 4694 wpa_auth |= WPA2_AUTH_PSK; 4695 else if (wpa_auth & WPA2_AUTH_1X_SHA256) 4696 wpa_auth |= WPA2_AUTH_UNSPECIFIED; 4697 } else if (rsn_cap & RSN_CAP_MFPC_MASK) { 4698 brcmf_dbg(TRACE, "MFP Capable\n"); 4699 mfp = BRCMF_MFP_CAPABLE; 4700 } 4701 } 4702 offset += RSN_CAP_LEN; 4703 /* set wme_bss_disable to sync RSN Capabilities */ 4704 err = brcmf_fil_bsscfg_int_set(ifp, "wme_bss_disable", 4705 wme_bss_disable); 4706 if (err < 0) { 4707 bphy_err(drvr, "wme_bss_disable error %d\n", err); 4708 goto exit; 4709 } 4710 4711 /* Skip PMKID cnt as it is know to be 0 for AP. */ 4712 offset += RSN_PMKID_COUNT_LEN; 4713 4714 /* See if there is BIP wpa suite left for MFP */ 4715 if (brcmf_feat_is_enabled(ifp, BRCMF_FEAT_MFP) && 4716 ((offset + WPA_IE_MIN_OUI_LEN) <= len)) { 4717 err = brcmf_fil_bsscfg_data_set(ifp, "bip", 4718 &data[offset], 4719 WPA_IE_MIN_OUI_LEN); 4720 if (err < 0) { 4721 bphy_err(drvr, "bip error %d\n", err); 4722 goto exit; 4723 } 4724 } 4725 } 4726 /* FOR WPS , set SES_OW_ENABLED */ 4727 wsec = (pval | gval | SES_OW_ENABLED); 4728 4729 /* set auth */ 4730 err = brcmf_fil_bsscfg_int_set(ifp, "auth", auth); 4731 if (err < 0) { 4732 bphy_err(drvr, "auth error %d\n", err); 4733 goto exit; 4734 } 4735 /* set wsec */ 4736 err = brcmf_fil_bsscfg_int_set(ifp, "wsec", wsec); 4737 if (err < 0) { 4738 bphy_err(drvr, "wsec error %d\n", err); 4739 goto exit; 4740 } 4741 /* Configure MFP, this needs to go after wsec otherwise the wsec command 4742 * will overwrite the values set by MFP 4743 */ 4744 if (brcmf_feat_is_enabled(ifp, BRCMF_FEAT_MFP)) { 4745 err = brcmf_fil_bsscfg_int_set(ifp, "mfp", mfp); 4746 if (err < 0) { 4747 bphy_err(drvr, "mfp error %d\n", err); 4748 goto exit; 4749 } 4750 } 4751 /* set upper-layer auth */ 4752 err = brcmf_fil_bsscfg_int_set(ifp, "wpa_auth", wpa_auth); 4753 if (err < 0) { 4754 bphy_err(drvr, "wpa_auth error %d\n", err); 4755 goto exit; 4756 } 4757 4758 exit: 4759 return err; 4760 } 4761 4762 static s32 4763 brcmf_parse_vndr_ies(const u8 *vndr_ie_buf, u32 vndr_ie_len, 4764 struct parsed_vndr_ies *vndr_ies) 4765 { 4766 struct brcmf_vs_tlv *vndrie; 4767 struct brcmf_tlv *ie; 4768 struct parsed_vndr_ie_info *parsed_info; 4769 s32 remaining_len; 4770 4771 remaining_len = (s32)vndr_ie_len; 4772 memset(vndr_ies, 0, sizeof(*vndr_ies)); 4773 4774 ie = (struct brcmf_tlv *)vndr_ie_buf; 4775 while (ie) { 4776 if (ie->id != WLAN_EID_VENDOR_SPECIFIC) 4777 goto next; 4778 vndrie = (struct brcmf_vs_tlv *)ie; 4779 /* len should be bigger than OUI length + one */ 4780 if (vndrie->len < (VS_IE_FIXED_HDR_LEN - TLV_HDR_LEN + 1)) { 4781 brcmf_err("invalid vndr ie. length is too small %d\n", 4782 vndrie->len); 4783 goto next; 4784 } 4785 /* if wpa or wme ie, do not add ie */ 4786 if (!memcmp(vndrie->oui, (u8 *)WPA_OUI, TLV_OUI_LEN) && 4787 ((vndrie->oui_type == WPA_OUI_TYPE) || 4788 (vndrie->oui_type == WME_OUI_TYPE))) { 4789 brcmf_dbg(TRACE, "Found WPA/WME oui. Do not add it\n"); 4790 goto next; 4791 } 4792 4793 parsed_info = &vndr_ies->ie_info[vndr_ies->count]; 4794 4795 /* save vndr ie information */ 4796 parsed_info->ie_ptr = (char *)vndrie; 4797 parsed_info->ie_len = vndrie->len + TLV_HDR_LEN; 4798 memcpy(&parsed_info->vndrie, vndrie, sizeof(*vndrie)); 4799 4800 vndr_ies->count++; 4801 4802 brcmf_dbg(TRACE, "** OUI %3ph, type 0x%02x\n", 4803 parsed_info->vndrie.oui, 4804 parsed_info->vndrie.oui_type); 4805 4806 if (vndr_ies->count >= VNDR_IE_PARSE_LIMIT) 4807 break; 4808 next: 4809 remaining_len -= (ie->len + TLV_HDR_LEN); 4810 if (remaining_len <= TLV_HDR_LEN) 4811 ie = NULL; 4812 else 4813 ie = (struct brcmf_tlv *)(((u8 *)ie) + ie->len + 4814 TLV_HDR_LEN); 4815 } 4816 return 0; 4817 } 4818 4819 static u32 4820 brcmf_vndr_ie(u8 *iebuf, s32 pktflag, u8 *ie_ptr, u32 ie_len, s8 *add_del_cmd) 4821 { 4822 strscpy(iebuf, add_del_cmd, VNDR_IE_CMD_LEN); 4823 4824 put_unaligned_le32(1, &iebuf[VNDR_IE_COUNT_OFFSET]); 4825 4826 put_unaligned_le32(pktflag, &iebuf[VNDR_IE_PKTFLAG_OFFSET]); 4827 4828 memcpy(&iebuf[VNDR_IE_VSIE_OFFSET], ie_ptr, ie_len); 4829 4830 return ie_len + VNDR_IE_HDR_SIZE; 4831 } 4832 4833 s32 brcmf_vif_set_mgmt_ie(struct brcmf_cfg80211_vif *vif, s32 pktflag, 4834 const u8 *vndr_ie_buf, u32 vndr_ie_len) 4835 { 4836 struct brcmf_pub *drvr; 4837 struct brcmf_if *ifp; 4838 struct vif_saved_ie *saved_ie; 4839 s32 err = 0; 4840 u8 *iovar_ie_buf; 4841 u8 *curr_ie_buf; 4842 u8 *mgmt_ie_buf = NULL; 4843 int mgmt_ie_buf_len; 4844 u32 *mgmt_ie_len; 4845 u32 del_add_ie_buf_len = 0; 4846 u32 total_ie_buf_len = 0; 4847 u32 parsed_ie_buf_len = 0; 4848 struct parsed_vndr_ies old_vndr_ies; 4849 struct parsed_vndr_ies new_vndr_ies; 4850 struct parsed_vndr_ie_info *vndrie_info; 4851 s32 i; 4852 u8 *ptr; 4853 int remained_buf_len; 4854 4855 if (!vif) 4856 return -ENODEV; 4857 ifp = vif->ifp; 4858 drvr = ifp->drvr; 4859 saved_ie = &vif->saved_ie; 4860 4861 brcmf_dbg(TRACE, "bsscfgidx %d, pktflag : 0x%02X\n", ifp->bsscfgidx, 4862 pktflag); 4863 iovar_ie_buf = kzalloc(WL_EXTRA_BUF_MAX, GFP_KERNEL); 4864 if (!iovar_ie_buf) 4865 return -ENOMEM; 4866 curr_ie_buf = iovar_ie_buf; 4867 switch (pktflag) { 4868 case BRCMF_VNDR_IE_PRBREQ_FLAG: 4869 mgmt_ie_buf = saved_ie->probe_req_ie; 4870 mgmt_ie_len = &saved_ie->probe_req_ie_len; 4871 mgmt_ie_buf_len = sizeof(saved_ie->probe_req_ie); 4872 break; 4873 case BRCMF_VNDR_IE_PRBRSP_FLAG: 4874 mgmt_ie_buf = saved_ie->probe_res_ie; 4875 mgmt_ie_len = &saved_ie->probe_res_ie_len; 4876 mgmt_ie_buf_len = sizeof(saved_ie->probe_res_ie); 4877 break; 4878 case BRCMF_VNDR_IE_BEACON_FLAG: 4879 mgmt_ie_buf = saved_ie->beacon_ie; 4880 mgmt_ie_len = &saved_ie->beacon_ie_len; 4881 mgmt_ie_buf_len = sizeof(saved_ie->beacon_ie); 4882 break; 4883 case BRCMF_VNDR_IE_ASSOCREQ_FLAG: 4884 mgmt_ie_buf = saved_ie->assoc_req_ie; 4885 mgmt_ie_len = &saved_ie->assoc_req_ie_len; 4886 mgmt_ie_buf_len = sizeof(saved_ie->assoc_req_ie); 4887 break; 4888 case BRCMF_VNDR_IE_ASSOCRSP_FLAG: 4889 mgmt_ie_buf = saved_ie->assoc_res_ie; 4890 mgmt_ie_len = &saved_ie->assoc_res_ie_len; 4891 mgmt_ie_buf_len = sizeof(saved_ie->assoc_res_ie); 4892 break; 4893 default: 4894 err = -EPERM; 4895 bphy_err(drvr, "not suitable type\n"); 4896 goto exit; 4897 } 4898 4899 if (vndr_ie_len > mgmt_ie_buf_len) { 4900 err = -ENOMEM; 4901 bphy_err(drvr, "extra IE size too big\n"); 4902 goto exit; 4903 } 4904 4905 /* parse and save new vndr_ie in curr_ie_buff before comparing it */ 4906 if (vndr_ie_buf && vndr_ie_len && curr_ie_buf) { 4907 ptr = curr_ie_buf; 4908 brcmf_parse_vndr_ies(vndr_ie_buf, vndr_ie_len, &new_vndr_ies); 4909 for (i = 0; i < new_vndr_ies.count; i++) { 4910 vndrie_info = &new_vndr_ies.ie_info[i]; 4911 memcpy(ptr + parsed_ie_buf_len, vndrie_info->ie_ptr, 4912 vndrie_info->ie_len); 4913 parsed_ie_buf_len += vndrie_info->ie_len; 4914 } 4915 } 4916 4917 if (mgmt_ie_buf && *mgmt_ie_len) { 4918 if (parsed_ie_buf_len && (parsed_ie_buf_len == *mgmt_ie_len) && 4919 (memcmp(mgmt_ie_buf, curr_ie_buf, 4920 parsed_ie_buf_len) == 0)) { 4921 brcmf_dbg(TRACE, "Previous mgmt IE equals to current IE\n"); 4922 goto exit; 4923 } 4924 4925 /* parse old vndr_ie */ 4926 brcmf_parse_vndr_ies(mgmt_ie_buf, *mgmt_ie_len, &old_vndr_ies); 4927 4928 /* make a command to delete old ie */ 4929 for (i = 0; i < old_vndr_ies.count; i++) { 4930 vndrie_info = &old_vndr_ies.ie_info[i]; 4931 4932 brcmf_dbg(TRACE, "DEL ID : %d, Len: %d , OUI:%3ph\n", 4933 vndrie_info->vndrie.id, 4934 vndrie_info->vndrie.len, 4935 vndrie_info->vndrie.oui); 4936 4937 del_add_ie_buf_len = brcmf_vndr_ie(curr_ie_buf, pktflag, 4938 vndrie_info->ie_ptr, 4939 vndrie_info->ie_len, 4940 "del"); 4941 curr_ie_buf += del_add_ie_buf_len; 4942 total_ie_buf_len += del_add_ie_buf_len; 4943 } 4944 } 4945 4946 *mgmt_ie_len = 0; 4947 /* Add if there is any extra IE */ 4948 if (mgmt_ie_buf && parsed_ie_buf_len) { 4949 ptr = mgmt_ie_buf; 4950 4951 remained_buf_len = mgmt_ie_buf_len; 4952 4953 /* make a command to add new ie */ 4954 for (i = 0; i < new_vndr_ies.count; i++) { 4955 vndrie_info = &new_vndr_ies.ie_info[i]; 4956 4957 /* verify remained buf size before copy data */ 4958 if (remained_buf_len < (vndrie_info->vndrie.len + 4959 VNDR_IE_VSIE_OFFSET)) { 4960 bphy_err(drvr, "no space in mgmt_ie_buf: len left %d", 4961 remained_buf_len); 4962 break; 4963 } 4964 remained_buf_len -= (vndrie_info->ie_len + 4965 VNDR_IE_VSIE_OFFSET); 4966 4967 brcmf_dbg(TRACE, "ADDED ID : %d, Len: %d, OUI:%3ph\n", 4968 vndrie_info->vndrie.id, 4969 vndrie_info->vndrie.len, 4970 vndrie_info->vndrie.oui); 4971 4972 del_add_ie_buf_len = brcmf_vndr_ie(curr_ie_buf, pktflag, 4973 vndrie_info->ie_ptr, 4974 vndrie_info->ie_len, 4975 "add"); 4976 4977 /* save the parsed IE in wl struct */ 4978 memcpy(ptr + (*mgmt_ie_len), vndrie_info->ie_ptr, 4979 vndrie_info->ie_len); 4980 *mgmt_ie_len += vndrie_info->ie_len; 4981 4982 curr_ie_buf += del_add_ie_buf_len; 4983 total_ie_buf_len += del_add_ie_buf_len; 4984 } 4985 } 4986 if (total_ie_buf_len) { 4987 err = brcmf_fil_bsscfg_data_set(ifp, "vndr_ie", iovar_ie_buf, 4988 total_ie_buf_len); 4989 if (err) 4990 bphy_err(drvr, "vndr ie set error : %d\n", err); 4991 } 4992 4993 exit: 4994 kfree(iovar_ie_buf); 4995 return err; 4996 } 4997 4998 s32 brcmf_vif_clear_mgmt_ies(struct brcmf_cfg80211_vif *vif) 4999 { 5000 static const s32 pktflags[] = { 5001 BRCMF_VNDR_IE_PRBREQ_FLAG, 5002 BRCMF_VNDR_IE_PRBRSP_FLAG, 5003 BRCMF_VNDR_IE_BEACON_FLAG 5004 }; 5005 int i; 5006 5007 for (i = 0; i < ARRAY_SIZE(pktflags); i++) 5008 brcmf_vif_set_mgmt_ie(vif, pktflags[i], NULL, 0); 5009 5010 memset(&vif->saved_ie, 0, sizeof(vif->saved_ie)); 5011 return 0; 5012 } 5013 5014 static s32 5015 brcmf_config_ap_mgmt_ie(struct brcmf_cfg80211_vif *vif, 5016 struct cfg80211_beacon_data *beacon) 5017 { 5018 struct brcmf_pub *drvr = vif->ifp->drvr; 5019 s32 err; 5020 5021 /* Set Beacon IEs to FW */ 5022 err = brcmf_vif_set_mgmt_ie(vif, BRCMF_VNDR_IE_BEACON_FLAG, 5023 beacon->tail, beacon->tail_len); 5024 if (err) { 5025 bphy_err(drvr, "Set Beacon IE Failed\n"); 5026 return err; 5027 } 5028 brcmf_dbg(TRACE, "Applied Vndr IEs for Beacon\n"); 5029 5030 /* Set Probe Response IEs to FW */ 5031 err = brcmf_vif_set_mgmt_ie(vif, BRCMF_VNDR_IE_PRBRSP_FLAG, 5032 beacon->proberesp_ies, 5033 beacon->proberesp_ies_len); 5034 if (err) 5035 bphy_err(drvr, "Set Probe Resp IE Failed\n"); 5036 else 5037 brcmf_dbg(TRACE, "Applied Vndr IEs for Probe Resp\n"); 5038 5039 /* Set Assoc Response IEs to FW */ 5040 err = brcmf_vif_set_mgmt_ie(vif, BRCMF_VNDR_IE_ASSOCRSP_FLAG, 5041 beacon->assocresp_ies, 5042 beacon->assocresp_ies_len); 5043 if (err) 5044 brcmf_err("Set Assoc Resp IE Failed\n"); 5045 else 5046 brcmf_dbg(TRACE, "Applied Vndr IEs for Assoc Resp\n"); 5047 5048 return err; 5049 } 5050 5051 static s32 5052 brcmf_parse_configure_security(struct brcmf_if *ifp, 5053 struct cfg80211_ap_settings *settings, 5054 enum nl80211_iftype dev_role) 5055 { 5056 const struct brcmf_tlv *rsn_ie; 5057 const struct brcmf_vs_tlv *wpa_ie; 5058 s32 err = 0; 5059 5060 /* find the RSN_IE */ 5061 rsn_ie = brcmf_parse_tlvs((u8 *)settings->beacon.tail, 5062 settings->beacon.tail_len, WLAN_EID_RSN); 5063 5064 /* find the WPA_IE */ 5065 wpa_ie = brcmf_find_wpaie((u8 *)settings->beacon.tail, 5066 settings->beacon.tail_len); 5067 5068 if (wpa_ie || rsn_ie) { 5069 brcmf_dbg(TRACE, "WPA(2) IE is found\n"); 5070 if (wpa_ie) { 5071 /* WPA IE */ 5072 err = brcmf_configure_wpaie(ifp, wpa_ie, false); 5073 if (err < 0) 5074 return err; 5075 } else { 5076 struct brcmf_vs_tlv *tmp_ie; 5077 5078 tmp_ie = (struct brcmf_vs_tlv *)rsn_ie; 5079 5080 /* RSN IE */ 5081 err = brcmf_configure_wpaie(ifp, tmp_ie, true); 5082 if (err < 0) 5083 return err; 5084 } 5085 } else { 5086 brcmf_dbg(TRACE, "No WPA(2) IEs found\n"); 5087 brcmf_configure_opensecurity(ifp); 5088 } 5089 5090 return err; 5091 } 5092 5093 static s32 5094 brcmf_cfg80211_start_ap(struct wiphy *wiphy, struct net_device *ndev, 5095 struct cfg80211_ap_settings *settings) 5096 { 5097 s32 ie_offset; 5098 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy); 5099 struct brcmf_if *ifp = netdev_priv(ndev); 5100 struct brcmf_pub *drvr = cfg->pub; 5101 struct brcmf_cfg80211_profile *profile = &ifp->vif->profile; 5102 struct cfg80211_crypto_settings *crypto = &settings->crypto; 5103 const struct brcmf_tlv *ssid_ie; 5104 const struct brcmf_tlv *country_ie; 5105 struct brcmf_ssid_le ssid_le; 5106 s32 err = -EPERM; 5107 struct brcmf_join_params join_params; 5108 enum nl80211_iftype dev_role; 5109 struct brcmf_fil_bss_enable_le bss_enable; 5110 u16 chanspec = chandef_to_chanspec(&cfg->d11inf, &settings->chandef); 5111 bool mbss; 5112 int is_11d; 5113 bool supports_11d; 5114 bool closednet; 5115 5116 brcmf_dbg(TRACE, "ctrlchn=%d, center=%d, bw=%d, beacon_interval=%d, dtim_period=%d,\n", 5117 settings->chandef.chan->hw_value, 5118 settings->chandef.center_freq1, settings->chandef.width, 5119 settings->beacon_interval, settings->dtim_period); 5120 brcmf_dbg(TRACE, "ssid=%s(%zu), auth_type=%d, inactivity_timeout=%d\n", 5121 settings->ssid, settings->ssid_len, settings->auth_type, 5122 settings->inactivity_timeout); 5123 dev_role = ifp->vif->wdev.iftype; 5124 mbss = ifp->vif->mbss; 5125 5126 /* store current 11d setting */ 5127 if (brcmf_fil_cmd_int_get(ifp, BRCMF_C_GET_REGULATORY, 5128 &ifp->vif->is_11d)) { 5129 is_11d = supports_11d = false; 5130 } else { 5131 country_ie = brcmf_parse_tlvs((u8 *)settings->beacon.tail, 5132 settings->beacon.tail_len, 5133 WLAN_EID_COUNTRY); 5134 is_11d = country_ie ? 1 : 0; 5135 supports_11d = true; 5136 } 5137 5138 memset(&ssid_le, 0, sizeof(ssid_le)); 5139 if (settings->ssid == NULL || settings->ssid_len == 0) { 5140 ie_offset = DOT11_MGMT_HDR_LEN + DOT11_BCN_PRB_FIXED_LEN; 5141 ssid_ie = brcmf_parse_tlvs( 5142 (u8 *)&settings->beacon.head[ie_offset], 5143 settings->beacon.head_len - ie_offset, 5144 WLAN_EID_SSID); 5145 if (!ssid_ie || ssid_ie->len > IEEE80211_MAX_SSID_LEN) 5146 return -EINVAL; 5147 5148 memcpy(ssid_le.SSID, ssid_ie->data, ssid_ie->len); 5149 ssid_le.SSID_len = cpu_to_le32(ssid_ie->len); 5150 brcmf_dbg(TRACE, "SSID is (%s) in Head\n", ssid_le.SSID); 5151 } else { 5152 memcpy(ssid_le.SSID, settings->ssid, settings->ssid_len); 5153 ssid_le.SSID_len = cpu_to_le32((u32)settings->ssid_len); 5154 } 5155 5156 if (!mbss) { 5157 brcmf_set_mpc(ifp, 0); 5158 brcmf_configure_arp_nd_offload(ifp, false); 5159 } 5160 5161 /* Parameters shared by all radio interfaces */ 5162 if (!mbss) { 5163 if ((supports_11d) && (is_11d != ifp->vif->is_11d)) { 5164 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_REGULATORY, 5165 is_11d); 5166 if (err < 0) { 5167 bphy_err(drvr, "Regulatory Set Error, %d\n", 5168 err); 5169 goto exit; 5170 } 5171 } 5172 if (settings->beacon_interval) { 5173 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_BCNPRD, 5174 settings->beacon_interval); 5175 if (err < 0) { 5176 bphy_err(drvr, "Beacon Interval Set Error, %d\n", 5177 err); 5178 goto exit; 5179 } 5180 } 5181 if (settings->dtim_period) { 5182 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_DTIMPRD, 5183 settings->dtim_period); 5184 if (err < 0) { 5185 bphy_err(drvr, "DTIM Interval Set Error, %d\n", 5186 err); 5187 goto exit; 5188 } 5189 } 5190 5191 if ((dev_role == NL80211_IFTYPE_AP) && 5192 ((ifp->ifidx == 0) || 5193 (!brcmf_feat_is_enabled(ifp, BRCMF_FEAT_RSDB) && 5194 !brcmf_feat_is_enabled(ifp, BRCMF_FEAT_MCHAN)))) { 5195 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_DOWN, 1); 5196 if (err < 0) { 5197 bphy_err(drvr, "BRCMF_C_DOWN error %d\n", 5198 err); 5199 goto exit; 5200 } 5201 brcmf_fil_iovar_int_set(ifp, "apsta", 0); 5202 } 5203 5204 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_INFRA, 1); 5205 if (err < 0) { 5206 bphy_err(drvr, "SET INFRA error %d\n", err); 5207 goto exit; 5208 } 5209 } else if (WARN_ON(supports_11d && (is_11d != ifp->vif->is_11d))) { 5210 /* Multiple-BSS should use same 11d configuration */ 5211 err = -EINVAL; 5212 goto exit; 5213 } 5214 5215 /* Interface specific setup */ 5216 if (dev_role == NL80211_IFTYPE_AP) { 5217 if ((brcmf_feat_is_enabled(ifp, BRCMF_FEAT_MBSS)) && (!mbss)) 5218 brcmf_fil_iovar_int_set(ifp, "mbss", 1); 5219 5220 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_AP, 1); 5221 if (err < 0) { 5222 bphy_err(drvr, "setting AP mode failed %d\n", 5223 err); 5224 goto exit; 5225 } 5226 if (!mbss) { 5227 /* Firmware 10.x requires setting channel after enabling 5228 * AP and before bringing interface up. 5229 */ 5230 err = brcmf_fil_iovar_int_set(ifp, "chanspec", chanspec); 5231 if (err < 0) { 5232 bphy_err(drvr, "Set Channel failed: chspec=%d, %d\n", 5233 chanspec, err); 5234 goto exit; 5235 } 5236 } 5237 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_UP, 1); 5238 if (err < 0) { 5239 bphy_err(drvr, "BRCMF_C_UP error (%d)\n", err); 5240 goto exit; 5241 } 5242 5243 if (crypto->psk) { 5244 brcmf_dbg(INFO, "using PSK offload\n"); 5245 profile->use_fwauth |= BIT(BRCMF_PROFILE_FWAUTH_PSK); 5246 err = brcmf_set_pmk(ifp, crypto->psk, 5247 BRCMF_WSEC_MAX_PSK_LEN); 5248 if (err < 0) 5249 goto exit; 5250 } 5251 if (crypto->sae_pwd) { 5252 brcmf_dbg(INFO, "using SAE offload\n"); 5253 profile->use_fwauth |= BIT(BRCMF_PROFILE_FWAUTH_SAE); 5254 err = brcmf_fwvid_set_sae_password(ifp, crypto); 5255 if (err < 0) 5256 goto exit; 5257 } 5258 if (profile->use_fwauth == 0) 5259 profile->use_fwauth = BIT(BRCMF_PROFILE_FWAUTH_NONE); 5260 5261 err = brcmf_parse_configure_security(ifp, settings, 5262 NL80211_IFTYPE_AP); 5263 if (err < 0) { 5264 bphy_err(drvr, "brcmf_parse_configure_security error\n"); 5265 goto exit; 5266 } 5267 5268 /* On DOWN the firmware removes the WEP keys, reconfigure 5269 * them if they were set. 5270 */ 5271 brcmf_cfg80211_reconfigure_wep(ifp); 5272 5273 memset(&join_params, 0, sizeof(join_params)); 5274 /* join parameters starts with ssid */ 5275 memcpy(&join_params.ssid_le, &ssid_le, sizeof(ssid_le)); 5276 /* create softap */ 5277 err = brcmf_fil_cmd_data_set(ifp, BRCMF_C_SET_SSID, 5278 &join_params, sizeof(join_params)); 5279 if (err < 0) { 5280 bphy_err(drvr, "SET SSID error (%d)\n", err); 5281 goto exit; 5282 } 5283 5284 closednet = 5285 (settings->hidden_ssid != NL80211_HIDDEN_SSID_NOT_IN_USE); 5286 err = brcmf_fil_iovar_int_set(ifp, "closednet", closednet); 5287 if (err) { 5288 bphy_err(drvr, "%s closednet error (%d)\n", 5289 (closednet ? "enabled" : "disabled"), 5290 err); 5291 goto exit; 5292 } 5293 5294 brcmf_dbg(TRACE, "AP mode configuration complete\n"); 5295 } else if (dev_role == NL80211_IFTYPE_P2P_GO) { 5296 err = brcmf_fil_iovar_int_set(ifp, "chanspec", chanspec); 5297 if (err < 0) { 5298 bphy_err(drvr, "Set Channel failed: chspec=%d, %d\n", 5299 chanspec, err); 5300 goto exit; 5301 } 5302 5303 err = brcmf_parse_configure_security(ifp, settings, 5304 NL80211_IFTYPE_P2P_GO); 5305 if (err < 0) { 5306 brcmf_err("brcmf_parse_configure_security error\n"); 5307 goto exit; 5308 } 5309 5310 err = brcmf_fil_bsscfg_data_set(ifp, "ssid", &ssid_le, 5311 sizeof(ssid_le)); 5312 if (err < 0) { 5313 bphy_err(drvr, "setting ssid failed %d\n", err); 5314 goto exit; 5315 } 5316 bss_enable.bsscfgidx = cpu_to_le32(ifp->bsscfgidx); 5317 bss_enable.enable = cpu_to_le32(1); 5318 err = brcmf_fil_iovar_data_set(ifp, "bss", &bss_enable, 5319 sizeof(bss_enable)); 5320 if (err < 0) { 5321 bphy_err(drvr, "bss_enable config failed %d\n", err); 5322 goto exit; 5323 } 5324 5325 brcmf_dbg(TRACE, "GO mode configuration complete\n"); 5326 } else { 5327 WARN_ON(1); 5328 } 5329 5330 brcmf_config_ap_mgmt_ie(ifp->vif, &settings->beacon); 5331 set_bit(BRCMF_VIF_STATUS_AP_CREATED, &ifp->vif->sme_state); 5332 brcmf_net_setcarrier(ifp, true); 5333 5334 exit: 5335 if ((err) && (!mbss)) { 5336 brcmf_set_mpc(ifp, 1); 5337 brcmf_configure_arp_nd_offload(ifp, true); 5338 } 5339 return err; 5340 } 5341 5342 static int brcmf_cfg80211_stop_ap(struct wiphy *wiphy, struct net_device *ndev, 5343 unsigned int link_id) 5344 { 5345 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy); 5346 struct brcmf_if *ifp = netdev_priv(ndev); 5347 struct brcmf_pub *drvr = cfg->pub; 5348 struct brcmf_cfg80211_profile *profile = &ifp->vif->profile; 5349 s32 err; 5350 struct brcmf_fil_bss_enable_le bss_enable; 5351 struct brcmf_join_params join_params; 5352 5353 brcmf_dbg(TRACE, "Enter\n"); 5354 5355 if (ifp->vif->wdev.iftype == NL80211_IFTYPE_AP) { 5356 /* Due to most likely deauths outstanding we sleep */ 5357 /* first to make sure they get processed by fw. */ 5358 msleep(400); 5359 5360 if (profile->use_fwauth != BIT(BRCMF_PROFILE_FWAUTH_NONE)) { 5361 struct cfg80211_crypto_settings crypto = {}; 5362 5363 if (profile->use_fwauth & BIT(BRCMF_PROFILE_FWAUTH_PSK)) 5364 brcmf_set_pmk(ifp, NULL, 0); 5365 if (profile->use_fwauth & BIT(BRCMF_PROFILE_FWAUTH_SAE)) 5366 brcmf_fwvid_set_sae_password(ifp, &crypto); 5367 profile->use_fwauth = BIT(BRCMF_PROFILE_FWAUTH_NONE); 5368 } 5369 5370 if (ifp->vif->mbss) { 5371 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_DOWN, 1); 5372 return err; 5373 } 5374 5375 /* First BSS doesn't get a full reset */ 5376 if (ifp->bsscfgidx == 0) 5377 brcmf_fil_iovar_int_set(ifp, "closednet", 0); 5378 5379 memset(&join_params, 0, sizeof(join_params)); 5380 err = brcmf_fil_cmd_data_set(ifp, BRCMF_C_SET_SSID, 5381 &join_params, sizeof(join_params)); 5382 if (err < 0) 5383 bphy_err(drvr, "SET SSID error (%d)\n", err); 5384 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_DOWN, 1); 5385 if (err < 0) 5386 bphy_err(drvr, "BRCMF_C_DOWN error %d\n", err); 5387 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_AP, 0); 5388 if (err < 0) 5389 bphy_err(drvr, "setting AP mode failed %d\n", err); 5390 if (brcmf_feat_is_enabled(ifp, BRCMF_FEAT_MBSS)) 5391 brcmf_fil_iovar_int_set(ifp, "mbss", 0); 5392 brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_REGULATORY, 5393 ifp->vif->is_11d); 5394 /* Bring device back up so it can be used again */ 5395 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_UP, 1); 5396 if (err < 0) 5397 bphy_err(drvr, "BRCMF_C_UP error %d\n", err); 5398 5399 brcmf_vif_clear_mgmt_ies(ifp->vif); 5400 } else { 5401 bss_enable.bsscfgidx = cpu_to_le32(ifp->bsscfgidx); 5402 bss_enable.enable = cpu_to_le32(0); 5403 err = brcmf_fil_iovar_data_set(ifp, "bss", &bss_enable, 5404 sizeof(bss_enable)); 5405 if (err < 0) 5406 bphy_err(drvr, "bss_enable config failed %d\n", err); 5407 } 5408 brcmf_set_mpc(ifp, 1); 5409 brcmf_configure_arp_nd_offload(ifp, true); 5410 clear_bit(BRCMF_VIF_STATUS_AP_CREATED, &ifp->vif->sme_state); 5411 brcmf_net_setcarrier(ifp, false); 5412 5413 return err; 5414 } 5415 5416 static s32 5417 brcmf_cfg80211_change_beacon(struct wiphy *wiphy, struct net_device *ndev, 5418 struct cfg80211_ap_update *info) 5419 { 5420 struct brcmf_if *ifp = netdev_priv(ndev); 5421 5422 brcmf_dbg(TRACE, "Enter\n"); 5423 5424 return brcmf_config_ap_mgmt_ie(ifp->vif, &info->beacon); 5425 } 5426 5427 static int 5428 brcmf_cfg80211_del_station(struct wiphy *wiphy, struct net_device *ndev, 5429 struct station_del_parameters *params) 5430 { 5431 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy); 5432 struct brcmf_pub *drvr = cfg->pub; 5433 struct brcmf_scb_val_le scbval; 5434 struct brcmf_if *ifp = netdev_priv(ndev); 5435 s32 err; 5436 5437 if (!params->mac) 5438 return -EFAULT; 5439 5440 brcmf_dbg(TRACE, "Enter %pM\n", params->mac); 5441 5442 if (ifp->vif == cfg->p2p.bss_idx[P2PAPI_BSSCFG_DEVICE].vif) 5443 ifp = cfg->p2p.bss_idx[P2PAPI_BSSCFG_PRIMARY].vif->ifp; 5444 if (!check_vif_up(ifp->vif)) 5445 return -EIO; 5446 5447 memcpy(&scbval.ea, params->mac, ETH_ALEN); 5448 scbval.val = cpu_to_le32(params->reason_code); 5449 err = brcmf_fil_cmd_data_set(ifp, BRCMF_C_SCB_DEAUTHENTICATE_FOR_REASON, 5450 &scbval, sizeof(scbval)); 5451 if (err) 5452 bphy_err(drvr, "SCB_DEAUTHENTICATE_FOR_REASON failed %d\n", 5453 err); 5454 5455 brcmf_dbg(TRACE, "Exit\n"); 5456 return err; 5457 } 5458 5459 static int 5460 brcmf_cfg80211_change_station(struct wiphy *wiphy, struct net_device *ndev, 5461 const u8 *mac, struct station_parameters *params) 5462 { 5463 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy); 5464 struct brcmf_pub *drvr = cfg->pub; 5465 struct brcmf_if *ifp = netdev_priv(ndev); 5466 s32 err; 5467 5468 brcmf_dbg(TRACE, "Enter, MAC %pM, mask 0x%04x set 0x%04x\n", mac, 5469 params->sta_flags_mask, params->sta_flags_set); 5470 5471 /* Ignore all 00 MAC */ 5472 if (is_zero_ether_addr(mac)) 5473 return 0; 5474 5475 if (!(params->sta_flags_mask & BIT(NL80211_STA_FLAG_AUTHORIZED))) 5476 return 0; 5477 5478 if (params->sta_flags_set & BIT(NL80211_STA_FLAG_AUTHORIZED)) 5479 err = brcmf_fil_cmd_data_set(ifp, BRCMF_C_SET_SCB_AUTHORIZE, 5480 (void *)mac, ETH_ALEN); 5481 else 5482 err = brcmf_fil_cmd_data_set(ifp, BRCMF_C_SET_SCB_DEAUTHORIZE, 5483 (void *)mac, ETH_ALEN); 5484 if (err < 0) 5485 bphy_err(drvr, "Setting SCB (de-)authorize failed, %d\n", err); 5486 5487 return err; 5488 } 5489 5490 static void 5491 brcmf_cfg80211_update_mgmt_frame_registrations(struct wiphy *wiphy, 5492 struct wireless_dev *wdev, 5493 struct mgmt_frame_regs *upd) 5494 { 5495 struct brcmf_cfg80211_vif *vif; 5496 5497 vif = container_of(wdev, struct brcmf_cfg80211_vif, wdev); 5498 5499 vif->mgmt_rx_reg = upd->interface_stypes; 5500 } 5501 5502 5503 static int 5504 brcmf_cfg80211_mgmt_tx(struct wiphy *wiphy, struct wireless_dev *wdev, 5505 struct cfg80211_mgmt_tx_params *params, u64 *cookie) 5506 { 5507 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy); 5508 struct ieee80211_channel *chan = params->chan; 5509 struct brcmf_pub *drvr = cfg->pub; 5510 const u8 *buf = params->buf; 5511 size_t len = params->len; 5512 const struct ieee80211_mgmt *mgmt; 5513 struct brcmf_cfg80211_vif *vif; 5514 s32 err = 0; 5515 s32 ie_offset; 5516 s32 ie_len; 5517 struct brcmf_fil_action_frame_le *action_frame; 5518 struct brcmf_fil_af_params_le *af_params; 5519 bool ack; 5520 s32 chan_nr; 5521 u32 freq; 5522 5523 brcmf_dbg(TRACE, "Enter\n"); 5524 5525 *cookie = 0; 5526 5527 mgmt = (const struct ieee80211_mgmt *)buf; 5528 5529 if (!ieee80211_is_mgmt(mgmt->frame_control)) { 5530 bphy_err(drvr, "Driver only allows MGMT packet type\n"); 5531 return -EPERM; 5532 } 5533 5534 vif = container_of(wdev, struct brcmf_cfg80211_vif, wdev); 5535 5536 if (ieee80211_is_probe_resp(mgmt->frame_control)) { 5537 /* Right now the only reason to get a probe response */ 5538 /* is for p2p listen response or for p2p GO from */ 5539 /* wpa_supplicant. Unfortunately the probe is send */ 5540 /* on primary ndev, while dongle wants it on the p2p */ 5541 /* vif. Since this is only reason for a probe */ 5542 /* response to be sent, the vif is taken from cfg. */ 5543 /* If ever desired to send proberesp for non p2p */ 5544 /* response then data should be checked for */ 5545 /* "DIRECT-". Note in future supplicant will take */ 5546 /* dedicated p2p wdev to do this and then this 'hack'*/ 5547 /* is not needed anymore. */ 5548 ie_offset = DOT11_MGMT_HDR_LEN + 5549 DOT11_BCN_PRB_FIXED_LEN; 5550 ie_len = len - ie_offset; 5551 if (vif == cfg->p2p.bss_idx[P2PAPI_BSSCFG_PRIMARY].vif) 5552 vif = cfg->p2p.bss_idx[P2PAPI_BSSCFG_DEVICE].vif; 5553 err = brcmf_vif_set_mgmt_ie(vif, 5554 BRCMF_VNDR_IE_PRBRSP_FLAG, 5555 &buf[ie_offset], 5556 ie_len); 5557 cfg80211_mgmt_tx_status(wdev, *cookie, buf, len, true, 5558 GFP_KERNEL); 5559 } else if (ieee80211_is_action(mgmt->frame_control)) { 5560 if (len > BRCMF_FIL_ACTION_FRAME_SIZE + DOT11_MGMT_HDR_LEN) { 5561 bphy_err(drvr, "invalid action frame length\n"); 5562 err = -EINVAL; 5563 goto exit; 5564 } 5565 af_params = kzalloc(sizeof(*af_params), GFP_KERNEL); 5566 if (af_params == NULL) { 5567 bphy_err(drvr, "unable to allocate frame\n"); 5568 err = -ENOMEM; 5569 goto exit; 5570 } 5571 action_frame = &af_params->action_frame; 5572 /* Add the packet Id */ 5573 action_frame->packet_id = cpu_to_le32(*cookie); 5574 /* Add BSSID */ 5575 memcpy(&action_frame->da[0], &mgmt->da[0], ETH_ALEN); 5576 memcpy(&af_params->bssid[0], &mgmt->bssid[0], ETH_ALEN); 5577 /* Add the length exepted for 802.11 header */ 5578 action_frame->len = cpu_to_le16(len - DOT11_MGMT_HDR_LEN); 5579 /* Add the channel. Use the one specified as parameter if any or 5580 * the current one (got from the firmware) otherwise 5581 */ 5582 if (chan) 5583 freq = chan->center_freq; 5584 else 5585 brcmf_fil_cmd_int_get(vif->ifp, BRCMF_C_GET_CHANNEL, 5586 &freq); 5587 chan_nr = ieee80211_frequency_to_channel(freq); 5588 af_params->channel = cpu_to_le32(chan_nr); 5589 af_params->dwell_time = cpu_to_le32(params->wait); 5590 memcpy(action_frame->data, &buf[DOT11_MGMT_HDR_LEN], 5591 le16_to_cpu(action_frame->len)); 5592 5593 brcmf_dbg(TRACE, "Action frame, cookie=%lld, len=%d, freq=%d\n", 5594 *cookie, le16_to_cpu(action_frame->len), freq); 5595 5596 ack = brcmf_p2p_send_action_frame(cfg, cfg_to_ndev(cfg), 5597 af_params); 5598 5599 cfg80211_mgmt_tx_status(wdev, *cookie, buf, len, ack, 5600 GFP_KERNEL); 5601 kfree(af_params); 5602 } else { 5603 brcmf_dbg(TRACE, "Unhandled, fc=%04x!!\n", mgmt->frame_control); 5604 brcmf_dbg_hex_dump(true, buf, len, "payload, len=%zu\n", len); 5605 } 5606 5607 exit: 5608 return err; 5609 } 5610 5611 static int brcmf_cfg80211_set_cqm_rssi_range_config(struct wiphy *wiphy, 5612 struct net_device *ndev, 5613 s32 rssi_low, s32 rssi_high) 5614 { 5615 struct brcmf_cfg80211_vif *vif; 5616 struct brcmf_if *ifp; 5617 int err = 0; 5618 5619 brcmf_dbg(TRACE, "low=%d high=%d", rssi_low, rssi_high); 5620 5621 ifp = netdev_priv(ndev); 5622 vif = ifp->vif; 5623 5624 if (rssi_low != vif->cqm_rssi_low || rssi_high != vif->cqm_rssi_high) { 5625 /* The firmware will send an event when the RSSI is less than or 5626 * equal to a configured level and the previous RSSI event was 5627 * less than or equal to a different level. Set a third level 5628 * so that we also detect the transition from rssi <= rssi_high 5629 * to rssi > rssi_high. 5630 */ 5631 struct brcmf_rssi_event_le config = { 5632 .rate_limit_msec = cpu_to_le32(0), 5633 .rssi_level_num = 3, 5634 .rssi_levels = { 5635 clamp_val(rssi_low, S8_MIN, S8_MAX - 2), 5636 clamp_val(rssi_high, S8_MIN + 1, S8_MAX - 1), 5637 S8_MAX, 5638 }, 5639 }; 5640 5641 err = brcmf_fil_iovar_data_set(ifp, "rssi_event", &config, 5642 sizeof(config)); 5643 if (err) { 5644 err = -EINVAL; 5645 } else { 5646 vif->cqm_rssi_low = rssi_low; 5647 vif->cqm_rssi_high = rssi_high; 5648 } 5649 } 5650 5651 return err; 5652 } 5653 5654 static int 5655 brcmf_cfg80211_cancel_remain_on_channel(struct wiphy *wiphy, 5656 struct wireless_dev *wdev, 5657 u64 cookie) 5658 { 5659 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy); 5660 struct brcmf_pub *drvr = cfg->pub; 5661 struct brcmf_cfg80211_vif *vif; 5662 int err = 0; 5663 5664 brcmf_dbg(TRACE, "Enter p2p listen cancel\n"); 5665 5666 vif = cfg->p2p.bss_idx[P2PAPI_BSSCFG_DEVICE].vif; 5667 if (vif == NULL) { 5668 bphy_err(drvr, "No p2p device available for probe response\n"); 5669 err = -ENODEV; 5670 goto exit; 5671 } 5672 brcmf_p2p_cancel_remain_on_channel(vif->ifp); 5673 exit: 5674 return err; 5675 } 5676 5677 static int brcmf_cfg80211_get_channel(struct wiphy *wiphy, 5678 struct wireless_dev *wdev, 5679 unsigned int link_id, 5680 struct cfg80211_chan_def *chandef) 5681 { 5682 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy); 5683 struct net_device *ndev = wdev->netdev; 5684 struct brcmf_pub *drvr = cfg->pub; 5685 struct brcmu_chan ch; 5686 enum nl80211_band band = 0; 5687 enum nl80211_chan_width width = 0; 5688 u32 chanspec; 5689 int freq, err; 5690 5691 if (!ndev || drvr->bus_if->state != BRCMF_BUS_UP) 5692 return -ENODEV; 5693 5694 err = brcmf_fil_iovar_int_get(netdev_priv(ndev), "chanspec", &chanspec); 5695 if (err) { 5696 bphy_err(drvr, "chanspec failed (%d)\n", err); 5697 return err; 5698 } 5699 5700 ch.chspec = chanspec; 5701 cfg->d11inf.decchspec(&ch); 5702 5703 switch (ch.band) { 5704 case BRCMU_CHAN_BAND_2G: 5705 band = NL80211_BAND_2GHZ; 5706 break; 5707 case BRCMU_CHAN_BAND_5G: 5708 band = NL80211_BAND_5GHZ; 5709 break; 5710 } 5711 5712 switch (ch.bw) { 5713 case BRCMU_CHAN_BW_80: 5714 width = NL80211_CHAN_WIDTH_80; 5715 break; 5716 case BRCMU_CHAN_BW_40: 5717 width = NL80211_CHAN_WIDTH_40; 5718 break; 5719 case BRCMU_CHAN_BW_20: 5720 width = NL80211_CHAN_WIDTH_20; 5721 break; 5722 case BRCMU_CHAN_BW_80P80: 5723 width = NL80211_CHAN_WIDTH_80P80; 5724 break; 5725 case BRCMU_CHAN_BW_160: 5726 width = NL80211_CHAN_WIDTH_160; 5727 break; 5728 } 5729 5730 freq = ieee80211_channel_to_frequency(ch.control_ch_num, band); 5731 chandef->chan = ieee80211_get_channel(wiphy, freq); 5732 chandef->width = width; 5733 chandef->center_freq1 = ieee80211_channel_to_frequency(ch.chnum, band); 5734 chandef->center_freq2 = 0; 5735 5736 return 0; 5737 } 5738 5739 static int brcmf_cfg80211_crit_proto_start(struct wiphy *wiphy, 5740 struct wireless_dev *wdev, 5741 enum nl80211_crit_proto_id proto, 5742 u16 duration) 5743 { 5744 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy); 5745 struct brcmf_cfg80211_vif *vif; 5746 5747 vif = container_of(wdev, struct brcmf_cfg80211_vif, wdev); 5748 5749 /* only DHCP support for now */ 5750 if (proto != NL80211_CRIT_PROTO_DHCP) 5751 return -EINVAL; 5752 5753 /* suppress and abort scanning */ 5754 set_bit(BRCMF_SCAN_STATUS_SUPPRESS, &cfg->scan_status); 5755 brcmf_abort_scanning(cfg); 5756 5757 return brcmf_btcoex_set_mode(vif, BRCMF_BTCOEX_DISABLED, duration); 5758 } 5759 5760 static void brcmf_cfg80211_crit_proto_stop(struct wiphy *wiphy, 5761 struct wireless_dev *wdev) 5762 { 5763 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy); 5764 struct brcmf_cfg80211_vif *vif; 5765 5766 vif = container_of(wdev, struct brcmf_cfg80211_vif, wdev); 5767 5768 brcmf_btcoex_set_mode(vif, BRCMF_BTCOEX_ENABLED, 0); 5769 clear_bit(BRCMF_SCAN_STATUS_SUPPRESS, &cfg->scan_status); 5770 } 5771 5772 static s32 5773 brcmf_notify_tdls_peer_event(struct brcmf_if *ifp, 5774 const struct brcmf_event_msg *e, void *data) 5775 { 5776 switch (e->reason) { 5777 case BRCMF_E_REASON_TDLS_PEER_DISCOVERED: 5778 brcmf_dbg(TRACE, "TDLS Peer Discovered\n"); 5779 break; 5780 case BRCMF_E_REASON_TDLS_PEER_CONNECTED: 5781 brcmf_dbg(TRACE, "TDLS Peer Connected\n"); 5782 brcmf_proto_add_tdls_peer(ifp->drvr, ifp->ifidx, (u8 *)e->addr); 5783 break; 5784 case BRCMF_E_REASON_TDLS_PEER_DISCONNECTED: 5785 brcmf_dbg(TRACE, "TDLS Peer Disconnected\n"); 5786 brcmf_proto_delete_peer(ifp->drvr, ifp->ifidx, (u8 *)e->addr); 5787 break; 5788 } 5789 5790 return 0; 5791 } 5792 5793 static int brcmf_convert_nl80211_tdls_oper(enum nl80211_tdls_operation oper) 5794 { 5795 int ret; 5796 5797 switch (oper) { 5798 case NL80211_TDLS_DISCOVERY_REQ: 5799 ret = BRCMF_TDLS_MANUAL_EP_DISCOVERY; 5800 break; 5801 case NL80211_TDLS_SETUP: 5802 ret = BRCMF_TDLS_MANUAL_EP_CREATE; 5803 break; 5804 case NL80211_TDLS_TEARDOWN: 5805 ret = BRCMF_TDLS_MANUAL_EP_DELETE; 5806 break; 5807 default: 5808 brcmf_err("unsupported operation: %d\n", oper); 5809 ret = -EOPNOTSUPP; 5810 } 5811 return ret; 5812 } 5813 5814 static int brcmf_cfg80211_tdls_oper(struct wiphy *wiphy, 5815 struct net_device *ndev, const u8 *peer, 5816 enum nl80211_tdls_operation oper) 5817 { 5818 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy); 5819 struct brcmf_pub *drvr = cfg->pub; 5820 struct brcmf_if *ifp; 5821 struct brcmf_tdls_iovar_le info; 5822 int ret = 0; 5823 5824 ret = brcmf_convert_nl80211_tdls_oper(oper); 5825 if (ret < 0) 5826 return ret; 5827 5828 ifp = netdev_priv(ndev); 5829 memset(&info, 0, sizeof(info)); 5830 info.mode = (u8)ret; 5831 if (peer) 5832 memcpy(info.ea, peer, ETH_ALEN); 5833 5834 ret = brcmf_fil_iovar_data_set(ifp, "tdls_endpoint", 5835 &info, sizeof(info)); 5836 if (ret < 0) 5837 bphy_err(drvr, "tdls_endpoint iovar failed: ret=%d\n", ret); 5838 5839 return ret; 5840 } 5841 5842 static int 5843 brcmf_cfg80211_update_conn_params(struct wiphy *wiphy, 5844 struct net_device *ndev, 5845 struct cfg80211_connect_params *sme, 5846 u32 changed) 5847 { 5848 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy); 5849 struct brcmf_pub *drvr = cfg->pub; 5850 struct brcmf_if *ifp; 5851 int err; 5852 5853 if (!(changed & UPDATE_ASSOC_IES)) 5854 return 0; 5855 5856 ifp = netdev_priv(ndev); 5857 err = brcmf_vif_set_mgmt_ie(ifp->vif, BRCMF_VNDR_IE_ASSOCREQ_FLAG, 5858 sme->ie, sme->ie_len); 5859 if (err) 5860 bphy_err(drvr, "Set Assoc REQ IE Failed\n"); 5861 else 5862 brcmf_dbg(TRACE, "Applied Vndr IEs for Assoc request\n"); 5863 5864 return err; 5865 } 5866 5867 #ifdef CONFIG_PM 5868 static int 5869 brcmf_cfg80211_set_rekey_data(struct wiphy *wiphy, struct net_device *ndev, 5870 struct cfg80211_gtk_rekey_data *gtk) 5871 { 5872 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy); 5873 struct brcmf_pub *drvr = cfg->pub; 5874 struct brcmf_if *ifp = netdev_priv(ndev); 5875 struct brcmf_gtk_keyinfo_le gtk_le; 5876 int ret; 5877 5878 brcmf_dbg(TRACE, "Enter, bssidx=%d\n", ifp->bsscfgidx); 5879 5880 memcpy(gtk_le.kck, gtk->kck, sizeof(gtk_le.kck)); 5881 memcpy(gtk_le.kek, gtk->kek, sizeof(gtk_le.kek)); 5882 memcpy(gtk_le.replay_counter, gtk->replay_ctr, 5883 sizeof(gtk_le.replay_counter)); 5884 5885 ret = brcmf_fil_iovar_data_set(ifp, "gtk_key_info", >k_le, 5886 sizeof(gtk_le)); 5887 if (ret < 0) 5888 bphy_err(drvr, "gtk_key_info iovar failed: ret=%d\n", ret); 5889 5890 return ret; 5891 } 5892 #endif 5893 5894 static int brcmf_cfg80211_set_pmk(struct wiphy *wiphy, struct net_device *dev, 5895 const struct cfg80211_pmk_conf *conf) 5896 { 5897 struct brcmf_if *ifp; 5898 5899 brcmf_dbg(TRACE, "enter\n"); 5900 5901 /* expect using firmware supplicant for 1X */ 5902 ifp = netdev_priv(dev); 5903 if (WARN_ON(ifp->vif->profile.use_fwsup != BRCMF_PROFILE_FWSUP_1X)) 5904 return -EINVAL; 5905 5906 if (conf->pmk_len > BRCMF_WSEC_MAX_PSK_LEN) 5907 return -ERANGE; 5908 5909 return brcmf_set_pmk(ifp, conf->pmk, conf->pmk_len); 5910 } 5911 5912 static int brcmf_cfg80211_del_pmk(struct wiphy *wiphy, struct net_device *dev, 5913 const u8 *aa) 5914 { 5915 struct brcmf_if *ifp; 5916 5917 brcmf_dbg(TRACE, "enter\n"); 5918 ifp = netdev_priv(dev); 5919 if (WARN_ON(ifp->vif->profile.use_fwsup != BRCMF_PROFILE_FWSUP_1X)) 5920 return -EINVAL; 5921 5922 return brcmf_set_pmk(ifp, NULL, 0); 5923 } 5924 5925 static struct cfg80211_ops brcmf_cfg80211_ops = { 5926 .add_virtual_intf = brcmf_cfg80211_add_iface, 5927 .del_virtual_intf = brcmf_cfg80211_del_iface, 5928 .change_virtual_intf = brcmf_cfg80211_change_iface, 5929 .scan = brcmf_cfg80211_scan, 5930 .set_wiphy_params = brcmf_cfg80211_set_wiphy_params, 5931 .join_ibss = brcmf_cfg80211_join_ibss, 5932 .leave_ibss = brcmf_cfg80211_leave_ibss, 5933 .get_station = brcmf_cfg80211_get_station, 5934 .dump_station = brcmf_cfg80211_dump_station, 5935 .set_tx_power = brcmf_cfg80211_set_tx_power, 5936 .get_tx_power = brcmf_cfg80211_get_tx_power, 5937 .add_key = brcmf_cfg80211_add_key, 5938 .del_key = brcmf_cfg80211_del_key, 5939 .get_key = brcmf_cfg80211_get_key, 5940 .set_default_key = brcmf_cfg80211_config_default_key, 5941 .set_default_mgmt_key = brcmf_cfg80211_config_default_mgmt_key, 5942 .set_power_mgmt = brcmf_cfg80211_set_power_mgmt, 5943 .connect = brcmf_cfg80211_connect, 5944 .disconnect = brcmf_cfg80211_disconnect, 5945 .suspend = brcmf_cfg80211_suspend, 5946 .resume = brcmf_cfg80211_resume, 5947 .set_pmksa = brcmf_cfg80211_set_pmksa, 5948 .del_pmksa = brcmf_cfg80211_del_pmksa, 5949 .flush_pmksa = brcmf_cfg80211_flush_pmksa, 5950 .start_ap = brcmf_cfg80211_start_ap, 5951 .stop_ap = brcmf_cfg80211_stop_ap, 5952 .change_beacon = brcmf_cfg80211_change_beacon, 5953 .del_station = brcmf_cfg80211_del_station, 5954 .change_station = brcmf_cfg80211_change_station, 5955 .sched_scan_start = brcmf_cfg80211_sched_scan_start, 5956 .sched_scan_stop = brcmf_cfg80211_sched_scan_stop, 5957 .update_mgmt_frame_registrations = 5958 brcmf_cfg80211_update_mgmt_frame_registrations, 5959 .mgmt_tx = brcmf_cfg80211_mgmt_tx, 5960 .set_cqm_rssi_range_config = brcmf_cfg80211_set_cqm_rssi_range_config, 5961 .remain_on_channel = brcmf_p2p_remain_on_channel, 5962 .cancel_remain_on_channel = brcmf_cfg80211_cancel_remain_on_channel, 5963 .get_channel = brcmf_cfg80211_get_channel, 5964 .start_p2p_device = brcmf_p2p_start_device, 5965 .stop_p2p_device = brcmf_p2p_stop_device, 5966 .crit_proto_start = brcmf_cfg80211_crit_proto_start, 5967 .crit_proto_stop = brcmf_cfg80211_crit_proto_stop, 5968 .tdls_oper = brcmf_cfg80211_tdls_oper, 5969 .update_connect_params = brcmf_cfg80211_update_conn_params, 5970 .set_pmk = brcmf_cfg80211_set_pmk, 5971 .del_pmk = brcmf_cfg80211_del_pmk, 5972 }; 5973 5974 struct cfg80211_ops *brcmf_cfg80211_get_ops(struct brcmf_mp_device *settings) 5975 { 5976 struct cfg80211_ops *ops; 5977 5978 ops = kmemdup(&brcmf_cfg80211_ops, sizeof(brcmf_cfg80211_ops), 5979 GFP_KERNEL); 5980 5981 if (ops && settings->roamoff) 5982 ops->update_connect_params = NULL; 5983 5984 return ops; 5985 } 5986 5987 struct brcmf_cfg80211_vif *brcmf_alloc_vif(struct brcmf_cfg80211_info *cfg, 5988 enum nl80211_iftype type) 5989 { 5990 struct brcmf_cfg80211_vif *vif_walk; 5991 struct brcmf_cfg80211_vif *vif; 5992 bool mbss; 5993 struct brcmf_if *ifp = brcmf_get_ifp(cfg->pub, 0); 5994 5995 brcmf_dbg(TRACE, "allocating virtual interface (size=%zu)\n", 5996 sizeof(*vif)); 5997 vif = kzalloc(sizeof(*vif), GFP_KERNEL); 5998 if (!vif) 5999 return ERR_PTR(-ENOMEM); 6000 6001 vif->wdev.wiphy = cfg->wiphy; 6002 vif->wdev.iftype = type; 6003 6004 brcmf_init_prof(&vif->profile); 6005 6006 if (type == NL80211_IFTYPE_AP && 6007 brcmf_feat_is_enabled(ifp, BRCMF_FEAT_MBSS)) { 6008 mbss = false; 6009 list_for_each_entry(vif_walk, &cfg->vif_list, list) { 6010 if (vif_walk->wdev.iftype == NL80211_IFTYPE_AP) { 6011 mbss = true; 6012 break; 6013 } 6014 } 6015 vif->mbss = mbss; 6016 } 6017 6018 list_add_tail(&vif->list, &cfg->vif_list); 6019 return vif; 6020 } 6021 6022 void brcmf_free_vif(struct brcmf_cfg80211_vif *vif) 6023 { 6024 list_del(&vif->list); 6025 kfree(vif); 6026 } 6027 6028 void brcmf_cfg80211_free_netdev(struct net_device *ndev) 6029 { 6030 struct brcmf_cfg80211_vif *vif; 6031 struct brcmf_if *ifp; 6032 6033 ifp = netdev_priv(ndev); 6034 vif = ifp->vif; 6035 6036 if (vif) 6037 brcmf_free_vif(vif); 6038 } 6039 6040 static bool brcmf_is_linkup(struct brcmf_cfg80211_vif *vif, 6041 const struct brcmf_event_msg *e) 6042 { 6043 u32 event = e->event_code; 6044 u32 status = e->status; 6045 6046 if ((vif->profile.use_fwsup == BRCMF_PROFILE_FWSUP_PSK || 6047 vif->profile.use_fwsup == BRCMF_PROFILE_FWSUP_SAE) && 6048 event == BRCMF_E_PSK_SUP && 6049 status == BRCMF_E_STATUS_FWSUP_COMPLETED) 6050 set_bit(BRCMF_VIF_STATUS_EAP_SUCCESS, &vif->sme_state); 6051 if (event == BRCMF_E_SET_SSID && status == BRCMF_E_STATUS_SUCCESS) { 6052 brcmf_dbg(CONN, "Processing set ssid\n"); 6053 memcpy(vif->profile.bssid, e->addr, ETH_ALEN); 6054 if (vif->profile.use_fwsup != BRCMF_PROFILE_FWSUP_PSK && 6055 vif->profile.use_fwsup != BRCMF_PROFILE_FWSUP_SAE) 6056 return true; 6057 6058 set_bit(BRCMF_VIF_STATUS_ASSOC_SUCCESS, &vif->sme_state); 6059 } 6060 6061 if (test_bit(BRCMF_VIF_STATUS_EAP_SUCCESS, &vif->sme_state) && 6062 test_bit(BRCMF_VIF_STATUS_ASSOC_SUCCESS, &vif->sme_state)) { 6063 clear_bit(BRCMF_VIF_STATUS_EAP_SUCCESS, &vif->sme_state); 6064 clear_bit(BRCMF_VIF_STATUS_ASSOC_SUCCESS, &vif->sme_state); 6065 return true; 6066 } 6067 return false; 6068 } 6069 6070 static bool brcmf_is_linkdown(struct brcmf_cfg80211_vif *vif, 6071 const struct brcmf_event_msg *e) 6072 { 6073 u32 event = e->event_code; 6074 u16 flags = e->flags; 6075 6076 if ((event == BRCMF_E_DEAUTH) || (event == BRCMF_E_DEAUTH_IND) || 6077 (event == BRCMF_E_DISASSOC_IND) || 6078 ((event == BRCMF_E_LINK) && (!(flags & BRCMF_EVENT_MSG_LINK)))) { 6079 brcmf_dbg(CONN, "Processing link down\n"); 6080 clear_bit(BRCMF_VIF_STATUS_EAP_SUCCESS, &vif->sme_state); 6081 clear_bit(BRCMF_VIF_STATUS_ASSOC_SUCCESS, &vif->sme_state); 6082 return true; 6083 } 6084 return false; 6085 } 6086 6087 static bool brcmf_is_nonetwork(struct brcmf_cfg80211_info *cfg, 6088 const struct brcmf_event_msg *e) 6089 { 6090 u32 event = e->event_code; 6091 u32 status = e->status; 6092 6093 if (event == BRCMF_E_LINK && status == BRCMF_E_STATUS_NO_NETWORKS) { 6094 brcmf_dbg(CONN, "Processing Link %s & no network found\n", 6095 e->flags & BRCMF_EVENT_MSG_LINK ? "up" : "down"); 6096 return true; 6097 } 6098 6099 if (event == BRCMF_E_SET_SSID && status != BRCMF_E_STATUS_SUCCESS) { 6100 brcmf_dbg(CONN, "Processing connecting & no network found\n"); 6101 return true; 6102 } 6103 6104 if (event == BRCMF_E_PSK_SUP && 6105 status != BRCMF_E_STATUS_FWSUP_COMPLETED) { 6106 brcmf_dbg(CONN, "Processing failed supplicant state: %u\n", 6107 status); 6108 return true; 6109 } 6110 6111 return false; 6112 } 6113 6114 static void brcmf_clear_assoc_ies(struct brcmf_cfg80211_info *cfg) 6115 { 6116 struct brcmf_cfg80211_connect_info *conn_info = cfg_to_conn(cfg); 6117 6118 kfree(conn_info->req_ie); 6119 conn_info->req_ie = NULL; 6120 conn_info->req_ie_len = 0; 6121 kfree(conn_info->resp_ie); 6122 conn_info->resp_ie = NULL; 6123 conn_info->resp_ie_len = 0; 6124 } 6125 6126 u8 brcmf_map_prio_to_prec(void *config, u8 prio) 6127 { 6128 struct brcmf_cfg80211_info *cfg = (struct brcmf_cfg80211_info *)config; 6129 6130 if (!cfg) 6131 return (prio == PRIO_8021D_NONE || prio == PRIO_8021D_BE) ? 6132 (prio ^ 2) : prio; 6133 6134 /* For those AC(s) with ACM flag set to 1, convert its 4-level priority 6135 * to an 8-level precedence which is the same as BE's 6136 */ 6137 if (prio > PRIO_8021D_EE && 6138 cfg->ac_priority[prio] == cfg->ac_priority[PRIO_8021D_BE]) 6139 return cfg->ac_priority[prio] * 2; 6140 6141 /* Conversion of 4-level priority to 8-level precedence */ 6142 if (prio == PRIO_8021D_BE || prio == PRIO_8021D_BK || 6143 prio == PRIO_8021D_CL || prio == PRIO_8021D_VO) 6144 return cfg->ac_priority[prio] * 2; 6145 else 6146 return cfg->ac_priority[prio] * 2 + 1; 6147 } 6148 6149 u8 brcmf_map_prio_to_aci(void *config, u8 prio) 6150 { 6151 /* Prio here refers to the 802.1d priority in range of 0 to 7. 6152 * ACI here refers to the WLAN AC Index in range of 0 to 3. 6153 * This function will return ACI corresponding to input prio. 6154 */ 6155 struct brcmf_cfg80211_info *cfg = (struct brcmf_cfg80211_info *)config; 6156 6157 if (cfg) 6158 return cfg->ac_priority[prio]; 6159 6160 return prio; 6161 } 6162 6163 static void brcmf_init_wmm_prio(u8 *priority) 6164 { 6165 /* Initialize AC priority array to default 6166 * 802.1d priority as per following table: 6167 * 802.1d prio 0,3 maps to BE 6168 * 802.1d prio 1,2 maps to BK 6169 * 802.1d prio 4,5 maps to VI 6170 * 802.1d prio 6,7 maps to VO 6171 */ 6172 priority[0] = BRCMF_FWS_FIFO_AC_BE; 6173 priority[3] = BRCMF_FWS_FIFO_AC_BE; 6174 priority[1] = BRCMF_FWS_FIFO_AC_BK; 6175 priority[2] = BRCMF_FWS_FIFO_AC_BK; 6176 priority[4] = BRCMF_FWS_FIFO_AC_VI; 6177 priority[5] = BRCMF_FWS_FIFO_AC_VI; 6178 priority[6] = BRCMF_FWS_FIFO_AC_VO; 6179 priority[7] = BRCMF_FWS_FIFO_AC_VO; 6180 } 6181 6182 static void brcmf_wifi_prioritize_acparams(const 6183 struct brcmf_cfg80211_edcf_acparam *acp, u8 *priority) 6184 { 6185 u8 aci; 6186 u8 aifsn; 6187 u8 ecwmin; 6188 u8 ecwmax; 6189 u8 acm; 6190 u8 ranking_basis[EDCF_AC_COUNT]; 6191 u8 aci_prio[EDCF_AC_COUNT]; /* AC_BE, AC_BK, AC_VI, AC_VO */ 6192 u8 index; 6193 6194 for (aci = 0; aci < EDCF_AC_COUNT; aci++, acp++) { 6195 aifsn = acp->ACI & EDCF_AIFSN_MASK; 6196 acm = (acp->ACI & EDCF_ACM_MASK) ? 1 : 0; 6197 ecwmin = acp->ECW & EDCF_ECWMIN_MASK; 6198 ecwmax = (acp->ECW & EDCF_ECWMAX_MASK) >> EDCF_ECWMAX_SHIFT; 6199 brcmf_dbg(CONN, "ACI %d aifsn %d acm %d ecwmin %d ecwmax %d\n", 6200 aci, aifsn, acm, ecwmin, ecwmax); 6201 /* Default AC_VO will be the lowest ranking value */ 6202 ranking_basis[aci] = aifsn + ecwmin + ecwmax; 6203 /* Initialise priority starting at 0 (AC_BE) */ 6204 aci_prio[aci] = 0; 6205 6206 /* If ACM is set, STA can't use this AC as per 802.11. 6207 * Change the ranking to BE 6208 */ 6209 if (aci != AC_BE && aci != AC_BK && acm == 1) 6210 ranking_basis[aci] = ranking_basis[AC_BE]; 6211 } 6212 6213 /* Ranking method which works for AC priority 6214 * swapping when values for cwmin, cwmax and aifsn are varied 6215 * Compare each aci_prio against each other aci_prio 6216 */ 6217 for (aci = 0; aci < EDCF_AC_COUNT; aci++) { 6218 for (index = 0; index < EDCF_AC_COUNT; index++) { 6219 if (index != aci) { 6220 /* Smaller ranking value has higher priority, 6221 * so increment priority for each ACI which has 6222 * a higher ranking value 6223 */ 6224 if (ranking_basis[aci] < ranking_basis[index]) 6225 aci_prio[aci]++; 6226 } 6227 } 6228 } 6229 6230 /* By now, aci_prio[] will be in range of 0 to 3. 6231 * Use ACI prio to get the new priority value for 6232 * each 802.1d traffic type, in this range. 6233 */ 6234 if (!(aci_prio[AC_BE] == aci_prio[AC_BK] && 6235 aci_prio[AC_BK] == aci_prio[AC_VI] && 6236 aci_prio[AC_VI] == aci_prio[AC_VO])) { 6237 /* 802.1d 0,3 maps to BE */ 6238 priority[0] = aci_prio[AC_BE]; 6239 priority[3] = aci_prio[AC_BE]; 6240 6241 /* 802.1d 1,2 maps to BK */ 6242 priority[1] = aci_prio[AC_BK]; 6243 priority[2] = aci_prio[AC_BK]; 6244 6245 /* 802.1d 4,5 maps to VO */ 6246 priority[4] = aci_prio[AC_VI]; 6247 priority[5] = aci_prio[AC_VI]; 6248 6249 /* 802.1d 6,7 maps to VO */ 6250 priority[6] = aci_prio[AC_VO]; 6251 priority[7] = aci_prio[AC_VO]; 6252 } else { 6253 /* Initialize to default priority */ 6254 brcmf_init_wmm_prio(priority); 6255 } 6256 6257 brcmf_dbg(CONN, "Adj prio BE 0->%d, BK 1->%d, BK 2->%d, BE 3->%d\n", 6258 priority[0], priority[1], priority[2], priority[3]); 6259 6260 brcmf_dbg(CONN, "Adj prio VI 4->%d, VI 5->%d, VO 6->%d, VO 7->%d\n", 6261 priority[4], priority[5], priority[6], priority[7]); 6262 } 6263 6264 static s32 brcmf_get_assoc_ies(struct brcmf_cfg80211_info *cfg, 6265 struct brcmf_if *ifp) 6266 { 6267 struct brcmf_pub *drvr = cfg->pub; 6268 struct brcmf_cfg80211_assoc_ielen_le *assoc_info; 6269 struct brcmf_cfg80211_connect_info *conn_info = cfg_to_conn(cfg); 6270 struct brcmf_cfg80211_edcf_acparam edcf_acparam_info[EDCF_AC_COUNT]; 6271 u32 req_len; 6272 u32 resp_len; 6273 s32 err = 0; 6274 6275 brcmf_clear_assoc_ies(cfg); 6276 6277 err = brcmf_fil_iovar_data_get(ifp, "assoc_info", 6278 cfg->extra_buf, WL_ASSOC_INFO_MAX); 6279 if (err) { 6280 bphy_err(drvr, "could not get assoc info (%d)\n", err); 6281 return err; 6282 } 6283 assoc_info = 6284 (struct brcmf_cfg80211_assoc_ielen_le *)cfg->extra_buf; 6285 req_len = le32_to_cpu(assoc_info->req_len); 6286 resp_len = le32_to_cpu(assoc_info->resp_len); 6287 if (req_len > WL_EXTRA_BUF_MAX || resp_len > WL_EXTRA_BUF_MAX) { 6288 bphy_err(drvr, "invalid lengths in assoc info: req %u resp %u\n", 6289 req_len, resp_len); 6290 return -EINVAL; 6291 } 6292 if (req_len) { 6293 err = brcmf_fil_iovar_data_get(ifp, "assoc_req_ies", 6294 cfg->extra_buf, 6295 WL_ASSOC_INFO_MAX); 6296 if (err) { 6297 bphy_err(drvr, "could not get assoc req (%d)\n", err); 6298 return err; 6299 } 6300 conn_info->req_ie_len = req_len; 6301 conn_info->req_ie = 6302 kmemdup(cfg->extra_buf, conn_info->req_ie_len, 6303 GFP_KERNEL); 6304 if (!conn_info->req_ie) 6305 conn_info->req_ie_len = 0; 6306 } else { 6307 conn_info->req_ie_len = 0; 6308 conn_info->req_ie = NULL; 6309 } 6310 if (resp_len) { 6311 err = brcmf_fil_iovar_data_get(ifp, "assoc_resp_ies", 6312 cfg->extra_buf, 6313 WL_ASSOC_INFO_MAX); 6314 if (err) { 6315 bphy_err(drvr, "could not get assoc resp (%d)\n", err); 6316 return err; 6317 } 6318 conn_info->resp_ie_len = resp_len; 6319 conn_info->resp_ie = 6320 kmemdup(cfg->extra_buf, conn_info->resp_ie_len, 6321 GFP_KERNEL); 6322 if (!conn_info->resp_ie) 6323 conn_info->resp_ie_len = 0; 6324 6325 err = brcmf_fil_iovar_data_get(ifp, "wme_ac_sta", 6326 edcf_acparam_info, 6327 sizeof(edcf_acparam_info)); 6328 if (err) { 6329 brcmf_err("could not get wme_ac_sta (%d)\n", err); 6330 return err; 6331 } 6332 6333 brcmf_wifi_prioritize_acparams(edcf_acparam_info, 6334 cfg->ac_priority); 6335 } else { 6336 conn_info->resp_ie_len = 0; 6337 conn_info->resp_ie = NULL; 6338 } 6339 brcmf_dbg(CONN, "req len (%d) resp len (%d)\n", 6340 conn_info->req_ie_len, conn_info->resp_ie_len); 6341 6342 return err; 6343 } 6344 6345 static s32 6346 brcmf_bss_roaming_done(struct brcmf_cfg80211_info *cfg, 6347 struct net_device *ndev, 6348 const struct brcmf_event_msg *e) 6349 { 6350 struct brcmf_if *ifp = netdev_priv(ndev); 6351 struct brcmf_cfg80211_profile *profile = &ifp->vif->profile; 6352 struct brcmf_cfg80211_connect_info *conn_info = cfg_to_conn(cfg); 6353 struct wiphy *wiphy = cfg_to_wiphy(cfg); 6354 struct ieee80211_channel *notify_channel = NULL; 6355 struct ieee80211_supported_band *band; 6356 struct brcmf_bss_info_le *bi; 6357 struct brcmu_chan ch; 6358 struct cfg80211_roam_info roam_info = {}; 6359 u32 freq; 6360 s32 err = 0; 6361 u8 *buf; 6362 6363 brcmf_dbg(TRACE, "Enter\n"); 6364 6365 brcmf_get_assoc_ies(cfg, ifp); 6366 memcpy(profile->bssid, e->addr, ETH_ALEN); 6367 brcmf_update_bss_info(cfg, ifp); 6368 6369 buf = kzalloc(WL_BSS_INFO_MAX, GFP_KERNEL); 6370 if (buf == NULL) { 6371 err = -ENOMEM; 6372 goto done; 6373 } 6374 6375 /* data sent to dongle has to be little endian */ 6376 *(__le32 *)buf = cpu_to_le32(WL_BSS_INFO_MAX); 6377 err = brcmf_fil_cmd_data_get(ifp, BRCMF_C_GET_BSS_INFO, 6378 buf, WL_BSS_INFO_MAX); 6379 6380 if (err) 6381 goto done; 6382 6383 bi = (struct brcmf_bss_info_le *)(buf + 4); 6384 ch.chspec = le16_to_cpu(bi->chanspec); 6385 cfg->d11inf.decchspec(&ch); 6386 6387 if (ch.band == BRCMU_CHAN_BAND_2G) 6388 band = wiphy->bands[NL80211_BAND_2GHZ]; 6389 else 6390 band = wiphy->bands[NL80211_BAND_5GHZ]; 6391 6392 freq = ieee80211_channel_to_frequency(ch.control_ch_num, band->band); 6393 notify_channel = ieee80211_get_channel(wiphy, freq); 6394 6395 done: 6396 kfree(buf); 6397 6398 roam_info.links[0].channel = notify_channel; 6399 roam_info.links[0].bssid = profile->bssid; 6400 roam_info.req_ie = conn_info->req_ie; 6401 roam_info.req_ie_len = conn_info->req_ie_len; 6402 roam_info.resp_ie = conn_info->resp_ie; 6403 roam_info.resp_ie_len = conn_info->resp_ie_len; 6404 6405 cfg80211_roamed(ndev, &roam_info, GFP_KERNEL); 6406 brcmf_dbg(CONN, "Report roaming result\n"); 6407 6408 if (profile->use_fwsup == BRCMF_PROFILE_FWSUP_1X && profile->is_ft) { 6409 cfg80211_port_authorized(ndev, profile->bssid, NULL, 0, GFP_KERNEL); 6410 brcmf_dbg(CONN, "Report port authorized\n"); 6411 } 6412 6413 set_bit(BRCMF_VIF_STATUS_CONNECTED, &ifp->vif->sme_state); 6414 brcmf_dbg(TRACE, "Exit\n"); 6415 return err; 6416 } 6417 6418 static s32 6419 brcmf_bss_connect_done(struct brcmf_cfg80211_info *cfg, 6420 struct net_device *ndev, const struct brcmf_event_msg *e, 6421 bool completed) 6422 { 6423 struct brcmf_if *ifp = netdev_priv(ndev); 6424 struct brcmf_cfg80211_profile *profile = &ifp->vif->profile; 6425 struct brcmf_cfg80211_connect_info *conn_info = cfg_to_conn(cfg); 6426 struct cfg80211_connect_resp_params conn_params; 6427 6428 brcmf_dbg(TRACE, "Enter\n"); 6429 6430 if (test_and_clear_bit(BRCMF_VIF_STATUS_CONNECTING, 6431 &ifp->vif->sme_state)) { 6432 memset(&conn_params, 0, sizeof(conn_params)); 6433 if (completed) { 6434 brcmf_get_assoc_ies(cfg, ifp); 6435 brcmf_update_bss_info(cfg, ifp); 6436 set_bit(BRCMF_VIF_STATUS_CONNECTED, 6437 &ifp->vif->sme_state); 6438 conn_params.status = WLAN_STATUS_SUCCESS; 6439 } else { 6440 clear_bit(BRCMF_VIF_STATUS_EAP_SUCCESS, 6441 &ifp->vif->sme_state); 6442 clear_bit(BRCMF_VIF_STATUS_ASSOC_SUCCESS, 6443 &ifp->vif->sme_state); 6444 conn_params.status = WLAN_STATUS_AUTH_TIMEOUT; 6445 } 6446 conn_params.links[0].bssid = profile->bssid; 6447 conn_params.req_ie = conn_info->req_ie; 6448 conn_params.req_ie_len = conn_info->req_ie_len; 6449 conn_params.resp_ie = conn_info->resp_ie; 6450 conn_params.resp_ie_len = conn_info->resp_ie_len; 6451 cfg80211_connect_done(ndev, &conn_params, GFP_KERNEL); 6452 brcmf_dbg(CONN, "Report connect result - connection %s\n", 6453 completed ? "succeeded" : "failed"); 6454 } 6455 brcmf_dbg(TRACE, "Exit\n"); 6456 return 0; 6457 } 6458 6459 static s32 6460 brcmf_notify_connect_status_ap(struct brcmf_cfg80211_info *cfg, 6461 struct net_device *ndev, 6462 const struct brcmf_event_msg *e, void *data) 6463 { 6464 struct brcmf_pub *drvr = cfg->pub; 6465 static int generation; 6466 u32 event = e->event_code; 6467 u32 reason = e->reason; 6468 struct station_info *sinfo; 6469 6470 brcmf_dbg(CONN, "event %s (%u), reason %d\n", 6471 brcmf_fweh_event_name(event), event, reason); 6472 if (event == BRCMF_E_LINK && reason == BRCMF_E_REASON_LINK_BSSCFG_DIS && 6473 ndev != cfg_to_ndev(cfg)) { 6474 brcmf_dbg(CONN, "AP mode link down\n"); 6475 complete(&cfg->vif_disabled); 6476 return 0; 6477 } 6478 6479 if (((event == BRCMF_E_ASSOC_IND) || (event == BRCMF_E_REASSOC_IND)) && 6480 (reason == BRCMF_E_STATUS_SUCCESS)) { 6481 if (!data) { 6482 bphy_err(drvr, "No IEs present in ASSOC/REASSOC_IND\n"); 6483 return -EINVAL; 6484 } 6485 6486 sinfo = kzalloc(sizeof(*sinfo), GFP_KERNEL); 6487 if (!sinfo) 6488 return -ENOMEM; 6489 6490 sinfo->assoc_req_ies = data; 6491 sinfo->assoc_req_ies_len = e->datalen; 6492 generation++; 6493 sinfo->generation = generation; 6494 cfg80211_new_sta(ndev, e->addr, sinfo, GFP_KERNEL); 6495 6496 kfree(sinfo); 6497 } else if ((event == BRCMF_E_DISASSOC_IND) || 6498 (event == BRCMF_E_DEAUTH_IND) || 6499 (event == BRCMF_E_DEAUTH)) { 6500 cfg80211_del_sta(ndev, e->addr, GFP_KERNEL); 6501 } 6502 return 0; 6503 } 6504 6505 static s32 6506 brcmf_notify_connect_status(struct brcmf_if *ifp, 6507 const struct brcmf_event_msg *e, void *data) 6508 { 6509 struct brcmf_cfg80211_info *cfg = ifp->drvr->config; 6510 struct net_device *ndev = ifp->ndev; 6511 struct brcmf_cfg80211_profile *profile = &ifp->vif->profile; 6512 struct ieee80211_channel *chan; 6513 s32 err = 0; 6514 6515 if ((e->event_code == BRCMF_E_DEAUTH) || 6516 (e->event_code == BRCMF_E_DEAUTH_IND) || 6517 (e->event_code == BRCMF_E_DISASSOC_IND) || 6518 ((e->event_code == BRCMF_E_LINK) && (!e->flags))) { 6519 brcmf_proto_delete_peer(ifp->drvr, ifp->ifidx, (u8 *)e->addr); 6520 } 6521 6522 if (brcmf_is_apmode(ifp->vif)) { 6523 err = brcmf_notify_connect_status_ap(cfg, ndev, e, data); 6524 } else if (brcmf_is_linkup(ifp->vif, e)) { 6525 brcmf_dbg(CONN, "Linkup\n"); 6526 if (brcmf_is_ibssmode(ifp->vif)) { 6527 brcmf_inform_ibss(cfg, ndev, e->addr); 6528 chan = ieee80211_get_channel(cfg->wiphy, cfg->channel); 6529 memcpy(profile->bssid, e->addr, ETH_ALEN); 6530 cfg80211_ibss_joined(ndev, e->addr, chan, GFP_KERNEL); 6531 clear_bit(BRCMF_VIF_STATUS_CONNECTING, 6532 &ifp->vif->sme_state); 6533 set_bit(BRCMF_VIF_STATUS_CONNECTED, 6534 &ifp->vif->sme_state); 6535 } else 6536 brcmf_bss_connect_done(cfg, ndev, e, true); 6537 brcmf_net_setcarrier(ifp, true); 6538 } else if (brcmf_is_linkdown(ifp->vif, e)) { 6539 brcmf_dbg(CONN, "Linkdown\n"); 6540 if (!brcmf_is_ibssmode(ifp->vif) && 6541 (test_bit(BRCMF_VIF_STATUS_CONNECTED, 6542 &ifp->vif->sme_state) || 6543 test_bit(BRCMF_VIF_STATUS_CONNECTING, 6544 &ifp->vif->sme_state))) { 6545 if (test_bit(BRCMF_VIF_STATUS_CONNECTED, 6546 &ifp->vif->sme_state) && 6547 memcmp(profile->bssid, e->addr, ETH_ALEN)) 6548 return err; 6549 6550 brcmf_bss_connect_done(cfg, ndev, e, false); 6551 brcmf_link_down(ifp->vif, 6552 brcmf_map_fw_linkdown_reason(e), 6553 e->event_code & 6554 (BRCMF_E_DEAUTH_IND | 6555 BRCMF_E_DISASSOC_IND) 6556 ? false : true); 6557 brcmf_init_prof(ndev_to_prof(ndev)); 6558 if (ndev != cfg_to_ndev(cfg)) 6559 complete(&cfg->vif_disabled); 6560 brcmf_net_setcarrier(ifp, false); 6561 } 6562 } else if (brcmf_is_nonetwork(cfg, e)) { 6563 if (brcmf_is_ibssmode(ifp->vif)) 6564 clear_bit(BRCMF_VIF_STATUS_CONNECTING, 6565 &ifp->vif->sme_state); 6566 else 6567 brcmf_bss_connect_done(cfg, ndev, e, false); 6568 } 6569 6570 return err; 6571 } 6572 6573 static s32 6574 brcmf_notify_roaming_status(struct brcmf_if *ifp, 6575 const struct brcmf_event_msg *e, void *data) 6576 { 6577 struct brcmf_cfg80211_info *cfg = ifp->drvr->config; 6578 u32 event = e->event_code; 6579 u32 status = e->status; 6580 6581 if (event == BRCMF_E_ROAM && status == BRCMF_E_STATUS_SUCCESS) { 6582 if (test_bit(BRCMF_VIF_STATUS_CONNECTED, 6583 &ifp->vif->sme_state)) { 6584 brcmf_bss_roaming_done(cfg, ifp->ndev, e); 6585 } else { 6586 brcmf_bss_connect_done(cfg, ifp->ndev, e, true); 6587 brcmf_net_setcarrier(ifp, true); 6588 } 6589 } 6590 6591 return 0; 6592 } 6593 6594 static s32 6595 brcmf_notify_mic_status(struct brcmf_if *ifp, 6596 const struct brcmf_event_msg *e, void *data) 6597 { 6598 u16 flags = e->flags; 6599 enum nl80211_key_type key_type; 6600 6601 if (flags & BRCMF_EVENT_MSG_GROUP) 6602 key_type = NL80211_KEYTYPE_GROUP; 6603 else 6604 key_type = NL80211_KEYTYPE_PAIRWISE; 6605 6606 cfg80211_michael_mic_failure(ifp->ndev, (u8 *)&e->addr, key_type, -1, 6607 NULL, GFP_KERNEL); 6608 6609 return 0; 6610 } 6611 6612 static s32 brcmf_notify_rssi(struct brcmf_if *ifp, 6613 const struct brcmf_event_msg *e, void *data) 6614 { 6615 struct brcmf_cfg80211_vif *vif = ifp->vif; 6616 struct brcmf_rssi_be *info = data; 6617 s32 rssi, snr = 0, noise = 0; 6618 s32 low, high, last; 6619 6620 if (e->datalen >= sizeof(*info)) { 6621 rssi = be32_to_cpu(info->rssi); 6622 snr = be32_to_cpu(info->snr); 6623 noise = be32_to_cpu(info->noise); 6624 } else if (e->datalen >= sizeof(rssi)) { 6625 rssi = be32_to_cpu(*(__be32 *)data); 6626 } else { 6627 brcmf_err("insufficient RSSI event data\n"); 6628 return 0; 6629 } 6630 6631 low = vif->cqm_rssi_low; 6632 high = vif->cqm_rssi_high; 6633 last = vif->cqm_rssi_last; 6634 6635 brcmf_dbg(TRACE, "rssi=%d snr=%d noise=%d low=%d high=%d last=%d\n", 6636 rssi, snr, noise, low, high, last); 6637 6638 vif->cqm_rssi_last = rssi; 6639 6640 if (rssi <= low || rssi == 0) { 6641 brcmf_dbg(INFO, "LOW rssi=%d\n", rssi); 6642 cfg80211_cqm_rssi_notify(ifp->ndev, 6643 NL80211_CQM_RSSI_THRESHOLD_EVENT_LOW, 6644 rssi, GFP_KERNEL); 6645 } else if (rssi > high) { 6646 brcmf_dbg(INFO, "HIGH rssi=%d\n", rssi); 6647 cfg80211_cqm_rssi_notify(ifp->ndev, 6648 NL80211_CQM_RSSI_THRESHOLD_EVENT_HIGH, 6649 rssi, GFP_KERNEL); 6650 } 6651 6652 return 0; 6653 } 6654 6655 static s32 brcmf_notify_vif_event(struct brcmf_if *ifp, 6656 const struct brcmf_event_msg *e, void *data) 6657 { 6658 struct brcmf_cfg80211_info *cfg = ifp->drvr->config; 6659 struct brcmf_if_event *ifevent = (struct brcmf_if_event *)data; 6660 struct brcmf_cfg80211_vif_event *event = &cfg->vif_event; 6661 struct brcmf_cfg80211_vif *vif; 6662 6663 brcmf_dbg(TRACE, "Enter: action %u flags %u ifidx %u bsscfgidx %u\n", 6664 ifevent->action, ifevent->flags, ifevent->ifidx, 6665 ifevent->bsscfgidx); 6666 6667 spin_lock(&event->vif_event_lock); 6668 event->action = ifevent->action; 6669 vif = event->vif; 6670 6671 switch (ifevent->action) { 6672 case BRCMF_E_IF_ADD: 6673 /* waiting process may have timed out */ 6674 if (!cfg->vif_event.vif) { 6675 spin_unlock(&event->vif_event_lock); 6676 return -EBADF; 6677 } 6678 6679 ifp->vif = vif; 6680 vif->ifp = ifp; 6681 if (ifp->ndev) { 6682 vif->wdev.netdev = ifp->ndev; 6683 ifp->ndev->ieee80211_ptr = &vif->wdev; 6684 SET_NETDEV_DEV(ifp->ndev, wiphy_dev(cfg->wiphy)); 6685 } 6686 spin_unlock(&event->vif_event_lock); 6687 wake_up(&event->vif_wq); 6688 return 0; 6689 6690 case BRCMF_E_IF_DEL: 6691 spin_unlock(&event->vif_event_lock); 6692 /* event may not be upon user request */ 6693 if (brcmf_cfg80211_vif_event_armed(cfg)) 6694 wake_up(&event->vif_wq); 6695 return 0; 6696 6697 case BRCMF_E_IF_CHANGE: 6698 spin_unlock(&event->vif_event_lock); 6699 wake_up(&event->vif_wq); 6700 return 0; 6701 6702 default: 6703 spin_unlock(&event->vif_event_lock); 6704 break; 6705 } 6706 return -EINVAL; 6707 } 6708 6709 static void brcmf_init_conf(struct brcmf_cfg80211_conf *conf) 6710 { 6711 conf->frag_threshold = (u32)-1; 6712 conf->rts_threshold = (u32)-1; 6713 conf->retry_short = (u32)-1; 6714 conf->retry_long = (u32)-1; 6715 } 6716 6717 static void brcmf_register_event_handlers(struct brcmf_cfg80211_info *cfg) 6718 { 6719 brcmf_fweh_register(cfg->pub, BRCMF_E_LINK, 6720 brcmf_notify_connect_status); 6721 brcmf_fweh_register(cfg->pub, BRCMF_E_DEAUTH_IND, 6722 brcmf_notify_connect_status); 6723 brcmf_fweh_register(cfg->pub, BRCMF_E_DEAUTH, 6724 brcmf_notify_connect_status); 6725 brcmf_fweh_register(cfg->pub, BRCMF_E_DISASSOC_IND, 6726 brcmf_notify_connect_status); 6727 brcmf_fweh_register(cfg->pub, BRCMF_E_ASSOC_IND, 6728 brcmf_notify_connect_status); 6729 brcmf_fweh_register(cfg->pub, BRCMF_E_REASSOC_IND, 6730 brcmf_notify_connect_status); 6731 brcmf_fweh_register(cfg->pub, BRCMF_E_ROAM, 6732 brcmf_notify_roaming_status); 6733 brcmf_fweh_register(cfg->pub, BRCMF_E_MIC_ERROR, 6734 brcmf_notify_mic_status); 6735 brcmf_fweh_register(cfg->pub, BRCMF_E_SET_SSID, 6736 brcmf_notify_connect_status); 6737 brcmf_fweh_register(cfg->pub, BRCMF_E_PFN_NET_FOUND, 6738 brcmf_notify_sched_scan_results); 6739 brcmf_fweh_register(cfg->pub, BRCMF_E_IF, 6740 brcmf_notify_vif_event); 6741 brcmf_fweh_register(cfg->pub, BRCMF_E_P2P_PROBEREQ_MSG, 6742 brcmf_p2p_notify_rx_mgmt_p2p_probereq); 6743 brcmf_fweh_register(cfg->pub, BRCMF_E_P2P_DISC_LISTEN_COMPLETE, 6744 brcmf_p2p_notify_listen_complete); 6745 brcmf_fweh_register(cfg->pub, BRCMF_E_ACTION_FRAME_RX, 6746 brcmf_p2p_notify_action_frame_rx); 6747 brcmf_fweh_register(cfg->pub, BRCMF_E_ACTION_FRAME_COMPLETE, 6748 brcmf_p2p_notify_action_tx_complete); 6749 brcmf_fweh_register(cfg->pub, BRCMF_E_ACTION_FRAME_OFF_CHAN_COMPLETE, 6750 brcmf_p2p_notify_action_tx_complete); 6751 brcmf_fweh_register(cfg->pub, BRCMF_E_PSK_SUP, 6752 brcmf_notify_connect_status); 6753 brcmf_fweh_register(cfg->pub, BRCMF_E_RSSI, brcmf_notify_rssi); 6754 } 6755 6756 static void brcmf_deinit_priv_mem(struct brcmf_cfg80211_info *cfg) 6757 { 6758 kfree(cfg->conf); 6759 cfg->conf = NULL; 6760 kfree(cfg->extra_buf); 6761 cfg->extra_buf = NULL; 6762 kfree(cfg->wowl.nd); 6763 cfg->wowl.nd = NULL; 6764 kfree(cfg->wowl.nd_info); 6765 cfg->wowl.nd_info = NULL; 6766 kfree(cfg->escan_info.escan_buf); 6767 cfg->escan_info.escan_buf = NULL; 6768 } 6769 6770 static s32 brcmf_init_priv_mem(struct brcmf_cfg80211_info *cfg) 6771 { 6772 cfg->conf = kzalloc(sizeof(*cfg->conf), GFP_KERNEL); 6773 if (!cfg->conf) 6774 goto init_priv_mem_out; 6775 cfg->extra_buf = kzalloc(WL_EXTRA_BUF_MAX, GFP_KERNEL); 6776 if (!cfg->extra_buf) 6777 goto init_priv_mem_out; 6778 cfg->wowl.nd = kzalloc(sizeof(*cfg->wowl.nd) + sizeof(u32), GFP_KERNEL); 6779 if (!cfg->wowl.nd) 6780 goto init_priv_mem_out; 6781 cfg->wowl.nd_info = kzalloc(sizeof(*cfg->wowl.nd_info) + 6782 sizeof(struct cfg80211_wowlan_nd_match *), 6783 GFP_KERNEL); 6784 if (!cfg->wowl.nd_info) 6785 goto init_priv_mem_out; 6786 cfg->escan_info.escan_buf = kzalloc(BRCMF_ESCAN_BUF_SIZE, GFP_KERNEL); 6787 if (!cfg->escan_info.escan_buf) 6788 goto init_priv_mem_out; 6789 6790 return 0; 6791 6792 init_priv_mem_out: 6793 brcmf_deinit_priv_mem(cfg); 6794 6795 return -ENOMEM; 6796 } 6797 6798 static s32 wl_init_priv(struct brcmf_cfg80211_info *cfg) 6799 { 6800 s32 err = 0; 6801 6802 cfg->scan_request = NULL; 6803 cfg->pwr_save = true; 6804 cfg->dongle_up = false; /* dongle is not up yet */ 6805 err = brcmf_init_priv_mem(cfg); 6806 if (err) 6807 return err; 6808 brcmf_register_event_handlers(cfg); 6809 mutex_init(&cfg->usr_sync); 6810 brcmf_init_escan(cfg); 6811 brcmf_init_conf(cfg->conf); 6812 brcmf_init_wmm_prio(cfg->ac_priority); 6813 init_completion(&cfg->vif_disabled); 6814 return err; 6815 } 6816 6817 static void wl_deinit_priv(struct brcmf_cfg80211_info *cfg) 6818 { 6819 cfg->dongle_up = false; /* dongle down */ 6820 brcmf_abort_scanning(cfg); 6821 brcmf_deinit_priv_mem(cfg); 6822 brcmf_clear_assoc_ies(cfg); 6823 } 6824 6825 static void init_vif_event(struct brcmf_cfg80211_vif_event *event) 6826 { 6827 init_waitqueue_head(&event->vif_wq); 6828 spin_lock_init(&event->vif_event_lock); 6829 } 6830 6831 static s32 brcmf_dongle_roam(struct brcmf_if *ifp) 6832 { 6833 struct brcmf_pub *drvr = ifp->drvr; 6834 s32 err; 6835 u32 bcn_timeout; 6836 __le32 roamtrigger[2]; 6837 __le32 roam_delta[2]; 6838 6839 /* Configure beacon timeout value based upon roaming setting */ 6840 if (ifp->drvr->settings->roamoff) 6841 bcn_timeout = BRCMF_DEFAULT_BCN_TIMEOUT_ROAM_OFF; 6842 else 6843 bcn_timeout = BRCMF_DEFAULT_BCN_TIMEOUT_ROAM_ON; 6844 err = brcmf_fil_iovar_int_set(ifp, "bcn_timeout", bcn_timeout); 6845 if (err) { 6846 bphy_err(drvr, "bcn_timeout error (%d)\n", err); 6847 goto roam_setup_done; 6848 } 6849 6850 /* Enable/Disable built-in roaming to allow supplicant to take care of 6851 * roaming. 6852 */ 6853 brcmf_dbg(INFO, "Internal Roaming = %s\n", 6854 ifp->drvr->settings->roamoff ? "Off" : "On"); 6855 err = brcmf_fil_iovar_int_set(ifp, "roam_off", 6856 ifp->drvr->settings->roamoff); 6857 if (err) { 6858 bphy_err(drvr, "roam_off error (%d)\n", err); 6859 goto roam_setup_done; 6860 } 6861 6862 roamtrigger[0] = cpu_to_le32(WL_ROAM_TRIGGER_LEVEL); 6863 roamtrigger[1] = cpu_to_le32(BRCM_BAND_ALL); 6864 err = brcmf_fil_cmd_data_set(ifp, BRCMF_C_SET_ROAM_TRIGGER, 6865 (void *)roamtrigger, sizeof(roamtrigger)); 6866 if (err) 6867 bphy_err(drvr, "WLC_SET_ROAM_TRIGGER error (%d)\n", err); 6868 6869 roam_delta[0] = cpu_to_le32(WL_ROAM_DELTA); 6870 roam_delta[1] = cpu_to_le32(BRCM_BAND_ALL); 6871 err = brcmf_fil_cmd_data_set(ifp, BRCMF_C_SET_ROAM_DELTA, 6872 (void *)roam_delta, sizeof(roam_delta)); 6873 if (err) 6874 bphy_err(drvr, "WLC_SET_ROAM_DELTA error (%d)\n", err); 6875 6876 return 0; 6877 6878 roam_setup_done: 6879 return err; 6880 } 6881 6882 static s32 6883 brcmf_dongle_scantime(struct brcmf_if *ifp) 6884 { 6885 struct brcmf_pub *drvr = ifp->drvr; 6886 s32 err = 0; 6887 6888 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_SCAN_CHANNEL_TIME, 6889 BRCMF_SCAN_CHANNEL_TIME); 6890 if (err) { 6891 bphy_err(drvr, "Scan assoc time error (%d)\n", err); 6892 goto dongle_scantime_out; 6893 } 6894 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_SCAN_UNASSOC_TIME, 6895 BRCMF_SCAN_UNASSOC_TIME); 6896 if (err) { 6897 bphy_err(drvr, "Scan unassoc time error (%d)\n", err); 6898 goto dongle_scantime_out; 6899 } 6900 6901 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_SCAN_PASSIVE_TIME, 6902 BRCMF_SCAN_PASSIVE_TIME); 6903 if (err) { 6904 bphy_err(drvr, "Scan passive time error (%d)\n", err); 6905 goto dongle_scantime_out; 6906 } 6907 6908 dongle_scantime_out: 6909 return err; 6910 } 6911 6912 static void brcmf_update_bw40_channel_flag(struct ieee80211_channel *channel, 6913 struct brcmu_chan *ch) 6914 { 6915 u32 ht40_flag; 6916 6917 ht40_flag = channel->flags & IEEE80211_CHAN_NO_HT40; 6918 if (ch->sb == BRCMU_CHAN_SB_U) { 6919 if (ht40_flag == IEEE80211_CHAN_NO_HT40) 6920 channel->flags &= ~IEEE80211_CHAN_NO_HT40; 6921 channel->flags |= IEEE80211_CHAN_NO_HT40PLUS; 6922 } else { 6923 /* It should be one of 6924 * IEEE80211_CHAN_NO_HT40 or 6925 * IEEE80211_CHAN_NO_HT40PLUS 6926 */ 6927 channel->flags &= ~IEEE80211_CHAN_NO_HT40; 6928 if (ht40_flag == IEEE80211_CHAN_NO_HT40) 6929 channel->flags |= IEEE80211_CHAN_NO_HT40MINUS; 6930 } 6931 } 6932 6933 static int brcmf_construct_chaninfo(struct brcmf_cfg80211_info *cfg, 6934 u32 bw_cap[]) 6935 { 6936 struct wiphy *wiphy = cfg_to_wiphy(cfg); 6937 struct brcmf_pub *drvr = cfg->pub; 6938 struct brcmf_if *ifp = brcmf_get_ifp(drvr, 0); 6939 struct ieee80211_supported_band *band; 6940 struct ieee80211_channel *channel; 6941 struct brcmf_chanspec_list *list; 6942 struct brcmu_chan ch; 6943 int err; 6944 u8 *pbuf; 6945 u32 i, j; 6946 u32 total; 6947 u32 chaninfo; 6948 6949 pbuf = kzalloc(BRCMF_DCMD_MEDLEN, GFP_KERNEL); 6950 6951 if (pbuf == NULL) 6952 return -ENOMEM; 6953 6954 list = (struct brcmf_chanspec_list *)pbuf; 6955 6956 err = brcmf_fil_iovar_data_get(ifp, "chanspecs", pbuf, 6957 BRCMF_DCMD_MEDLEN); 6958 if (err) { 6959 bphy_err(drvr, "get chanspecs error (%d)\n", err); 6960 goto fail_pbuf; 6961 } 6962 6963 band = wiphy->bands[NL80211_BAND_2GHZ]; 6964 if (band) 6965 for (i = 0; i < band->n_channels; i++) 6966 band->channels[i].flags = IEEE80211_CHAN_DISABLED; 6967 band = wiphy->bands[NL80211_BAND_5GHZ]; 6968 if (band) 6969 for (i = 0; i < band->n_channels; i++) 6970 band->channels[i].flags = IEEE80211_CHAN_DISABLED; 6971 6972 total = le32_to_cpu(list->count); 6973 if (total > BRCMF_MAX_CHANSPEC_LIST) { 6974 bphy_err(drvr, "Invalid count of channel Spec. (%u)\n", 6975 total); 6976 err = -EINVAL; 6977 goto fail_pbuf; 6978 } 6979 6980 for (i = 0; i < total; i++) { 6981 ch.chspec = (u16)le32_to_cpu(list->element[i]); 6982 cfg->d11inf.decchspec(&ch); 6983 6984 if (ch.band == BRCMU_CHAN_BAND_2G) { 6985 band = wiphy->bands[NL80211_BAND_2GHZ]; 6986 } else if (ch.band == BRCMU_CHAN_BAND_5G) { 6987 band = wiphy->bands[NL80211_BAND_5GHZ]; 6988 } else { 6989 bphy_err(drvr, "Invalid channel Spec. 0x%x.\n", 6990 ch.chspec); 6991 continue; 6992 } 6993 if (!band) 6994 continue; 6995 if (!(bw_cap[band->band] & WLC_BW_40MHZ_BIT) && 6996 ch.bw == BRCMU_CHAN_BW_40) 6997 continue; 6998 if (!(bw_cap[band->band] & WLC_BW_80MHZ_BIT) && 6999 ch.bw == BRCMU_CHAN_BW_80) 7000 continue; 7001 7002 channel = NULL; 7003 for (j = 0; j < band->n_channels; j++) { 7004 if (band->channels[j].hw_value == ch.control_ch_num) { 7005 channel = &band->channels[j]; 7006 break; 7007 } 7008 } 7009 if (!channel) { 7010 /* It seems firmware supports some channel we never 7011 * considered. Something new in IEEE standard? 7012 */ 7013 bphy_err(drvr, "Ignoring unexpected firmware channel %d\n", 7014 ch.control_ch_num); 7015 continue; 7016 } 7017 7018 if (channel->orig_flags & IEEE80211_CHAN_DISABLED) 7019 continue; 7020 7021 /* assuming the chanspecs order is HT20, 7022 * HT40 upper, HT40 lower, and VHT80. 7023 */ 7024 switch (ch.bw) { 7025 case BRCMU_CHAN_BW_160: 7026 channel->flags &= ~IEEE80211_CHAN_NO_160MHZ; 7027 break; 7028 case BRCMU_CHAN_BW_80: 7029 channel->flags &= ~IEEE80211_CHAN_NO_80MHZ; 7030 break; 7031 case BRCMU_CHAN_BW_40: 7032 brcmf_update_bw40_channel_flag(channel, &ch); 7033 break; 7034 default: 7035 wiphy_warn(wiphy, "Firmware reported unsupported bandwidth %d\n", 7036 ch.bw); 7037 fallthrough; 7038 case BRCMU_CHAN_BW_20: 7039 /* enable the channel and disable other bandwidths 7040 * for now as mentioned order assure they are enabled 7041 * for subsequent chanspecs. 7042 */ 7043 channel->flags = IEEE80211_CHAN_NO_HT40 | 7044 IEEE80211_CHAN_NO_80MHZ | 7045 IEEE80211_CHAN_NO_160MHZ; 7046 ch.bw = BRCMU_CHAN_BW_20; 7047 cfg->d11inf.encchspec(&ch); 7048 chaninfo = ch.chspec; 7049 err = brcmf_fil_bsscfg_int_get(ifp, "per_chan_info", 7050 &chaninfo); 7051 if (!err) { 7052 if (chaninfo & WL_CHAN_RADAR) 7053 channel->flags |= 7054 (IEEE80211_CHAN_RADAR | 7055 IEEE80211_CHAN_NO_IR); 7056 if (chaninfo & WL_CHAN_PASSIVE) 7057 channel->flags |= 7058 IEEE80211_CHAN_NO_IR; 7059 } 7060 } 7061 } 7062 7063 fail_pbuf: 7064 kfree(pbuf); 7065 return err; 7066 } 7067 7068 static int brcmf_enable_bw40_2g(struct brcmf_cfg80211_info *cfg) 7069 { 7070 struct brcmf_pub *drvr = cfg->pub; 7071 struct brcmf_if *ifp = brcmf_get_ifp(drvr, 0); 7072 struct ieee80211_supported_band *band; 7073 struct brcmf_fil_bwcap_le band_bwcap; 7074 struct brcmf_chanspec_list *list; 7075 u8 *pbuf; 7076 u32 val; 7077 int err; 7078 struct brcmu_chan ch; 7079 u32 num_chan; 7080 int i, j; 7081 7082 /* verify support for bw_cap command */ 7083 val = WLC_BAND_5G; 7084 err = brcmf_fil_iovar_int_get(ifp, "bw_cap", &val); 7085 7086 if (!err) { 7087 /* only set 2G bandwidth using bw_cap command */ 7088 band_bwcap.band = cpu_to_le32(WLC_BAND_2G); 7089 band_bwcap.bw_cap = cpu_to_le32(WLC_BW_CAP_40MHZ); 7090 err = brcmf_fil_iovar_data_set(ifp, "bw_cap", &band_bwcap, 7091 sizeof(band_bwcap)); 7092 } else { 7093 brcmf_dbg(INFO, "fallback to mimo_bw_cap\n"); 7094 val = WLC_N_BW_40ALL; 7095 err = brcmf_fil_iovar_int_set(ifp, "mimo_bw_cap", val); 7096 } 7097 7098 if (!err) { 7099 /* update channel info in 2G band */ 7100 pbuf = kzalloc(BRCMF_DCMD_MEDLEN, GFP_KERNEL); 7101 7102 if (pbuf == NULL) 7103 return -ENOMEM; 7104 7105 ch.band = BRCMU_CHAN_BAND_2G; 7106 ch.bw = BRCMU_CHAN_BW_40; 7107 ch.sb = BRCMU_CHAN_SB_NONE; 7108 ch.chnum = 0; 7109 cfg->d11inf.encchspec(&ch); 7110 7111 /* pass encoded chanspec in query */ 7112 *(__le16 *)pbuf = cpu_to_le16(ch.chspec); 7113 7114 err = brcmf_fil_iovar_data_get(ifp, "chanspecs", pbuf, 7115 BRCMF_DCMD_MEDLEN); 7116 if (err) { 7117 bphy_err(drvr, "get chanspecs error (%d)\n", err); 7118 kfree(pbuf); 7119 return err; 7120 } 7121 7122 band = cfg_to_wiphy(cfg)->bands[NL80211_BAND_2GHZ]; 7123 list = (struct brcmf_chanspec_list *)pbuf; 7124 num_chan = le32_to_cpu(list->count); 7125 if (num_chan > BRCMF_MAX_CHANSPEC_LIST) { 7126 bphy_err(drvr, "Invalid count of channel Spec. (%u)\n", 7127 num_chan); 7128 kfree(pbuf); 7129 return -EINVAL; 7130 } 7131 7132 for (i = 0; i < num_chan; i++) { 7133 ch.chspec = (u16)le32_to_cpu(list->element[i]); 7134 cfg->d11inf.decchspec(&ch); 7135 if (WARN_ON(ch.band != BRCMU_CHAN_BAND_2G)) 7136 continue; 7137 if (WARN_ON(ch.bw != BRCMU_CHAN_BW_40)) 7138 continue; 7139 for (j = 0; j < band->n_channels; j++) { 7140 if (band->channels[j].hw_value == ch.control_ch_num) 7141 break; 7142 } 7143 if (WARN_ON(j == band->n_channels)) 7144 continue; 7145 7146 brcmf_update_bw40_channel_flag(&band->channels[j], &ch); 7147 } 7148 kfree(pbuf); 7149 } 7150 return err; 7151 } 7152 7153 static void brcmf_get_bwcap(struct brcmf_if *ifp, u32 bw_cap[]) 7154 { 7155 struct brcmf_pub *drvr = ifp->drvr; 7156 u32 band, mimo_bwcap; 7157 int err; 7158 7159 band = WLC_BAND_2G; 7160 err = brcmf_fil_iovar_int_get(ifp, "bw_cap", &band); 7161 if (!err) { 7162 bw_cap[NL80211_BAND_2GHZ] = band; 7163 band = WLC_BAND_5G; 7164 err = brcmf_fil_iovar_int_get(ifp, "bw_cap", &band); 7165 if (!err) { 7166 bw_cap[NL80211_BAND_5GHZ] = band; 7167 return; 7168 } 7169 WARN_ON(1); 7170 return; 7171 } 7172 brcmf_dbg(INFO, "fallback to mimo_bw_cap info\n"); 7173 mimo_bwcap = 0; 7174 err = brcmf_fil_iovar_int_get(ifp, "mimo_bw_cap", &mimo_bwcap); 7175 if (err) 7176 /* assume 20MHz if firmware does not give a clue */ 7177 mimo_bwcap = WLC_N_BW_20ALL; 7178 7179 switch (mimo_bwcap) { 7180 case WLC_N_BW_40ALL: 7181 bw_cap[NL80211_BAND_2GHZ] |= WLC_BW_40MHZ_BIT; 7182 fallthrough; 7183 case WLC_N_BW_20IN2G_40IN5G: 7184 bw_cap[NL80211_BAND_5GHZ] |= WLC_BW_40MHZ_BIT; 7185 fallthrough; 7186 case WLC_N_BW_20ALL: 7187 bw_cap[NL80211_BAND_2GHZ] |= WLC_BW_20MHZ_BIT; 7188 bw_cap[NL80211_BAND_5GHZ] |= WLC_BW_20MHZ_BIT; 7189 break; 7190 default: 7191 bphy_err(drvr, "invalid mimo_bw_cap value\n"); 7192 } 7193 } 7194 7195 static void brcmf_update_ht_cap(struct ieee80211_supported_band *band, 7196 u32 bw_cap[2], u32 nchain) 7197 { 7198 band->ht_cap.ht_supported = true; 7199 if (bw_cap[band->band] & WLC_BW_40MHZ_BIT) { 7200 band->ht_cap.cap |= IEEE80211_HT_CAP_SGI_40; 7201 band->ht_cap.cap |= IEEE80211_HT_CAP_SUP_WIDTH_20_40; 7202 } 7203 band->ht_cap.cap |= IEEE80211_HT_CAP_SGI_20; 7204 band->ht_cap.cap |= IEEE80211_HT_CAP_DSSSCCK40; 7205 band->ht_cap.ampdu_factor = IEEE80211_HT_MAX_AMPDU_64K; 7206 band->ht_cap.ampdu_density = IEEE80211_HT_MPDU_DENSITY_16; 7207 memset(band->ht_cap.mcs.rx_mask, 0xff, nchain); 7208 band->ht_cap.mcs.tx_params = IEEE80211_HT_MCS_TX_DEFINED; 7209 } 7210 7211 static __le16 brcmf_get_mcs_map(u32 nchain, enum ieee80211_vht_mcs_support supp) 7212 { 7213 u16 mcs_map; 7214 int i; 7215 7216 for (i = 0, mcs_map = 0xFFFF; i < nchain; i++) 7217 mcs_map = (mcs_map << 2) | supp; 7218 7219 return cpu_to_le16(mcs_map); 7220 } 7221 7222 static void brcmf_update_vht_cap(struct ieee80211_supported_band *band, 7223 u32 bw_cap[2], u32 nchain, u32 txstreams, 7224 u32 txbf_bfe_cap, u32 txbf_bfr_cap) 7225 { 7226 __le16 mcs_map; 7227 7228 /* not allowed in 2.4G band */ 7229 if (band->band == NL80211_BAND_2GHZ) 7230 return; 7231 7232 band->vht_cap.vht_supported = true; 7233 /* 80MHz is mandatory */ 7234 band->vht_cap.cap |= IEEE80211_VHT_CAP_SHORT_GI_80; 7235 if (bw_cap[band->band] & WLC_BW_160MHZ_BIT) { 7236 band->vht_cap.cap |= IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160MHZ; 7237 band->vht_cap.cap |= IEEE80211_VHT_CAP_SHORT_GI_160; 7238 } 7239 /* all support 256-QAM */ 7240 mcs_map = brcmf_get_mcs_map(nchain, IEEE80211_VHT_MCS_SUPPORT_0_9); 7241 band->vht_cap.vht_mcs.rx_mcs_map = mcs_map; 7242 band->vht_cap.vht_mcs.tx_mcs_map = mcs_map; 7243 7244 /* Beamforming support information */ 7245 if (txbf_bfe_cap & BRCMF_TXBF_SU_BFE_CAP) 7246 band->vht_cap.cap |= IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE; 7247 if (txbf_bfe_cap & BRCMF_TXBF_MU_BFE_CAP) 7248 band->vht_cap.cap |= IEEE80211_VHT_CAP_MU_BEAMFORMEE_CAPABLE; 7249 if (txbf_bfr_cap & BRCMF_TXBF_SU_BFR_CAP) 7250 band->vht_cap.cap |= IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE; 7251 if (txbf_bfr_cap & BRCMF_TXBF_MU_BFR_CAP) 7252 band->vht_cap.cap |= IEEE80211_VHT_CAP_MU_BEAMFORMER_CAPABLE; 7253 7254 if ((txbf_bfe_cap || txbf_bfr_cap) && (txstreams > 1)) { 7255 band->vht_cap.cap |= 7256 (2 << IEEE80211_VHT_CAP_BEAMFORMEE_STS_SHIFT); 7257 band->vht_cap.cap |= ((txstreams - 1) << 7258 IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_SHIFT); 7259 band->vht_cap.cap |= 7260 IEEE80211_VHT_CAP_VHT_LINK_ADAPTATION_VHT_MRQ_MFB; 7261 } 7262 } 7263 7264 static int brcmf_setup_wiphybands(struct brcmf_cfg80211_info *cfg) 7265 { 7266 struct brcmf_pub *drvr = cfg->pub; 7267 struct brcmf_if *ifp = brcmf_get_ifp(drvr, 0); 7268 struct wiphy *wiphy = cfg_to_wiphy(cfg); 7269 u32 nmode = 0; 7270 u32 vhtmode = 0; 7271 u32 bw_cap[2] = { WLC_BW_20MHZ_BIT, WLC_BW_20MHZ_BIT }; 7272 u32 rxchain = 0; 7273 u32 nchain; 7274 int err; 7275 s32 i; 7276 struct ieee80211_supported_band *band; 7277 u32 txstreams = 0; 7278 u32 txbf_bfe_cap = 0; 7279 u32 txbf_bfr_cap = 0; 7280 7281 (void)brcmf_fil_iovar_int_get(ifp, "vhtmode", &vhtmode); 7282 err = brcmf_fil_iovar_int_get(ifp, "nmode", &nmode); 7283 if (err) { 7284 bphy_err(drvr, "nmode error (%d)\n", err); 7285 } else { 7286 brcmf_get_bwcap(ifp, bw_cap); 7287 } 7288 brcmf_dbg(INFO, "nmode=%d, vhtmode=%d, bw_cap=(%d, %d)\n", 7289 nmode, vhtmode, bw_cap[NL80211_BAND_2GHZ], 7290 bw_cap[NL80211_BAND_5GHZ]); 7291 7292 err = brcmf_fil_iovar_int_get(ifp, "rxchain", &rxchain); 7293 if (err) { 7294 /* rxchain unsupported by firmware of older chips */ 7295 if (err == -EBADE) 7296 bphy_info_once(drvr, "rxchain unsupported\n"); 7297 else 7298 bphy_err(drvr, "rxchain error (%d)\n", err); 7299 7300 nchain = 1; 7301 } else { 7302 for (nchain = 0; rxchain; nchain++) 7303 rxchain = rxchain & (rxchain - 1); 7304 } 7305 brcmf_dbg(INFO, "nchain=%d\n", nchain); 7306 7307 err = brcmf_construct_chaninfo(cfg, bw_cap); 7308 if (err) { 7309 bphy_err(drvr, "brcmf_construct_chaninfo failed (%d)\n", err); 7310 return err; 7311 } 7312 7313 if (vhtmode) { 7314 (void)brcmf_fil_iovar_int_get(ifp, "txstreams", &txstreams); 7315 (void)brcmf_fil_iovar_int_get(ifp, "txbf_bfe_cap", 7316 &txbf_bfe_cap); 7317 (void)brcmf_fil_iovar_int_get(ifp, "txbf_bfr_cap", 7318 &txbf_bfr_cap); 7319 } 7320 7321 for (i = 0; i < ARRAY_SIZE(wiphy->bands); i++) { 7322 band = wiphy->bands[i]; 7323 if (band == NULL) 7324 continue; 7325 7326 if (nmode) 7327 brcmf_update_ht_cap(band, bw_cap, nchain); 7328 if (vhtmode) 7329 brcmf_update_vht_cap(band, bw_cap, nchain, txstreams, 7330 txbf_bfe_cap, txbf_bfr_cap); 7331 } 7332 7333 return 0; 7334 } 7335 7336 static const struct ieee80211_txrx_stypes 7337 brcmf_txrx_stypes[NUM_NL80211_IFTYPES] = { 7338 [NL80211_IFTYPE_STATION] = { 7339 .tx = 0xffff, 7340 .rx = BIT(IEEE80211_STYPE_ACTION >> 4) | 7341 BIT(IEEE80211_STYPE_PROBE_REQ >> 4) 7342 }, 7343 [NL80211_IFTYPE_P2P_CLIENT] = { 7344 .tx = 0xffff, 7345 .rx = BIT(IEEE80211_STYPE_ACTION >> 4) | 7346 BIT(IEEE80211_STYPE_PROBE_REQ >> 4) 7347 }, 7348 [NL80211_IFTYPE_P2P_GO] = { 7349 .tx = 0xffff, 7350 .rx = BIT(IEEE80211_STYPE_ASSOC_REQ >> 4) | 7351 BIT(IEEE80211_STYPE_REASSOC_REQ >> 4) | 7352 BIT(IEEE80211_STYPE_PROBE_REQ >> 4) | 7353 BIT(IEEE80211_STYPE_DISASSOC >> 4) | 7354 BIT(IEEE80211_STYPE_AUTH >> 4) | 7355 BIT(IEEE80211_STYPE_DEAUTH >> 4) | 7356 BIT(IEEE80211_STYPE_ACTION >> 4) 7357 }, 7358 [NL80211_IFTYPE_P2P_DEVICE] = { 7359 .tx = 0xffff, 7360 .rx = BIT(IEEE80211_STYPE_ACTION >> 4) | 7361 BIT(IEEE80211_STYPE_PROBE_REQ >> 4) 7362 }, 7363 [NL80211_IFTYPE_AP] = { 7364 .tx = 0xffff, 7365 .rx = BIT(IEEE80211_STYPE_ASSOC_REQ >> 4) | 7366 BIT(IEEE80211_STYPE_REASSOC_REQ >> 4) | 7367 BIT(IEEE80211_STYPE_PROBE_REQ >> 4) | 7368 BIT(IEEE80211_STYPE_DISASSOC >> 4) | 7369 BIT(IEEE80211_STYPE_AUTH >> 4) | 7370 BIT(IEEE80211_STYPE_DEAUTH >> 4) | 7371 BIT(IEEE80211_STYPE_ACTION >> 4) 7372 } 7373 }; 7374 7375 /** 7376 * brcmf_setup_ifmodes() - determine interface modes and combinations. 7377 * 7378 * @wiphy: wiphy object. 7379 * @ifp: interface object needed for feat module api. 7380 * 7381 * The interface modes and combinations are determined dynamically here 7382 * based on firmware functionality. 7383 * 7384 * no p2p and no mbss: 7385 * 7386 * #STA <= 1, #AP <= 1, channels = 1, 2 total 7387 * 7388 * no p2p and mbss: 7389 * 7390 * #STA <= 1, #AP <= 1, channels = 1, 2 total 7391 * #AP <= 4, matching BI, channels = 1, 4 total 7392 * 7393 * no p2p and rsdb: 7394 * #STA <= 1, #AP <= 2, channels = 2, 4 total 7395 * 7396 * p2p, no mchan, and mbss: 7397 * 7398 * #STA <= 1, #P2P-DEV <= 1, #{P2P-CL, P2P-GO} <= 1, channels = 1, 3 total 7399 * #STA <= 1, #P2P-DEV <= 1, #AP <= 1, #P2P-CL <= 1, channels = 1, 4 total 7400 * #AP <= 4, matching BI, channels = 1, 4 total 7401 * 7402 * p2p, mchan, and mbss: 7403 * 7404 * #STA <= 2, #P2P-DEV <= 1, #{P2P-CL, P2P-GO} <= 1, channels = 2, 3 total 7405 * #STA <= 1, #P2P-DEV <= 1, #AP <= 1, #P2P-CL <= 1, channels = 1, 4 total 7406 * #AP <= 4, matching BI, channels = 1, 4 total 7407 * 7408 * p2p, rsdb, and no mbss: 7409 * #STA <= 1, #P2P-DEV <= 1, #{P2P-CL, P2P-GO} <= 2, AP <= 2, 7410 * channels = 2, 4 total 7411 */ 7412 static int brcmf_setup_ifmodes(struct wiphy *wiphy, struct brcmf_if *ifp) 7413 { 7414 struct ieee80211_iface_combination *combo = NULL; 7415 struct ieee80211_iface_limit *c0_limits = NULL; 7416 struct ieee80211_iface_limit *p2p_limits = NULL; 7417 struct ieee80211_iface_limit *mbss_limits = NULL; 7418 bool mon_flag, mbss, p2p, rsdb, mchan; 7419 int i, c, n_combos, n_limits; 7420 7421 mon_flag = brcmf_feat_is_enabled(ifp, BRCMF_FEAT_MONITOR_FLAG); 7422 mbss = brcmf_feat_is_enabled(ifp, BRCMF_FEAT_MBSS); 7423 p2p = brcmf_feat_is_enabled(ifp, BRCMF_FEAT_P2P); 7424 rsdb = brcmf_feat_is_enabled(ifp, BRCMF_FEAT_RSDB); 7425 mchan = brcmf_feat_is_enabled(ifp, BRCMF_FEAT_MCHAN); 7426 7427 n_combos = 1 + !!(p2p && !rsdb) + !!mbss; 7428 combo = kcalloc(n_combos, sizeof(*combo), GFP_KERNEL); 7429 if (!combo) 7430 goto err; 7431 7432 wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) | 7433 BIT(NL80211_IFTYPE_ADHOC) | 7434 BIT(NL80211_IFTYPE_AP); 7435 if (mon_flag) 7436 wiphy->interface_modes |= BIT(NL80211_IFTYPE_MONITOR); 7437 if (p2p) 7438 wiphy->interface_modes |= BIT(NL80211_IFTYPE_P2P_CLIENT) | 7439 BIT(NL80211_IFTYPE_P2P_GO) | 7440 BIT(NL80211_IFTYPE_P2P_DEVICE); 7441 7442 c = 0; 7443 i = 0; 7444 n_limits = 1 + mon_flag + (p2p ? 2 : 0) + (rsdb || !p2p); 7445 c0_limits = kcalloc(n_limits, sizeof(*c0_limits), GFP_KERNEL); 7446 if (!c0_limits) 7447 goto err; 7448 7449 combo[c].num_different_channels = 1 + (rsdb || (p2p && mchan)); 7450 c0_limits[i].max = 1 + (p2p && mchan); 7451 c0_limits[i++].types = BIT(NL80211_IFTYPE_STATION); 7452 if (mon_flag) { 7453 c0_limits[i].max = 1; 7454 c0_limits[i++].types = BIT(NL80211_IFTYPE_MONITOR); 7455 } 7456 if (p2p) { 7457 c0_limits[i].max = 1; 7458 c0_limits[i++].types = BIT(NL80211_IFTYPE_P2P_DEVICE); 7459 c0_limits[i].max = 1 + rsdb; 7460 c0_limits[i++].types = BIT(NL80211_IFTYPE_P2P_CLIENT) | 7461 BIT(NL80211_IFTYPE_P2P_GO); 7462 } 7463 if (p2p && rsdb) { 7464 c0_limits[i].max = 2; 7465 c0_limits[i++].types = BIT(NL80211_IFTYPE_AP); 7466 combo[c].max_interfaces = 4; 7467 } else if (p2p) { 7468 combo[c].max_interfaces = i; 7469 } else if (rsdb) { 7470 c0_limits[i].max = 2; 7471 c0_limits[i++].types = BIT(NL80211_IFTYPE_AP); 7472 combo[c].max_interfaces = 3; 7473 } else { 7474 c0_limits[i].max = 1; 7475 c0_limits[i++].types = BIT(NL80211_IFTYPE_AP); 7476 combo[c].max_interfaces = i; 7477 } 7478 combo[c].n_limits = i; 7479 combo[c].limits = c0_limits; 7480 7481 if (p2p && !rsdb) { 7482 c++; 7483 i = 0; 7484 p2p_limits = kcalloc(4, sizeof(*p2p_limits), GFP_KERNEL); 7485 if (!p2p_limits) 7486 goto err; 7487 p2p_limits[i].max = 1; 7488 p2p_limits[i++].types = BIT(NL80211_IFTYPE_STATION); 7489 p2p_limits[i].max = 1; 7490 p2p_limits[i++].types = BIT(NL80211_IFTYPE_AP); 7491 p2p_limits[i].max = 1; 7492 p2p_limits[i++].types = BIT(NL80211_IFTYPE_P2P_CLIENT); 7493 p2p_limits[i].max = 1; 7494 p2p_limits[i++].types = BIT(NL80211_IFTYPE_P2P_DEVICE); 7495 combo[c].num_different_channels = 1; 7496 combo[c].max_interfaces = i; 7497 combo[c].n_limits = i; 7498 combo[c].limits = p2p_limits; 7499 } 7500 7501 if (mbss) { 7502 c++; 7503 i = 0; 7504 n_limits = 1 + mon_flag; 7505 mbss_limits = kcalloc(n_limits, sizeof(*mbss_limits), 7506 GFP_KERNEL); 7507 if (!mbss_limits) 7508 goto err; 7509 mbss_limits[i].max = 4; 7510 mbss_limits[i++].types = BIT(NL80211_IFTYPE_AP); 7511 if (mon_flag) { 7512 mbss_limits[i].max = 1; 7513 mbss_limits[i++].types = BIT(NL80211_IFTYPE_MONITOR); 7514 } 7515 combo[c].beacon_int_infra_match = true; 7516 combo[c].num_different_channels = 1; 7517 combo[c].max_interfaces = 4 + mon_flag; 7518 combo[c].n_limits = i; 7519 combo[c].limits = mbss_limits; 7520 } 7521 7522 wiphy->n_iface_combinations = n_combos; 7523 wiphy->iface_combinations = combo; 7524 return 0; 7525 7526 err: 7527 kfree(c0_limits); 7528 kfree(p2p_limits); 7529 kfree(mbss_limits); 7530 kfree(combo); 7531 return -ENOMEM; 7532 } 7533 7534 #ifdef CONFIG_PM 7535 static const struct wiphy_wowlan_support brcmf_wowlan_support = { 7536 .flags = WIPHY_WOWLAN_MAGIC_PKT | WIPHY_WOWLAN_DISCONNECT, 7537 .n_patterns = BRCMF_WOWL_MAXPATTERNS, 7538 .pattern_max_len = BRCMF_WOWL_MAXPATTERNSIZE, 7539 .pattern_min_len = 1, 7540 .max_pkt_offset = 1500, 7541 }; 7542 #endif 7543 7544 static void brcmf_wiphy_wowl_params(struct wiphy *wiphy, struct brcmf_if *ifp) 7545 { 7546 #ifdef CONFIG_PM 7547 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy); 7548 struct brcmf_pub *drvr = cfg->pub; 7549 struct wiphy_wowlan_support *wowl; 7550 7551 wowl = kmemdup(&brcmf_wowlan_support, sizeof(brcmf_wowlan_support), 7552 GFP_KERNEL); 7553 if (!wowl) { 7554 bphy_err(drvr, "only support basic wowlan features\n"); 7555 wiphy->wowlan = &brcmf_wowlan_support; 7556 return; 7557 } 7558 7559 if (brcmf_feat_is_enabled(ifp, BRCMF_FEAT_PNO)) { 7560 if (brcmf_feat_is_enabled(ifp, BRCMF_FEAT_WOWL_ND)) { 7561 wowl->flags |= WIPHY_WOWLAN_NET_DETECT; 7562 wowl->max_nd_match_sets = BRCMF_PNO_MAX_PFN_COUNT; 7563 init_waitqueue_head(&cfg->wowl.nd_data_wait); 7564 } 7565 } 7566 if (brcmf_feat_is_enabled(ifp, BRCMF_FEAT_WOWL_GTK)) { 7567 wowl->flags |= WIPHY_WOWLAN_SUPPORTS_GTK_REKEY; 7568 wowl->flags |= WIPHY_WOWLAN_GTK_REKEY_FAILURE; 7569 } 7570 7571 wiphy->wowlan = wowl; 7572 #endif 7573 } 7574 7575 static int brcmf_setup_wiphy(struct wiphy *wiphy, struct brcmf_if *ifp) 7576 { 7577 struct brcmf_pub *drvr = ifp->drvr; 7578 const struct ieee80211_iface_combination *combo; 7579 struct ieee80211_supported_band *band; 7580 u16 max_interfaces = 0; 7581 bool gscan; 7582 __le32 bandlist[3]; 7583 u32 n_bands; 7584 int err, i; 7585 7586 wiphy->max_scan_ssids = WL_NUM_SCAN_MAX; 7587 wiphy->max_scan_ie_len = BRCMF_SCAN_IE_LEN_MAX; 7588 wiphy->max_num_pmkids = BRCMF_MAXPMKID; 7589 7590 err = brcmf_setup_ifmodes(wiphy, ifp); 7591 if (err) 7592 return err; 7593 7594 for (i = 0, combo = wiphy->iface_combinations; 7595 i < wiphy->n_iface_combinations; i++, combo++) { 7596 max_interfaces = max(max_interfaces, combo->max_interfaces); 7597 } 7598 7599 for (i = 0; i < max_interfaces && i < ARRAY_SIZE(drvr->addresses); 7600 i++) { 7601 u8 *addr = drvr->addresses[i].addr; 7602 7603 memcpy(addr, drvr->mac, ETH_ALEN); 7604 if (i) { 7605 addr[0] |= BIT(1); 7606 addr[ETH_ALEN - 1] ^= i; 7607 } 7608 } 7609 wiphy->addresses = drvr->addresses; 7610 wiphy->n_addresses = i; 7611 7612 wiphy->signal_type = CFG80211_SIGNAL_TYPE_MBM; 7613 wiphy->cipher_suites = brcmf_cipher_suites; 7614 wiphy->n_cipher_suites = ARRAY_SIZE(brcmf_cipher_suites); 7615 if (!brcmf_feat_is_enabled(ifp, BRCMF_FEAT_MFP)) 7616 wiphy->n_cipher_suites--; 7617 wiphy->bss_select_support = BIT(NL80211_BSS_SELECT_ATTR_RSSI) | 7618 BIT(NL80211_BSS_SELECT_ATTR_BAND_PREF) | 7619 BIT(NL80211_BSS_SELECT_ATTR_RSSI_ADJUST); 7620 7621 wiphy->flags |= WIPHY_FLAG_NETNS_OK | 7622 WIPHY_FLAG_PS_ON_BY_DEFAULT | 7623 WIPHY_FLAG_HAVE_AP_SME | 7624 WIPHY_FLAG_OFFCHAN_TX | 7625 WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL; 7626 if (brcmf_feat_is_enabled(ifp, BRCMF_FEAT_TDLS)) 7627 wiphy->flags |= WIPHY_FLAG_SUPPORTS_TDLS; 7628 if (!ifp->drvr->settings->roamoff) 7629 wiphy->flags |= WIPHY_FLAG_SUPPORTS_FW_ROAM; 7630 if (brcmf_feat_is_enabled(ifp, BRCMF_FEAT_FWSUP)) { 7631 wiphy_ext_feature_set(wiphy, 7632 NL80211_EXT_FEATURE_4WAY_HANDSHAKE_STA_PSK); 7633 wiphy_ext_feature_set(wiphy, 7634 NL80211_EXT_FEATURE_4WAY_HANDSHAKE_STA_1X); 7635 if (brcmf_feat_is_enabled(ifp, BRCMF_FEAT_SAE)) 7636 wiphy_ext_feature_set(wiphy, 7637 NL80211_EXT_FEATURE_SAE_OFFLOAD); 7638 } 7639 if (brcmf_feat_is_enabled(ifp, BRCMF_FEAT_FWAUTH)) { 7640 wiphy_ext_feature_set(wiphy, 7641 NL80211_EXT_FEATURE_4WAY_HANDSHAKE_AP_PSK); 7642 if (brcmf_feat_is_enabled(ifp, BRCMF_FEAT_SAE)) 7643 wiphy_ext_feature_set(wiphy, 7644 NL80211_EXT_FEATURE_SAE_OFFLOAD_AP); 7645 } 7646 wiphy->mgmt_stypes = brcmf_txrx_stypes; 7647 wiphy->max_remain_on_channel_duration = 5000; 7648 if (brcmf_feat_is_enabled(ifp, BRCMF_FEAT_PNO)) { 7649 gscan = brcmf_feat_is_enabled(ifp, BRCMF_FEAT_GSCAN); 7650 brcmf_pno_wiphy_params(wiphy, gscan); 7651 } 7652 /* vendor commands/events support */ 7653 wiphy->vendor_commands = brcmf_vendor_cmds; 7654 wiphy->n_vendor_commands = BRCMF_VNDR_CMDS_LAST - 1; 7655 7656 if (brcmf_feat_is_enabled(ifp, BRCMF_FEAT_WOWL)) 7657 brcmf_wiphy_wowl_params(wiphy, ifp); 7658 err = brcmf_fil_cmd_data_get(ifp, BRCMF_C_GET_BANDLIST, &bandlist, 7659 sizeof(bandlist)); 7660 if (err) { 7661 bphy_err(drvr, "could not obtain band info: err=%d\n", err); 7662 return err; 7663 } 7664 /* first entry in bandlist is number of bands */ 7665 n_bands = le32_to_cpu(bandlist[0]); 7666 for (i = 1; i <= n_bands && i < ARRAY_SIZE(bandlist); i++) { 7667 if (bandlist[i] == cpu_to_le32(WLC_BAND_2G)) { 7668 band = kmemdup(&__wl_band_2ghz, sizeof(__wl_band_2ghz), 7669 GFP_KERNEL); 7670 if (!band) 7671 return -ENOMEM; 7672 7673 band->channels = kmemdup(&__wl_2ghz_channels, 7674 sizeof(__wl_2ghz_channels), 7675 GFP_KERNEL); 7676 if (!band->channels) { 7677 kfree(band); 7678 return -ENOMEM; 7679 } 7680 7681 band->n_channels = ARRAY_SIZE(__wl_2ghz_channels); 7682 wiphy->bands[NL80211_BAND_2GHZ] = band; 7683 } 7684 if (bandlist[i] == cpu_to_le32(WLC_BAND_5G)) { 7685 band = kmemdup(&__wl_band_5ghz, sizeof(__wl_band_5ghz), 7686 GFP_KERNEL); 7687 if (!band) 7688 return -ENOMEM; 7689 7690 band->channels = kmemdup(&__wl_5ghz_channels, 7691 sizeof(__wl_5ghz_channels), 7692 GFP_KERNEL); 7693 if (!band->channels) { 7694 kfree(band); 7695 return -ENOMEM; 7696 } 7697 7698 band->n_channels = ARRAY_SIZE(__wl_5ghz_channels); 7699 wiphy->bands[NL80211_BAND_5GHZ] = band; 7700 } 7701 } 7702 7703 if (wiphy->bands[NL80211_BAND_5GHZ] && 7704 brcmf_feat_is_enabled(ifp, BRCMF_FEAT_DOT11H)) 7705 wiphy_ext_feature_set(wiphy, 7706 NL80211_EXT_FEATURE_DFS_OFFLOAD); 7707 7708 wiphy_ext_feature_set(wiphy, NL80211_EXT_FEATURE_CQM_RSSI_LIST); 7709 7710 wiphy_read_of_freq_limits(wiphy); 7711 7712 return 0; 7713 } 7714 7715 static s32 brcmf_config_dongle(struct brcmf_cfg80211_info *cfg) 7716 { 7717 struct brcmf_pub *drvr = cfg->pub; 7718 struct net_device *ndev; 7719 struct wireless_dev *wdev; 7720 struct brcmf_if *ifp; 7721 s32 power_mode; 7722 s32 err = 0; 7723 7724 if (cfg->dongle_up) 7725 return err; 7726 7727 ndev = cfg_to_ndev(cfg); 7728 wdev = ndev->ieee80211_ptr; 7729 ifp = netdev_priv(ndev); 7730 7731 /* make sure RF is ready for work */ 7732 brcmf_fil_cmd_int_set(ifp, BRCMF_C_UP, 0); 7733 7734 brcmf_dongle_scantime(ifp); 7735 7736 power_mode = cfg->pwr_save ? PM_FAST : PM_OFF; 7737 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_PM, power_mode); 7738 if (err) 7739 goto default_conf_out; 7740 brcmf_dbg(INFO, "power save set to %s\n", 7741 (power_mode ? "enabled" : "disabled")); 7742 7743 err = brcmf_dongle_roam(ifp); 7744 if (err) 7745 goto default_conf_out; 7746 err = brcmf_cfg80211_change_iface(wdev->wiphy, ndev, wdev->iftype, 7747 NULL); 7748 if (err) 7749 goto default_conf_out; 7750 7751 brcmf_configure_arp_nd_offload(ifp, true); 7752 7753 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_FAKEFRAG, 1); 7754 if (err) { 7755 bphy_err(drvr, "failed to set frameburst mode\n"); 7756 goto default_conf_out; 7757 } 7758 7759 cfg->dongle_up = true; 7760 default_conf_out: 7761 7762 return err; 7763 7764 } 7765 7766 static s32 __brcmf_cfg80211_up(struct brcmf_if *ifp) 7767 { 7768 set_bit(BRCMF_VIF_STATUS_READY, &ifp->vif->sme_state); 7769 7770 return brcmf_config_dongle(ifp->drvr->config); 7771 } 7772 7773 static s32 __brcmf_cfg80211_down(struct brcmf_if *ifp) 7774 { 7775 struct brcmf_cfg80211_info *cfg = ifp->drvr->config; 7776 7777 /* 7778 * While going down, if associated with AP disassociate 7779 * from AP to save power 7780 */ 7781 if (check_vif_up(ifp->vif)) { 7782 brcmf_link_down(ifp->vif, WLAN_REASON_UNSPECIFIED, true); 7783 7784 /* Make sure WPA_Supplicant receives all the event 7785 generated due to DISASSOC call to the fw to keep 7786 the state fw and WPA_Supplicant state consistent 7787 */ 7788 brcmf_delay(500); 7789 } 7790 7791 brcmf_abort_scanning(cfg); 7792 clear_bit(BRCMF_VIF_STATUS_READY, &ifp->vif->sme_state); 7793 7794 return 0; 7795 } 7796 7797 s32 brcmf_cfg80211_up(struct net_device *ndev) 7798 { 7799 struct brcmf_if *ifp = netdev_priv(ndev); 7800 struct brcmf_cfg80211_info *cfg = ifp->drvr->config; 7801 s32 err = 0; 7802 7803 mutex_lock(&cfg->usr_sync); 7804 err = __brcmf_cfg80211_up(ifp); 7805 mutex_unlock(&cfg->usr_sync); 7806 7807 return err; 7808 } 7809 7810 s32 brcmf_cfg80211_down(struct net_device *ndev) 7811 { 7812 struct brcmf_if *ifp = netdev_priv(ndev); 7813 struct brcmf_cfg80211_info *cfg = ifp->drvr->config; 7814 s32 err = 0; 7815 7816 mutex_lock(&cfg->usr_sync); 7817 err = __brcmf_cfg80211_down(ifp); 7818 mutex_unlock(&cfg->usr_sync); 7819 7820 return err; 7821 } 7822 7823 enum nl80211_iftype brcmf_cfg80211_get_iftype(struct brcmf_if *ifp) 7824 { 7825 struct wireless_dev *wdev = &ifp->vif->wdev; 7826 7827 return wdev->iftype; 7828 } 7829 7830 bool brcmf_get_vif_state_any(struct brcmf_cfg80211_info *cfg, 7831 unsigned long state) 7832 { 7833 struct brcmf_cfg80211_vif *vif; 7834 7835 list_for_each_entry(vif, &cfg->vif_list, list) { 7836 if (test_bit(state, &vif->sme_state)) 7837 return true; 7838 } 7839 return false; 7840 } 7841 7842 static inline bool vif_event_equals(struct brcmf_cfg80211_vif_event *event, 7843 u8 action) 7844 { 7845 u8 evt_action; 7846 7847 spin_lock(&event->vif_event_lock); 7848 evt_action = event->action; 7849 spin_unlock(&event->vif_event_lock); 7850 return evt_action == action; 7851 } 7852 7853 void brcmf_cfg80211_arm_vif_event(struct brcmf_cfg80211_info *cfg, 7854 struct brcmf_cfg80211_vif *vif) 7855 { 7856 struct brcmf_cfg80211_vif_event *event = &cfg->vif_event; 7857 7858 spin_lock(&event->vif_event_lock); 7859 event->vif = vif; 7860 event->action = 0; 7861 spin_unlock(&event->vif_event_lock); 7862 } 7863 7864 bool brcmf_cfg80211_vif_event_armed(struct brcmf_cfg80211_info *cfg) 7865 { 7866 struct brcmf_cfg80211_vif_event *event = &cfg->vif_event; 7867 bool armed; 7868 7869 spin_lock(&event->vif_event_lock); 7870 armed = event->vif != NULL; 7871 spin_unlock(&event->vif_event_lock); 7872 7873 return armed; 7874 } 7875 7876 int brcmf_cfg80211_wait_vif_event(struct brcmf_cfg80211_info *cfg, 7877 u8 action, ulong timeout) 7878 { 7879 struct brcmf_cfg80211_vif_event *event = &cfg->vif_event; 7880 7881 return wait_event_timeout(event->vif_wq, 7882 vif_event_equals(event, action), timeout); 7883 } 7884 7885 static bool brmcf_use_iso3166_ccode_fallback(struct brcmf_pub *drvr) 7886 { 7887 if (drvr->settings->trivial_ccode_map) 7888 return true; 7889 7890 switch (drvr->bus_if->chip) { 7891 case BRCM_CC_43430_CHIP_ID: 7892 case BRCM_CC_4345_CHIP_ID: 7893 case BRCM_CC_4356_CHIP_ID: 7894 case BRCM_CC_43602_CHIP_ID: 7895 return true; 7896 default: 7897 return false; 7898 } 7899 } 7900 7901 static s32 brcmf_translate_country_code(struct brcmf_pub *drvr, char alpha2[2], 7902 struct brcmf_fil_country_le *ccreq) 7903 { 7904 struct brcmfmac_pd_cc *country_codes; 7905 struct brcmfmac_pd_cc_entry *cc; 7906 s32 found_index; 7907 int i; 7908 7909 if ((alpha2[0] == ccreq->country_abbrev[0]) && 7910 (alpha2[1] == ccreq->country_abbrev[1])) { 7911 brcmf_dbg(TRACE, "Country code already set\n"); 7912 return -EAGAIN; 7913 } 7914 7915 country_codes = drvr->settings->country_codes; 7916 if (!country_codes) { 7917 if (brmcf_use_iso3166_ccode_fallback(drvr)) { 7918 brcmf_dbg(TRACE, "No country codes configured for device, using ISO3166 code and 0 rev\n"); 7919 memset(ccreq, 0, sizeof(*ccreq)); 7920 ccreq->country_abbrev[0] = alpha2[0]; 7921 ccreq->country_abbrev[1] = alpha2[1]; 7922 ccreq->ccode[0] = alpha2[0]; 7923 ccreq->ccode[1] = alpha2[1]; 7924 return 0; 7925 } 7926 7927 brcmf_dbg(TRACE, "No country codes configured for device\n"); 7928 return -EINVAL; 7929 } 7930 7931 found_index = -1; 7932 for (i = 0; i < country_codes->table_size; i++) { 7933 cc = &country_codes->table[i]; 7934 if ((cc->iso3166[0] == '\0') && (found_index == -1)) 7935 found_index = i; 7936 if ((cc->iso3166[0] == alpha2[0]) && 7937 (cc->iso3166[1] == alpha2[1])) { 7938 found_index = i; 7939 break; 7940 } 7941 } 7942 if (found_index == -1) { 7943 brcmf_dbg(TRACE, "No country code match found\n"); 7944 return -EINVAL; 7945 } 7946 memset(ccreq, 0, sizeof(*ccreq)); 7947 ccreq->rev = cpu_to_le32(country_codes->table[found_index].rev); 7948 memcpy(ccreq->ccode, country_codes->table[found_index].cc, 7949 BRCMF_COUNTRY_BUF_SZ); 7950 ccreq->country_abbrev[0] = alpha2[0]; 7951 ccreq->country_abbrev[1] = alpha2[1]; 7952 ccreq->country_abbrev[2] = 0; 7953 7954 return 0; 7955 } 7956 7957 static int 7958 brcmf_parse_dump_obss(char *buf, struct brcmf_dump_survey *survey) 7959 { 7960 int i; 7961 char *token; 7962 char delim[] = "\n "; 7963 unsigned long val; 7964 int err = 0; 7965 7966 token = strsep(&buf, delim); 7967 while (token) { 7968 if (!strcmp(token, "OBSS")) { 7969 for (i = 0; i < OBSS_TOKEN_IDX; i++) 7970 token = strsep(&buf, delim); 7971 err = kstrtoul(token, 10, &val); 7972 if (err) 7973 break; 7974 survey->obss = val; 7975 } 7976 7977 if (!strcmp(token, "IBSS")) { 7978 for (i = 0; i < IBSS_TOKEN_IDX; i++) 7979 token = strsep(&buf, delim); 7980 err = kstrtoul(token, 10, &val); 7981 if (err) 7982 break; 7983 survey->ibss = val; 7984 } 7985 7986 if (!strcmp(token, "TXDur")) { 7987 for (i = 0; i < TX_TOKEN_IDX; i++) 7988 token = strsep(&buf, delim); 7989 err = kstrtoul(token, 10, &val); 7990 if (err) 7991 break; 7992 survey->tx = val; 7993 } 7994 7995 if (!strcmp(token, "Category")) { 7996 for (i = 0; i < CTG_TOKEN_IDX; i++) 7997 token = strsep(&buf, delim); 7998 err = kstrtoul(token, 10, &val); 7999 if (err) 8000 break; 8001 survey->no_ctg = val; 8002 } 8003 8004 if (!strcmp(token, "Packet")) { 8005 for (i = 0; i < PKT_TOKEN_IDX; i++) 8006 token = strsep(&buf, delim); 8007 err = kstrtoul(token, 10, &val); 8008 if (err) 8009 break; 8010 survey->no_pckt = val; 8011 } 8012 8013 if (!strcmp(token, "Opp(time):")) { 8014 for (i = 0; i < IDLE_TOKEN_IDX; i++) 8015 token = strsep(&buf, delim); 8016 err = kstrtoul(token, 10, &val); 8017 if (err) 8018 break; 8019 survey->idle = val; 8020 } 8021 8022 token = strsep(&buf, delim); 8023 } 8024 8025 return err; 8026 } 8027 8028 static int 8029 brcmf_dump_obss(struct brcmf_if *ifp, struct cca_msrmnt_query req, 8030 struct brcmf_dump_survey *survey) 8031 { 8032 struct cca_stats_n_flags *results; 8033 char *buf; 8034 int err; 8035 8036 buf = kzalloc(sizeof(char) * BRCMF_DCMD_MEDLEN, GFP_KERNEL); 8037 if (!buf) 8038 return -ENOMEM; 8039 8040 memcpy(buf, &req, sizeof(struct cca_msrmnt_query)); 8041 err = brcmf_fil_iovar_data_get(ifp, "dump_obss", 8042 buf, BRCMF_DCMD_MEDLEN); 8043 if (err) { 8044 brcmf_err("dump_obss error (%d)\n", err); 8045 err = -EINVAL; 8046 goto exit; 8047 } 8048 results = (struct cca_stats_n_flags *)(buf); 8049 8050 if (req.msrmnt_query) 8051 brcmf_parse_dump_obss(results->buf, survey); 8052 8053 exit: 8054 kfree(buf); 8055 return err; 8056 } 8057 8058 static s32 8059 brcmf_set_channel(struct brcmf_cfg80211_info *cfg, struct ieee80211_channel *chan) 8060 { 8061 u16 chspec = 0; 8062 int err = 0; 8063 struct brcmf_if *ifp = netdev_priv(cfg_to_ndev(cfg)); 8064 8065 if (chan->flags & IEEE80211_CHAN_DISABLED) 8066 return -EINVAL; 8067 8068 /* set_channel */ 8069 chspec = channel_to_chanspec(&cfg->d11inf, chan); 8070 if (chspec != INVCHANSPEC) { 8071 err = brcmf_fil_iovar_int_set(ifp, "chanspec", chspec); 8072 if (err) { 8073 brcmf_err("set chanspec 0x%04x fail, reason %d\n", chspec, err); 8074 err = -EINVAL; 8075 } 8076 } else { 8077 brcmf_err("failed to convert host chanspec to fw chanspec\n"); 8078 err = -EINVAL; 8079 } 8080 8081 return err; 8082 } 8083 8084 static int 8085 brcmf_cfg80211_dump_survey(struct wiphy *wiphy, struct net_device *ndev, 8086 int idx, struct survey_info *info) 8087 { 8088 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy); 8089 struct brcmf_if *ifp = netdev_priv(cfg_to_ndev(cfg)); 8090 struct brcmf_dump_survey survey = {}; 8091 struct ieee80211_supported_band *band; 8092 enum nl80211_band band_id; 8093 struct cca_msrmnt_query req; 8094 u32 noise; 8095 int err; 8096 8097 brcmf_dbg(TRACE, "Enter: channel idx=%d\n", idx); 8098 8099 /* Do not run survey when VIF in CONNECTING / CONNECTED states */ 8100 if ((test_bit(BRCMF_VIF_STATUS_CONNECTING, &ifp->vif->sme_state)) || 8101 (test_bit(BRCMF_VIF_STATUS_CONNECTED, &ifp->vif->sme_state))) { 8102 return -EBUSY; 8103 } 8104 8105 for (band_id = 0; band_id < NUM_NL80211_BANDS; band_id++) { 8106 band = wiphy->bands[band_id]; 8107 if (!band) 8108 continue; 8109 if (idx >= band->n_channels) { 8110 idx -= band->n_channels; 8111 continue; 8112 } 8113 8114 info->channel = &band->channels[idx]; 8115 break; 8116 } 8117 if (band_id == NUM_NL80211_BANDS) 8118 return -ENOENT; 8119 8120 /* Setting current channel to the requested channel */ 8121 info->filled = 0; 8122 if (brcmf_set_channel(cfg, info->channel)) 8123 return 0; 8124 8125 /* Disable mpc */ 8126 brcmf_set_mpc(ifp, 0); 8127 8128 /* Set interface up, explicitly. */ 8129 err = brcmf_fil_cmd_int_set(ifp, BRCMF_C_UP, 1); 8130 if (err) { 8131 brcmf_err("set interface up failed, err = %d\n", err); 8132 goto exit; 8133 } 8134 8135 /* Get noise value */ 8136 err = brcmf_fil_cmd_int_get(ifp, BRCMF_C_GET_PHY_NOISE, &noise); 8137 if (err) { 8138 brcmf_err("Get Phy Noise failed, use dummy value\n"); 8139 noise = CHAN_NOISE_DUMMY; 8140 } 8141 8142 /* Start Measurement for obss stats on current channel */ 8143 req.msrmnt_query = 0; 8144 req.time_req = ACS_MSRMNT_DELAY; 8145 err = brcmf_dump_obss(ifp, req, &survey); 8146 if (err) 8147 goto exit; 8148 8149 /* Add 10 ms for IOVAR completion */ 8150 msleep(ACS_MSRMNT_DELAY + 10); 8151 8152 /* Issue IOVAR to collect measurement results */ 8153 req.msrmnt_query = 1; 8154 err = brcmf_dump_obss(ifp, req, &survey); 8155 if (err) 8156 goto exit; 8157 8158 info->noise = noise; 8159 info->time = ACS_MSRMNT_DELAY; 8160 info->time_busy = ACS_MSRMNT_DELAY - survey.idle; 8161 info->time_rx = survey.obss + survey.ibss + survey.no_ctg + 8162 survey.no_pckt; 8163 info->time_tx = survey.tx; 8164 info->filled = SURVEY_INFO_NOISE_DBM | SURVEY_INFO_TIME | 8165 SURVEY_INFO_TIME_BUSY | SURVEY_INFO_TIME_RX | 8166 SURVEY_INFO_TIME_TX; 8167 8168 brcmf_dbg(INFO, "OBSS dump: channel %d: survey duration %d\n", 8169 ieee80211_frequency_to_channel(info->channel->center_freq), 8170 ACS_MSRMNT_DELAY); 8171 brcmf_dbg(INFO, "noise(%d) busy(%llu) rx(%llu) tx(%llu)\n", 8172 info->noise, info->time_busy, info->time_rx, info->time_tx); 8173 8174 exit: 8175 if (!brcmf_is_apmode(ifp->vif)) 8176 brcmf_set_mpc(ifp, 1); 8177 return err; 8178 } 8179 8180 static void brcmf_cfg80211_reg_notifier(struct wiphy *wiphy, 8181 struct regulatory_request *req) 8182 { 8183 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy); 8184 struct brcmf_if *ifp = brcmf_get_ifp(cfg->pub, 0); 8185 struct brcmf_pub *drvr = cfg->pub; 8186 struct brcmf_fil_country_le ccreq; 8187 s32 err; 8188 int i; 8189 8190 /* The country code gets set to "00" by default at boot, ignore */ 8191 if (req->alpha2[0] == '0' && req->alpha2[1] == '0') 8192 return; 8193 8194 /* ignore non-ISO3166 country codes */ 8195 for (i = 0; i < 2; i++) 8196 if (req->alpha2[i] < 'A' || req->alpha2[i] > 'Z') { 8197 bphy_err(drvr, "not an ISO3166 code (0x%02x 0x%02x)\n", 8198 req->alpha2[0], req->alpha2[1]); 8199 return; 8200 } 8201 8202 brcmf_dbg(TRACE, "Enter: initiator=%d, alpha=%c%c\n", req->initiator, 8203 req->alpha2[0], req->alpha2[1]); 8204 8205 err = brcmf_fil_iovar_data_get(ifp, "country", &ccreq, sizeof(ccreq)); 8206 if (err) { 8207 bphy_err(drvr, "Country code iovar returned err = %d\n", err); 8208 return; 8209 } 8210 8211 err = brcmf_translate_country_code(ifp->drvr, req->alpha2, &ccreq); 8212 if (err) 8213 return; 8214 8215 err = brcmf_fil_iovar_data_set(ifp, "country", &ccreq, sizeof(ccreq)); 8216 if (err) { 8217 bphy_err(drvr, "Firmware rejected country setting\n"); 8218 return; 8219 } 8220 brcmf_setup_wiphybands(cfg); 8221 } 8222 8223 static void brcmf_free_wiphy(struct wiphy *wiphy) 8224 { 8225 int i; 8226 8227 if (!wiphy) 8228 return; 8229 8230 if (wiphy->iface_combinations) { 8231 for (i = 0; i < wiphy->n_iface_combinations; i++) 8232 kfree(wiphy->iface_combinations[i].limits); 8233 } 8234 kfree(wiphy->iface_combinations); 8235 if (wiphy->bands[NL80211_BAND_2GHZ]) { 8236 kfree(wiphy->bands[NL80211_BAND_2GHZ]->channels); 8237 kfree(wiphy->bands[NL80211_BAND_2GHZ]); 8238 } 8239 if (wiphy->bands[NL80211_BAND_5GHZ]) { 8240 kfree(wiphy->bands[NL80211_BAND_5GHZ]->channels); 8241 kfree(wiphy->bands[NL80211_BAND_5GHZ]); 8242 } 8243 #if IS_ENABLED(CONFIG_PM) 8244 if (wiphy->wowlan != &brcmf_wowlan_support) 8245 kfree(wiphy->wowlan); 8246 #endif 8247 } 8248 8249 struct brcmf_cfg80211_info *brcmf_cfg80211_attach(struct brcmf_pub *drvr, 8250 struct cfg80211_ops *ops, 8251 bool p2pdev_forced) 8252 { 8253 struct wiphy *wiphy = drvr->wiphy; 8254 struct net_device *ndev = brcmf_get_ifp(drvr, 0)->ndev; 8255 struct brcmf_cfg80211_info *cfg; 8256 struct brcmf_cfg80211_vif *vif; 8257 struct brcmf_if *ifp; 8258 s32 err = 0; 8259 s32 io_type; 8260 u16 *cap = NULL; 8261 8262 if (!ndev) { 8263 bphy_err(drvr, "ndev is invalid\n"); 8264 return NULL; 8265 } 8266 8267 cfg = kzalloc(sizeof(*cfg), GFP_KERNEL); 8268 if (!cfg) { 8269 bphy_err(drvr, "Could not allocate wiphy device\n"); 8270 return NULL; 8271 } 8272 8273 cfg->wiphy = wiphy; 8274 cfg->pub = drvr; 8275 init_vif_event(&cfg->vif_event); 8276 INIT_LIST_HEAD(&cfg->vif_list); 8277 8278 vif = brcmf_alloc_vif(cfg, NL80211_IFTYPE_STATION); 8279 if (IS_ERR(vif)) 8280 goto wiphy_out; 8281 8282 ifp = netdev_priv(ndev); 8283 vif->ifp = ifp; 8284 vif->wdev.netdev = ndev; 8285 ndev->ieee80211_ptr = &vif->wdev; 8286 SET_NETDEV_DEV(ndev, wiphy_dev(cfg->wiphy)); 8287 8288 err = wl_init_priv(cfg); 8289 if (err) { 8290 bphy_err(drvr, "Failed to init iwm_priv (%d)\n", err); 8291 brcmf_free_vif(vif); 8292 goto wiphy_out; 8293 } 8294 ifp->vif = vif; 8295 8296 /* determine d11 io type before wiphy setup */ 8297 err = brcmf_fil_cmd_int_get(ifp, BRCMF_C_GET_VERSION, &io_type); 8298 if (err) { 8299 bphy_err(drvr, "Failed to get D11 version (%d)\n", err); 8300 goto priv_out; 8301 } 8302 cfg->d11inf.io_type = (u8)io_type; 8303 brcmu_d11_attach(&cfg->d11inf); 8304 8305 /* regulatory notifer below needs access to cfg so 8306 * assign it now. 8307 */ 8308 drvr->config = cfg; 8309 8310 err = brcmf_setup_wiphy(wiphy, ifp); 8311 if (err < 0) 8312 goto priv_out; 8313 8314 brcmf_dbg(INFO, "Registering custom regulatory\n"); 8315 wiphy->reg_notifier = brcmf_cfg80211_reg_notifier; 8316 wiphy->regulatory_flags |= REGULATORY_CUSTOM_REG; 8317 wiphy_apply_custom_regulatory(wiphy, &brcmf_regdom); 8318 8319 /* firmware defaults to 40MHz disabled in 2G band. We signal 8320 * cfg80211 here that we do and have it decide we can enable 8321 * it. But first check if device does support 2G operation. 8322 */ 8323 if (wiphy->bands[NL80211_BAND_2GHZ]) { 8324 cap = &wiphy->bands[NL80211_BAND_2GHZ]->ht_cap.cap; 8325 *cap |= IEEE80211_HT_CAP_SUP_WIDTH_20_40; 8326 } 8327 #ifdef CONFIG_PM 8328 if (brcmf_feat_is_enabled(ifp, BRCMF_FEAT_WOWL_GTK)) 8329 ops->set_rekey_data = brcmf_cfg80211_set_rekey_data; 8330 #endif 8331 if (brcmf_feat_is_enabled(ifp, BRCMF_FEAT_DUMP_OBSS)) 8332 ops->dump_survey = brcmf_cfg80211_dump_survey; 8333 8334 err = wiphy_register(wiphy); 8335 if (err < 0) { 8336 bphy_err(drvr, "Could not register wiphy device (%d)\n", err); 8337 goto priv_out; 8338 } 8339 8340 err = brcmf_setup_wiphybands(cfg); 8341 if (err) { 8342 bphy_err(drvr, "Setting wiphy bands failed (%d)\n", err); 8343 goto wiphy_unreg_out; 8344 } 8345 8346 /* If cfg80211 didn't disable 40MHz HT CAP in wiphy_register(), 8347 * setup 40MHz in 2GHz band and enable OBSS scanning. 8348 */ 8349 if (cap && (*cap & IEEE80211_HT_CAP_SUP_WIDTH_20_40)) { 8350 err = brcmf_enable_bw40_2g(cfg); 8351 if (!err) 8352 err = brcmf_fil_iovar_int_set(ifp, "obss_coex", 8353 BRCMF_OBSS_COEX_AUTO); 8354 else 8355 *cap &= ~IEEE80211_HT_CAP_SUP_WIDTH_20_40; 8356 } 8357 8358 err = brcmf_fweh_activate_events(ifp); 8359 if (err) { 8360 bphy_err(drvr, "FWEH activation failed (%d)\n", err); 8361 goto wiphy_unreg_out; 8362 } 8363 8364 err = brcmf_p2p_attach(cfg, p2pdev_forced); 8365 if (err) { 8366 bphy_err(drvr, "P2P initialisation failed (%d)\n", err); 8367 goto wiphy_unreg_out; 8368 } 8369 err = brcmf_btcoex_attach(cfg); 8370 if (err) { 8371 bphy_err(drvr, "BT-coex initialisation failed (%d)\n", err); 8372 brcmf_p2p_detach(&cfg->p2p); 8373 goto wiphy_unreg_out; 8374 } 8375 err = brcmf_pno_attach(cfg); 8376 if (err) { 8377 bphy_err(drvr, "PNO initialisation failed (%d)\n", err); 8378 brcmf_btcoex_detach(cfg); 8379 brcmf_p2p_detach(&cfg->p2p); 8380 goto wiphy_unreg_out; 8381 } 8382 8383 if (brcmf_feat_is_enabled(ifp, BRCMF_FEAT_TDLS)) { 8384 err = brcmf_fil_iovar_int_set(ifp, "tdls_enable", 1); 8385 if (err) { 8386 brcmf_dbg(INFO, "TDLS not enabled (%d)\n", err); 8387 wiphy->flags &= ~WIPHY_FLAG_SUPPORTS_TDLS; 8388 } else { 8389 brcmf_fweh_register(cfg->pub, BRCMF_E_TDLS_PEER_EVENT, 8390 brcmf_notify_tdls_peer_event); 8391 } 8392 } 8393 8394 /* (re-) activate FWEH event handling */ 8395 err = brcmf_fweh_activate_events(ifp); 8396 if (err) { 8397 bphy_err(drvr, "FWEH activation failed (%d)\n", err); 8398 goto detach; 8399 } 8400 8401 /* Fill in some of the advertised nl80211 supported features */ 8402 if (brcmf_feat_is_enabled(ifp, BRCMF_FEAT_SCAN_RANDOM_MAC)) { 8403 wiphy->features |= NL80211_FEATURE_SCHED_SCAN_RANDOM_MAC_ADDR; 8404 #ifdef CONFIG_PM 8405 if (wiphy->wowlan && 8406 wiphy->wowlan->flags & WIPHY_WOWLAN_NET_DETECT) 8407 wiphy->features |= NL80211_FEATURE_ND_RANDOM_MAC_ADDR; 8408 #endif 8409 } 8410 8411 return cfg; 8412 8413 detach: 8414 brcmf_pno_detach(cfg); 8415 brcmf_btcoex_detach(cfg); 8416 brcmf_p2p_detach(&cfg->p2p); 8417 wiphy_unreg_out: 8418 wiphy_unregister(cfg->wiphy); 8419 priv_out: 8420 wl_deinit_priv(cfg); 8421 brcmf_free_vif(vif); 8422 ifp->vif = NULL; 8423 wiphy_out: 8424 brcmf_free_wiphy(wiphy); 8425 kfree(cfg); 8426 return NULL; 8427 } 8428 8429 void brcmf_cfg80211_detach(struct brcmf_cfg80211_info *cfg) 8430 { 8431 if (!cfg) 8432 return; 8433 8434 brcmf_pno_detach(cfg); 8435 brcmf_btcoex_detach(cfg); 8436 wiphy_unregister(cfg->wiphy); 8437 wl_deinit_priv(cfg); 8438 cancel_work_sync(&cfg->escan_timeout_work); 8439 brcmf_free_wiphy(cfg->wiphy); 8440 kfree(cfg); 8441 } 8442