Lines Matching +full:ccode +full:- +full:map
1 // SPDX-License-Identifier: ISC
51 #define WPA_CIPHER_WEP_40 1 /* WEP (40-bit) */
54 #define WPA_CIPHER_WEP_104 5 /* WEP (104-bit) */
58 #define RSN_AKM_PSK 2 /* Pre-shared Key */
60 #define RSN_AKM_SHA256_PSK 6 /* SHA256, Pre-shared Key */
94 #define CHAN_NOISE_DUMMY (-80)
103 (sizeof(struct brcmf_assoc_params_le) - sizeof(u16))
106 (BRCMF_DCMD_MEDLEN / sizeof(__le32) - 1)
130 if (!test_bit(BRCMF_VIF_STATUS_READY, &vif->sme_state)) {
132 vif->sme_state);
164 #define wl_a_rates_size (wl_g_rates_size - 4)
225 REG_RULE(2412-10, 2472+10, 40, 6, 20, 0),
227 /* IEEE 802.11 channel 14 - Only JP enables
230 REG_RULE(2484-10, 2484+10, 20, 6, 20, 0),
232 REG_RULE(5150-10, 5350+10, 160, 6, 20, 0),
234 REG_RULE(5470-10, 5850+10, 160, 6, 20, 0), }
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) {
352 if (primary_offset == -30)
354 else if (primary_offset == -10)
363 if (primary_offset == -70)
365 else if (primary_offset == -50)
367 else if (primary_offset == -30)
369 else if (primary_offset == -10)
386 switch (ch->chan->band) {
397 d11inf->encchspec(&ch_inf);
408 ch_inf.chnum = ieee80211_frequency_to_channel(ch->center_freq);
410 d11inf->encchspec(&ch_inf);
415 /* Traverse a string of 1-byte tag/1-byte length/variable-length value
427 int len = elt->len;
430 if ((elt->id == key) && (totlen >= (len + TLV_HDR_LEN)))
434 totlen -= (len + TLV_HDR_LEN);
459 *tlvs_len -= (int)(ie - *tlvs);
503 list_for_each_entry(pos, &cfg->vif_list, list)
509 params.iftype_num[pos->wdev.iftype]++;
513 ret = cfg80211_check_combinations(cfg->wiphy, ¶ms);
526 list_for_each_entry(pos, &cfg->vif_list, list)
527 params.iftype_num[pos->wdev.iftype]++;
530 return cfg80211_check_combinations(cfg->wiphy, ¶ms);
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));
550 struct brcmf_pub *drvr = ifp->drvr;
573 ifp = vif->ifp;
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,
581 brcmf_proto_configure_addr_mode(ifp->drvr, ifp->ifidx,
593 if (!drvr->iflist[bsscfgidx])
597 return -ENOMEM;
602 u8 mac_idx = ifp->drvr->sta_mac_idx;
605 memcpy(mac_addr, ifp->mac_addr, ETH_ALEN);
610 ifp->drvr->sta_mac_idx = mac_idx;
670 return -EOPNOTSUPP;
694 err = -EOPNOTSUPP;
701 return -EIO;
713 struct brcmf_pub *drvr = ifp->drvr;
763 return -EOPNOTSUPP;
784 err = -EOPNOTSUPP;
792 bsscfgidx = brcmf_get_first_free_bsscfgidx(ifp->drvr);
811 * brcmf_apsta_add_vif() - create a new AP or STA virtual interface
818 * Return: pointer to new vif on success, ERR_PTR(-errno) if not
827 struct brcmf_pub *drvr = cfg->pub;
832 return ERR_PTR(-EINVAL);
835 return ERR_PTR(-EBUSY);
846 err = brcmf_cfg80211_request_sta_if(ifp, params->macaddr);
860 err = -EIO;
865 ifp = vif->ifp;
868 err = -ENOENT;
872 strscpy(ifp->ndev->name, name, sizeof(ifp->ndev->name));
876 free_netdev(ifp->ndev);
880 return &ifp->vif->wdev;
891 iftype = vif->wdev.iftype;
897 return vif->wdev.iftype == NL80211_IFTYPE_ADHOC;
901 * brcmf_mon_add_vif() - create monitor mode virtual interface
906 * Return: pointer to new vif on success, ERR_PTR(-errno) if not
917 if (cfg->pub->mon_if) {
918 err = -EEXIST;
930 err = -ENOMEM;
933 ndev->type = ARPHRD_IEEE80211_RADIOTAP;
934 ndev->ieee80211_ptr = &vif->wdev;
935 ndev->needs_free_netdev = true;
936 ndev->priv_destructor = brcmf_cfg80211_free_netdev;
937 SET_NETDEV_DEV(ndev, wiphy_dev(cfg->wiphy));
940 ifp->vif = vif;
941 ifp->ndev = ndev;
942 ifp->drvr = cfg->pub;
944 vif->ifp = ifp;
945 vif->wdev.netdev = ndev;
949 brcmf_err("Failed to attach %s device\n", ndev->name);
954 cfg->pub->mon_if = ifp;
956 return &vif->wdev;
967 struct net_device *ndev = wdev->netdev;
969 ndev->netdev_ops->ndo_stop(ndev);
973 cfg->pub->mon_if = NULL;
985 struct brcmf_pub *drvr = cfg->pub;
1000 return ERR_PTR(-EOPNOTSUPP);
1014 return ERR_PTR(-EINVAL);
1034 struct brcmf_pub *drvr = ifp->drvr;
1037 if (check_vif_up(ifp->vif)) {
1054 memcpy(¶ms_le->ssid_le, ¶ms_v2_le->ssid_le,
1055 sizeof(params_le->ssid_le));
1056 memcpy(¶ms_le->bssid, ¶ms_v2_le->bssid,
1057 sizeof(params_le->bssid));
1059 params_le->bss_type = params_v2_le->bss_type;
1060 params_le->scan_type = le32_to_cpu(params_v2_le->scan_type);
1061 params_le->nprobes = params_v2_le->nprobes;
1062 params_le->active_time = params_v2_le->active_time;
1063 params_le->passive_time = params_v2_le->passive_time;
1064 params_le->home_time = params_v2_le->home_time;
1065 params_le->channel_num = params_v2_le->channel_num;
1067 ch = le32_to_cpu(params_v2_le->channel_num);
1077 memcpy(¶ms_le->channel_list[0],
1078 ¶ms_v2_le->channel_list[0], params_size);
1094 eth_broadcast_addr(params_le->bssid);
1098 params_le->version = cpu_to_le16(BRCMF_SCAN_PARAMS_VERSION_V2);
1099 params_le->bss_type = DOT11_BSSTYPE_ANY;
1100 params_le->scan_type = cpu_to_le32(BRCMF_SCANTYPE_ACTIVE);
1101 params_le->channel_num = 0;
1102 params_le->nprobes = cpu_to_le32(-1);
1103 params_le->active_time = cpu_to_le32(-1);
1104 params_le->passive_time = cpu_to_le32(-1);
1105 params_le->home_time = cpu_to_le32(-1);
1106 memset(¶ms_le->ssid_le, 0, sizeof(params_le->ssid_le));
1111 params_le->channel_num = cpu_to_le32(1);
1112 params_le->channel_list[0] = cpu_to_le16(-1);
1113 params_le->length = cpu_to_le16(length);
1117 n_ssids = request->n_ssids;
1118 n_channels = request->n_channels;
1126 chanspec = channel_to_chanspec(&cfg->d11inf,
1127 request->channels[i]);
1129 request->channels[i]->hw_value, chanspec);
1130 params_le->channel_list[i] = cpu_to_le16(chanspec);
1147 cpu_to_le32(request->ssids[i].ssid_len);
1148 memcpy(ssid_le.SSID, request->ssids[i].ssid,
1149 request->ssids[i].ssid_len);
1160 params_le->scan_type = cpu_to_le32(BRCMF_SCANTYPE_PASSIVE);
1162 params_le->length = cpu_to_le16(length);
1164 params_le->channel_num =
1173 struct brcmf_pub *drvr = cfg->pub;
1184 scan_request = cfg->scan_request;
1185 cfg->scan_request = NULL;
1187 timer_delete_sync(&cfg->escan_timeout);
1195 /* E-Scan (or anyother type) can be aborted by SCAN */
1216 * e-scan can be initiated internally
1219 if (cfg->int_escan_map) {
1221 cfg->int_escan_map);
1222 while (cfg->int_escan_map) {
1223 bucket = __ffs(cfg->int_escan_map);
1224 cfg->int_escan_map &= ~BIT(bucket);
1225 reqid = brcmf_pno_find_reqid_by_bucket(cfg->pno,
1243 if (!test_and_clear_bit(BRCMF_SCAN_STATUS_BUSY, &cfg->scan_status))
1253 struct net_device *ndev = wdev->netdev;
1255 struct brcmf_pub *drvr = cfg->pub;
1259 brcmf_cfg80211_arm_vif_event(cfg, ifp->vif);
1272 err = -EIO;
1287 struct net_device *ndev = wdev->netdev;
1290 return -ENOTSUPP;
1294 return -EBUSY;
1297 if (test_bit(BRCMF_SCAN_STATUS_BUSY, &cfg->scan_status) &&
1298 cfg->escan_info.ifp == netdev_priv(ndev))
1305 switch (wdev->iftype) {
1310 return -EOPNOTSUPP;
1322 return -EINVAL;
1324 return -EOPNOTSUPP;
1334 struct brcmf_cfg80211_vif *vif = ifp->vif;
1335 struct brcmf_pub *drvr = cfg->pub;
1340 brcmf_dbg(TRACE, "Enter, bsscfgidx=%d, type=%d\n", ifp->bsscfgidx,
1352 ((vif->wdev.iftype == NL80211_IFTYPE_P2P_CLIENT) ||
1353 (vif->wdev.iftype == NL80211_IFTYPE_P2P_GO) ||
1354 (vif->wdev.iftype == NL80211_IFTYPE_P2P_DEVICE))) {
1368 if (cfg->p2p.p2pdev_dynamically)
1369 return -EOPNOTSUPP;
1383 return -EOPNOTSUPP;
1395 err = -EINVAL;
1411 err = -EAGAIN;
1417 ndev->ieee80211_ptr->iftype = type;
1419 brcmf_cfg80211_update_proto_addr_mode(&vif->wdev);
1431 struct brcmf_pub *drvr = cfg->pub;
1437 brcmf_dbg(SCAN, "E-SCAN START\n");
1441 params_size += sizeof(u32) * ((request->n_channels + 1) / 2);
1444 params_size += sizeof(struct brcmf_ssid_le) * request->n_ssids;
1449 err = -ENOMEM;
1453 brcmf_escan_prep(cfg, ¶ms->params_v2_le, request);
1455 params->version = cpu_to_le32(BRCMF_ESCAN_REQ_VERSION_V2);
1460 params_size -= BRCMF_SCAN_PARAMS_V2_FIXED_SIZE;
1464 err = -ENOMEM;
1467 params_v1->version = cpu_to_le32(BRCMF_ESCAN_REQ_VERSION);
1468 brcmf_scan_params_v2_to_v1(¶ms->params_v2_le, ¶ms_v1->params_le);
1473 params->action = cpu_to_le16(WL_ESCAN_ACTION_START);
1474 params->sync_id = cpu_to_le16(0x1234);
1478 if (err == -EBUSY)
1493 struct brcmf_cfg80211_info *cfg = ifp->drvr->config;
1496 struct escan_info *escan = &cfg->escan_info;
1499 escan->ifp = ifp;
1500 escan->wiphy = cfg->wiphy;
1501 escan->escan_state = WL_ESCAN_STATE_SCANNING;
1504 results = (struct brcmf_scan_results *)cfg->escan_info.escan_buf;
1505 results->version = 0;
1506 results->count = 0;
1507 results->buflen = WL_ESCAN_RESULTS_FIXED_SIZE;
1509 err = escan->run(cfg, ifp, request);
1519 struct brcmf_pub *drvr = cfg->pub;
1524 vif = container_of(request->wdev, struct brcmf_cfg80211_vif, wdev);
1526 return -EIO;
1528 if (test_bit(BRCMF_SCAN_STATUS_BUSY, &cfg->scan_status)) {
1530 cfg->scan_status);
1531 return -EAGAIN;
1533 if (test_bit(BRCMF_SCAN_STATUS_ABORT, &cfg->scan_status)) {
1535 cfg->scan_status);
1536 return -EAGAIN;
1538 if (test_bit(BRCMF_SCAN_STATUS_SUPPRESS, &cfg->scan_status)) {
1540 cfg->scan_status);
1541 return -EAGAIN;
1543 if (test_bit(BRCMF_VIF_STATUS_CONNECTING, &vif->sme_state)) {
1544 bphy_err(drvr, "Connecting: status (%lu)\n", vif->sme_state);
1545 return -EAGAIN;
1549 if (vif == cfg->p2p.bss_idx[P2PAPI_BSSCFG_DEVICE].vif)
1550 vif = cfg->p2p.bss_idx[P2PAPI_BSSCFG_PRIMARY].vif;
1554 cfg->scan_request = request;
1555 set_bit(BRCMF_SCAN_STATUS_BUSY, &cfg->scan_status);
1557 cfg->escan_info.run = brcmf_run_escan;
1563 request->ie, request->ie_len);
1567 err = brcmf_do_escan(vif->ifp, request);
1572 mod_timer(&cfg->escan_timeout,
1579 clear_bit(BRCMF_SCAN_STATUS_BUSY, &cfg->scan_status);
1580 cfg->scan_request = NULL;
1587 struct brcmf_pub *drvr = ifp->drvr;
1600 struct brcmf_pub *drvr = ifp->drvr;
1614 struct brcmf_pub *drvr = ifp->drvr;
1634 if (!check_vif_up(ifp->vif))
1635 return -EIO;
1638 (cfg->conf->rts_threshold != wiphy->rts_threshold)) {
1639 cfg->conf->rts_threshold = wiphy->rts_threshold;
1640 err = brcmf_set_rts(ndev, cfg->conf->rts_threshold);
1645 (cfg->conf->frag_threshold != wiphy->frag_threshold)) {
1646 cfg->conf->frag_threshold = wiphy->frag_threshold;
1647 err = brcmf_set_frag(ndev, cfg->conf->frag_threshold);
1652 && (cfg->conf->retry_long != wiphy->retry_long)) {
1653 cfg->conf->retry_long = wiphy->retry_long;
1654 err = brcmf_set_retry(ndev, cfg->conf->retry_long, true);
1659 && (cfg->conf->retry_short != wiphy->retry_short)) {
1660 cfg->conf->retry_short = wiphy->retry_short;
1661 err = brcmf_set_retry(ndev, cfg->conf->retry_short, false);
1680 switch (e->event_code) {
1684 reason = e->reason;
1696 struct brcmf_pub *drvr = ifp->drvr;
1703 return -EINVAL;
1732 struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(vif->wdev.wiphy);
1733 struct brcmf_pub *drvr = cfg->pub;
1734 bool bus_up = drvr->bus_if->state == BRCMF_BUS_UP;
1739 if (test_and_clear_bit(BRCMF_VIF_STATUS_CONNECTED, &vif->sme_state)) {
1742 err = brcmf_fil_cmd_data_set(vif->ifp,
1749 if ((vif->wdev.iftype == NL80211_IFTYPE_STATION) ||
1750 (vif->wdev.iftype == NL80211_IFTYPE_P2P_CLIENT))
1751 cfg80211_disconnected(vif->wdev.netdev, reason, NULL, 0,
1754 clear_bit(BRCMF_VIF_STATUS_CONNECTING, &vif->sme_state);
1755 clear_bit(BRCMF_VIF_STATUS_EAP_SUCCESS, &vif->sme_state);
1756 clear_bit(BRCMF_VIF_STATUS_ASSOC_SUCCESS, &vif->sme_state);
1757 clear_bit(BRCMF_SCAN_STATUS_SUPPRESS, &cfg->scan_status);
1759 if (vif->profile.use_fwsup != BRCMF_PROFILE_FWSUP_NONE) {
1761 brcmf_set_pmk(vif->ifp, NULL, 0);
1762 vif->profile.use_fwsup = BRCMF_PROFILE_FWSUP_NONE;
1773 struct brcmf_cfg80211_profile *profile = &ifp->vif->profile;
1774 struct brcmf_pub *drvr = cfg->pub;
1784 if (!check_vif_up(ifp->vif))
1785 return -EIO;
1787 if (params->ssid)
1788 brcmf_dbg(CONN, "SSID: %s\n", params->ssid);
1791 return -EOPNOTSUPP;
1794 set_bit(BRCMF_VIF_STATUS_CONNECTING, &ifp->vif->sme_state);
1796 if (params->bssid)
1797 brcmf_dbg(CONN, "BSSID: %pM\n", params->bssid);
1801 if (params->chandef.chan)
1803 params->chandef.chan->center_freq);
1807 if (params->channel_fixed)
1812 if (params->ie && params->ie_len)
1813 brcmf_dbg(CONN, "ie len: %d\n", params->ie_len);
1817 if (params->beacon_interval)
1819 params->beacon_interval);
1823 if (params->basic_rates)
1824 brcmf_dbg(CONN, "basic rates: %08X\n", params->basic_rates);
1828 if (params->privacy)
1834 if (params->privacy)
1844 if (params->beacon_interval)
1845 bcnprd = params->beacon_interval;
1859 ssid_len = min_t(u32, params->ssid_len, IEEE80211_MAX_SSID_LEN);
1860 memcpy(join_params.ssid_le.SSID, params->ssid, ssid_len);
1865 if (params->bssid) {
1866 memcpy(join_params.params_le.bssid, params->bssid, ETH_ALEN);
1868 memcpy(profile->bssid, params->bssid, ETH_ALEN);
1871 eth_zero_addr(profile->bssid);
1875 if (params->chandef.chan) {
1878 cfg->channel =
1880 params->chandef.chan->center_freq);
1881 if (params->channel_fixed) {
1883 chanspec = chandef_to_chanspec(&cfg->d11inf,
1884 ¶ms->chandef);
1892 target_channel = cfg->channel;
1900 cfg->channel = 0;
1902 cfg->ibss_starter = false;
1914 clear_bit(BRCMF_VIF_STATUS_CONNECTING, &ifp->vif->sme_state);
1925 if (!check_vif_up(ifp->vif)) {
1933 brcmf_link_down(ifp->vif, WLAN_REASON_DEAUTH_LEAVING, true);
1946 struct brcmf_pub *drvr = ifp->drvr;
1951 if (sme->crypto.wpa_versions & NL80211_WPA_VERSION_1)
1953 else if (sme->crypto.wpa_versions & NL80211_WPA_VERSION_2)
1955 else if (sme->crypto.wpa_versions & NL80211_WPA_VERSION_3)
1965 sec = &profile->sec;
1966 sec->wpa_versions = sme->crypto.wpa_versions;
1975 struct brcmf_pub *drvr = ifp->drvr;
1980 switch (sme->auth_type) {
1995 brcmf_dbg(CONN, "automatic, auth type (%d)\n", sme->auth_type);
2004 sec = &profile->sec;
2005 sec->auth_type = sme->auth_type;
2015 struct brcmf_pub *drvr = ifp->drvr;
2022 if (sme->crypto.n_ciphers_pairwise) {
2023 switch (sme->crypto.ciphers_pairwise[0]) {
2039 sme->crypto.ciphers_pairwise[0]);
2040 return -EINVAL;
2043 if (sme->crypto.cipher_group) {
2044 switch (sme->crypto.cipher_group) {
2060 sme->crypto.cipher_group);
2061 return -EINVAL;
2067 /* setting AES. WPS-2.0 allows no security */
2068 if (brcmf_find_wpsie(sme->ie, sme->ie_len) && !pval && !gval &&
2069 sme->privacy)
2079 sec = &profile->sec;
2080 sec->cipher_pairwise = sme->crypto.ciphers_pairwise[0];
2081 sec->cipher_group = sme->crypto.cipher_group;
2090 struct brcmf_cfg80211_profile *profile = &ifp->vif->profile;
2091 struct brcmf_pub *drvr = ifp->drvr;
2102 profile->use_fwsup = BRCMF_PROFILE_FWSUP_NONE;
2103 profile->is_ft = false;
2105 if (!sme->crypto.n_akm_suites)
2115 switch (sme->crypto.akm_suites[0]) {
2118 if (sme->want_1x)
2119 profile->use_fwsup = BRCMF_PROFILE_FWSUP_1X;
2126 sme->crypto.akm_suites[0]);
2127 return -EINVAL;
2130 switch (sme->crypto.akm_suites[0]) {
2133 if (sme->want_1x)
2134 profile->use_fwsup = BRCMF_PROFILE_FWSUP_1X;
2138 if (sme->want_1x)
2139 profile->use_fwsup = BRCMF_PROFILE_FWSUP_1X;
2149 profile->is_ft = true;
2150 if (sme->want_1x)
2151 profile->use_fwsup = BRCMF_PROFILE_FWSUP_1X;
2155 profile->is_ft = true;
2159 sme->crypto.akm_suites[0]);
2160 return -EINVAL;
2163 switch (sme->crypto.akm_suites[0]) {
2166 if (sme->crypto.sae_pwd) {
2168 profile->use_fwsup = BRCMF_PROFILE_FWSUP_SAE;
2173 profile->is_ft = true;
2174 if (sme->crypto.sae_pwd) {
2176 profile->use_fwsup = BRCMF_PROFILE_FWSUP_SAE;
2181 sme->crypto.akm_suites[0]);
2182 return -EINVAL;
2186 if (profile->use_fwsup == BRCMF_PROFILE_FWSUP_1X)
2194 rsn_ie = brcmf_parse_tlvs((const u8 *)sme->ie, sme->ie_len,
2199 ie_len = rsn_ie->len + TLV_HDR_LEN;
2239 struct brcmf_pub *drvr = ifp->drvr;
2246 brcmf_dbg(CONN, "key len (%d)\n", sme->key_len);
2248 if (sme->key_len == 0)
2251 sec = &profile->sec;
2253 sec->wpa_versions, sec->cipher_pairwise);
2255 if (sec->wpa_versions & (NL80211_WPA_VERSION_1 | NL80211_WPA_VERSION_2 |
2259 if (!(sec->cipher_pairwise &
2264 key.len = (u32) sme->key_len;
2265 key.index = (u32) sme->key_idx;
2268 return -EINVAL;
2270 memcpy(key.data, sme->key, key.len);
2272 switch (sec->cipher_pairwise) {
2281 sme->crypto.ciphers_pairwise[0]);
2282 return -EINVAL;
2292 if (sec->auth_type == NL80211_AUTHTYPE_SHARED_KEY) {
2317 struct brcmf_pub *drvr = ifp->drvr;
2325 if (bss_select->behaviour != NL80211_BSS_SELECT_ATTR_BAND_PREF)
2328 switch (bss_select->behaviour) {
2334 band = bss_select->param.band_pref;
2340 band = bss_select->param.adjust.band;
2342 join_pref_params[i].rssi_gain = bss_select->param.adjust.delta;
2365 struct brcmf_cfg80211_profile *profile = &ifp->vif->profile;
2366 struct ieee80211_channel *chan = sme->channel;
2367 struct brcmf_pub *drvr = ifp->drvr;
2380 if (!check_vif_up(ifp->vif))
2381 return -EIO;
2383 if (!sme->ssid) {
2385 return -EOPNOTSUPP;
2388 if (sme->channel_hint)
2389 chan = sme->channel_hint;
2391 if (sme->bssid_hint)
2392 sme->bssid = sme->bssid_hint;
2394 if (ifp->vif == cfg->p2p.bss_idx[P2PAPI_BSSCFG_PRIMARY].vif) {
2399 wpa_ie = brcmf_find_wpaie((u8 *)sme->ie, sme->ie_len);
2402 ie_len = wpa_ie->len + TLV_HDR_LEN;
2405 rsn_ie = brcmf_parse_tlvs((const u8 *)sme->ie,
2406 sme->ie_len,
2410 ie_len = rsn_ie->len + TLV_HDR_LEN;
2416 err = brcmf_vif_set_mgmt_ie(ifp->vif, BRCMF_VNDR_IE_ASSOCREQ_FLAG,
2417 sme->ie, sme->ie_len);
2423 set_bit(BRCMF_VIF_STATUS_CONNECTING, &ifp->vif->sme_state);
2426 cfg->channel =
2427 ieee80211_frequency_to_channel(chan->center_freq);
2428 chanspec = channel_to_chanspec(&cfg->d11inf, chan);
2430 cfg->channel, chan->center_freq, chanspec);
2432 cfg->channel = 0;
2436 brcmf_dbg(INFO, "ie (%p), ie_len (%zd)\n", sme->ie, sme->ie_len);
2444 sme->auth_type = brcmf_war_auth_type(ifp, sme->auth_type);
2469 if (sme->crypto.psk &&
2470 profile->use_fwsup != BRCMF_PROFILE_FWSUP_SAE) {
2471 if (WARN_ON(profile->use_fwsup != BRCMF_PROFILE_FWSUP_NONE)) {
2472 err = -EINVAL;
2476 profile->use_fwsup = BRCMF_PROFILE_FWSUP_PSK;
2479 if (profile->use_fwsup != BRCMF_PROFILE_FWSUP_NONE) {
2488 if (profile->use_fwsup == BRCMF_PROFILE_FWSUP_PSK)
2489 err = brcmf_set_pmk(ifp, sme->crypto.psk,
2491 else if (profile->use_fwsup == BRCMF_PROFILE_FWSUP_SAE) {
2492 /* clean up user-space RSNE */
2495 bphy_err(drvr, "failed to clean up user-space RSNE\n");
2498 err = brcmf_fwvid_set_sae_password(ifp, &sme->crypto);
2499 if (!err && sme->crypto.psk)
2500 err = brcmf_set_pmk(ifp, sme->crypto.psk,
2511 if (cfg->channel)
2515 err = -ENOMEM;
2518 ssid_len = min_t(u32, sme->ssid_len, IEEE80211_MAX_SSID_LEN);
2519 ext_join_params->ssid_le.SSID_len = cpu_to_le32(ssid_len);
2520 memcpy(&ext_join_params->ssid_le.SSID, sme->ssid, ssid_len);
2523 ext_join_params->ssid_le.SSID, ssid_len);
2526 ext_join_params->scan_le.scan_type = -1;
2527 ext_join_params->scan_le.home_time = cpu_to_le32(-1);
2529 if (sme->bssid)
2530 memcpy(&ext_join_params->assoc_le.bssid, sme->bssid, ETH_ALEN);
2532 eth_broadcast_addr(ext_join_params->assoc_le.bssid);
2534 if (cfg->channel) {
2535 ext_join_params->assoc_le.chanspec_num = cpu_to_le32(1);
2537 ext_join_params->assoc_le.chanspec_list[0] =
2543 ext_join_params->scan_le.active_time =
2545 ext_join_params->scan_le.passive_time =
2551 ext_join_params->scan_le.nprobes =
2555 ext_join_params->scan_le.active_time = cpu_to_le32(-1);
2556 ext_join_params->scan_le.passive_time = cpu_to_le32(-1);
2557 ext_join_params->scan_le.nprobes = cpu_to_le32(-1);
2560 brcmf_set_join_pref(ifp, &sme->bss_select);
2573 memcpy(&join_params.ssid_le.SSID, sme->ssid, ssid_len);
2576 if (sme->bssid)
2577 memcpy(join_params.params_le.bssid, sme->bssid, ETH_ALEN);
2581 if (cfg->channel) {
2593 clear_bit(BRCMF_VIF_STATUS_CONNECTING, &ifp->vif->sme_state);
2604 struct brcmf_cfg80211_profile *profile = &ifp->vif->profile;
2605 struct brcmf_pub *drvr = cfg->pub;
2610 if (!check_vif_up(ifp->vif))
2611 return -EIO;
2613 clear_bit(BRCMF_VIF_STATUS_CONNECTED, &ifp->vif->sme_state);
2614 clear_bit(BRCMF_VIF_STATUS_CONNECTING, &ifp->vif->sme_state);
2615 clear_bit(BRCMF_VIF_STATUS_EAP_SUCCESS, &ifp->vif->sme_state);
2616 clear_bit(BRCMF_VIF_STATUS_ASSOC_SUCCESS, &ifp->vif->sme_state);
2619 memcpy(&scbval.ea, &profile->bssid, ETH_ALEN);
2637 struct brcmf_pub *drvr = cfg->pub;
2643 if (!check_vif_up(ifp->vif))
2644 return -EIO;
2652 bphy_err(drvr, "TX_POWER_FIXED - dbm is negative\n");
2653 err = -EINVAL;
2663 err = -EINVAL;
2687 struct brcmf_pub *drvr = cfg->pub;
2693 return -EIO;
2695 err = brcmf_fil_iovar_int_get(vif->ifp, "qtxpower", &qdbm);
2713 struct brcmf_pub *drvr = ifp->drvr;
2720 if (!check_vif_up(ifp->vif))
2721 return -EIO;
2754 if (!check_vif_up(ifp->vif))
2755 return -EIO;
2759 return -EINVAL;
2762 key = &ifp->vif->profile.key[key_idx];
2764 if (key->algo == CRYPTO_ALGO_OFF) {
2766 return -EINVAL;
2770 key->index = (u32)key_idx;
2771 key->flags = BRCMF_PRIMARY_KEY;
2787 struct brcmf_pub *drvr = cfg->pub;
2797 if (!check_vif_up(ifp->vif))
2798 return -EIO;
2803 return -EINVAL;
2806 if (params->key_len == 0)
2807 return brcmf_cfg80211_del_key(wiphy, ndev, -1, key_idx,
2810 if (params->key_len > sizeof(key->data)) {
2811 bphy_err(drvr, "Too long key length (%u)\n", params->key_len);
2812 return -EINVAL;
2816 if (mac_addr && (params->cipher != WLAN_CIPHER_SUITE_WEP40) &&
2817 (params->cipher != WLAN_CIPHER_SUITE_WEP104)) {
2822 key = &ifp->vif->profile.key[key_idx];
2825 memcpy((char *)&key->ea, (void *)mac_addr, ETH_ALEN);
2826 key->len = params->key_len;
2827 key->index = key_idx;
2828 memcpy(key->data, params->key, key->len);
2830 key->flags = BRCMF_PRIMARY_KEY;
2832 if (params->seq && params->seq_len == 6) {
2836 ivptr = (u8 *)params->seq;
2837 key->rxiv.hi = (ivptr[5] << 24) | (ivptr[4] << 16) |
2839 key->rxiv.lo = (ivptr[1] << 8) | ivptr[0];
2840 key->iv_initialized = true;
2843 switch (params->cipher) {
2845 key->algo = CRYPTO_ALGO_WEP1;
2850 key->algo = CRYPTO_ALGO_WEP128;
2855 if (!brcmf_is_apmode(ifp->vif)) {
2857 memcpy(keybuf, &key->data[24], sizeof(keybuf));
2858 memcpy(&key->data[24], &key->data[16], sizeof(keybuf));
2859 memcpy(&key->data[16], keybuf, sizeof(keybuf));
2861 key->algo = CRYPTO_ALGO_TKIP;
2866 key->algo = CRYPTO_ALGO_AES_CCM;
2871 key->algo = CRYPTO_ALGO_AES_CCM;
2876 bphy_err(drvr, "Invalid cipher (0x%x)\n", params->cipher);
2877 err = -EINVAL;
2912 struct brcmf_cfg80211_profile *profile = &ifp->vif->profile;
2913 struct brcmf_pub *drvr = cfg->pub;
2920 if (!check_vif_up(ifp->vif))
2921 return -EIO;
2929 err = -EAGAIN;
2933 sec = &profile->sec;
2934 if (sec->cipher_pairwise & WLAN_CIPHER_SUITE_WEP40) {
2937 } else if (sec->cipher_pairwise & WLAN_CIPHER_SUITE_WEP104) {
2949 err = -EINVAL;
2973 return -EOPNOTSUPP;
2979 struct brcmf_pub *drvr = ifp->drvr;
2986 key = &ifp->vif->profile.key[key_idx];
2987 if ((key->algo == CRYPTO_ALGO_WEP1) ||
2988 (key->algo == CRYPTO_ALGO_WEP128))
3015 si->filled |= BIT_ULL(NL80211_STA_INFO_STA_FLAGS);
3016 sfu = &si->sta_flags;
3017 sfu->mask = BIT(NL80211_STA_FLAG_WME) |
3022 sfu->set |= BIT(NL80211_STA_FLAG_WME);
3024 sfu->set |= BIT(NL80211_STA_FLAG_AUTHENTICATED);
3026 sfu->set |= BIT(NL80211_STA_FLAG_ASSOCIATED);
3028 sfu->set |= BIT(NL80211_STA_FLAG_AUTHORIZED);
3033 struct brcmf_pub *drvr = ifp->drvr;
3045 buf->len = cpu_to_le32(WL_BSS_INFO_MAX);
3052 si->filled |= BIT_ULL(NL80211_STA_INFO_BSS_PARAM);
3053 si->bss_param.beacon_interval = le16_to_cpu(buf->bss_le.beacon_period);
3054 si->bss_param.dtim_period = buf->bss_le.dtim_period;
3055 capability = le16_to_cpu(buf->bss_le.capability);
3057 si->bss_param.flags |= BSS_PARAM_FLAGS_CTS_PROT;
3059 si->bss_param.flags |= BSS_PARAM_FLAGS_SHORT_PREAMBLE;
3061 si->bss_param.flags |= BSS_PARAM_FLAGS_SHORT_SLOT_TIME;
3071 struct brcmf_pub *drvr = ifp->drvr;
3084 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_TX_BITRATE);
3085 sinfo->txrate.legacy = rate * 5;
3095 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_SIGNAL);
3096 sinfo->signal = rssi;
3104 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_RX_PACKETS) |
3108 sinfo->rx_packets = le32_to_cpu(pktcnt.rx_good_pkt);
3109 sinfo->rx_dropped_misc = le32_to_cpu(pktcnt.rx_bad_pkt);
3110 sinfo->tx_packets = le32_to_cpu(pktcnt.tx_good_pkt);
3111 sinfo->tx_failed = le32_to_cpu(pktcnt.tx_bad_pkt);
3122 struct brcmf_pub *drvr = cfg->pub;
3135 if (!check_vif_up(ifp->vif))
3136 return -EIO;
3138 if (brcmf_is_ibssmode(ifp->vif))
3157 sinfo->filled = BIT_ULL(NL80211_STA_INFO_INACTIVE_TIME);
3158 sinfo->inactive_time = le32_to_cpu(sta_info_le.idle) * 1000;
3161 sinfo->sta_flags.mask |= BIT(NL80211_STA_FLAG_TDLS_PEER);
3163 sinfo->sta_flags.set |= BIT(NL80211_STA_FLAG_TDLS_PEER);
3165 sinfo->sta_flags.set &= ~BIT(NL80211_STA_FLAG_TDLS_PEER);
3167 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_CONNECTED_TIME);
3168 sinfo->connected_time = le32_to_cpu(sta_info_le.in);
3172 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_TX_FAILED);
3173 sinfo->tx_failed = le32_to_cpu(sta_info_le.tx_failures);
3174 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_TX_PACKETS);
3175 sinfo->tx_packets = le32_to_cpu(sta_info_le.tx_pkts);
3176 sinfo->tx_packets += le32_to_cpu(sta_info_le.tx_mcast_pkts);
3177 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_RX_PACKETS);
3178 sinfo->rx_packets = le32_to_cpu(sta_info_le.rx_ucast_pkts);
3179 sinfo->rx_packets += le32_to_cpu(sta_info_le.rx_mcast_pkts);
3180 if (sinfo->tx_packets) {
3181 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_TX_BITRATE);
3182 sinfo->txrate.legacy =
3185 if (sinfo->rx_packets) {
3186 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_RX_BITRATE);
3187 sinfo->rxrate.legacy =
3191 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_TX_BYTES);
3192 sinfo->tx_bytes = le64_to_cpu(sta_info_le.tx_tot_bytes);
3193 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_RX_BYTES);
3194 sinfo->rx_bytes = le64_to_cpu(sta_info_le.rx_tot_bytes);
3200 sinfo->chains |= BIT(count_rssi);
3201 sinfo->chain_signal[count_rssi] =
3203 sinfo->chain_signal_avg[count_rssi] =
3210 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_SIGNAL);
3211 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_SIGNAL_AVG);
3212 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_CHAIN_SIGNAL);
3213 sinfo->filled |=
3215 sinfo->signal = total_rssi / count_rssi;
3216 sinfo->signal_avg = total_rssi_avg / count_rssi;
3218 &ifp->vif->sme_state)) {
3228 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_SIGNAL);
3229 sinfo->signal = rssi;
3245 struct brcmf_pub *drvr = cfg->pub;
3251 cfg->assoclist.count = cpu_to_le32(BRCMF_MAX_ASSOCLIST);
3253 &cfg->assoclist,
3254 sizeof(cfg->assoclist));
3257 if (err == -EBADE)
3263 cfg->assoclist.count = 0;
3264 return -EOPNOTSUPP;
3267 if (idx < le32_to_cpu(cfg->assoclist.count)) {
3268 memcpy(mac, cfg->assoclist.mac[idx], ETH_ALEN);
3271 return -ENOENT;
3282 struct brcmf_pub *drvr = cfg->pub;
3293 cfg->pwr_save = enabled;
3294 if (!check_vif_up(ifp->vif)) {
3302 if (ifp->vif->wdev.iftype == NL80211_IFTYPE_P2P_CLIENT) {
3310 if (err == -ENODEV)
3330 struct brcmf_pub *drvr = cfg->pub;
3342 if (le32_to_cpu(bi->length) > WL_BSS_INFO_MAX) {
3344 return -EINVAL;
3347 if (!bi->ctl_ch) {
3348 ch.chspec = le16_to_cpu(bi->chanspec);
3349 cfg->d11inf.decchspec(&ch);
3350 bi->ctl_ch = ch.control_ch_num;
3352 channel = bi->ctl_ch;
3363 notify_capability = le16_to_cpu(bi->capability);
3364 notify_interval = le16_to_cpu(bi->beacon_period);
3365 notify_ie = (u8 *)bi + le16_to_cpu(bi->ie_offset);
3366 notify_ielen = le32_to_cpu(bi->ie_length);
3367 bss_data.signal = (s16)le16_to_cpu(bi->RSSI) * 100;
3369 brcmf_dbg(CONN, "bssid: %pM\n", bi->BSSID);
3377 (const u8 *)bi->BSSID,
3383 return -ENOMEM;
3394 return list->bss_info_le;
3396 le32_to_cpu(bss->length));
3401 struct brcmf_pub *drvr = cfg->pub;
3407 bss_list = (struct brcmf_scan_results *)cfg->escan_info.escan_buf;
3408 if (bss_list->count != 0 &&
3409 bss_list->version != BRCMF_BSS_INFO_VERSION) {
3411 bss_list->version);
3412 return -EOPNOTSUPP;
3414 brcmf_dbg(SCAN, "scanned AP count (%d)\n", bss_list->count);
3415 for (i = 0; i < bss_list->count; i++) {
3428 struct brcmf_pub *drvr = cfg->pub;
3447 err = -ENOMEM;
3462 ch.chspec = le16_to_cpu(bi->chanspec);
3463 cfg->d11inf.decchspec(&ch);
3466 band = wiphy->bands[NL80211_BAND_2GHZ];
3468 band = wiphy->bands[NL80211_BAND_5GHZ];
3470 freq = ieee80211_channel_to_frequency(ch.control_ch_num, band->band);
3471 cfg->channel = freq;
3474 notify_capability = le16_to_cpu(bi->capability);
3475 notify_interval = le16_to_cpu(bi->beacon_period);
3476 notify_ie = (u8 *)bi + le16_to_cpu(bi->ie_offset);
3477 notify_ielen = le32_to_cpu(bi->ie_length);
3478 notify_signal = (s16)le16_to_cpu(bi->RSSI) * 100;
3492 err = -ENOMEM;
3510 struct brcmf_pub *drvr = cfg->pub;
3515 if (brcmf_is_ibssmode(ifp->vif))
3518 *(__le32 *)cfg->extra_buf = cpu_to_le32(WL_EXTRA_BUF_MAX);
3520 cfg->extra_buf, WL_EXTRA_BUF_MAX);
3525 bi = (struct brcmf_bss_info_le *)(cfg->extra_buf + 4);
3535 struct escan_info *escan = &cfg->escan_info;
3537 set_bit(BRCMF_SCAN_STATUS_ABORT, &cfg->scan_status);
3538 if (cfg->int_escan_map || cfg->scan_request) {
3539 escan->escan_state = WL_ESCAN_STATE_IDLE;
3540 brcmf_notify_escan_complete(cfg, escan->ifp, true, true);
3542 clear_bit(BRCMF_SCAN_STATUS_BUSY, &cfg->scan_status);
3543 clear_bit(BRCMF_SCAN_STATUS_ABORT, &cfg->scan_status);
3553 brcmf_notify_escan_complete(cfg, cfg->escan_info.ifp, true, true);
3560 struct brcmf_pub *drvr = cfg->pub;
3562 if (cfg->int_escan_map || cfg->scan_request) {
3564 schedule_work(&cfg->escan_timeout_work);
3575 ch_bss.chspec = le16_to_cpu(bss->chanspec);
3576 cfg->d11inf.decchspec(&ch_bss);
3577 ch_bss_info_le.chspec = le16_to_cpu(bss_info_le->chanspec);
3578 cfg->d11inf.decchspec(&ch_bss_info_le);
3580 if (!memcmp(&bss_info_le->BSSID, &bss->BSSID, ETH_ALEN) &&
3582 bss_info_le->SSID_len == bss->SSID_len &&
3583 !memcmp(bss_info_le->SSID, bss->SSID, bss_info_le->SSID_len)) {
3584 if ((bss->flags & BRCMF_BSS_RSSI_ON_CHANNEL) ==
3585 (bss_info_le->flags & BRCMF_BSS_RSSI_ON_CHANNEL)) {
3586 s16 bss_rssi = le16_to_cpu(bss->RSSI);
3587 s16 bss_info_rssi = le16_to_cpu(bss_info_le->RSSI);
3590 * both on-channel or both off-channel
3593 bss->RSSI = bss_info_le->RSSI;
3594 } else if ((bss->flags & BRCMF_BSS_RSSI_ON_CHANNEL) &&
3595 (bss_info_le->flags & BRCMF_BSS_RSSI_ON_CHANNEL) == 0) {
3596 /* preserve the on-channel rssi measurement
3599 bss->RSSI = bss_info_le->RSSI;
3600 bss->flags |= BRCMF_BSS_RSSI_ON_CHANNEL;
3611 struct brcmf_pub *drvr = ifp->drvr;
3612 struct brcmf_cfg80211_info *cfg = drvr->config;
3623 status = e->status;
3628 if (!test_bit(BRCMF_SCAN_STATUS_BUSY, &cfg->scan_status)) {
3630 ifp->bsscfgidx);
3631 return -EPERM;
3636 if (e->datalen < sizeof(*escan_result_le)) {
3645 escan_buflen = le32_to_cpu(escan_result_le->buflen);
3647 escan_buflen > e->datalen ||
3653 if (le16_to_cpu(escan_result_le->bss_count) != 1) {
3655 escan_result_le->bss_count);
3658 bss_info_le = &escan_result_le->bss_info_le;
3663 if (!cfg->int_escan_map && !cfg->scan_request) {
3668 bi_length = le32_to_cpu(bss_info_le->length);
3669 if (bi_length != escan_buflen - WL_ESCAN_RESULTS_FIXED_SIZE) {
3675 if (!(cfg_to_wiphy(cfg)->interface_modes &
3677 if (le16_to_cpu(bss_info_le->capability) &
3685 cfg->escan_info.escan_buf;
3686 if (bi_length > BRCMF_ESCAN_BUF_SIZE - list->buflen) {
3691 for (i = 0; i < list->count; i++) {
3694 le32_to_cpu(bss->length)) : list->bss_info_le;
3699 memcpy(&cfg->escan_info.escan_buf[list->buflen], bss_info_le,
3701 list->version = le32_to_cpu(bss_info_le->version);
3702 list->buflen += bi_length;
3703 list->count++;
3705 cfg->escan_info.escan_state = WL_ESCAN_STATE_IDLE;
3708 if (cfg->int_escan_map || cfg->scan_request) {
3722 brcmf_fweh_register(cfg->pub, BRCMF_E_ESCAN_RESULT,
3724 cfg->escan_info.escan_state = WL_ESCAN_STATE_IDLE;
3726 timer_setup(&cfg->escan_timeout, brcmf_escan_timeout, 0);
3727 INIT_WORK(&cfg->escan_timeout_work,
3737 n_netinfo * sizeof(req->channels[0]) +
3738 n_netinfo * sizeof(*req->ssids);
3742 req->wiphy = wiphy;
3743 req->ssids = (void *)(&req->channels[0]) +
3744 n_netinfo * sizeof(req->channels[0]);
3763 return -EINVAL;
3765 chan = ieee80211_get_channel(req->wiphy, freq);
3767 return -EINVAL;
3769 for (i = 0; i < req->n_channels; i++) {
3770 if (req->channels[i] == chan)
3773 if (i == req->n_channels) {
3774 req->n_channels++;
3775 req->channels[i] = chan;
3778 for (i = 0; i < req->n_ssids; i++) {
3779 if (req->ssids[i].ssid_len == ssid_len &&
3780 !memcmp(req->ssids[i].ssid, ssid, ssid_len))
3783 if (i == req->n_ssids) {
3784 memcpy(req->ssids[req->n_ssids].ssid, ssid, ssid_len);
3785 req->ssids[req->n_ssids++].ssid_len = ssid_len;
3793 struct brcmf_cfg80211_info *cfg = ifp->drvr->config;
3796 if (test_bit(BRCMF_SCAN_STATUS_BUSY, &cfg->scan_status)) {
3797 if (cfg->int_escan_map)
3798 brcmf_dbg(SCAN, "aborting internal scan: map=%u\n",
3799 cfg->int_escan_map);
3800 /* Abort any on-going scan */
3804 brcmf_dbg(SCAN, "start internal scan: map=%u\n", fwmap);
3805 set_bit(BRCMF_SCAN_STATUS_BUSY, &cfg->scan_status);
3806 cfg->escan_info.run = brcmf_run_escan;
3809 clear_bit(BRCMF_SCAN_STATUS_BUSY, &cfg->scan_status);
3812 cfg->int_escan_map = fwmap;
3822 switch (pfn_v1->version) {
3848 struct brcmf_pub *drvr = ifp->drvr;
3849 struct brcmf_cfg80211_info *cfg = drvr->config;
3862 if (e->datalen < (sizeof(*pfn_result) + sizeof(*netinfo))) {
3867 if (e->event_code == BRCMF_E_PFN_NET_LOST) {
3873 result_count = le32_to_cpu(pfn_result->count);
3874 status = le32_to_cpu(pfn_result->status);
3887 datalen = e->datalen - ((void *)netinfo_start - (void *)pfn_result);
3896 err = -ENOMEM;
3904 if (netinfo->SSID_len > IEEE80211_MAX_SSID_LEN)
3905 netinfo->SSID_len = IEEE80211_MAX_SSID_LEN;
3907 netinfo->SSID, netinfo->channel);
3908 bucket_map |= brcmf_pno_get_bucket_map(cfg->pno, netinfo);
3910 netinfo->SSID,
3911 netinfo->SSID_len,
3912 netinfo->channel);
3938 struct brcmf_pub *drvr = cfg->pub;
3941 req->n_match_sets, req->n_ssids);
3943 if (test_bit(BRCMF_SCAN_STATUS_SUPPRESS, &cfg->scan_status)) {
3945 cfg->scan_status);
3946 return -EAGAIN;
3949 if (req->n_match_sets <= 0) {
3951 req->n_match_sets);
3952 return -EINVAL;
3966 if (cfg->int_escan_map)
3993 patternoffset = sizeof(*filter) - sizeof(filter->cmd) + masksize;
3998 return -ENOMEM;
4001 memcpy(filter->cmd, cmd, 4);
4002 filter->masksize = cpu_to_le32(masksize);
4003 filter->offset = cpu_to_le32(packet_offset);
4004 filter->patternoffset = cpu_to_le32(patternoffset);
4005 filter->patternsize = cpu_to_le32(patternsize);
4006 filter->type = cpu_to_le32(BRCMF_WOWL_PATTERN_TYPE_BITMAP);
4023 struct brcmf_pub *drvr = ifp->drvr;
4024 struct brcmf_cfg80211_info *cfg = drvr->config;
4030 if (e->datalen < (sizeof(*pfn_result) + sizeof(*netinfo))) {
4037 if (e->event_code == BRCMF_E_PFN_NET_LOST) {
4042 if (le32_to_cpu(pfn_result->count) < 1) {
4044 le32_to_cpu(pfn_result->count));
4045 return -EINVAL;
4049 if (netinfo->SSID_len > IEEE80211_MAX_SSID_LEN)
4050 netinfo->SSID_len = IEEE80211_MAX_SSID_LEN;
4051 memcpy(cfg->wowl.nd->ssid.ssid, netinfo->SSID, netinfo->SSID_len);
4052 cfg->wowl.nd->ssid.ssid_len = netinfo->SSID_len;
4053 cfg->wowl.nd->n_channels = 1;
4054 cfg->wowl.nd->channels[0] =
4055 ieee80211_channel_to_frequency(netinfo->channel,
4056 netinfo->channel <= CH_MAX_2G_CHANNEL ?
4058 cfg->wowl.nd_info->n_matches = 1;
4059 cfg->wowl.nd_info->matches[0] = cfg->wowl.nd;
4062 cfg->wowl.nd_data_completed = true;
4063 wake_up(&cfg->wowl.nd_data_wait);
4073 struct brcmf_pub *drvr = cfg->pub;
4094 wakeup_data.pattern_idx = -1;
4114 /* For now always map to pattern 0, no API to get
4121 time_left = wait_event_timeout(cfg->wowl.nd_data_wait,
4122 cfg->wowl.nd_data_completed,
4127 wakeup_data.net_detect = cfg->wowl.nd_info;
4136 cfg80211_report_wowlan_wakeup(&ifp->vif->wdev, wakeup, GFP_KERNEL);
4155 if (cfg->wowl.active) {
4162 cfg->wowl.pre_pmmode);
4163 cfg->wowl.active = false;
4164 if (cfg->wowl.nd_enabled) {
4165 brcmf_cfg80211_sched_scan_stop(cfg->wiphy, ifp->ndev, 0);
4166 brcmf_fweh_unregister(cfg->pub, BRCMF_E_PFN_NET_FOUND);
4167 brcmf_fweh_register(cfg->pub, BRCMF_E_PFN_NET_FOUND,
4169 cfg->wowl.nd_enabled = false;
4187 brcmf_fil_cmd_int_get(ifp, BRCMF_C_GET_PM, &cfg->wowl.pre_pmmode);
4191 if (wowl->disconnect)
4193 if (wowl->magic_pkt)
4195 if ((wowl->patterns) && (wowl->n_patterns)) {
4197 for (i = 0; i < wowl->n_patterns; i++) {
4199 (u8 *)wowl->patterns[i].pattern,
4200 wowl->patterns[i].pattern_len,
4201 (u8 *)wowl->patterns[i].mask,
4202 wowl->patterns[i].pkt_offset);
4205 if (wowl->nd_config) {
4206 brcmf_cfg80211_sched_scan_start(cfg->wiphy, ifp->ndev,
4207 wowl->nd_config);
4210 cfg->wowl.nd_data_completed = false;
4211 cfg->wowl.nd_enabled = true;
4213 brcmf_fweh_unregister(cfg->pub, BRCMF_E_PFN_NET_FOUND);
4214 brcmf_fweh_register(cfg->pub, BRCMF_E_PFN_NET_FOUND,
4217 if (wowl->gtk_rekey_failure)
4219 if (!test_bit(BRCMF_VIF_STATUS_CONNECTED, &ifp->vif->sme_state))
4227 brcmf_bus_wowl_config(cfg->pub->bus_if, true);
4228 cfg->wowl.active = true;
4244 brcmf_err("keep-alive packet config failed, ret=%d\n", ret);
4262 if (!check_vif_up(ifp->vif))
4270 if (test_bit(BRCMF_SCAN_STATUS_BUSY, &cfg->scan_status))
4274 brcmf_bus_wowl_config(cfg->pub->bus_if, false);
4275 list_for_each_entry(vif, &cfg->vif_list, list) {
4276 if (!test_bit(BRCMF_VIF_STATUS_READY, &vif->sme_state))
4296 /* Prevent disassociation due to inactivity with keep-alive */
4303 cfg->scan_status = 0;
4317 return -ENOMEM;
4319 pmk_op->version = cpu_to_le16(BRCMF_PMKSA_VER_3);
4323 pmk_op->count = cpu_to_le16(0);
4326 pmk_op->count = cpu_to_le16(1);
4328 if (pmksa->bssid)
4329 memcpy(pmk_op->pmk[0].bssid, pmksa->bssid, ETH_ALEN);
4330 if (pmksa->pmkid) {
4331 memcpy(pmk_op->pmk[0].pmkid, pmksa->pmkid, WLAN_PMKID_LEN);
4332 pmk_op->pmk[0].pmkid_len = WLAN_PMKID_LEN;
4334 if (pmksa->ssid && pmksa->ssid_len) {
4335 memcpy(pmk_op->pmk[0].ssid.SSID, pmksa->ssid, pmksa->ssid_len);
4336 pmk_op->pmk[0].ssid.SSID_len = pmksa->ssid_len;
4338 pmk_op->pmk[0].time_left = cpu_to_le32(alive ? BRCMF_PMKSA_NO_EXPIRY : 0);
4341 pmk_op->length = cpu_to_le16(length);
4355 pmk_list = &cfg->pmk_list;
4356 npmk = le32_to_cpu(pmk_list->npmk);
4360 brcmf_dbg(CONN, "PMK[%d]: %pM\n", i, &pmk_list->pmk[i].bssid);
4372 struct brcmf_pmksa *pmk = &cfg->pmk_list.pmk[0];
4373 struct brcmf_pub *drvr = cfg->pub;
4378 if (!check_vif_up(ifp->vif))
4379 return -EIO;
4381 brcmf_dbg(CONN, "set_pmksa - PMK bssid: %pM =\n", pmksa->bssid);
4382 brcmf_dbg(CONN, "%*ph\n", WLAN_PMKID_LEN, pmksa->pmkid);
4389 npmk = le32_to_cpu(cfg->pmk_list.npmk);
4391 if (!memcmp(pmksa->bssid, pmk[i].bssid, ETH_ALEN))
4394 memcpy(pmk[i].bssid, pmksa->bssid, ETH_ALEN);
4395 memcpy(pmk[i].pmkid, pmksa->pmkid, WLAN_PMKID_LEN);
4398 cfg->pmk_list.npmk = cpu_to_le32(npmk);
4402 return -EINVAL;
4417 struct brcmf_pmksa *pmk = &cfg->pmk_list.pmk[0];
4418 struct brcmf_pub *drvr = cfg->pub;
4423 if (!check_vif_up(ifp->vif))
4424 return -EIO;
4426 brcmf_dbg(CONN, "del_pmksa - PMK bssid = %pM\n", pmksa->bssid);
4433 npmk = le32_to_cpu(cfg->pmk_list.npmk);
4435 if (!memcmp(pmksa->bssid, pmk[i].bssid, ETH_ALEN))
4439 for (; i < (npmk - 1); i++) {
4445 cfg->pmk_list.npmk = cpu_to_le32(npmk - 1);
4448 return -EINVAL;
4466 if (!check_vif_up(ifp->vif))
4467 return -EIO;
4474 memset(&cfg->pmk_list, 0, sizeof(cfg->pmk_list));
4484 struct brcmf_pub *drvr = ifp->drvr;
4500 /* set upper-layer auth */
4501 if (brcmf_is_ibssmode(ifp->vif))
4527 struct brcmf_pub *drvr = ifp->drvr;
4547 len = wpa_ie->len + TLV_HDR_LEN;
4557 err = -EINVAL;
4563 err = -EINVAL;
4585 err = -EINVAL;
4596 err = -EINVAL;
4602 err = -EINVAL;
4630 err = -EINVAL;
4636 err = -EINVAL;
4691 err = -EINVAL;
4756 /* set upper-layer auth */
4781 if (ie->id != WLAN_EID_VENDOR_SPECIFIC)
4785 if (vndrie->len < (VS_IE_FIXED_HDR_LEN - TLV_HDR_LEN + 1)) {
4787 vndrie->len);
4791 if (!memcmp(vndrie->oui, (u8 *)WPA_OUI, TLV_OUI_LEN) &&
4792 ((vndrie->oui_type == WPA_OUI_TYPE) ||
4793 (vndrie->oui_type == WME_OUI_TYPE))) {
4798 parsed_info = &vndr_ies->ie_info[vndr_ies->count];
4801 parsed_info->ie_ptr = (char *)vndrie;
4802 parsed_info->ie_len = vndrie->len + TLV_HDR_LEN;
4803 memcpy(&parsed_info->vndrie, vndrie, sizeof(*vndrie));
4805 vndr_ies->count++;
4808 parsed_info->vndrie.oui,
4809 parsed_info->vndrie.oui_type);
4811 if (vndr_ies->count >= VNDR_IE_PARSE_LIMIT)
4814 remaining_len -= (ie->len + TLV_HDR_LEN);
4818 ie = (struct brcmf_tlv *)(((u8 *)ie) + ie->len +
4861 return -ENODEV;
4862 ifp = vif->ifp;
4863 drvr = ifp->drvr;
4864 saved_ie = &vif->saved_ie;
4866 brcmf_dbg(TRACE, "bsscfgidx %d, pktflag : 0x%02X\n", ifp->bsscfgidx,
4870 return -ENOMEM;
4874 mgmt_ie_buf = saved_ie->probe_req_ie;
4875 mgmt_ie_len = &saved_ie->probe_req_ie_len;
4876 mgmt_ie_buf_len = sizeof(saved_ie->probe_req_ie);
4879 mgmt_ie_buf = saved_ie->probe_res_ie;
4880 mgmt_ie_len = &saved_ie->probe_res_ie_len;
4881 mgmt_ie_buf_len = sizeof(saved_ie->probe_res_ie);
4884 mgmt_ie_buf = saved_ie->beacon_ie;
4885 mgmt_ie_len = &saved_ie->beacon_ie_len;
4886 mgmt_ie_buf_len = sizeof(saved_ie->beacon_ie);
4889 mgmt_ie_buf = saved_ie->assoc_req_ie;
4890 mgmt_ie_len = &saved_ie->assoc_req_ie_len;
4891 mgmt_ie_buf_len = sizeof(saved_ie->assoc_req_ie);
4894 mgmt_ie_buf = saved_ie->assoc_res_ie;
4895 mgmt_ie_len = &saved_ie->assoc_res_ie_len;
4896 mgmt_ie_buf_len = sizeof(saved_ie->assoc_res_ie);
4899 err = -EPERM;
4905 err = -ENOMEM;
4916 memcpy(ptr + parsed_ie_buf_len, vndrie_info->ie_ptr,
4917 vndrie_info->ie_len);
4918 parsed_ie_buf_len += vndrie_info->ie_len;
4938 vndrie_info->vndrie.id,
4939 vndrie_info->vndrie.len,
4940 vndrie_info->vndrie.oui);
4943 vndrie_info->ie_ptr,
4944 vndrie_info->ie_len,
4963 if (remained_buf_len < (vndrie_info->vndrie.len +
4969 remained_buf_len -= (vndrie_info->ie_len +
4973 vndrie_info->vndrie.id,
4974 vndrie_info->vndrie.len,
4975 vndrie_info->vndrie.oui);
4978 vndrie_info->ie_ptr,
4979 vndrie_info->ie_len,
4983 memcpy(ptr + (*mgmt_ie_len), vndrie_info->ie_ptr,
4984 vndrie_info->ie_len);
4985 *mgmt_ie_len += vndrie_info->ie_len;
5011 if (vif->wdev.iftype == NL80211_IFTYPE_AP)
5019 memset(&vif->saved_ie, 0, sizeof(vif->saved_ie));
5027 struct brcmf_pub *drvr = vif->ifp->drvr;
5032 beacon->tail, beacon->tail_len);
5041 beacon->proberesp_ies,
5042 beacon->proberesp_ies_len);
5050 beacon->assocresp_ies,
5051 beacon->assocresp_ies_len);
5070 rsn_ie = brcmf_parse_tlvs((u8 *)settings->beacon.tail,
5071 settings->beacon.tail_len, WLAN_EID_RSN);
5074 wpa_ie = brcmf_find_wpaie((u8 *)settings->beacon.tail,
5075 settings->beacon.tail_len);
5109 struct brcmf_pub *drvr = cfg->pub;
5110 struct brcmf_cfg80211_profile *profile = &ifp->vif->profile;
5111 struct cfg80211_crypto_settings *crypto = &settings->crypto;
5115 s32 err = -EPERM;
5119 u16 chanspec = chandef_to_chanspec(&cfg->d11inf, &settings->chandef);
5126 settings->chandef.chan->hw_value,
5127 settings->chandef.center_freq1, settings->chandef.width,
5128 settings->beacon_interval, settings->dtim_period);
5130 settings->ssid, settings->ssid_len, settings->auth_type,
5131 settings->inactivity_timeout);
5132 dev_role = ifp->vif->wdev.iftype;
5133 mbss = ifp->vif->mbss;
5137 &ifp->vif->is_11d)) {
5140 country_ie = brcmf_parse_tlvs((u8 *)settings->beacon.tail,
5141 settings->beacon.tail_len,
5148 if (settings->ssid == NULL || settings->ssid_len == 0) {
5151 (u8 *)&settings->beacon.head[ie_offset],
5152 settings->beacon.head_len - ie_offset,
5154 if (!ssid_ie || ssid_ie->len > IEEE80211_MAX_SSID_LEN)
5155 return -EINVAL;
5157 memcpy(ssid_le.SSID, ssid_ie->data, ssid_ie->len);
5158 ssid_le.SSID_len = cpu_to_le32(ssid_ie->len);
5161 memcpy(ssid_le.SSID, settings->ssid, settings->ssid_len);
5162 ssid_le.SSID_len = cpu_to_le32((u32)settings->ssid_len);
5172 if ((supports_11d) && (is_11d != ifp->vif->is_11d)) {
5181 if (settings->beacon_interval) {
5183 settings->beacon_interval);
5190 if (settings->dtim_period) {
5192 settings->dtim_period);
5201 ((ifp->ifidx == 0) ||
5218 } else if (WARN_ON(supports_11d && (is_11d != ifp->vif->is_11d))) {
5219 /* Multiple-BSS should use same 11d configuration */
5220 err = -EINVAL;
5252 if (crypto->psk) {
5254 profile->use_fwauth |= BIT(BRCMF_PROFILE_FWAUTH_PSK);
5255 err = brcmf_set_pmk(ifp, crypto->psk,
5260 if (crypto->sae_pwd) {
5262 profile->use_fwauth |= BIT(BRCMF_PROFILE_FWAUTH_SAE);
5267 if (profile->use_fwauth == 0)
5268 profile->use_fwauth = BIT(BRCMF_PROFILE_FWAUTH_NONE);
5294 (settings->hidden_ssid != NL80211_HIDDEN_SSID_NOT_IN_USE);
5325 bss_enable.bsscfgidx = cpu_to_le32(ifp->bsscfgidx);
5339 brcmf_config_ap_mgmt_ie(ifp->vif, &settings->beacon);
5340 set_bit(BRCMF_VIF_STATUS_AP_CREATED, &ifp->vif->sme_state);
5356 struct brcmf_pub *drvr = cfg->pub;
5357 struct brcmf_cfg80211_profile *profile = &ifp->vif->profile;
5364 if (ifp->vif->wdev.iftype == NL80211_IFTYPE_AP) {
5369 if (profile->use_fwauth != BIT(BRCMF_PROFILE_FWAUTH_NONE)) {
5372 if (profile->use_fwauth & BIT(BRCMF_PROFILE_FWAUTH_PSK))
5374 if (profile->use_fwauth & BIT(BRCMF_PROFILE_FWAUTH_SAE))
5376 profile->use_fwauth = BIT(BRCMF_PROFILE_FWAUTH_NONE);
5379 if (ifp->vif->mbss) {
5385 if (ifp->bsscfgidx == 0)
5402 ifp->vif->is_11d);
5408 brcmf_vif_clear_mgmt_ies(ifp->vif);
5410 bss_enable.bsscfgidx = cpu_to_le32(ifp->bsscfgidx);
5419 clear_bit(BRCMF_VIF_STATUS_AP_CREATED, &ifp->vif->sme_state);
5433 return brcmf_config_ap_mgmt_ie(ifp->vif, &info->beacon);
5441 struct brcmf_pub *drvr = cfg->pub;
5446 if (!params->mac)
5447 return -EFAULT;
5449 brcmf_dbg(TRACE, "Enter %pM\n", params->mac);
5451 if (ifp->vif == cfg->p2p.bss_idx[P2PAPI_BSSCFG_DEVICE].vif)
5452 ifp = cfg->p2p.bss_idx[P2PAPI_BSSCFG_PRIMARY].vif->ifp;
5453 if (!check_vif_up(ifp->vif))
5454 return -EIO;
5456 memcpy(&scbval.ea, params->mac, ETH_ALEN);
5457 scbval.val = cpu_to_le32(params->reason_code);
5473 struct brcmf_pub *drvr = cfg->pub;
5478 params->sta_flags_mask, params->sta_flags_set);
5484 if (!(params->sta_flags_mask & BIT(NL80211_STA_FLAG_AUTHORIZED)))
5487 if (params->sta_flags_set & BIT(NL80211_STA_FLAG_AUTHORIZED))
5494 bphy_err(drvr, "Setting SCB (de-)authorize failed, %d\n", err);
5508 vif->mgmt_rx_reg = upd->interface_stypes;
5517 struct ieee80211_channel *chan = params->chan;
5518 struct brcmf_pub *drvr = cfg->pub;
5519 const u8 *buf = params->buf;
5520 size_t len = params->len;
5538 if (!ieee80211_is_mgmt(mgmt->frame_control)) {
5540 return -EPERM;
5545 if (ieee80211_is_probe_resp(mgmt->frame_control)) {
5554 /* "DIRECT-". Note in future supplicant will take */
5559 ie_len = len - ie_offset;
5560 if (vif == cfg->p2p.bss_idx[P2PAPI_BSSCFG_PRIMARY].vif)
5561 vif = cfg->p2p.bss_idx[P2PAPI_BSSCFG_DEVICE].vif;
5568 } else if (ieee80211_is_action(mgmt->frame_control)) {
5571 err = -EINVAL;
5577 err = -ENOMEM;
5580 action_frame = &af_params->action_frame;
5582 action_frame->packet_id = cpu_to_le32(*cookie);
5584 memcpy(&action_frame->da[0], &mgmt->da[0], ETH_ALEN);
5585 memcpy(&af_params->bssid[0], &mgmt->bssid[0], ETH_ALEN);
5587 action_frame->len = cpu_to_le16(len - DOT11_MGMT_HDR_LEN);
5592 freq = chan->center_freq;
5594 brcmf_fil_cmd_int_get(vif->ifp, BRCMF_C_GET_CHANNEL,
5597 af_params->channel = cpu_to_le32(chan_nr);
5598 af_params->dwell_time = cpu_to_le32(params->wait);
5599 memcpy(action_frame->data, &buf[DOT11_MGMT_HDR_LEN],
5600 le16_to_cpu(action_frame->len));
5603 *cookie, le16_to_cpu(action_frame->len), freq);
5612 brcmf_dbg(TRACE, "Unhandled, fc=%04x!!\n", mgmt->frame_control);
5631 vif = ifp->vif;
5633 if (rssi_low != vif->cqm_rssi_low || rssi_high != vif->cqm_rssi_high) {
5644 clamp_val(rssi_low, S8_MIN, S8_MAX - 2),
5645 clamp_val(rssi_high, S8_MIN + 1, S8_MAX - 1),
5653 err = -EINVAL;
5655 vif->cqm_rssi_low = rssi_low;
5656 vif->cqm_rssi_high = rssi_high;
5669 struct brcmf_pub *drvr = cfg->pub;
5675 vif = cfg->p2p.bss_idx[P2PAPI_BSSCFG_DEVICE].vif;
5678 err = -ENODEV;
5681 brcmf_p2p_cancel_remain_on_channel(vif->ifp);
5692 struct net_device *ndev = wdev->netdev;
5693 struct brcmf_pub *drvr = cfg->pub;
5700 if (!ndev || drvr->bus_if->state != BRCMF_BUS_UP)
5701 return -ENODEV;
5710 cfg->d11inf.decchspec(&ch);
5740 chandef->chan = ieee80211_get_channel(wiphy, freq);
5741 chandef->width = width;
5742 chandef->center_freq1 = ieee80211_channel_to_frequency(ch.chnum, band);
5743 chandef->center_freq2 = 0;
5760 return -EINVAL;
5763 set_bit(BRCMF_SCAN_STATUS_SUPPRESS, &cfg->scan_status);
5778 clear_bit(BRCMF_SCAN_STATUS_SUPPRESS, &cfg->scan_status);
5785 switch (e->reason) {
5791 brcmf_proto_add_tdls_peer(ifp->drvr, ifp->ifidx, (u8 *)e->addr);
5795 brcmf_proto_delete_peer(ifp->drvr, ifp->ifidx, (u8 *)e->addr);
5818 ret = -EOPNOTSUPP;
5828 struct brcmf_pub *drvr = cfg->pub;
5858 struct brcmf_pub *drvr = cfg->pub;
5866 err = brcmf_vif_set_mgmt_ie(ifp->vif, BRCMF_VNDR_IE_ASSOCREQ_FLAG,
5867 sme->ie, sme->ie_len);
5882 struct brcmf_pub *drvr = cfg->pub;
5887 brcmf_dbg(TRACE, "Enter, bssidx=%d\n", ifp->bsscfgidx);
5889 memcpy(gtk_le.kck, gtk->kck, sizeof(gtk_le.kck));
5890 memcpy(gtk_le.kek, gtk->kek, sizeof(gtk_le.kek));
5891 memcpy(gtk_le.replay_counter, gtk->replay_ctr,
5912 if (WARN_ON(ifp->vif->profile.use_fwsup != BRCMF_PROFILE_FWSUP_1X))
5913 return -EINVAL;
5915 if (conf->pmk_len > BRCMF_WSEC_MAX_PSK_LEN)
5916 return -ERANGE;
5918 return brcmf_set_pmk(ifp, conf->pmk, conf->pmk_len);
5928 if (WARN_ON(ifp->vif->profile.use_fwsup != BRCMF_PROFILE_FWSUP_1X))
5929 return -EINVAL;
5990 if (ops && settings->roamoff)
5991 ops->update_connect_params = NULL;
6002 struct brcmf_if *ifp = brcmf_get_ifp(cfg->pub, 0);
6008 return ERR_PTR(-ENOMEM);
6010 vif->wdev.wiphy = cfg->wiphy;
6011 vif->wdev.iftype = type;
6013 brcmf_init_prof(&vif->profile);
6018 list_for_each_entry(vif_walk, &cfg->vif_list, list) {
6019 if (vif_walk->wdev.iftype == NL80211_IFTYPE_AP) {
6024 vif->mbss = mbss;
6027 list_add_tail(&vif->list, &cfg->vif_list);
6033 list_del(&vif->list);
6043 vif = ifp->vif;
6052 u32 event = e->event_code;
6053 u32 status = e->status;
6055 if ((vif->profile.use_fwsup == BRCMF_PROFILE_FWSUP_PSK ||
6056 vif->profile.use_fwsup == BRCMF_PROFILE_FWSUP_SAE) &&
6059 set_bit(BRCMF_VIF_STATUS_EAP_SUCCESS, &vif->sme_state);
6062 memcpy(vif->profile.bssid, e->addr, ETH_ALEN);
6063 if (vif->profile.use_fwsup != BRCMF_PROFILE_FWSUP_PSK &&
6064 vif->profile.use_fwsup != BRCMF_PROFILE_FWSUP_SAE)
6067 set_bit(BRCMF_VIF_STATUS_ASSOC_SUCCESS, &vif->sme_state);
6070 if (test_bit(BRCMF_VIF_STATUS_EAP_SUCCESS, &vif->sme_state) &&
6071 test_bit(BRCMF_VIF_STATUS_ASSOC_SUCCESS, &vif->sme_state)) {
6072 clear_bit(BRCMF_VIF_STATUS_EAP_SUCCESS, &vif->sme_state);
6073 clear_bit(BRCMF_VIF_STATUS_ASSOC_SUCCESS, &vif->sme_state);
6082 u32 event = e->event_code;
6083 u16 flags = e->flags;
6089 clear_bit(BRCMF_VIF_STATUS_EAP_SUCCESS, &vif->sme_state);
6090 clear_bit(BRCMF_VIF_STATUS_ASSOC_SUCCESS, &vif->sme_state);
6099 u32 event = e->event_code;
6100 u32 status = e->status;
6104 e->flags & BRCMF_EVENT_MSG_LINK ? "up" : "down");
6127 kfree(conn_info->req_ie);
6128 conn_info->req_ie = NULL;
6129 conn_info->req_ie_len = 0;
6130 kfree(conn_info->resp_ie);
6131 conn_info->resp_ie = NULL;
6132 conn_info->resp_ie_len = 0;
6143 /* For those AC(s) with ACM flag set to 1, convert its 4-level priority
6144 * to an 8-level precedence which is the same as BE's
6147 cfg->ac_priority[prio] == cfg->ac_priority[PRIO_8021D_BE])
6148 return cfg->ac_priority[prio] * 2;
6150 /* Conversion of 4-level priority to 8-level precedence */
6153 return cfg->ac_priority[prio] * 2;
6155 return cfg->ac_priority[prio] * 2 + 1;
6167 return cfg->ac_priority[prio];
6204 aifsn = acp->ACI & EDCF_AIFSN_MASK;
6205 acm = (acp->ACI & EDCF_ACM_MASK) ? 1 : 0;
6206 ecwmin = acp->ECW & EDCF_ECWMIN_MASK;
6207 ecwmax = (acp->ECW & EDCF_ECWMAX_MASK) >> EDCF_ECWMAX_SHIFT;
6266 brcmf_dbg(CONN, "Adj prio BE 0->%d, BK 1->%d, BK 2->%d, BE 3->%d\n",
6269 brcmf_dbg(CONN, "Adj prio VI 4->%d, VI 5->%d, VO 6->%d, VO 7->%d\n",
6276 struct brcmf_pub *drvr = cfg->pub;
6287 cfg->extra_buf, WL_ASSOC_INFO_MAX);
6293 (struct brcmf_cfg80211_assoc_ielen_le *)cfg->extra_buf;
6294 req_len = le32_to_cpu(assoc_info->req_len);
6295 resp_len = le32_to_cpu(assoc_info->resp_len);
6299 return -EINVAL;
6303 cfg->extra_buf,
6309 conn_info->req_ie_len = req_len;
6310 conn_info->req_ie =
6311 kmemdup(cfg->extra_buf, conn_info->req_ie_len,
6313 if (!conn_info->req_ie)
6314 conn_info->req_ie_len = 0;
6316 conn_info->req_ie_len = 0;
6317 conn_info->req_ie = NULL;
6321 cfg->extra_buf,
6327 conn_info->resp_ie_len = resp_len;
6328 conn_info->resp_ie =
6329 kmemdup(cfg->extra_buf, conn_info->resp_ie_len,
6331 if (!conn_info->resp_ie)
6332 conn_info->resp_ie_len = 0;
6343 cfg->ac_priority);
6345 conn_info->resp_ie_len = 0;
6346 conn_info->resp_ie = NULL;
6349 conn_info->req_ie_len, conn_info->resp_ie_len);
6360 struct brcmf_cfg80211_profile *profile = &ifp->vif->profile;
6375 memcpy(profile->bssid, e->addr, ETH_ALEN);
6380 err = -ENOMEM;
6393 ch.chspec = le16_to_cpu(bi->chanspec);
6394 cfg->d11inf.decchspec(&ch);
6397 band = wiphy->bands[NL80211_BAND_2GHZ];
6399 band = wiphy->bands[NL80211_BAND_5GHZ];
6401 freq = ieee80211_channel_to_frequency(ch.control_ch_num, band->band);
6408 roam_info.links[0].bssid = profile->bssid;
6409 roam_info.req_ie = conn_info->req_ie;
6410 roam_info.req_ie_len = conn_info->req_ie_len;
6411 roam_info.resp_ie = conn_info->resp_ie;
6412 roam_info.resp_ie_len = conn_info->resp_ie_len;
6417 if (profile->use_fwsup == BRCMF_PROFILE_FWSUP_1X && profile->is_ft) {
6418 cfg80211_port_authorized(ndev, profile->bssid, NULL, 0, GFP_KERNEL);
6422 set_bit(BRCMF_VIF_STATUS_CONNECTED, &ifp->vif->sme_state);
6433 struct brcmf_cfg80211_profile *profile = &ifp->vif->profile;
6440 &ifp->vif->sme_state)) {
6446 &ifp->vif->sme_state);
6450 &ifp->vif->sme_state);
6452 &ifp->vif->sme_state);
6455 conn_params.links[0].bssid = profile->bssid;
6456 conn_params.req_ie = conn_info->req_ie;
6457 conn_params.req_ie_len = conn_info->req_ie_len;
6458 conn_params.resp_ie = conn_info->resp_ie;
6459 conn_params.resp_ie_len = conn_info->resp_ie_len;
6461 brcmf_dbg(CONN, "Report connect result - connection %s\n",
6473 struct brcmf_pub *drvr = cfg->pub;
6475 u32 event = e->event_code;
6476 u32 reason = e->reason;
6484 complete(&cfg->vif_disabled);
6492 return -EINVAL;
6497 return -ENOMEM;
6499 sinfo->assoc_req_ies = data;
6500 sinfo->assoc_req_ies_len = e->datalen;
6502 sinfo->generation = generation;
6503 cfg80211_new_sta(ndev, e->addr, sinfo, GFP_KERNEL);
6509 cfg80211_del_sta(ndev, e->addr, GFP_KERNEL);
6518 struct brcmf_cfg80211_info *cfg = ifp->drvr->config;
6519 struct net_device *ndev = ifp->ndev;
6520 struct brcmf_cfg80211_profile *profile = &ifp->vif->profile;
6524 if ((e->event_code == BRCMF_E_DEAUTH) ||
6525 (e->event_code == BRCMF_E_DEAUTH_IND) ||
6526 (e->event_code == BRCMF_E_DISASSOC_IND) ||
6527 ((e->event_code == BRCMF_E_LINK) && (!e->flags))) {
6528 brcmf_proto_delete_peer(ifp->drvr, ifp->ifidx, (u8 *)e->addr);
6531 if (brcmf_is_apmode(ifp->vif)) {
6533 } else if (brcmf_is_linkup(ifp->vif, e)) {
6535 if (brcmf_is_ibssmode(ifp->vif)) {
6536 brcmf_inform_ibss(cfg, ndev, e->addr);
6537 chan = ieee80211_get_channel(cfg->wiphy, cfg->channel);
6538 memcpy(profile->bssid, e->addr, ETH_ALEN);
6539 cfg80211_ibss_joined(ndev, e->addr, chan, GFP_KERNEL);
6541 &ifp->vif->sme_state);
6543 &ifp->vif->sme_state);
6547 } else if (brcmf_is_linkdown(ifp->vif, e)) {
6549 if (!brcmf_is_ibssmode(ifp->vif) &&
6551 &ifp->vif->sme_state) ||
6553 &ifp->vif->sme_state))) {
6555 &ifp->vif->sme_state) &&
6556 memcmp(profile->bssid, e->addr, ETH_ALEN))
6560 brcmf_link_down(ifp->vif,
6562 e->event_code &
6568 complete(&cfg->vif_disabled);
6572 if (brcmf_is_ibssmode(ifp->vif))
6574 &ifp->vif->sme_state);
6586 struct brcmf_cfg80211_info *cfg = ifp->drvr->config;
6587 u32 event = e->event_code;
6588 u32 status = e->status;
6592 &ifp->vif->sme_state)) {
6593 brcmf_bss_roaming_done(cfg, ifp->ndev, e);
6595 brcmf_bss_connect_done(cfg, ifp->ndev, e, true);
6607 u16 flags = e->flags;
6615 cfg80211_michael_mic_failure(ifp->ndev, (u8 *)&e->addr, key_type, -1,
6624 struct brcmf_cfg80211_vif *vif = ifp->vif;
6629 if (e->datalen >= sizeof(*info)) {
6630 rssi = be32_to_cpu(info->rssi);
6631 snr = be32_to_cpu(info->snr);
6632 noise = be32_to_cpu(info->noise);
6633 } else if (e->datalen >= sizeof(rssi)) {
6640 low = vif->cqm_rssi_low;
6641 high = vif->cqm_rssi_high;
6642 last = vif->cqm_rssi_last;
6647 vif->cqm_rssi_last = rssi;
6651 cfg80211_cqm_rssi_notify(ifp->ndev,
6656 cfg80211_cqm_rssi_notify(ifp->ndev,
6667 struct brcmf_cfg80211_info *cfg = ifp->drvr->config;
6669 struct brcmf_cfg80211_vif_event *event = &cfg->vif_event;
6673 ifevent->action, ifevent->flags, ifevent->ifidx,
6674 ifevent->bsscfgidx);
6676 spin_lock(&event->vif_event_lock);
6677 event->action = ifevent->action;
6678 vif = event->vif;
6680 switch (ifevent->action) {
6683 if (!cfg->vif_event.vif) {
6684 spin_unlock(&event->vif_event_lock);
6685 return -EBADF;
6688 ifp->vif = vif;
6689 vif->ifp = ifp;
6690 if (ifp->ndev) {
6691 vif->wdev.netdev = ifp->ndev;
6692 ifp->ndev->ieee80211_ptr = &vif->wdev;
6693 SET_NETDEV_DEV(ifp->ndev, wiphy_dev(cfg->wiphy));
6695 spin_unlock(&event->vif_event_lock);
6696 wake_up(&event->vif_wq);
6700 spin_unlock(&event->vif_event_lock);
6703 wake_up(&event->vif_wq);
6707 spin_unlock(&event->vif_event_lock);
6708 wake_up(&event->vif_wq);
6712 spin_unlock(&event->vif_event_lock);
6715 return -EINVAL;
6720 conf->frag_threshold = (u32)-1;
6721 conf->rts_threshold = (u32)-1;
6722 conf->retry_short = (u32)-1;
6723 conf->retry_long = (u32)-1;
6728 brcmf_fweh_register(cfg->pub, BRCMF_E_LINK,
6730 brcmf_fweh_register(cfg->pub, BRCMF_E_DEAUTH_IND,
6732 brcmf_fweh_register(cfg->pub, BRCMF_E_DEAUTH,
6734 brcmf_fweh_register(cfg->pub, BRCMF_E_DISASSOC_IND,
6736 brcmf_fweh_register(cfg->pub, BRCMF_E_ASSOC_IND,
6738 brcmf_fweh_register(cfg->pub, BRCMF_E_REASSOC_IND,
6740 brcmf_fweh_register(cfg->pub, BRCMF_E_ROAM,
6742 brcmf_fweh_register(cfg->pub, BRCMF_E_MIC_ERROR,
6744 brcmf_fweh_register(cfg->pub, BRCMF_E_SET_SSID,
6746 brcmf_fweh_register(cfg->pub, BRCMF_E_PFN_NET_FOUND,
6748 brcmf_fweh_register(cfg->pub, BRCMF_E_IF,
6750 brcmf_fweh_register(cfg->pub, BRCMF_E_P2P_PROBEREQ_MSG,
6752 brcmf_fweh_register(cfg->pub, BRCMF_E_P2P_DISC_LISTEN_COMPLETE,
6754 brcmf_fweh_register(cfg->pub, BRCMF_E_ACTION_FRAME_RX,
6756 brcmf_fweh_register(cfg->pub, BRCMF_E_ACTION_FRAME_COMPLETE,
6758 brcmf_fweh_register(cfg->pub, BRCMF_E_ACTION_FRAME_OFF_CHAN_COMPLETE,
6760 brcmf_fweh_register(cfg->pub, BRCMF_E_PSK_SUP,
6762 brcmf_fweh_register(cfg->pub, BRCMF_E_RSSI, brcmf_notify_rssi);
6767 kfree(cfg->conf);
6768 cfg->conf = NULL;
6769 kfree(cfg->extra_buf);
6770 cfg->extra_buf = NULL;
6771 kfree(cfg->wowl.nd);
6772 cfg->wowl.nd = NULL;
6773 kfree(cfg->wowl.nd_info);
6774 cfg->wowl.nd_info = NULL;
6775 kfree(cfg->escan_info.escan_buf);
6776 cfg->escan_info.escan_buf = NULL;
6781 cfg->conf = kzalloc(sizeof(*cfg->conf), GFP_KERNEL);
6782 if (!cfg->conf)
6784 cfg->extra_buf = kzalloc(WL_EXTRA_BUF_MAX, GFP_KERNEL);
6785 if (!cfg->extra_buf)
6787 cfg->wowl.nd = kzalloc(sizeof(*cfg->wowl.nd) + sizeof(u32), GFP_KERNEL);
6788 if (!cfg->wowl.nd)
6790 cfg->wowl.nd_info = kzalloc(sizeof(*cfg->wowl.nd_info) +
6793 if (!cfg->wowl.nd_info)
6795 cfg->escan_info.escan_buf = kzalloc(BRCMF_ESCAN_BUF_SIZE, GFP_KERNEL);
6796 if (!cfg->escan_info.escan_buf)
6804 return -ENOMEM;
6811 cfg->scan_request = NULL;
6812 cfg->pwr_save = true;
6813 cfg->dongle_up = false; /* dongle is not up yet */
6818 mutex_init(&cfg->usr_sync);
6820 brcmf_init_conf(cfg->conf);
6821 brcmf_init_wmm_prio(cfg->ac_priority);
6822 init_completion(&cfg->vif_disabled);
6828 cfg->dongle_up = false; /* dongle down */
6836 init_waitqueue_head(&event->vif_wq);
6837 spin_lock_init(&event->vif_event_lock);
6842 struct brcmf_pub *drvr = ifp->drvr;
6849 if (ifp->drvr->settings->roamoff)
6859 /* Enable/Disable built-in roaming to allow supplicant to take care of
6863 ifp->drvr->settings->roamoff ? "Off" : "On");
6865 ifp->drvr->settings->roamoff);
6894 struct brcmf_pub *drvr = ifp->drvr;
6926 ht40_flag = channel->flags & IEEE80211_CHAN_NO_HT40;
6927 if (ch->sb == BRCMU_CHAN_SB_U) {
6929 channel->flags &= ~IEEE80211_CHAN_NO_HT40;
6930 channel->flags |= IEEE80211_CHAN_NO_HT40PLUS;
6936 channel->flags &= ~IEEE80211_CHAN_NO_HT40;
6938 channel->flags |= IEEE80211_CHAN_NO_HT40MINUS;
6946 struct brcmf_pub *drvr = cfg->pub;
6961 return -ENOMEM;
6972 band = wiphy->bands[NL80211_BAND_2GHZ];
6974 for (i = 0; i < band->n_channels; i++)
6975 band->channels[i].flags = IEEE80211_CHAN_DISABLED;
6976 band = wiphy->bands[NL80211_BAND_5GHZ];
6978 for (i = 0; i < band->n_channels; i++)
6979 band->channels[i].flags = IEEE80211_CHAN_DISABLED;
6981 total = le32_to_cpu(list->count);
6985 err = -EINVAL;
6990 ch.chspec = (u16)le32_to_cpu(list->element[i]);
6991 cfg->d11inf.decchspec(&ch);
6994 band = wiphy->bands[NL80211_BAND_2GHZ];
6996 band = wiphy->bands[NL80211_BAND_5GHZ];
7004 if (!(bw_cap[band->band] & WLC_BW_40MHZ_BIT) &&
7007 if (!(bw_cap[band->band] & WLC_BW_80MHZ_BIT) &&
7012 for (j = 0; j < band->n_channels; j++) {
7013 if (band->channels[j].hw_value == ch.control_ch_num) {
7014 channel = &band->channels[j];
7027 if (channel->orig_flags & IEEE80211_CHAN_DISABLED)
7035 channel->flags &= ~IEEE80211_CHAN_NO_160MHZ;
7038 channel->flags &= ~IEEE80211_CHAN_NO_80MHZ;
7052 channel->flags = IEEE80211_CHAN_NO_HT40 |
7056 cfg->d11inf.encchspec(&ch);
7062 channel->flags |=
7066 channel->flags |=
7079 struct brcmf_pub *drvr = cfg->pub;
7112 return -ENOMEM;
7118 cfg->d11inf.encchspec(&ch);
7131 band = cfg_to_wiphy(cfg)->bands[NL80211_BAND_2GHZ];
7133 num_chan = le32_to_cpu(list->count);
7138 return -EINVAL;
7142 ch.chspec = (u16)le32_to_cpu(list->element[i]);
7143 cfg->d11inf.decchspec(&ch);
7148 for (j = 0; j < band->n_channels; j++) {
7149 if (band->channels[j].hw_value == ch.control_ch_num)
7152 if (WARN_ON(j == band->n_channels))
7155 brcmf_update_bw40_channel_flag(&band->channels[j], &ch);
7164 struct brcmf_pub *drvr = ifp->drvr;
7206 band->ht_cap.ht_supported = true;
7207 if (bw_cap[band->band] & WLC_BW_40MHZ_BIT) {
7208 band->ht_cap.cap |= IEEE80211_HT_CAP_SGI_40;
7209 band->ht_cap.cap |= IEEE80211_HT_CAP_SUP_WIDTH_20_40;
7211 band->ht_cap.cap |= IEEE80211_HT_CAP_SGI_20;
7212 band->ht_cap.cap |= IEEE80211_HT_CAP_DSSSCCK40;
7213 band->ht_cap.ampdu_factor = IEEE80211_HT_MAX_AMPDU_64K;
7214 band->ht_cap.ampdu_density = IEEE80211_HT_MPDU_DENSITY_16;
7215 memset(band->ht_cap.mcs.rx_mask, 0xff, nchain);
7216 band->ht_cap.mcs.tx_params = IEEE80211_HT_MCS_TX_DEFINED;
7237 if (band->band == NL80211_BAND_2GHZ)
7240 band->vht_cap.vht_supported = true;
7242 band->vht_cap.cap |= IEEE80211_VHT_CAP_SHORT_GI_80;
7243 if (bw_cap[band->band] & WLC_BW_160MHZ_BIT) {
7244 band->vht_cap.cap |= IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160MHZ;
7245 band->vht_cap.cap |= IEEE80211_VHT_CAP_SHORT_GI_160;
7247 /* all support 256-QAM */
7249 band->vht_cap.vht_mcs.rx_mcs_map = mcs_map;
7250 band->vht_cap.vht_mcs.tx_mcs_map = mcs_map;
7254 band->vht_cap.cap |= IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE;
7256 band->vht_cap.cap |= IEEE80211_VHT_CAP_MU_BEAMFORMEE_CAPABLE;
7258 band->vht_cap.cap |= IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE;
7260 band->vht_cap.cap |= IEEE80211_VHT_CAP_MU_BEAMFORMER_CAPABLE;
7263 band->vht_cap.cap |=
7265 band->vht_cap.cap |= ((txstreams - 1) <<
7267 band->vht_cap.cap |=
7274 struct brcmf_pub *drvr = cfg->pub;
7303 if (err == -EBADE)
7311 rxchain = rxchain & (rxchain - 1);
7329 for (i = 0; i < ARRAY_SIZE(wiphy->bands); i++) {
7330 band = wiphy->bands[i];
7384 * brcmf_setup_ifmodes() - determine interface modes and combinations.
7406 * #STA <= 1, #P2P-DEV <= 1, #{P2P-CL, P2P-GO} <= 1, channels = 1, 3 total
7407 * #STA <= 1, #P2P-DEV <= 1, #AP <= 1, #P2P-CL <= 1, channels = 1, 4 total
7412 * #STA <= 2, #P2P-DEV <= 1, #{P2P-CL, P2P-GO} <= 1, channels = 2, 3 total
7413 * #STA <= 1, #P2P-DEV <= 1, #AP <= 1, #P2P-CL <= 1, channels = 1, 4 total
7417 * #STA <= 1, #P2P-DEV <= 1, #{P2P-CL, P2P-GO} <= 2, AP <= 2,
7442 wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) |
7446 wiphy->interface_modes |= BIT(NL80211_IFTYPE_MONITOR);
7448 wiphy->interface_modes |= BIT(NL80211_IFTYPE_P2P_CLIENT) |
7532 wiphy->n_iface_combinations = n_combos;
7533 wiphy->iface_combinations = combo;
7541 return -ENOMEM;
7558 struct brcmf_pub *drvr = cfg->pub;
7565 wiphy->wowlan = &brcmf_wowlan_support;
7571 wowl->flags |= WIPHY_WOWLAN_NET_DETECT;
7572 wowl->max_nd_match_sets = BRCMF_PNO_MAX_PFN_COUNT;
7573 init_waitqueue_head(&cfg->wowl.nd_data_wait);
7577 wowl->flags |= WIPHY_WOWLAN_SUPPORTS_GTK_REKEY;
7578 wowl->flags |= WIPHY_WOWLAN_GTK_REKEY_FAILURE;
7581 wiphy->wowlan = wowl;
7587 struct brcmf_pub *drvr = ifp->drvr;
7596 wiphy->max_scan_ssids = WL_NUM_SCAN_MAX;
7597 wiphy->max_scan_ie_len = BRCMF_SCAN_IE_LEN_MAX;
7598 wiphy->max_num_pmkids = BRCMF_MAXPMKID;
7604 for (i = 0, combo = wiphy->iface_combinations;
7605 i < wiphy->n_iface_combinations; i++, combo++) {
7606 max_interfaces = max(max_interfaces, combo->max_interfaces);
7609 for (i = 0; i < max_interfaces && i < ARRAY_SIZE(drvr->addresses);
7611 u8 *addr = drvr->addresses[i].addr;
7613 memcpy(addr, drvr->mac, ETH_ALEN);
7616 addr[ETH_ALEN - 1] ^= i;
7619 wiphy->addresses = drvr->addresses;
7620 wiphy->n_addresses = i;
7622 wiphy->signal_type = CFG80211_SIGNAL_TYPE_MBM;
7623 wiphy->cipher_suites = brcmf_cipher_suites;
7624 wiphy->n_cipher_suites = ARRAY_SIZE(brcmf_cipher_suites);
7626 wiphy->n_cipher_suites--;
7627 wiphy->bss_select_support = BIT(NL80211_BSS_SELECT_ATTR_RSSI) |
7631 wiphy->flags |= WIPHY_FLAG_NETNS_OK |
7637 wiphy->flags |= WIPHY_FLAG_SUPPORTS_TDLS;
7638 if (!ifp->drvr->settings->roamoff)
7639 wiphy->flags |= WIPHY_FLAG_SUPPORTS_FW_ROAM;
7656 wiphy->mgmt_stypes = brcmf_txrx_stypes;
7657 wiphy->max_remain_on_channel_duration = 5000;
7663 wiphy->vendor_commands = brcmf_vendor_cmds;
7664 wiphy->n_vendor_commands = BRCMF_VNDR_CMDS_LAST - 1;
7681 return -ENOMEM;
7683 band->channels = kmemdup(&__wl_2ghz_channels,
7686 if (!band->channels) {
7688 return -ENOMEM;
7691 band->n_channels = ARRAY_SIZE(__wl_2ghz_channels);
7692 wiphy->bands[NL80211_BAND_2GHZ] = band;
7698 return -ENOMEM;
7700 band->channels = kmemdup(&__wl_5ghz_channels,
7703 if (!band->channels) {
7705 return -ENOMEM;
7708 band->n_channels = ARRAY_SIZE(__wl_5ghz_channels);
7709 wiphy->bands[NL80211_BAND_5GHZ] = band;
7713 if (wiphy->bands[NL80211_BAND_5GHZ] &&
7727 struct brcmf_pub *drvr = cfg->pub;
7734 if (cfg->dongle_up)
7738 wdev = ndev->ieee80211_ptr;
7746 power_mode = cfg->pwr_save ? PM_FAST : PM_OFF;
7756 err = brcmf_cfg80211_change_iface(wdev->wiphy, ndev, wdev->iftype,
7769 cfg->dongle_up = true;
7778 set_bit(BRCMF_VIF_STATUS_READY, &ifp->vif->sme_state);
7780 return brcmf_config_dongle(ifp->drvr->config);
7785 struct brcmf_cfg80211_info *cfg = ifp->drvr->config;
7791 if (check_vif_up(ifp->vif)) {
7792 brcmf_link_down(ifp->vif, WLAN_REASON_UNSPECIFIED, true);
7802 clear_bit(BRCMF_VIF_STATUS_READY, &ifp->vif->sme_state);
7810 struct brcmf_cfg80211_info *cfg = ifp->drvr->config;
7813 mutex_lock(&cfg->usr_sync);
7815 mutex_unlock(&cfg->usr_sync);
7823 struct brcmf_cfg80211_info *cfg = ifp->drvr->config;
7826 mutex_lock(&cfg->usr_sync);
7828 mutex_unlock(&cfg->usr_sync);
7838 list_for_each_entry(vif, &cfg->vif_list, list) {
7839 if (test_bit(state, &vif->sme_state))
7850 spin_lock(&event->vif_event_lock);
7851 evt_action = event->action;
7852 spin_unlock(&event->vif_event_lock);
7859 struct brcmf_cfg80211_vif_event *event = &cfg->vif_event;
7861 spin_lock(&event->vif_event_lock);
7862 event->vif = vif;
7863 event->action = 0;
7864 spin_unlock(&event->vif_event_lock);
7869 struct brcmf_cfg80211_vif_event *event = &cfg->vif_event;
7872 spin_lock(&event->vif_event_lock);
7873 armed = event->vif != NULL;
7874 spin_unlock(&event->vif_event_lock);
7882 struct brcmf_cfg80211_vif_event *event = &cfg->vif_event;
7884 return wait_event_timeout(event->vif_wq,
7890 if (drvr->settings->trivial_ccode_map)
7893 switch (drvr->bus_if->chip) {
7912 if ((alpha2[0] == ccreq->country_abbrev[0]) &&
7913 (alpha2[1] == ccreq->country_abbrev[1])) {
7915 return -EAGAIN;
7918 country_codes = drvr->settings->country_codes;
7923 ccreq->country_abbrev[0] = alpha2[0];
7924 ccreq->country_abbrev[1] = alpha2[1];
7925 ccreq->ccode[0] = alpha2[0];
7926 ccreq->ccode[1] = alpha2[1];
7931 return -EINVAL;
7934 found_index = -1;
7935 for (i = 0; i < country_codes->table_size; i++) {
7936 cc = &country_codes->table[i];
7937 if ((cc->iso3166[0] == '\0') && (found_index == -1))
7939 if ((cc->iso3166[0] == alpha2[0]) &&
7940 (cc->iso3166[1] == alpha2[1])) {
7945 if (found_index == -1) {
7947 return -EINVAL;
7950 ccreq->rev = cpu_to_le32(country_codes->table[found_index].rev);
7951 memcpy(ccreq->ccode, country_codes->table[found_index].cc,
7953 ccreq->country_abbrev[0] = alpha2[0];
7954 ccreq->country_abbrev[1] = alpha2[1];
7955 ccreq->country_abbrev[2] = 0;
7977 survey->obss = val;
7986 survey->ibss = val;
7995 survey->tx = val;
8004 survey->no_ctg = val;
8013 survey->no_pckt = val;
8022 survey->idle = val;
8041 return -ENOMEM;
8048 err = -EINVAL;
8054 brcmf_parse_dump_obss(results->buf, survey);
8068 if (chan->flags & IEEE80211_CHAN_DISABLED)
8069 return -EINVAL;
8072 chspec = channel_to_chanspec(&cfg->d11inf, chan);
8077 err = -EINVAL;
8081 err = -EINVAL;
8103 if ((test_bit(BRCMF_VIF_STATUS_CONNECTING, &ifp->vif->sme_state)) ||
8104 (test_bit(BRCMF_VIF_STATUS_CONNECTED, &ifp->vif->sme_state))) {
8105 return -EBUSY;
8109 band = wiphy->bands[band_id];
8112 if (idx >= band->n_channels) {
8113 idx -= band->n_channels;
8117 info->channel = &band->channels[idx];
8121 return -ENOENT;
8124 info->filled = 0;
8125 if (brcmf_set_channel(cfg, info->channel))
8161 info->noise = noise;
8162 info->time = ACS_MSRMNT_DELAY;
8163 info->time_busy = ACS_MSRMNT_DELAY - survey.idle;
8164 info->time_rx = survey.obss + survey.ibss + survey.no_ctg +
8166 info->time_tx = survey.tx;
8167 info->filled = SURVEY_INFO_NOISE_DBM | SURVEY_INFO_TIME |
8172 ieee80211_frequency_to_channel(info->channel->center_freq),
8175 info->noise, info->time_busy, info->time_rx, info->time_tx);
8178 if (!brcmf_is_apmode(ifp->vif))
8187 struct brcmf_if *ifp = brcmf_get_ifp(cfg->pub, 0);
8188 struct brcmf_pub *drvr = cfg->pub;
8194 if (req->alpha2[0] == '0' && req->alpha2[1] == '0')
8197 /* ignore non-ISO3166 country codes */
8199 if (req->alpha2[i] < 'A' || req->alpha2[i] > 'Z') {
8201 req->alpha2[0], req->alpha2[1]);
8205 brcmf_dbg(TRACE, "Enter: initiator=%d, alpha=%c%c\n", req->initiator,
8206 req->alpha2[0], req->alpha2[1]);
8214 err = brcmf_translate_country_code(ifp->drvr, req->alpha2, &ccreq);
8233 if (wiphy->iface_combinations) {
8234 for (i = 0; i < wiphy->n_iface_combinations; i++)
8235 kfree(wiphy->iface_combinations[i].limits);
8237 kfree(wiphy->iface_combinations);
8238 if (wiphy->bands[NL80211_BAND_2GHZ]) {
8239 kfree(wiphy->bands[NL80211_BAND_2GHZ]->channels);
8240 kfree(wiphy->bands[NL80211_BAND_2GHZ]);
8242 if (wiphy->bands[NL80211_BAND_5GHZ]) {
8243 kfree(wiphy->bands[NL80211_BAND_5GHZ]->channels);
8244 kfree(wiphy->bands[NL80211_BAND_5GHZ]);
8247 if (wiphy->wowlan != &brcmf_wowlan_support)
8248 kfree(wiphy->wowlan);
8256 struct wiphy *wiphy = drvr->wiphy;
8257 struct net_device *ndev = brcmf_get_ifp(drvr, 0)->ndev;
8276 cfg->wiphy = wiphy;
8277 cfg->pub = drvr;
8278 init_vif_event(&cfg->vif_event);
8279 INIT_LIST_HEAD(&cfg->vif_list);
8286 vif->ifp = ifp;
8287 vif->wdev.netdev = ndev;
8288 ndev->ieee80211_ptr = &vif->wdev;
8289 SET_NETDEV_DEV(ndev, wiphy_dev(cfg->wiphy));
8297 ifp->vif = vif;
8305 cfg->d11inf.io_type = (u8)io_type;
8306 brcmu_d11_attach(&cfg->d11inf);
8311 drvr->config = cfg;
8318 wiphy->reg_notifier = brcmf_cfg80211_reg_notifier;
8319 wiphy->regulatory_flags |= REGULATORY_CUSTOM_REG;
8326 if (wiphy->bands[NL80211_BAND_2GHZ]) {
8327 cap = &wiphy->bands[NL80211_BAND_2GHZ]->ht_cap.cap;
8332 ops->set_rekey_data = brcmf_cfg80211_set_rekey_data;
8335 ops->dump_survey = brcmf_cfg80211_dump_survey;
8374 bphy_err(drvr, "BT-coex initialisation failed (%d)\n", err);
8375 brcmf_p2p_detach(&cfg->p2p);
8382 brcmf_p2p_detach(&cfg->p2p);
8390 wiphy->flags &= ~WIPHY_FLAG_SUPPORTS_TDLS;
8392 brcmf_fweh_register(cfg->pub, BRCMF_E_TDLS_PEER_EVENT,
8397 /* (re-) activate FWEH event handling */
8406 wiphy->features |= NL80211_FEATURE_SCHED_SCAN_RANDOM_MAC_ADDR;
8408 if (wiphy->wowlan &&
8409 wiphy->wowlan->flags & WIPHY_WOWLAN_NET_DETECT)
8410 wiphy->features |= NL80211_FEATURE_ND_RANDOM_MAC_ADDR;
8419 brcmf_p2p_detach(&cfg->p2p);
8421 wiphy_unregister(cfg->wiphy);
8425 ifp->vif = NULL;
8439 wiphy_unregister(cfg->wiphy);
8441 cancel_work_sync(&cfg->escan_timeout_work);
8442 brcmf_free_wiphy(cfg->wiphy);