FILE
ioctl_cfg80211.c
File preview with syntax highlighting.
linux-6.19.14/drivers/staging/rtl8723bs/os_dep/ioctl_cfg80211.c
1// SPDX-License-Identifier: GPL-2.0 2/****************************************************************************** 3 * 4 * Copyright(c) 2007 - 2012 Realtek Corporation. All rights reserved. 5 * 6 ******************************************************************************/ 7 8#include <linux/etherdevice.h> 9#include <drv_types.h> 10#include <linux/jiffies.h> 11 12#include <rtw_wifi_regd.h> 13 14#define RTW_MAX_MGMT_TX_CNT (8) 15 16#define RTW_SCAN_IE_LEN_MAX 2304 17#define RTW_MAX_REMAIN_ON_CHANNEL_DURATION 5000 /* ms */ 18#define RTW_MAX_NUM_PMKIDS 4 19 20static const u32 rtw_cipher_suites[] = { 21 WLAN_CIPHER_SUITE_WEP40, 22 WLAN_CIPHER_SUITE_WEP104, 23 WLAN_CIPHER_SUITE_TKIP, 24 WLAN_CIPHER_SUITE_CCMP, 25 WLAN_CIPHER_SUITE_AES_CMAC, 26}; 27 28#define RATETAB_ENT(_rate, _rateid, _flags) \ 29 { \ 30 .bitrate = (_rate), \ 31 .hw_value = (_rateid), \ 32 .flags = (_flags), \ 33 } 34 35#define CHAN2G(_channel, _freq, _flags) { \ 36 .band = NL80211_BAND_2GHZ, \ 37 .center_freq = (_freq), \ 38 .hw_value = (_channel), \ 39 .flags = (_flags), \ 40 .max_antenna_gain = 0, \ 41 .max_power = 30, \ 42} 43 44/* if wowlan is not supported, kernel generate a disconnect at each suspend 45 * cf: /net/wireless/sysfs.c, so register a stub wowlan. 46 * Moreover wowlan has to be enabled via a the nl80211_set_wowlan callback. 47 * (from user space, e.g. iw phy0 wowlan enable) 48 */ 49static __maybe_unused const struct wiphy_wowlan_support wowlan_stub = { 50 .flags = WIPHY_WOWLAN_ANY, 51 .n_patterns = 0, 52 .pattern_max_len = 0, 53 .pattern_min_len = 0, 54 .max_pkt_offset = 0, 55}; 56 57static struct ieee80211_rate rtw_rates[] = { 58 RATETAB_ENT(10, 0x1, 0), 59 RATETAB_ENT(20, 0x2, 0), 60 RATETAB_ENT(55, 0x4, 0), 61 RATETAB_ENT(110, 0x8, 0), 62 RATETAB_ENT(60, 0x10, 0), 63 RATETAB_ENT(90, 0x20, 0), 64 RATETAB_ENT(120, 0x40, 0), 65 RATETAB_ENT(180, 0x80, 0), 66 RATETAB_ENT(240, 0x100, 0), 67 RATETAB_ENT(360, 0x200, 0), 68 RATETAB_ENT(480, 0x400, 0), 69 RATETAB_ENT(540, 0x800, 0), 70}; 71 72#define rtw_g_rates (rtw_rates + 0) 73#define RTW_G_RATES_NUM 12 74 75#define RTW_2G_CHANNELS_NUM 14 76 77static struct ieee80211_channel rtw_2ghz_channels[] = { 78 CHAN2G(1, 2412, 0), 79 CHAN2G(2, 2417, 0), 80 CHAN2G(3, 2422, 0), 81 CHAN2G(4, 2427, 0), 82 CHAN2G(5, 2432, 0), 83 CHAN2G(6, 2437, 0), 84 CHAN2G(7, 2442, 0), 85 CHAN2G(8, 2447, 0), 86 CHAN2G(9, 2452, 0), 87 CHAN2G(10, 2457, 0), 88 CHAN2G(11, 2462, 0), 89 CHAN2G(12, 2467, 0), 90 CHAN2G(13, 2472, 0), 91 CHAN2G(14, 2484, 0), 92}; 93 94static void rtw_2g_channels_init(struct ieee80211_channel *channels) 95{ 96 memcpy((void *)channels, (void *)rtw_2ghz_channels, 97 sizeof(struct ieee80211_channel) * RTW_2G_CHANNELS_NUM 98 ); 99} 100 101static void rtw_2g_rates_init(struct ieee80211_rate *rates) 102{ 103 memcpy(rates, rtw_g_rates, 104 sizeof(struct ieee80211_rate) * RTW_G_RATES_NUM 105 ); 106} 107 108static struct ieee80211_supported_band *rtw_spt_band_alloc( 109 enum nl80211_band band 110 ) 111{ 112 struct ieee80211_supported_band *spt_band = NULL; 113 int n_channels, n_bitrates; 114 115 if (band == NL80211_BAND_2GHZ) { 116 n_channels = RTW_2G_CHANNELS_NUM; 117 n_bitrates = RTW_G_RATES_NUM; 118 } else { 119 goto exit; 120 } 121 122 spt_band = rtw_zmalloc(sizeof(struct ieee80211_supported_band) + 123 sizeof(struct ieee80211_channel) * n_channels + 124 sizeof(struct ieee80211_rate) * n_bitrates); 125 if (!spt_band) 126 goto exit; 127 128 spt_band->channels = (struct ieee80211_channel *)(((u8 *)spt_band) + sizeof(struct ieee80211_supported_band)); 129 spt_band->bitrates = (struct ieee80211_rate *)(((u8 *)spt_band->channels) + sizeof(struct ieee80211_channel) * n_channels); 130 spt_band->band = band; 131 spt_band->n_channels = n_channels; 132 spt_band->n_bitrates = n_bitrates; 133 134 if (band == NL80211_BAND_2GHZ) { 135 rtw_2g_channels_init(spt_band->channels); 136 rtw_2g_rates_init(spt_band->bitrates); 137 } 138 139 /* spt_band.ht_cap */ 140 141exit: 142 143 return spt_band; 144} 145 146static const struct ieee80211_txrx_stypes 147rtw_cfg80211_default_mgmt_stypes[NUM_NL80211_IFTYPES] = { 148 [NL80211_IFTYPE_ADHOC] = { 149 .tx = 0xffff, 150 .rx = BIT(IEEE80211_STYPE_ACTION >> 4) 151 }, 152 [NL80211_IFTYPE_STATION] = { 153 .tx = 0xffff, 154 .rx = BIT(IEEE80211_STYPE_ACTION >> 4) | 155 BIT(IEEE80211_STYPE_PROBE_REQ >> 4) 156 }, 157 [NL80211_IFTYPE_AP] = { 158 .tx = 0xffff, 159 .rx = BIT(IEEE80211_STYPE_ASSOC_REQ >> 4) | 160 BIT(IEEE80211_STYPE_REASSOC_REQ >> 4) | 161 BIT(IEEE80211_STYPE_PROBE_REQ >> 4) | 162 BIT(IEEE80211_STYPE_DISASSOC >> 4) | 163 BIT(IEEE80211_STYPE_AUTH >> 4) | 164 BIT(IEEE80211_STYPE_DEAUTH >> 4) | 165 BIT(IEEE80211_STYPE_ACTION >> 4) 166 }, 167 [NL80211_IFTYPE_AP_VLAN] = { 168 /* copy AP */ 169 .tx = 0xffff, 170 .rx = BIT(IEEE80211_STYPE_ASSOC_REQ >> 4) | 171 BIT(IEEE80211_STYPE_REASSOC_REQ >> 4) | 172 BIT(IEEE80211_STYPE_PROBE_REQ >> 4) | 173 BIT(IEEE80211_STYPE_DISASSOC >> 4) | 174 BIT(IEEE80211_STYPE_AUTH >> 4) | 175 BIT(IEEE80211_STYPE_DEAUTH >> 4) | 176 BIT(IEEE80211_STYPE_ACTION >> 4) 177 }, 178 [NL80211_IFTYPE_P2P_CLIENT] = { 179 .tx = 0xffff, 180 .rx = BIT(IEEE80211_STYPE_ACTION >> 4) | 181 BIT(IEEE80211_STYPE_PROBE_REQ >> 4) 182 }, 183 [NL80211_IFTYPE_P2P_GO] = { 184 .tx = 0xffff, 185 .rx = BIT(IEEE80211_STYPE_ASSOC_REQ >> 4) | 186 BIT(IEEE80211_STYPE_REASSOC_REQ >> 4) | 187 BIT(IEEE80211_STYPE_PROBE_REQ >> 4) | 188 BIT(IEEE80211_STYPE_DISASSOC >> 4) | 189 BIT(IEEE80211_STYPE_AUTH >> 4) | 190 BIT(IEEE80211_STYPE_DEAUTH >> 4) | 191 BIT(IEEE80211_STYPE_ACTION >> 4) 192 }, 193}; 194 195int rtw_ieee80211_channel_to_frequency(int chan) 196{ 197 /* NL80211_BAND_2GHZ */ 198 if (chan == 14) 199 return 2484; 200 201 if (chan < 14) 202 return 2407 + chan * 5; 203 204 return 0; /* not supported */ 205} 206 207#define MAX_BSSINFO_LEN 1000 208struct cfg80211_bss *rtw_cfg80211_inform_bss(struct adapter *padapter, struct wlan_network *pnetwork) 209{ 210 struct ieee80211_channel *notify_channel; 211 struct cfg80211_bss *bss = NULL; 212 /* struct ieee80211_supported_band *band; */ 213 u16 channel; 214 u32 freq; 215 u64 notify_timestamp; 216 s32 notify_signal; 217 u8 *buf = NULL, *pbuf; 218 size_t len, bssinf_len = 0; 219 struct ieee80211_hdr *pwlanhdr; 220 __le16 *fctrl; 221 222 struct wireless_dev *wdev = padapter->rtw_wdev; 223 struct wiphy *wiphy = wdev->wiphy; 224 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv); 225 226 bssinf_len = pnetwork->network.ie_length + sizeof(struct ieee80211_hdr_3addr); 227 if (bssinf_len > MAX_BSSINFO_LEN) 228 goto exit; 229 230 { 231 u16 wapi_len = 0; 232 233 if (rtw_get_wapi_ie(pnetwork->network.ies, pnetwork->network.ie_length, NULL, &wapi_len) > 0) { 234 if (wapi_len > 0) 235 goto exit; 236 } 237 } 238 239 /* To reduce PBC Overlap rate */ 240 /* spin_lock_bh(&pwdev_priv->scan_req_lock); */ 241 if (adapter_wdev_data(padapter)->scan_request) { 242 u8 *psr = NULL, sr = 0; 243 struct ndis_802_11_ssid *pssid = &pnetwork->network.ssid; 244 struct cfg80211_scan_request *request = adapter_wdev_data(padapter)->scan_request; 245 struct cfg80211_ssid *ssids = request->ssids; 246 u32 wpsielen = 0; 247 u8 *wpsie = NULL; 248 249 wpsie = rtw_get_wps_ie(pnetwork->network.ies + _FIXED_IE_LENGTH_, pnetwork->network.ie_length - _FIXED_IE_LENGTH_, NULL, &wpsielen); 250 251 if (wpsie && wpsielen > 0) 252 psr = rtw_get_wps_attr_content(wpsie, wpsielen, WPS_ATTR_SELECTED_REGISTRAR, (u8 *)(&sr), NULL); 253 254 if (sr != 0) { 255 /* it means under processing WPS */ 256 if (request->n_ssids == 1 && request->n_channels == 1) { 257 if (ssids[0].ssid_len != 0 && 258 (pssid->ssid_length != ssids[0].ssid_len || 259 memcmp(pssid->ssid, ssids[0].ssid, ssids[0].ssid_len))) { 260 if (psr) 261 *psr = 0; /* clear sr */ 262 } 263 } 264 } 265 } 266 /* spin_unlock_bh(&pwdev_priv->scan_req_lock); */ 267 268 channel = pnetwork->network.configuration.ds_config; 269 freq = rtw_ieee80211_channel_to_frequency(channel); 270 271 notify_channel = ieee80211_get_channel(wiphy, freq); 272 273 notify_timestamp = ktime_to_us(ktime_get_boottime()); 274 275 /* We've set wiphy's signal_type as CFG80211_SIGNAL_TYPE_MBM: signal strength in mBm (100*dBm) */ 276 if (check_fwstate(pmlmepriv, _FW_LINKED) == true && 277 is_same_network(&pmlmepriv->cur_network.network, &pnetwork->network, 0)) { 278 notify_signal = 100 * translate_percentage_to_dbm(padapter->recvpriv.signal_strength);/* dbm */ 279 } else { 280 notify_signal = 100 * translate_percentage_to_dbm(pnetwork->network.phy_info.signal_strength);/* dbm */ 281 } 282 283 buf = kzalloc(MAX_BSSINFO_LEN, GFP_ATOMIC); 284 if (!buf) 285 goto exit; 286 pbuf = buf; 287 288 pwlanhdr = (struct ieee80211_hdr *)pbuf; 289 fctrl = &(pwlanhdr->frame_control); 290 *(fctrl) = 0; 291 292 SetSeqNum(pwlanhdr, 0/*pmlmeext->mgnt_seq*/); 293 /* pmlmeext->mgnt_seq++; */ 294 295 if (pnetwork->network.reserved[0] == 1) { /* WIFI_BEACON */ 296 eth_broadcast_addr(pwlanhdr->addr1); 297 SetFrameSubType(pbuf, WIFI_BEACON); 298 } else { 299 memcpy(pwlanhdr->addr1, myid(&(padapter->eeprompriv)), ETH_ALEN); 300 SetFrameSubType(pbuf, WIFI_PROBERSP); 301 } 302 303 memcpy(pwlanhdr->addr2, pnetwork->network.mac_address, ETH_ALEN); 304 memcpy(pwlanhdr->addr3, pnetwork->network.mac_address, ETH_ALEN); 305 306 pbuf += sizeof(struct ieee80211_hdr_3addr); 307 len = sizeof(struct ieee80211_hdr_3addr); 308 309 memcpy(pbuf, pnetwork->network.ies, pnetwork->network.ie_length); 310 len += pnetwork->network.ie_length; 311 312 *((__le64 *)pbuf) = cpu_to_le64(notify_timestamp); 313 314 bss = cfg80211_inform_bss_frame(wiphy, notify_channel, (struct ieee80211_mgmt *)buf, 315 len, notify_signal, GFP_ATOMIC); 316 317 if (unlikely(!bss)) 318 goto free_buf; 319 320 cfg80211_put_bss(wiphy, bss); 321free_buf: 322 kfree(buf); 323 324exit: 325 return bss; 326} 327 328/* 329 * Check the given bss is valid by kernel API cfg80211_get_bss() 330 * @padapter : the given adapter 331 * 332 * return true if bss is valid, false for not found. 333 */ 334int rtw_cfg80211_check_bss(struct adapter *padapter) 335{ 336 struct wlan_bssid_ex *pnetwork = &(padapter->mlmeextpriv.mlmext_info.network); 337 struct cfg80211_bss *bss = NULL; 338 struct ieee80211_channel *notify_channel = NULL; 339 u32 freq; 340 341 if (!(pnetwork) || !(padapter->rtw_wdev)) 342 return false; 343 344 freq = rtw_ieee80211_channel_to_frequency(pnetwork->configuration.ds_config); 345 346 notify_channel = ieee80211_get_channel(padapter->rtw_wdev->wiphy, freq); 347 bss = cfg80211_get_bss(padapter->rtw_wdev->wiphy, notify_channel, 348 pnetwork->mac_address, pnetwork->ssid.ssid, 349 pnetwork->ssid.ssid_length, 350 IEEE80211_BSS_TYPE_ANY, IEEE80211_PRIVACY_ANY); 351 352 cfg80211_put_bss(padapter->rtw_wdev->wiphy, bss); 353 354 return (bss != NULL); 355} 356 357void rtw_cfg80211_ibss_indicate_connect(struct adapter *padapter) 358{ 359 struct mlme_priv *pmlmepriv = &padapter->mlmepriv; 360 struct wlan_network *cur_network = &(pmlmepriv->cur_network); 361 struct wireless_dev *pwdev = padapter->rtw_wdev; 362 struct wiphy *wiphy = pwdev->wiphy; 363 int freq = (int)cur_network->network.configuration.ds_config; 364 struct ieee80211_channel *chan; 365 366 if (pwdev->iftype != NL80211_IFTYPE_ADHOC) 367 return; 368 369 if (!rtw_cfg80211_check_bss(padapter)) { 370 struct wlan_bssid_ex *pnetwork = &(padapter->mlmeextpriv.mlmext_info.network); 371 struct wlan_network *scanned = pmlmepriv->cur_network_scanned; 372 373 if (check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE) == true) { 374 memcpy(&cur_network->network, pnetwork, sizeof(struct wlan_bssid_ex)); 375 rtw_cfg80211_inform_bss(padapter, cur_network); 376 } else { 377 if (!scanned) { 378 rtw_warn_on(1); 379 return; 380 } 381 if (!memcmp(&(scanned->network.ssid), &(pnetwork->ssid), sizeof(struct ndis_802_11_ssid)) 382 && !memcmp(scanned->network.mac_address, pnetwork->mac_address, sizeof(NDIS_802_11_MAC_ADDRESS)) 383 ) 384 rtw_cfg80211_inform_bss(padapter, scanned); 385 else 386 rtw_warn_on(1); 387 } 388 389 if (!rtw_cfg80211_check_bss(padapter)) 390 netdev_dbg(padapter->pnetdev, 391 FUNC_ADPT_FMT " BSS not found !!\n", 392 FUNC_ADPT_ARG(padapter)); 393 } 394 /* notify cfg80211 that device joined an IBSS */ 395 chan = ieee80211_get_channel(wiphy, freq); 396 cfg80211_ibss_joined(padapter->pnetdev, cur_network->network.mac_address, chan, GFP_ATOMIC); 397} 398 399void rtw_cfg80211_indicate_connect(struct adapter *padapter) 400{ 401 struct mlme_priv *pmlmepriv = &padapter->mlmepriv; 402 struct wlan_network *cur_network = &(pmlmepriv->cur_network); 403 struct wireless_dev *pwdev = padapter->rtw_wdev; 404 405 if (pwdev->iftype != NL80211_IFTYPE_STATION 406 && pwdev->iftype != NL80211_IFTYPE_P2P_CLIENT 407 ) { 408 return; 409 } 410 411 if (check_fwstate(pmlmepriv, WIFI_AP_STATE) == true) 412 return; 413 414 { 415 struct wlan_bssid_ex *pnetwork = &(padapter->mlmeextpriv.mlmext_info.network); 416 struct wlan_network *scanned = pmlmepriv->cur_network_scanned; 417 418 if (!scanned) { 419 rtw_warn_on(1); 420 goto check_bss; 421 } 422 423 if (!memcmp(scanned->network.mac_address, pnetwork->mac_address, sizeof(NDIS_802_11_MAC_ADDRESS)) 424 && !memcmp(&(scanned->network.ssid), &(pnetwork->ssid), sizeof(struct ndis_802_11_ssid)) 425 ) 426 rtw_cfg80211_inform_bss(padapter, scanned); 427 else 428 rtw_warn_on(1); 429 } 430 431check_bss: 432 if (!rtw_cfg80211_check_bss(padapter)) 433 netdev_dbg(padapter->pnetdev, 434 FUNC_ADPT_FMT " BSS not found !!\n", 435 FUNC_ADPT_ARG(padapter)); 436 437 if (rtw_to_roam(padapter) > 0) { 438 struct wiphy *wiphy = pwdev->wiphy; 439 struct ieee80211_channel *notify_channel; 440 u32 freq; 441 u16 channel = cur_network->network.configuration.ds_config; 442 struct cfg80211_roam_info roam_info = {}; 443 444 freq = rtw_ieee80211_channel_to_frequency(channel); 445 446 notify_channel = ieee80211_get_channel(wiphy, freq); 447 448 roam_info.links[0].channel = notify_channel; 449 roam_info.links[0].bssid = cur_network->network.mac_address; 450 roam_info.req_ie = 451 pmlmepriv->assoc_req + sizeof(struct ieee80211_hdr_3addr) + 2; 452 roam_info.req_ie_len = 453 pmlmepriv->assoc_req_len - sizeof(struct ieee80211_hdr_3addr) - 2; 454 roam_info.resp_ie = 455 pmlmepriv->assoc_rsp + sizeof(struct ieee80211_hdr_3addr) + 6; 456 roam_info.resp_ie_len = 457 pmlmepriv->assoc_rsp_len - sizeof(struct ieee80211_hdr_3addr) - 6; 458 cfg80211_roamed(padapter->pnetdev, &roam_info, GFP_ATOMIC); 459 } else { 460 cfg80211_connect_result(padapter->pnetdev, cur_network->network.mac_address 461 , pmlmepriv->assoc_req + sizeof(struct ieee80211_hdr_3addr) + 2 462 , pmlmepriv->assoc_req_len - sizeof(struct ieee80211_hdr_3addr) - 2 463 , pmlmepriv->assoc_rsp + sizeof(struct ieee80211_hdr_3addr) + 6 464 , pmlmepriv->assoc_rsp_len - sizeof(struct ieee80211_hdr_3addr) - 6 465 , WLAN_STATUS_SUCCESS, GFP_ATOMIC); 466 } 467} 468 469void rtw_cfg80211_indicate_disconnect(struct adapter *padapter) 470{ 471 struct mlme_priv *pmlmepriv = &padapter->mlmepriv; 472 struct wireless_dev *pwdev = padapter->rtw_wdev; 473 474 if (pwdev->iftype != NL80211_IFTYPE_STATION 475 && pwdev->iftype != NL80211_IFTYPE_P2P_CLIENT 476 ) { 477 return; 478 } 479 480 if (check_fwstate(pmlmepriv, WIFI_AP_STATE) == true) 481 return; 482 483 if (!padapter->mlmepriv.not_indic_disco) { 484 if (check_fwstate(&padapter->mlmepriv, _FW_LINKED)) { 485 cfg80211_disconnected(padapter->pnetdev, 0, 486 NULL, 0, true, GFP_ATOMIC); 487 } else { 488 cfg80211_connect_result(padapter->pnetdev, NULL, NULL, 0, NULL, 0, 489 WLAN_STATUS_UNSPECIFIED_FAILURE, GFP_ATOMIC/*GFP_KERNEL*/); 490 } 491 } 492} 493 494static int rtw_cfg80211_ap_set_encryption(struct net_device *dev, struct ieee_param *param, u32 param_len) 495{ 496 int ret = 0; 497 u32 wep_key_idx, wep_key_len; 498 struct sta_info *psta = NULL, *pbcmc_sta = NULL; 499 struct adapter *padapter = rtw_netdev_priv(dev); 500 struct mlme_priv *pmlmepriv = &padapter->mlmepriv; 501 struct security_priv *psecuritypriv = &(padapter->securitypriv); 502 struct sta_priv *pstapriv = &padapter->stapriv; 503 char *grpkey = padapter->securitypriv.dot118021XGrpKey[param->u.crypt.idx].skey; 504 char *txkey = padapter->securitypriv.dot118021XGrptxmickey[param->u.crypt.idx].skey; 505 char *rxkey = padapter->securitypriv.dot118021XGrprxmickey[param->u.crypt.idx].skey; 506 507 param->u.crypt.err = 0; 508 param->u.crypt.alg[IEEE_CRYPT_ALG_NAME_LEN - 1] = '\0'; 509 510 if (param_len != sizeof(struct ieee_param) + param->u.crypt.key_len) { 511 ret = -EINVAL; 512 goto exit; 513 } 514 515 if (param->sta_addr[0] == 0xff && param->sta_addr[1] == 0xff && 516 param->sta_addr[2] == 0xff && param->sta_addr[3] == 0xff && 517 param->sta_addr[4] == 0xff && param->sta_addr[5] == 0xff) { 518 if (param->u.crypt.idx >= WEP_KEYS) { 519 ret = -EINVAL; 520 goto exit; 521 } 522 } else { 523 psta = rtw_get_stainfo(pstapriv, param->sta_addr); 524 if (!psta) 525 /* ret = -EINVAL; */ 526 goto exit; 527 } 528 529 if (strcmp(param->u.crypt.alg, "none") == 0 && !psta) 530 goto exit; 531 532 if (strcmp(param->u.crypt.alg, "WEP") == 0 && !psta) { 533 wep_key_idx = param->u.crypt.idx; 534 wep_key_len = param->u.crypt.key_len; 535 536 if ((wep_key_idx >= WEP_KEYS) || (wep_key_len <= 0)) { 537 ret = -EINVAL; 538 goto exit; 539 } 540 541 if (wep_key_len > 0) 542 wep_key_len = wep_key_len <= 5 ? 5 : 13; 543 544 if (psecuritypriv->bWepDefaultKeyIdxSet == 0) { 545 /* wep default key has not been set, so use this key index as default key. */ 546 547 psecuritypriv->dot11AuthAlgrthm = dot11AuthAlgrthm_Auto; 548 psecuritypriv->ndisencryptstatus = Ndis802_11Encryption1Enabled; 549 psecuritypriv->dot11PrivacyAlgrthm = _WEP40_; 550 psecuritypriv->dot118021XGrpPrivacy = _WEP40_; 551 552 if (wep_key_len == 13) { 553 psecuritypriv->dot11PrivacyAlgrthm = _WEP104_; 554 psecuritypriv->dot118021XGrpPrivacy = _WEP104_; 555 } 556 557 psecuritypriv->dot11PrivacyKeyIndex = wep_key_idx; 558 } 559 560 memcpy(&(psecuritypriv->dot11DefKey[wep_key_idx].skey[0]), param->u.crypt.key, wep_key_len); 561 562 psecuritypriv->dot11DefKeylen[wep_key_idx] = wep_key_len; 563 564 rtw_ap_set_wep_key(padapter, param->u.crypt.key, wep_key_len, wep_key_idx, 1); 565 566 goto exit; 567 } 568 569 /* group key */ 570 if (!psta && check_fwstate(pmlmepriv, WIFI_AP_STATE)) { 571 /* group key */ 572 if (param->u.crypt.set_tx == 0) { 573 if (strcmp(param->u.crypt.alg, "WEP") == 0) { 574 memcpy(grpkey, param->u.crypt.key, (param->u.crypt.key_len > 16 ? 16 : param->u.crypt.key_len)); 575 576 psecuritypriv->dot118021XGrpPrivacy = _WEP40_; 577 if (param->u.crypt.key_len == 13) 578 psecuritypriv->dot118021XGrpPrivacy = _WEP104_; 579 580 } else if (strcmp(param->u.crypt.alg, "TKIP") == 0) { 581 psecuritypriv->dot118021XGrpPrivacy = _TKIP_; 582 583 memcpy(grpkey, param->u.crypt.key, (param->u.crypt.key_len > 16 ? 16 : param->u.crypt.key_len)); 584 585 /* set mic key */ 586 memcpy(txkey, &(param->u.crypt.key[16]), 8); 587 memcpy(rxkey, &(param->u.crypt.key[24]), 8); 588 589 psecuritypriv->busetkipkey = true; 590 591 } else if (strcmp(param->u.crypt.alg, "CCMP") == 0) { 592 psecuritypriv->dot118021XGrpPrivacy = _AES_; 593 594 memcpy(grpkey, param->u.crypt.key, (param->u.crypt.key_len > 16 ? 16 : param->u.crypt.key_len)); 595 } else { 596 psecuritypriv->dot118021XGrpPrivacy = _NO_PRIVACY_; 597 } 598 599 psecuritypriv->dot118021XGrpKeyid = param->u.crypt.idx; 600 601 psecuritypriv->binstallGrpkey = true; 602 603 psecuritypriv->dot11PrivacyAlgrthm = psecuritypriv->dot118021XGrpPrivacy;/* */ 604 605 rtw_ap_set_group_key(padapter, param->u.crypt.key, psecuritypriv->dot118021XGrpPrivacy, param->u.crypt.idx); 606 607 pbcmc_sta = rtw_get_bcmc_stainfo(padapter); 608 if (pbcmc_sta) { 609 pbcmc_sta->ieee8021x_blocked = false; 610 pbcmc_sta->dot118021XPrivacy = psecuritypriv->dot118021XGrpPrivacy;/* rx will use bmc_sta's dot118021XPrivacy */ 611 } 612 } 613 614 goto exit; 615 } 616 617 if (psecuritypriv->dot11AuthAlgrthm == dot11AuthAlgrthm_8021X && psta) { /* psk/802_1x */ 618 if (check_fwstate(pmlmepriv, WIFI_AP_STATE)) { 619 if (param->u.crypt.set_tx == 1) { /* pairwise key */ 620 memcpy(psta->dot118021x_UncstKey.skey, param->u.crypt.key, (param->u.crypt.key_len > 16 ? 16 : param->u.crypt.key_len)); 621 622 if (strcmp(param->u.crypt.alg, "WEP") == 0) { 623 psta->dot118021XPrivacy = _WEP40_; 624 if (param->u.crypt.key_len == 13) 625 psta->dot118021XPrivacy = _WEP104_; 626 } else if (strcmp(param->u.crypt.alg, "TKIP") == 0) { 627 psta->dot118021XPrivacy = _TKIP_; 628 629 /* set mic key */ 630 memcpy(psta->dot11tkiptxmickey.skey, &(param->u.crypt.key[16]), 8); 631 memcpy(psta->dot11tkiprxmickey.skey, &(param->u.crypt.key[24]), 8); 632 633 psecuritypriv->busetkipkey = true; 634 635 } else if (strcmp(param->u.crypt.alg, "CCMP") == 0) { 636 psta->dot118021XPrivacy = _AES_; 637 } else { 638 psta->dot118021XPrivacy = _NO_PRIVACY_; 639 } 640 641 rtw_ap_set_pairwise_key(padapter, psta); 642 643 psta->ieee8021x_blocked = false; 644 645 psta->bpairwise_key_installed = true; 646 647 } else { /* group key??? */ 648 if (strcmp(param->u.crypt.alg, "WEP") == 0) { 649 memcpy(grpkey, param->u.crypt.key, (param->u.crypt.key_len > 16 ? 16 : param->u.crypt.key_len)); 650 651 psecuritypriv->dot118021XGrpPrivacy = _WEP40_; 652 if (param->u.crypt.key_len == 13) 653 psecuritypriv->dot118021XGrpPrivacy = _WEP104_; 654 } else if (strcmp(param->u.crypt.alg, "TKIP") == 0) { 655 psecuritypriv->dot118021XGrpPrivacy = _TKIP_; 656 657 memcpy(grpkey, param->u.crypt.key, (param->u.crypt.key_len > 16 ? 16 : param->u.crypt.key_len)); 658 659 /* set mic key */ 660 memcpy(txkey, &(param->u.crypt.key[16]), 8); 661 memcpy(rxkey, &(param->u.crypt.key[24]), 8); 662 663 psecuritypriv->busetkipkey = true; 664 665 } else if (strcmp(param->u.crypt.alg, "CCMP") == 0) { 666 psecuritypriv->dot118021XGrpPrivacy = _AES_; 667 668 memcpy(grpkey, param->u.crypt.key, (param->u.crypt.key_len > 16 ? 16 : param->u.crypt.key_len)); 669 } else { 670 psecuritypriv->dot118021XGrpPrivacy = _NO_PRIVACY_; 671 } 672 673 psecuritypriv->dot118021XGrpKeyid = param->u.crypt.idx; 674 675 psecuritypriv->binstallGrpkey = true; 676 677 psecuritypriv->dot11PrivacyAlgrthm = psecuritypriv->dot118021XGrpPrivacy;/* */ 678 679 rtw_ap_set_group_key(padapter, param->u.crypt.key, psecuritypriv->dot118021XGrpPrivacy, param->u.crypt.idx); 680 681 pbcmc_sta = rtw_get_bcmc_stainfo(padapter); 682 if (pbcmc_sta) { 683 pbcmc_sta->ieee8021x_blocked = false; 684 pbcmc_sta->dot118021XPrivacy = psecuritypriv->dot118021XGrpPrivacy;/* rx will use bmc_sta's dot118021XPrivacy */ 685 } 686 } 687 } 688 } 689 690exit: 691 692 return ret; 693} 694 695static int rtw_cfg80211_set_encryption(struct net_device *dev, struct ieee_param *param, u32 param_len) 696{ 697 int ret = 0; 698 u8 max_idx; 699 u32 wep_key_idx, wep_key_len; 700 struct adapter *padapter = rtw_netdev_priv(dev); 701 struct mlme_priv *pmlmepriv = &padapter->mlmepriv; 702 struct security_priv *psecuritypriv = &padapter->securitypriv; 703 704 param->u.crypt.err = 0; 705 param->u.crypt.alg[IEEE_CRYPT_ALG_NAME_LEN - 1] = '\0'; 706 707 if (param_len < (u32)((u8 *)param->u.crypt.key - (u8 *)param) + param->u.crypt.key_len) { 708 ret = -EINVAL; 709 goto exit; 710 } 711 712 if (param->sta_addr[0] != 0xff || param->sta_addr[1] != 0xff || 713 param->sta_addr[2] != 0xff || param->sta_addr[3] != 0xff || 714 param->sta_addr[4] != 0xff || param->sta_addr[5] != 0xff) { 715 ret = -EINVAL; 716 goto exit; 717 } 718 719 if (strcmp(param->u.crypt.alg, "WEP") == 0) 720 max_idx = WEP_KEYS - 1; 721 else 722 max_idx = BIP_MAX_KEYID; 723 724 if (param->u.crypt.idx > max_idx) { 725 netdev_err(dev, "Error crypt.idx %d > %d\n", param->u.crypt.idx, max_idx); 726 ret = -EINVAL; 727 goto exit; 728 } 729 730 if (strcmp(param->u.crypt.alg, "WEP") == 0) { 731 wep_key_idx = param->u.crypt.idx; 732 wep_key_len = param->u.crypt.key_len; 733 734 if (wep_key_len <= 0) { 735 ret = -EINVAL; 736 goto exit; 737 } 738 739 if (psecuritypriv->bWepDefaultKeyIdxSet == 0) { 740 /* wep default key has not been set, so use this key index as default key. */ 741 742 wep_key_len = wep_key_len <= 5 ? 5 : 13; 743 744 psecuritypriv->ndisencryptstatus = Ndis802_11Encryption1Enabled; 745 psecuritypriv->dot11PrivacyAlgrthm = _WEP40_; 746 psecuritypriv->dot118021XGrpPrivacy = _WEP40_; 747 748 if (wep_key_len == 13) { 749 psecuritypriv->dot11PrivacyAlgrthm = _WEP104_; 750 psecuritypriv->dot118021XGrpPrivacy = _WEP104_; 751 } 752 753 psecuritypriv->dot11PrivacyKeyIndex = wep_key_idx; 754 } 755 756 memcpy(&(psecuritypriv->dot11DefKey[wep_key_idx].skey[0]), param->u.crypt.key, wep_key_len); 757 758 psecuritypriv->dot11DefKeylen[wep_key_idx] = wep_key_len; 759 760 rtw_set_key(padapter, psecuritypriv, wep_key_idx, 0, true); 761 762 goto exit; 763 } 764 765 if (padapter->securitypriv.dot11AuthAlgrthm == dot11AuthAlgrthm_8021X) { /* 802_1x */ 766 struct sta_info *psta, *pbcmc_sta; 767 struct sta_priv *pstapriv = &padapter->stapriv; 768 769 if (check_fwstate(pmlmepriv, WIFI_STATION_STATE | WIFI_MP_STATE) == true) { /* sta mode */ 770 psta = rtw_get_stainfo(pstapriv, get_bssid(pmlmepriv)); 771 if (psta) { 772 /* Jeff: don't disable ieee8021x_blocked while clearing key */ 773 if (strcmp(param->u.crypt.alg, "none") != 0) 774 psta->ieee8021x_blocked = false; 775 776 if ((padapter->securitypriv.ndisencryptstatus == Ndis802_11Encryption2Enabled) || 777 (padapter->securitypriv.ndisencryptstatus == Ndis802_11Encryption3Enabled)) { 778 psta->dot118021XPrivacy = padapter->securitypriv.dot11PrivacyAlgrthm; 779 } 780 781 if (param->u.crypt.set_tx == 1) { /* pairwise key */ 782 783 memcpy(psta->dot118021x_UncstKey.skey, param->u.crypt.key, (param->u.crypt.key_len > 16 ? 16 : param->u.crypt.key_len)); 784 785 if (strcmp(param->u.crypt.alg, "TKIP") == 0) { /* set mic key */ 786 memcpy(psta->dot11tkiptxmickey.skey, &(param->u.crypt.key[16]), 8); 787 memcpy(psta->dot11tkiprxmickey.skey, &(param->u.crypt.key[24]), 8); 788 789 padapter->securitypriv.busetkipkey = false; 790 /* _set_timer(&padapter->securitypriv.tkip_timer, 50); */ 791 } 792 793 rtw_setstakey_cmd(padapter, psta, true, true); 794 } else { /* group key */ 795 if (strcmp(param->u.crypt.alg, "TKIP") == 0 || strcmp(param->u.crypt.alg, "CCMP") == 0) { 796 memcpy(padapter->securitypriv.dot118021XGrpKey[param->u.crypt.idx].skey, param->u.crypt.key, (param->u.crypt.key_len > 16 ? 16 : param->u.crypt.key_len)); 797 memcpy(padapter->securitypriv.dot118021XGrptxmickey[param->u.crypt.idx].skey, &(param->u.crypt.key[16]), 8); 798 memcpy(padapter->securitypriv.dot118021XGrprxmickey[param->u.crypt.idx].skey, &(param->u.crypt.key[24]), 8); 799 padapter->securitypriv.binstallGrpkey = true; 800 801 padapter->securitypriv.dot118021XGrpKeyid = param->u.crypt.idx; 802 rtw_set_key(padapter, &padapter->securitypriv, param->u.crypt.idx, 1, true); 803 } else if (strcmp(param->u.crypt.alg, "BIP") == 0) { 804 /* save the IGTK key, length 16 bytes */ 805 memcpy(padapter->securitypriv.dot11wBIPKey[param->u.crypt.idx].skey, param->u.crypt.key, (param->u.crypt.key_len > 16 ? 16 : param->u.crypt.key_len)); 806 padapter->securitypriv.dot11wBIPKeyid = param->u.crypt.idx; 807 padapter->securitypriv.binstallBIPkey = true; 808 } 809 } 810 } 811 812 pbcmc_sta = rtw_get_bcmc_stainfo(padapter); 813 if (pbcmc_sta) { 814 /* Jeff: don't disable ieee8021x_blocked while clearing key */ 815 if (strcmp(param->u.crypt.alg, "none") != 0) 816 pbcmc_sta->ieee8021x_blocked = false; 817 818 if ((padapter->securitypriv.ndisencryptstatus == Ndis802_11Encryption2Enabled) || 819 (padapter->securitypriv.ndisencryptstatus == Ndis802_11Encryption3Enabled)) { 820 pbcmc_sta->dot118021XPrivacy = padapter->securitypriv.dot11PrivacyAlgrthm; 821 } 822 } 823 } else if (check_fwstate(pmlmepriv, WIFI_ADHOC_STATE)) { /* adhoc mode */ 824 } 825 } 826 827exit: 828 829 return ret; 830} 831 832static int cfg80211_rtw_add_key(struct wiphy *wiphy, struct net_device *ndev, 833 int link_id, u8 key_index, bool pairwise, 834 const u8 *mac_addr, struct key_params *params) 835{ 836 char *alg_name; 837 u32 param_len; 838 struct ieee_param *param = NULL; 839 int ret = 0; 840 struct adapter *padapter = rtw_netdev_priv(ndev); 841 struct mlme_priv *pmlmepriv = &padapter->mlmepriv; 842 843 param_len = sizeof(struct ieee_param) + params->key_len; 844 param = rtw_malloc(param_len); 845 if (!param) 846 return -1; 847 848 memset(param, 0, param_len); 849 850 param->cmd = IEEE_CMD_SET_ENCRYPTION; 851 eth_broadcast_addr(param->sta_addr); 852 853 switch (params->cipher) { 854 case IW_AUTH_CIPHER_NONE: 855 /* todo: remove key */ 856 /* remove = 1; */ 857 alg_name = "none"; 858 break; 859 case WLAN_CIPHER_SUITE_WEP40: 860 case WLAN_CIPHER_SUITE_WEP104: 861 alg_name = "WEP"; 862 break; 863 case WLAN_CIPHER_SUITE_TKIP: 864 alg_name = "TKIP"; 865 break; 866 case WLAN_CIPHER_SUITE_CCMP: 867 alg_name = "CCMP"; 868 break; 869 case WLAN_CIPHER_SUITE_AES_CMAC: 870 alg_name = "BIP"; 871 break; 872 default: 873 ret = -ENOTSUPP; 874 goto addkey_end; 875 } 876 877 strscpy(param->u.crypt.alg, alg_name); 878 879 if (!mac_addr || is_broadcast_ether_addr(mac_addr)) 880 param->u.crypt.set_tx = 0; /* for wpa/wpa2 group key */ 881 else 882 param->u.crypt.set_tx = 1; /* for wpa/wpa2 pairwise key */ 883 884 param->u.crypt.idx = key_index; 885 886 if (params->seq_len && params->seq) 887 memcpy(param->u.crypt.seq, (u8 *)params->seq, params->seq_len); 888 889 if (params->key_len && params->key) { 890 param->u.crypt.key_len = params->key_len; 891 memcpy(param->u.crypt.key, (u8 *)params->key, params->key_len); 892 } 893 894 if (check_fwstate(pmlmepriv, WIFI_STATION_STATE) == true) { 895 ret = rtw_cfg80211_set_encryption(ndev, param, param_len); 896 } else if (check_fwstate(pmlmepriv, WIFI_AP_STATE) == true) { 897 if (mac_addr) 898 memcpy(param->sta_addr, (void *)mac_addr, ETH_ALEN); 899 900 ret = rtw_cfg80211_ap_set_encryption(ndev, param, param_len); 901 } else if (check_fwstate(pmlmepriv, WIFI_ADHOC_STATE) == true 902 || check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE) == true) { 903 ret = rtw_cfg80211_set_encryption(ndev, param, param_len); 904 } 905 906addkey_end: 907 kfree(param); 908 909 return ret; 910} 911 912static int cfg80211_rtw_get_key(struct wiphy *wiphy, struct net_device *ndev, 913 int link_id, u8 key_index, bool pairwise, 914 const u8 *mac_addr, void *cookie, 915 void (*callback)(void *cookie, 916 struct key_params*)) 917{ 918 return 0; 919} 920 921static int cfg80211_rtw_del_key(struct wiphy *wiphy, struct net_device *ndev, 922 int link_id, u8 key_index, bool pairwise, 923 const u8 *mac_addr) 924{ 925 struct adapter *padapter = rtw_netdev_priv(ndev); 926 struct security_priv *psecuritypriv = &padapter->securitypriv; 927 928 if (key_index == psecuritypriv->dot11PrivacyKeyIndex) { 929 /* clear the flag of wep default key set. */ 930 psecuritypriv->bWepDefaultKeyIdxSet = 0; 931 } 932 933 return 0; 934} 935 936static int cfg80211_rtw_set_default_key(struct wiphy *wiphy, 937 struct net_device *ndev, int link_id, 938 u8 key_index, bool unicast, 939 bool multicast) 940{ 941 struct adapter *padapter = rtw_netdev_priv(ndev); 942 struct security_priv *psecuritypriv = &padapter->securitypriv; 943 944 if ((key_index < WEP_KEYS) && ((psecuritypriv->dot11PrivacyAlgrthm == _WEP40_) || (psecuritypriv->dot11PrivacyAlgrthm == _WEP104_))) { /* set wep default key */ 945 psecuritypriv->ndisencryptstatus = Ndis802_11Encryption1Enabled; 946 947 psecuritypriv->dot11PrivacyKeyIndex = key_index; 948 949 psecuritypriv->dot11PrivacyAlgrthm = _WEP40_; 950 psecuritypriv->dot118021XGrpPrivacy = _WEP40_; 951 if (psecuritypriv->dot11DefKeylen[key_index] == 13) { 952 psecuritypriv->dot11PrivacyAlgrthm = _WEP104_; 953 psecuritypriv->dot118021XGrpPrivacy = _WEP104_; 954 } 955 956 psecuritypriv->bWepDefaultKeyIdxSet = 1; /* set the flag to represent that wep default key has been set */ 957 } 958 959 return 0; 960} 961 962static int cfg80211_rtw_get_station(struct wiphy *wiphy, 963 struct net_device *ndev, 964 const u8 *mac, 965 struct station_info *sinfo) 966{ 967 int ret = 0; 968 struct adapter *padapter = rtw_netdev_priv(ndev); 969 struct mlme_priv *pmlmepriv = &padapter->mlmepriv; 970 struct sta_info *psta = NULL; 971 struct sta_priv *pstapriv = &padapter->stapriv; 972 973 sinfo->filled = 0; 974 975 if (!mac) { 976 ret = -ENOENT; 977 goto exit; 978 } 979 980 psta = rtw_get_stainfo(pstapriv, (u8 *)mac); 981 if (!psta) { 982 ret = -ENOENT; 983 goto exit; 984 } 985 986 /* for infra./P2PClient mode */ 987 if (check_fwstate(pmlmepriv, WIFI_STATION_STATE) 988 && check_fwstate(pmlmepriv, _FW_LINKED)) { 989 struct wlan_network *cur_network = &(pmlmepriv->cur_network); 990 991 if (memcmp((u8 *)mac, cur_network->network.mac_address, ETH_ALEN)) { 992 ret = -ENOENT; 993 goto exit; 994 } 995 996 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_SIGNAL); 997 sinfo->signal = translate_percentage_to_dbm(padapter->recvpriv.signal_strength); 998 999 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_TX_BITRATE); 1000 sinfo->txrate.legacy = rtw_get_cur_max_rate(padapter); 1001 1002 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_RX_PACKETS); 1003 sinfo->rx_packets = sta_rx_data_pkts(psta); 1004 1005 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_TX_PACKETS); 1006 sinfo->tx_packets = psta->sta_stats.tx_pkts; 1007 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_TX_FAILED); 1008 } 1009 1010 /* for Ad-Hoc/AP mode */ 1011 if ((check_fwstate(pmlmepriv, WIFI_ADHOC_STATE) || 1012 check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE) || 1013 check_fwstate(pmlmepriv, WIFI_AP_STATE)) && 1014 check_fwstate(pmlmepriv, _FW_LINKED)) { 1015 /* TODO: should acquire station info... */ 1016 } 1017 1018exit: 1019 return ret; 1020} 1021 1022static int cfg80211_rtw_change_iface(struct wiphy *wiphy, 1023 struct net_device *ndev, 1024 enum nl80211_iftype type, 1025 struct vif_params *params) 1026{ 1027 enum nl80211_iftype old_type; 1028 enum ndis_802_11_network_infrastructure networkType; 1029 struct adapter *padapter = rtw_netdev_priv(ndev); 1030 struct wireless_dev *rtw_wdev = padapter->rtw_wdev; 1031 struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv); 1032 int ret = 0; 1033 1034 if (adapter_to_dvobj(padapter)->processing_dev_remove == true) { 1035 ret = -EPERM; 1036 goto exit; 1037 } 1038 1039 { 1040 if (netdev_open(ndev) != 0) { 1041 ret = -EPERM; 1042 goto exit; 1043 } 1044 } 1045 1046 if (rtw_pwr_wakeup(padapter) == _FAIL) { 1047 ret = -EPERM; 1048 goto exit; 1049 } 1050 1051 old_type = rtw_wdev->iftype; 1052 1053 if (old_type != type) { 1054 pmlmeext->action_public_rxseq = 0xffff; 1055 pmlmeext->action_public_dialog_token = 0xff; 1056 } 1057 1058 switch (type) { 1059 case NL80211_IFTYPE_ADHOC: 1060 networkType = Ndis802_11IBSS; 1061 break; 1062 case NL80211_IFTYPE_STATION: 1063 networkType = Ndis802_11Infrastructure; 1064 break; 1065 case NL80211_IFTYPE_AP: 1066 networkType = Ndis802_11APMode; 1067 break; 1068 default: 1069 ret = -EOPNOTSUPP; 1070 goto exit; 1071 } 1072 1073 rtw_wdev->iftype = type; 1074 1075 if (rtw_set_802_11_infrastructure_mode(padapter, networkType) == false) { 1076 rtw_wdev->iftype = old_type; 1077 ret = -EPERM; 1078 goto exit; 1079 } 1080 1081 rtw_setopmode_cmd(padapter, networkType, true); 1082 1083exit: 1084 1085 return ret; 1086} 1087 1088void rtw_cfg80211_indicate_scan_done(struct adapter *adapter, bool aborted) 1089{ 1090 struct rtw_wdev_priv *pwdev_priv = adapter_wdev_data(adapter); 1091 struct cfg80211_scan_info info = { 1092 .aborted = aborted 1093 }; 1094 1095 spin_lock_bh(&pwdev_priv->scan_req_lock); 1096 if (pwdev_priv->scan_request) { 1097 /* avoid WARN_ON(request != wiphy_to_dev(request->wiphy)->scan_req); */ 1098 if (pwdev_priv->scan_request->wiphy == pwdev_priv->rtw_wdev->wiphy) 1099 cfg80211_scan_done(pwdev_priv->scan_request, &info); 1100 1101 pwdev_priv->scan_request = NULL; 1102 } 1103 spin_unlock_bh(&pwdev_priv->scan_req_lock); 1104} 1105 1106void rtw_cfg80211_unlink_bss(struct adapter *padapter, struct wlan_network *pnetwork) 1107{ 1108 struct wireless_dev *pwdev = padapter->rtw_wdev; 1109 struct wiphy *wiphy = pwdev->wiphy; 1110 struct cfg80211_bss *bss = NULL; 1111 struct wlan_bssid_ex *select_network = &pnetwork->network; 1112 1113 bss = cfg80211_get_bss(wiphy, NULL/*notify_channel*/, 1114 select_network->mac_address, 1115 select_network->ssid.ssid, 1116 select_network->ssid.ssid_length, 1117 IEEE80211_BSS_TYPE_ANY, IEEE80211_PRIVACY_ANY); 1118 1119 if (bss) { 1120 cfg80211_unlink_bss(wiphy, bss); 1121 cfg80211_put_bss(padapter->rtw_wdev->wiphy, bss); 1122 } 1123} 1124 1125void rtw_cfg80211_surveydone_event_callback(struct adapter *padapter) 1126{ 1127 struct list_head *plist, *phead; 1128 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv); 1129 struct __queue *queue = &(pmlmepriv->scanned_queue); 1130 struct wlan_network *pnetwork = NULL; 1131 1132 spin_lock_bh(&(pmlmepriv->scanned_queue.lock)); 1133 1134 phead = get_list_head(queue); 1135 list_for_each(plist, phead) 1136 { 1137 pnetwork = list_entry(plist, struct wlan_network, list); 1138 1139 /* report network only if the current channel set contains the channel to which this network belongs */ 1140 if (rtw_ch_set_search_ch(padapter->mlmeextpriv.channel_set, pnetwork->network.configuration.ds_config) >= 0 1141 && true == rtw_validate_ssid(&(pnetwork->network.ssid))) { 1142 /* ev =translate_scan(padapter, a, pnetwork, ev, stop); */ 1143 rtw_cfg80211_inform_bss(padapter, pnetwork); 1144 } 1145 } 1146 1147 spin_unlock_bh(&(pmlmepriv->scanned_queue.lock)); 1148} 1149 1150static int rtw_cfg80211_set_probe_req_wpsp2pie(struct adapter *padapter, char *buf, int len) 1151{ 1152 int ret = 0; 1153 uint wps_ielen = 0; 1154 u8 *wps_ie; 1155 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv); 1156 1157 if (len > 0) { 1158 wps_ie = rtw_get_wps_ie(buf, len, NULL, &wps_ielen); 1159 if (wps_ie) { 1160 if (pmlmepriv->wps_probe_req_ie) { 1161 pmlmepriv->wps_probe_req_ie_len = 0; 1162 kfree(pmlmepriv->wps_probe_req_ie); 1163 pmlmepriv->wps_probe_req_ie = NULL; 1164 } 1165 1166 pmlmepriv->wps_probe_req_ie = rtw_malloc(wps_ielen); 1167 if (!pmlmepriv->wps_probe_req_ie) 1168 return -EINVAL; 1169 1170 memcpy(pmlmepriv->wps_probe_req_ie, wps_ie, wps_ielen); 1171 pmlmepriv->wps_probe_req_ie_len = wps_ielen; 1172 } 1173 } 1174 1175 return ret; 1176} 1177 1178static int cfg80211_rtw_scan(struct wiphy *wiphy 1179 , struct cfg80211_scan_request *request) 1180{ 1181 struct net_device *ndev = wdev_to_ndev(request->wdev); 1182 int i; 1183 u8 _status = false; 1184 int ret = 0; 1185 struct ndis_802_11_ssid *ssid = NULL; 1186 struct rtw_ieee80211_channel ch[RTW_CHANNEL_SCAN_AMOUNT]; 1187 u8 survey_times = 3; 1188 u8 survey_times_for_one_ch = 6; 1189 struct cfg80211_ssid *ssids = request->ssids; 1190 int j = 0; 1191 bool need_indicate_scan_done = false; 1192 1193 struct adapter *padapter; 1194 struct rtw_wdev_priv *pwdev_priv; 1195 struct mlme_priv *pmlmepriv; 1196 1197 if (!ndev) { 1198 ret = -EINVAL; 1199 goto exit; 1200 } 1201 1202 padapter = rtw_netdev_priv(ndev); 1203 pwdev_priv = adapter_wdev_data(padapter); 1204 pmlmepriv = &padapter->mlmepriv; 1205/* endif */ 1206 1207 spin_lock_bh(&pwdev_priv->scan_req_lock); 1208 pwdev_priv->scan_request = request; 1209 spin_unlock_bh(&pwdev_priv->scan_req_lock); 1210 1211 if (check_fwstate(pmlmepriv, WIFI_AP_STATE) == true) { 1212 if (check_fwstate(pmlmepriv, WIFI_UNDER_WPS | _FW_UNDER_SURVEY | _FW_UNDER_LINKING) == true) { 1213 need_indicate_scan_done = true; 1214 goto check_need_indicate_scan_done; 1215 } 1216 } 1217 1218 rtw_ps_deny(padapter, PS_DENY_SCAN); 1219 if (rtw_pwr_wakeup(padapter) == _FAIL) { 1220 need_indicate_scan_done = true; 1221 goto check_need_indicate_scan_done; 1222 } 1223 1224 if (request->ie && request->ie_len > 0) 1225 rtw_cfg80211_set_probe_req_wpsp2pie(padapter, (u8 *)request->ie, request->ie_len); 1226 1227 if (check_fwstate(pmlmepriv, _FW_UNDER_SURVEY) == true) { 1228 need_indicate_scan_done = true; 1229 goto check_need_indicate_scan_done; 1230 } else if (check_fwstate(pmlmepriv, _FW_UNDER_LINKING) == true) { 1231 ret = -EBUSY; 1232 goto check_need_indicate_scan_done; 1233 } 1234 1235 if (pmlmepriv->LinkDetectInfo.bBusyTraffic == true) { 1236 static unsigned long lastscantime; 1237 unsigned long passtime; 1238 1239 passtime = jiffies_to_msecs(jiffies - lastscantime); 1240 lastscantime = jiffies; 1241 if (passtime > 12000) { 1242 need_indicate_scan_done = true; 1243 goto check_need_indicate_scan_done; 1244 } 1245 } 1246 1247 if (rtw_is_scan_deny(padapter)) { 1248 need_indicate_scan_done = true; 1249 goto check_need_indicate_scan_done; 1250 } 1251 1252 ssid = kcalloc(RTW_SSID_SCAN_AMOUNT, sizeof(*ssid), GFP_KERNEL); 1253 if (!ssid) { 1254 ret = -ENOMEM; 1255 goto check_need_indicate_scan_done; 1256 } 1257 1258 /* parsing request ssids, n_ssids */ 1259 for (i = 0; i < request->n_ssids && i < RTW_SSID_SCAN_AMOUNT; i++) { 1260 memcpy(ssid[i].ssid, ssids[i].ssid, ssids[i].ssid_len); 1261 ssid[i].ssid_length = ssids[i].ssid_len; 1262 } 1263 1264 /* parsing channels, n_channels */ 1265 memset(ch, 0, sizeof(struct rtw_ieee80211_channel) * RTW_CHANNEL_SCAN_AMOUNT); 1266 for (i = 0; i < request->n_channels && i < RTW_CHANNEL_SCAN_AMOUNT; i++) { 1267 ch[i].hw_value = request->channels[i]->hw_value; 1268 ch[i].flags = request->channels[i]->flags; 1269 } 1270 1271 spin_lock_bh(&pmlmepriv->lock); 1272 if (request->n_channels == 1) { 1273 for (i = 1; i < survey_times_for_one_ch; i++) 1274 memcpy(&ch[i], &ch[0], sizeof(struct rtw_ieee80211_channel)); 1275 _status = rtw_sitesurvey_cmd(padapter, ssid, RTW_SSID_SCAN_AMOUNT, ch, survey_times_for_one_ch); 1276 } else if (request->n_channels <= 4) { 1277 for (j = request->n_channels - 1; j >= 0; j--) 1278 for (i = 0; i < survey_times; i++) 1279 memcpy(&ch[j * survey_times + i], &ch[j], sizeof(struct rtw_ieee80211_channel)); 1280 _status = rtw_sitesurvey_cmd(padapter, ssid, RTW_SSID_SCAN_AMOUNT, ch, survey_times * request->n_channels); 1281 } else { 1282 _status = rtw_sitesurvey_cmd(padapter, ssid, RTW_SSID_SCAN_AMOUNT, NULL, 0); 1283 } 1284 spin_unlock_bh(&pmlmepriv->lock); 1285 1286 if (_status == false) 1287 ret = -1; 1288 1289check_need_indicate_scan_done: 1290 kfree(ssid); 1291 if (need_indicate_scan_done) { 1292 rtw_cfg80211_surveydone_event_callback(padapter); 1293 rtw_cfg80211_indicate_scan_done(padapter, false); 1294 } 1295 1296 rtw_ps_deny_cancel(padapter, PS_DENY_SCAN); 1297 1298exit: 1299 return ret; 1300} 1301 1302static int cfg80211_rtw_set_wiphy_params(struct wiphy *wiphy, int radio_idx, 1303 u32 changed) 1304{ 1305 return 0; 1306} 1307 1308static int rtw_cfg80211_set_wpa_version(struct security_priv *psecuritypriv, u32 wpa_version) 1309{ 1310 if (!wpa_version) { 1311 psecuritypriv->ndisauthtype = Ndis802_11AuthModeOpen; 1312 return 0; 1313 } 1314 1315 if (wpa_version & (NL80211_WPA_VERSION_1 | NL80211_WPA_VERSION_2)) 1316 psecuritypriv->ndisauthtype = Ndis802_11AuthModeWPAPSK; 1317 1318 return 0; 1319} 1320 1321static int rtw_cfg80211_set_auth_type(struct security_priv *psecuritypriv, 1322 enum nl80211_auth_type sme_auth_type) 1323{ 1324 switch (sme_auth_type) { 1325 case NL80211_AUTHTYPE_AUTOMATIC: 1326 1327 psecuritypriv->dot11AuthAlgrthm = dot11AuthAlgrthm_Auto; 1328 1329 break; 1330 case NL80211_AUTHTYPE_OPEN_SYSTEM: 1331 1332 psecuritypriv->dot11AuthAlgrthm = dot11AuthAlgrthm_Open; 1333 1334 if (psecuritypriv->ndisauthtype > Ndis802_11AuthModeWPA) 1335 psecuritypriv->dot11AuthAlgrthm = dot11AuthAlgrthm_8021X; 1336 1337 break; 1338 case NL80211_AUTHTYPE_SHARED_KEY: 1339 1340 psecuritypriv->dot11AuthAlgrthm = dot11AuthAlgrthm_Shared; 1341 1342 psecuritypriv->ndisencryptstatus = Ndis802_11Encryption1Enabled; 1343 1344 break; 1345 default: 1346 psecuritypriv->dot11AuthAlgrthm = dot11AuthAlgrthm_Open; 1347 /* return -ENOTSUPP; */ 1348 } 1349 1350 return 0; 1351} 1352 1353static int rtw_cfg80211_set_cipher(struct security_priv *psecuritypriv, u32 cipher, bool ucast) 1354{ 1355 u32 ndisencryptstatus = Ndis802_11EncryptionDisabled; 1356 1357 u32 *profile_cipher = ucast ? &psecuritypriv->dot11PrivacyAlgrthm : 1358 &psecuritypriv->dot118021XGrpPrivacy; 1359 1360 if (!cipher) { 1361 *profile_cipher = _NO_PRIVACY_; 1362 psecuritypriv->ndisencryptstatus = ndisencryptstatus; 1363 return 0; 1364 } 1365 1366 switch (cipher) { 1367 case IW_AUTH_CIPHER_NONE: 1368 *profile_cipher = _NO_PRIVACY_; 1369 ndisencryptstatus = Ndis802_11EncryptionDisabled; 1370 break; 1371 case WLAN_CIPHER_SUITE_WEP40: 1372 *profile_cipher = _WEP40_; 1373 ndisencryptstatus = Ndis802_11Encryption1Enabled; 1374 break; 1375 case WLAN_CIPHER_SUITE_WEP104: 1376 *profile_cipher = _WEP104_; 1377 ndisencryptstatus = Ndis802_11Encryption1Enabled; 1378 break; 1379 case WLAN_CIPHER_SUITE_TKIP: 1380 *profile_cipher = _TKIP_; 1381 ndisencryptstatus = Ndis802_11Encryption2Enabled; 1382 break; 1383 case WLAN_CIPHER_SUITE_CCMP: 1384 *profile_cipher = _AES_; 1385 ndisencryptstatus = Ndis802_11Encryption3Enabled; 1386 break; 1387 default: 1388 return -ENOTSUPP; 1389 } 1390 1391 if (ucast) { 1392 psecuritypriv->ndisencryptstatus = ndisencryptstatus; 1393 1394 /* if (psecuritypriv->dot11PrivacyAlgrthm >= _AES_) */ 1395 /* psecuritypriv->ndisauthtype = Ndis802_11AuthModeWPA2PSK; */ 1396 } 1397 1398 return 0; 1399} 1400 1401static int rtw_cfg80211_set_key_mgt(struct security_priv *psecuritypriv, u32 key_mgt) 1402{ 1403 if (key_mgt == WLAN_AKM_SUITE_8021X) 1404 /* auth_type = UMAC_AUTH_TYPE_8021X; */ 1405 psecuritypriv->dot11AuthAlgrthm = dot11AuthAlgrthm_8021X; 1406 else if (key_mgt == WLAN_AKM_SUITE_PSK) { 1407 psecuritypriv->dot11AuthAlgrthm = dot11AuthAlgrthm_8021X; 1408 } 1409 1410 return 0; 1411} 1412 1413static int rtw_cfg80211_set_wpa_ie(struct adapter *padapter, u8 *pie, size_t ielen) 1414{ 1415 u8 *buf = NULL; 1416 int group_cipher = 0, pairwise_cipher = 0; 1417 int ret = 0; 1418 int wpa_ielen = 0; 1419 int wpa2_ielen = 0; 1420 u8 *pwpa, *pwpa2; 1421 u8 null_addr[] = {0, 0, 0, 0, 0, 0}; 1422 1423 if (!pie || !ielen) { 1424 /* Treat this as normal case, but need to clear WIFI_UNDER_WPS */ 1425 _clr_fwstate_(&padapter->mlmepriv, WIFI_UNDER_WPS); 1426 goto exit; 1427 } 1428 1429 if (ielen > MAX_WPA_IE_LEN + MAX_WPS_IE_LEN + MAX_P2P_IE_LEN) { 1430 ret = -EINVAL; 1431 goto exit; 1432 } 1433 1434 buf = rtw_zmalloc(ielen); 1435 if (!buf) { 1436 ret = -ENOMEM; 1437 goto exit; 1438 } 1439 1440 memcpy(buf, pie, ielen); 1441 1442 if (ielen < RSN_HEADER_LEN) { 1443 ret = -1; 1444 goto exit; 1445 } 1446 1447 pwpa = rtw_get_wpa_ie(buf, &wpa_ielen, ielen); 1448 if (pwpa && wpa_ielen > 0) { 1449 if (rtw_parse_wpa_ie(pwpa, wpa_ielen + 2, &group_cipher, &pairwise_cipher, NULL) == _SUCCESS) { 1450 padapter->securitypriv.dot11AuthAlgrthm = dot11AuthAlgrthm_8021X; 1451 padapter->securitypriv.ndisauthtype = Ndis802_11AuthModeWPAPSK; 1452 memcpy(padapter->securitypriv.supplicant_ie, &pwpa[0], wpa_ielen + 2); 1453 } 1454 } 1455 1456 pwpa2 = rtw_get_wpa2_ie(buf, &wpa2_ielen, ielen); 1457 if (pwpa2 && wpa2_ielen > 0) { 1458 if (rtw_parse_wpa2_ie(pwpa2, wpa2_ielen + 2, &group_cipher, &pairwise_cipher, NULL) == _SUCCESS) { 1459 padapter->securitypriv.dot11AuthAlgrthm = dot11AuthAlgrthm_8021X; 1460 padapter->securitypriv.ndisauthtype = Ndis802_11AuthModeWPA2PSK; 1461 memcpy(padapter->securitypriv.supplicant_ie, &pwpa2[0], wpa2_ielen + 2); 1462 } 1463 } 1464 1465 if (group_cipher == 0) 1466 group_cipher = WPA_CIPHER_NONE; 1467 1468 if (pairwise_cipher == 0) 1469 pairwise_cipher = WPA_CIPHER_NONE; 1470 1471 switch (group_cipher) { 1472 case WPA_CIPHER_NONE: 1473 padapter->securitypriv.dot118021XGrpPrivacy = _NO_PRIVACY_; 1474 padapter->securitypriv.ndisencryptstatus = Ndis802_11EncryptionDisabled; 1475 break; 1476 case WPA_CIPHER_WEP40: 1477 padapter->securitypriv.dot118021XGrpPrivacy = _WEP40_; 1478 padapter->securitypriv.ndisencryptstatus = Ndis802_11Encryption1Enabled; 1479 break; 1480 case WPA_CIPHER_TKIP: 1481 padapter->securitypriv.dot118021XGrpPrivacy = _TKIP_; 1482 padapter->securitypriv.ndisencryptstatus = Ndis802_11Encryption2Enabled; 1483 break; 1484 case WPA_CIPHER_CCMP: 1485 padapter->securitypriv.dot118021XGrpPrivacy = _AES_; 1486 padapter->securitypriv.ndisencryptstatus = Ndis802_11Encryption3Enabled; 1487 break; 1488 case WPA_CIPHER_WEP104: 1489 padapter->securitypriv.dot118021XGrpPrivacy = _WEP104_; 1490 padapter->securitypriv.ndisencryptstatus = Ndis802_11Encryption1Enabled; 1491 break; 1492 } 1493 1494 switch (pairwise_cipher) { 1495 case WPA_CIPHER_NONE: 1496 padapter->securitypriv.dot11PrivacyAlgrthm = _NO_PRIVACY_; 1497 padapter->securitypriv.ndisencryptstatus = Ndis802_11EncryptionDisabled; 1498 break; 1499 case WPA_CIPHER_WEP40: 1500 padapter->securitypriv.dot11PrivacyAlgrthm = _WEP40_; 1501 padapter->securitypriv.ndisencryptstatus = Ndis802_11Encryption1Enabled; 1502 break; 1503 case WPA_CIPHER_TKIP: 1504 padapter->securitypriv.dot11PrivacyAlgrthm = _TKIP_; 1505 padapter->securitypriv.ndisencryptstatus = Ndis802_11Encryption2Enabled; 1506 break; 1507 case WPA_CIPHER_CCMP: 1508 padapter->securitypriv.dot11PrivacyAlgrthm = _AES_; 1509 padapter->securitypriv.ndisencryptstatus = Ndis802_11Encryption3Enabled; 1510 break; 1511 case WPA_CIPHER_WEP104: 1512 padapter->securitypriv.dot11PrivacyAlgrthm = _WEP104_; 1513 padapter->securitypriv.ndisencryptstatus = Ndis802_11Encryption1Enabled; 1514 break; 1515 } 1516 1517 {/* handle wps_ie */ 1518 uint wps_ielen; 1519 u8 *wps_ie; 1520 1521 wps_ie = rtw_get_wps_ie(buf, ielen, NULL, &wps_ielen); 1522 if (wps_ie && wps_ielen > 0) { 1523 padapter->securitypriv.wps_ie_len = min_t(uint, wps_ielen, MAX_WPS_IE_LEN); 1524 memcpy(padapter->securitypriv.wps_ie, wps_ie, padapter->securitypriv.wps_ie_len); 1525 set_fwstate(&padapter->mlmepriv, WIFI_UNDER_WPS); 1526 } else { 1527 _clr_fwstate_(&padapter->mlmepriv, WIFI_UNDER_WPS); 1528 } 1529 } 1530 1531 /* TKIP and AES disallow multicast packets until installing group key */ 1532 if (padapter->securitypriv.dot11PrivacyAlgrthm == _TKIP_ 1533 || padapter->securitypriv.dot11PrivacyAlgrthm == _TKIP_WTMIC_ 1534 || padapter->securitypriv.dot11PrivacyAlgrthm == _AES_) 1535 /* WPS open need to enable multicast */ 1536 /* check_fwstate(&padapter->mlmepriv, WIFI_UNDER_WPS) == true) */ 1537 rtw_hal_set_hwreg(padapter, HW_VAR_OFF_RCR_AM, null_addr); 1538 1539exit: 1540 kfree(buf); 1541 if (ret) 1542 _clr_fwstate_(&padapter->mlmepriv, WIFI_UNDER_WPS); 1543 return ret; 1544} 1545 1546static int cfg80211_rtw_join_ibss(struct wiphy *wiphy, struct net_device *ndev, 1547 struct cfg80211_ibss_params *params) 1548{ 1549 struct adapter *padapter = rtw_netdev_priv(ndev); 1550 struct ndis_802_11_ssid ndis_ssid; 1551 struct security_priv *psecuritypriv = &padapter->securitypriv; 1552 struct mlme_priv *pmlmepriv = &padapter->mlmepriv; 1553 int ret = 0; 1554 1555 if (rtw_pwr_wakeup(padapter) == _FAIL) { 1556 ret = -EPERM; 1557 goto exit; 1558 } 1559 1560 if (check_fwstate(pmlmepriv, WIFI_AP_STATE)) { 1561 ret = -EPERM; 1562 goto exit; 1563 } 1564 1565 if (!params->ssid || !params->ssid_len) { 1566 ret = -EINVAL; 1567 goto exit; 1568 } 1569 1570 if (params->ssid_len > IW_ESSID_MAX_SIZE) { 1571 ret = -E2BIG; 1572 goto exit; 1573 } 1574 1575 memset(&ndis_ssid, 0, sizeof(struct ndis_802_11_ssid)); 1576 ndis_ssid.ssid_length = params->ssid_len; 1577 memcpy(ndis_ssid.ssid, (u8 *)params->ssid, params->ssid_len); 1578 1579 psecuritypriv->ndisencryptstatus = Ndis802_11EncryptionDisabled; 1580 psecuritypriv->dot11PrivacyAlgrthm = _NO_PRIVACY_; 1581 psecuritypriv->dot118021XGrpPrivacy = _NO_PRIVACY_; 1582 psecuritypriv->dot11AuthAlgrthm = dot11AuthAlgrthm_Open; /* open system */ 1583 psecuritypriv->ndisauthtype = Ndis802_11AuthModeOpen; 1584 1585 ret = rtw_cfg80211_set_auth_type(psecuritypriv, NL80211_AUTHTYPE_OPEN_SYSTEM); 1586 rtw_set_802_11_authentication_mode(padapter, psecuritypriv->ndisauthtype); 1587 1588 if (rtw_set_802_11_ssid(padapter, &ndis_ssid) == false) { 1589 ret = -1; 1590 goto exit; 1591 } 1592 1593exit: 1594 return ret; 1595} 1596 1597static int cfg80211_rtw_leave_ibss(struct wiphy *wiphy, struct net_device *ndev) 1598{ 1599 struct adapter *padapter = rtw_netdev_priv(ndev); 1600 struct wireless_dev *rtw_wdev = padapter->rtw_wdev; 1601 enum nl80211_iftype old_type; 1602 int ret = 0; 1603 1604 old_type = rtw_wdev->iftype; 1605 1606 rtw_set_to_roam(padapter, 0); 1607 1608 if (check_fwstate(&padapter->mlmepriv, _FW_LINKED)) { 1609 rtw_scan_abort(padapter); 1610 LeaveAllPowerSaveMode(padapter); 1611 1612 rtw_wdev->iftype = NL80211_IFTYPE_STATION; 1613 1614 if (rtw_set_802_11_infrastructure_mode(padapter, Ndis802_11Infrastructure) == false) { 1615 rtw_wdev->iftype = old_type; 1616 ret = -EPERM; 1617 goto leave_ibss; 1618 } 1619 rtw_setopmode_cmd(padapter, Ndis802_11Infrastructure, true); 1620 } 1621 1622leave_ibss: 1623 return ret; 1624} 1625 1626static int cfg80211_rtw_connect(struct wiphy *wiphy, struct net_device *ndev, 1627 struct cfg80211_connect_params *sme) 1628{ 1629 int ret = 0; 1630 enum ndis_802_11_authentication_mode authmode; 1631 struct ndis_802_11_ssid ndis_ssid; 1632 struct adapter *padapter = rtw_netdev_priv(ndev); 1633 struct mlme_priv *pmlmepriv = &padapter->mlmepriv; 1634 struct security_priv *psecuritypriv = &padapter->securitypriv; 1635 1636 padapter->mlmepriv.not_indic_disco = true; 1637 1638 if (adapter_wdev_data(padapter)->block == true) { 1639 ret = -EBUSY; 1640 goto exit; 1641 } 1642 1643 rtw_ps_deny(padapter, PS_DENY_JOIN); 1644 if (rtw_pwr_wakeup(padapter) == _FAIL) { 1645 ret = -EPERM; 1646 goto exit; 1647 } 1648 1649 if (check_fwstate(pmlmepriv, WIFI_AP_STATE)) { 1650 ret = -EPERM; 1651 goto exit; 1652 } 1653 1654 if (!sme->ssid || !sme->ssid_len) { 1655 ret = -EINVAL; 1656 goto exit; 1657 } 1658 1659 if (sme->ssid_len > IW_ESSID_MAX_SIZE) { 1660 ret = -E2BIG; 1661 goto exit; 1662 } 1663 1664 memset(&ndis_ssid, 0, sizeof(struct ndis_802_11_ssid)); 1665 ndis_ssid.ssid_length = sme->ssid_len; 1666 memcpy(ndis_ssid.ssid, (u8 *)sme->ssid, sme->ssid_len); 1667 1668 if (check_fwstate(pmlmepriv, _FW_UNDER_LINKING) == true) { 1669 ret = -EBUSY; 1670 goto exit; 1671 } 1672 if (check_fwstate(pmlmepriv, _FW_UNDER_SURVEY) == true) 1673 rtw_scan_abort(padapter); 1674 1675 psecuritypriv->ndisencryptstatus = Ndis802_11EncryptionDisabled; 1676 psecuritypriv->dot11PrivacyAlgrthm = _NO_PRIVACY_; 1677 psecuritypriv->dot118021XGrpPrivacy = _NO_PRIVACY_; 1678 psecuritypriv->dot11AuthAlgrthm = dot11AuthAlgrthm_Open; /* open system */ 1679 psecuritypriv->ndisauthtype = Ndis802_11AuthModeOpen; 1680 1681 ret = rtw_cfg80211_set_wpa_version(psecuritypriv, sme->crypto.wpa_versions); 1682 if (ret < 0) 1683 goto exit; 1684 1685 ret = rtw_cfg80211_set_auth_type(psecuritypriv, sme->auth_type); 1686 1687 if (ret < 0) 1688 goto exit; 1689 1690 ret = rtw_cfg80211_set_wpa_ie(padapter, (u8 *)sme->ie, sme->ie_len); 1691 if (ret < 0) 1692 goto exit; 1693 1694 if (sme->crypto.n_ciphers_pairwise) { 1695 ret = rtw_cfg80211_set_cipher(psecuritypriv, sme->crypto.ciphers_pairwise[0], true); 1696 if (ret < 0) 1697 goto exit; 1698 } 1699 1700 /* For WEP Shared auth */ 1701 if ((psecuritypriv->dot11AuthAlgrthm == dot11AuthAlgrthm_Shared || 1702 psecuritypriv->dot11AuthAlgrthm == dot11AuthAlgrthm_Auto) && sme->key) { 1703 u32 wep_key_idx, wep_key_len, wep_total_len; 1704 struct ndis_802_11_wep *pwep = NULL; 1705 1706 wep_key_idx = sme->key_idx; 1707 wep_key_len = sme->key_len; 1708 1709 if (sme->key_idx > WEP_KEYS) { 1710 ret = -EINVAL; 1711 goto exit; 1712 } 1713 1714 if (wep_key_len > 0) { 1715 wep_key_len = wep_key_len <= 5 ? 5 : 13; 1716 wep_total_len = wep_key_len + 1717 offsetof(struct ndis_802_11_wep, key_material); 1718 pwep = rtw_malloc(wep_total_len); 1719 if (!pwep) { 1720 ret = -ENOMEM; 1721 goto exit; 1722 } 1723 1724 memset(pwep, 0, wep_total_len); 1725 1726 pwep->key_length = wep_key_len; 1727 pwep->length = wep_total_len; 1728 1729 if (wep_key_len == 13) { 1730 padapter->securitypriv.dot11PrivacyAlgrthm = _WEP104_; 1731 padapter->securitypriv.dot118021XGrpPrivacy = _WEP104_; 1732 } 1733 } else { 1734 ret = -EINVAL; 1735 goto exit; 1736 } 1737 1738 pwep->key_index = wep_key_idx; 1739 pwep->key_index |= 0x80000000; 1740 1741 memcpy(pwep->key_material, (void *)sme->key, pwep->key_length); 1742 1743 if (rtw_set_802_11_add_wep(padapter, pwep) == (u8)_FAIL) 1744 ret = -EOPNOTSUPP; 1745 1746 kfree(pwep); 1747 1748 if (ret < 0) 1749 goto exit; 1750 } 1751 1752 ret = rtw_cfg80211_set_cipher(psecuritypriv, sme->crypto.cipher_group, false); 1753 if (ret < 0) 1754 return ret; 1755 1756 if (sme->crypto.n_akm_suites) { 1757 ret = rtw_cfg80211_set_key_mgt(psecuritypriv, sme->crypto.akm_suites[0]); 1758 if (ret < 0) 1759 goto exit; 1760 } 1761 1762 authmode = psecuritypriv->ndisauthtype; 1763 rtw_set_802_11_authentication_mode(padapter, authmode); 1764 1765 /* rtw_set_802_11_encryption_mode(padapter, padapter->securitypriv.ndisencryptstatus); */ 1766 1767 if (rtw_set_802_11_connect(padapter, (u8 *)sme->bssid, &ndis_ssid) == false) { 1768 ret = -1; 1769 goto exit; 1770 } 1771 1772exit: 1773 1774 rtw_ps_deny_cancel(padapter, PS_DENY_JOIN); 1775 1776 padapter->mlmepriv.not_indic_disco = false; 1777 1778 return ret; 1779} 1780 1781static int cfg80211_rtw_disconnect(struct wiphy *wiphy, struct net_device *ndev, 1782 u16 reason_code) 1783{ 1784 struct adapter *padapter = rtw_netdev_priv(ndev); 1785 1786 rtw_set_to_roam(padapter, 0); 1787 1788 rtw_scan_abort(padapter); 1789 LeaveAllPowerSaveMode(padapter); 1790 rtw_disassoc_cmd(padapter, 500, false); 1791 1792 rtw_indicate_disconnect(padapter); 1793 1794 rtw_free_assoc_resources(padapter, 1); 1795 rtw_pwr_wakeup(padapter); 1796 1797 return 0; 1798} 1799 1800static int cfg80211_rtw_set_txpower(struct wiphy *wiphy, 1801 struct wireless_dev *wdev, int radio_idx, 1802 enum nl80211_tx_power_setting type, int mbm) 1803{ 1804 return 0; 1805} 1806 1807static int cfg80211_rtw_get_txpower(struct wiphy *wiphy, 1808 struct wireless_dev *wdev, 1809 int radio_idx, 1810 unsigned int link_id, int *dbm) 1811{ 1812 *dbm = (12); 1813 1814 return 0; 1815} 1816 1817inline bool rtw_cfg80211_pwr_mgmt(struct adapter *adapter) 1818{ 1819 struct rtw_wdev_priv *rtw_wdev_priv = adapter_wdev_data(adapter); 1820 1821 return rtw_wdev_priv->power_mgmt; 1822} 1823 1824static int cfg80211_rtw_set_power_mgmt(struct wiphy *wiphy, 1825 struct net_device *ndev, 1826 bool enabled, int timeout) 1827{ 1828 struct adapter *padapter = rtw_netdev_priv(ndev); 1829 struct rtw_wdev_priv *rtw_wdev_priv = adapter_wdev_data(padapter); 1830 1831 rtw_wdev_priv->power_mgmt = enabled; 1832 1833 if (!enabled) 1834 LPS_Leave(padapter, "CFG80211_PWRMGMT"); 1835 1836 return 0; 1837} 1838 1839static int cfg80211_rtw_set_pmksa(struct wiphy *wiphy, 1840 struct net_device *ndev, 1841 struct cfg80211_pmksa *pmksa) 1842{ 1843 u8 index, blInserted = false; 1844 struct adapter *padapter = rtw_netdev_priv(ndev); 1845 struct security_priv *psecuritypriv = &padapter->securitypriv; 1846 1847 if (is_zero_ether_addr((u8 *)pmksa->bssid)) 1848 return -EINVAL; 1849 1850 blInserted = false; 1851 1852 /* overwrite PMKID */ 1853 for (index = 0 ; index < NUM_PMKID_CACHE; index++) { 1854 if (!memcmp(psecuritypriv->PMKIDList[index].Bssid, (u8 *)pmksa->bssid, ETH_ALEN)) { 1855 memcpy(psecuritypriv->PMKIDList[index].PMKID, (u8 *)pmksa->pmkid, WLAN_PMKID_LEN); 1856 psecuritypriv->PMKIDList[index].bUsed = true; 1857 psecuritypriv->PMKIDIndex = index + 1; 1858 blInserted = true; 1859 break; 1860 } 1861 } 1862 1863 if (!blInserted) { 1864 memcpy(psecuritypriv->PMKIDList[psecuritypriv->PMKIDIndex].Bssid, (u8 *)pmksa->bssid, ETH_ALEN); 1865 memcpy(psecuritypriv->PMKIDList[psecuritypriv->PMKIDIndex].PMKID, (u8 *)pmksa->pmkid, WLAN_PMKID_LEN); 1866 1867 psecuritypriv->PMKIDList[psecuritypriv->PMKIDIndex].bUsed = true; 1868 psecuritypriv->PMKIDIndex++; 1869 if (psecuritypriv->PMKIDIndex == 16) 1870 psecuritypriv->PMKIDIndex = 0; 1871 } 1872 1873 return 0; 1874} 1875 1876static int cfg80211_rtw_del_pmksa(struct wiphy *wiphy, 1877 struct net_device *ndev, 1878 struct cfg80211_pmksa *pmksa) 1879{ 1880 u8 index, bMatched = false; 1881 struct adapter *padapter = rtw_netdev_priv(ndev); 1882 struct security_priv *psecuritypriv = &padapter->securitypriv; 1883 1884 for (index = 0 ; index < NUM_PMKID_CACHE; index++) { 1885 if (!memcmp(psecuritypriv->PMKIDList[index].Bssid, (u8 *)pmksa->bssid, ETH_ALEN)) { 1886 /* 1887 * BSSID is matched, the same AP => Remove this PMKID information 1888 * and reset it. 1889 */ 1890 eth_zero_addr(psecuritypriv->PMKIDList[index].Bssid); 1891 memset(psecuritypriv->PMKIDList[index].PMKID, 0x00, WLAN_PMKID_LEN); 1892 psecuritypriv->PMKIDList[index].bUsed = false; 1893 bMatched = true; 1894 break; 1895 } 1896 } 1897 1898 if (!bMatched) 1899 return -EINVAL; 1900 1901 return 0; 1902} 1903 1904static int cfg80211_rtw_flush_pmksa(struct wiphy *wiphy, 1905 struct net_device *ndev) 1906{ 1907 struct adapter *padapter = rtw_netdev_priv(ndev); 1908 struct security_priv *psecuritypriv = &padapter->securitypriv; 1909 1910 memset(&psecuritypriv->PMKIDList[0], 0x00, sizeof(struct rt_pmkid_list) * NUM_PMKID_CACHE); 1911 psecuritypriv->PMKIDIndex = 0; 1912 1913 return 0; 1914} 1915 1916void rtw_cfg80211_indicate_sta_assoc(struct adapter *padapter, u8 *pmgmt_frame, uint frame_len) 1917{ 1918 struct net_device *ndev = padapter->pnetdev; 1919 1920 { 1921 struct station_info sinfo = {}; 1922 u8 ie_offset; 1923 1924 if (GetFrameSubType(pmgmt_frame) == WIFI_ASSOCREQ) 1925 ie_offset = _ASOCREQ_IE_OFFSET_; 1926 else /* WIFI_REASSOCREQ */ 1927 ie_offset = _REASOCREQ_IE_OFFSET_; 1928 1929 sinfo.filled = 0; 1930 sinfo.assoc_req_ies = pmgmt_frame + WLAN_HDR_A3_LEN + ie_offset; 1931 sinfo.assoc_req_ies_len = frame_len - WLAN_HDR_A3_LEN - ie_offset; 1932 cfg80211_new_sta(ndev, GetAddr2Ptr(pmgmt_frame), &sinfo, GFP_ATOMIC); 1933 } 1934} 1935 1936void rtw_cfg80211_indicate_sta_disassoc(struct adapter *padapter, unsigned char *da, unsigned short reason) 1937{ 1938 struct net_device *ndev = padapter->pnetdev; 1939 1940 cfg80211_del_sta(ndev, da, GFP_ATOMIC); 1941} 1942 1943static u8 rtw_get_chan_type(struct adapter *adapter) 1944{ 1945 struct mlme_ext_priv *mlme_ext = &adapter->mlmeextpriv; 1946 1947 switch (mlme_ext->cur_bwmode) { 1948 case CHANNEL_WIDTH_20: 1949 if (is_supported_ht(adapter->registrypriv.wireless_mode)) 1950 return NL80211_CHAN_HT20; 1951 else 1952 return NL80211_CHAN_NO_HT; 1953 case CHANNEL_WIDTH_40: 1954 if (mlme_ext->cur_ch_offset == HAL_PRIME_CHNL_OFFSET_UPPER) 1955 return NL80211_CHAN_HT40PLUS; 1956 else 1957 return NL80211_CHAN_HT40MINUS; 1958 default: 1959 return NL80211_CHAN_HT20; 1960 } 1961 1962 return NL80211_CHAN_HT20; 1963} 1964 1965static int cfg80211_rtw_get_channel(struct wiphy *wiphy, struct wireless_dev *wdev, 1966 unsigned int link_id, 1967 struct cfg80211_chan_def *chandef) 1968{ 1969 struct adapter *adapter = wiphy_to_adapter(wiphy); 1970 struct registry_priv *registrypriv = &adapter->registrypriv; 1971 enum nl80211_channel_type chan_type; 1972 struct ieee80211_channel *chan = NULL; 1973 int channel; 1974 int freq; 1975 1976 if (!adapter->rtw_wdev) 1977 return -ENODEV; 1978 1979 channel = rtw_get_oper_ch(adapter); 1980 if (!channel) 1981 return -ENODATA; 1982 1983 freq = rtw_ieee80211_channel_to_frequency(channel); 1984 1985 chan = ieee80211_get_channel(adapter->rtw_wdev->wiphy, freq); 1986 1987 if (registrypriv->ht_enable) { 1988 chan_type = rtw_get_chan_type(adapter); 1989 cfg80211_chandef_create(chandef, chan, chan_type); 1990 } else { 1991 cfg80211_chandef_create(chandef, chan, NL80211_CHAN_NO_HT); 1992 } 1993 1994 return 0; 1995} 1996 1997static netdev_tx_t rtw_cfg80211_monitor_if_xmit_entry(struct sk_buff *skb, struct net_device *ndev) 1998{ 1999 int rtap_len; 2000 int qos_len = 0; 2001 int dot11_hdr_len = 24; 2002 int snap_len = 6; 2003 unsigned char *pdata; 2004 u16 frame_control; 2005 unsigned char src_mac_addr[6]; 2006 unsigned char dst_mac_addr[6]; 2007 struct ieee80211_hdr *dot11_hdr; 2008 struct ieee80211_radiotap_header *rtap_hdr; 2009 struct adapter *padapter = rtw_netdev_priv(ndev); 2010 2011 if (!skb) 2012 goto fail; 2013 2014 if (unlikely(skb->len < sizeof(struct ieee80211_radiotap_header))) 2015 goto fail; 2016 2017 rtap_hdr = (struct ieee80211_radiotap_header *)skb->data; 2018 if (unlikely(rtap_hdr->it_version)) 2019 goto fail; 2020 2021 rtap_len = ieee80211_get_radiotap_len(skb->data); 2022 if (unlikely(skb->len < rtap_len)) 2023 goto fail; 2024 2025 if (rtap_len != 14) 2026 goto fail; 2027 2028 /* Skip the ratio tap header */ 2029 skb_pull(skb, rtap_len); 2030 2031 dot11_hdr = (struct ieee80211_hdr *)skb->data; 2032 frame_control = le16_to_cpu(dot11_hdr->frame_control); 2033 /* Check if the QoS bit is set */ 2034 if ((frame_control & IEEE80211_FCTL_FTYPE) == IEEE80211_FTYPE_DATA) { 2035 /* Check if this ia a Wireless Distribution System (WDS) frame 2036 * which has 4 MAC addresses 2037 */ 2038 if (frame_control & 0x0080) 2039 qos_len = 2; 2040 if ((frame_control & 0x0300) == 0x0300) 2041 dot11_hdr_len += 6; 2042 2043 memcpy(dst_mac_addr, dot11_hdr->addr1, sizeof(dst_mac_addr)); 2044 memcpy(src_mac_addr, dot11_hdr->addr2, sizeof(src_mac_addr)); 2045 2046 /* Skip the 802.11 header, QoS (if any) and SNAP, but leave spaces for 2047 * two MAC addresses 2048 */ 2049 skb_pull(skb, dot11_hdr_len + qos_len + snap_len - sizeof(src_mac_addr) * 2); 2050 pdata = (unsigned char *)skb->data; 2051 memcpy(pdata, dst_mac_addr, sizeof(dst_mac_addr)); 2052 memcpy(pdata + sizeof(dst_mac_addr), src_mac_addr, sizeof(src_mac_addr)); 2053 2054 /* Use the real net device to transmit the packet */ 2055 _rtw_xmit_entry(skb, padapter->pnetdev); 2056 return NETDEV_TX_OK; 2057 2058 } else if ((frame_control & (IEEE80211_FCTL_FTYPE | IEEE80211_FCTL_STYPE)) == 2059 (IEEE80211_FTYPE_MGMT | IEEE80211_STYPE_ACTION)) { 2060 /* only for action frames */ 2061 struct xmit_frame *pmgntframe; 2062 struct pkt_attrib *pattrib; 2063 unsigned char *pframe; 2064 /* u8 category, action, OUI_Subtype, dialogToken = 0; */ 2065 /* unsigned char *frame_body; */ 2066 struct ieee80211_hdr *pwlanhdr; 2067 struct xmit_priv *pxmitpriv = &(padapter->xmitpriv); 2068 struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv); 2069 u8 *buf = skb->data; 2070 u32 len = skb->len; 2071 u8 category, action; 2072 2073 if (rtw_action_frame_parse(buf, len, &category, &action) == false) 2074 goto fail; 2075 2076 /* starting alloc mgmt frame to dump it */ 2077 pmgntframe = alloc_mgtxmitframe(pxmitpriv); 2078 if (!pmgntframe) 2079 goto fail; 2080 2081 /* update attribute */ 2082 pattrib = &pmgntframe->attrib; 2083 update_mgntframe_attrib(padapter, pattrib); 2084 pattrib->retry_ctrl = false; 2085 2086 memset(pmgntframe->buf_addr, 0, WLANHDR_OFFSET + TXDESC_OFFSET); 2087 2088 pframe = (u8 *)(pmgntframe->buf_addr) + TXDESC_OFFSET; 2089 2090 memcpy(pframe, (void *)buf, len); 2091 pattrib->pktlen = len; 2092 2093 pwlanhdr = (struct ieee80211_hdr *)pframe; 2094 /* update seq number */ 2095 pmlmeext->mgnt_seq = GetSequence(pwlanhdr); 2096 pattrib->seqnum = pmlmeext->mgnt_seq; 2097 pmlmeext->mgnt_seq++; 2098 2099 pattrib->last_txcmdsz = pattrib->pktlen; 2100 2101 dump_mgntframe(padapter, pmgntframe); 2102 } 2103 2104fail: 2105 2106 dev_kfree_skb_any(skb); 2107 2108 return NETDEV_TX_OK; 2109} 2110 2111static const struct net_device_ops rtw_cfg80211_monitor_if_ops = { 2112 .ndo_start_xmit = rtw_cfg80211_monitor_if_xmit_entry, 2113}; 2114 2115static int rtw_cfg80211_add_monitor_if(struct adapter *padapter, char *name, struct net_device **ndev) 2116{ 2117 int ret = 0; 2118 struct net_device *mon_ndev = NULL; 2119 struct wireless_dev *mon_wdev = NULL; 2120 struct rtw_netdev_priv_indicator *pnpi; 2121 struct rtw_wdev_priv *pwdev_priv = adapter_wdev_data(padapter); 2122 2123 if (!name) { 2124 ret = -EINVAL; 2125 goto out; 2126 } 2127 2128 if (pwdev_priv->pmon_ndev) { 2129 ret = -EBUSY; 2130 goto out; 2131 } 2132 2133 mon_ndev = alloc_etherdev(sizeof(struct rtw_netdev_priv_indicator)); 2134 if (!mon_ndev) { 2135 ret = -ENOMEM; 2136 goto out; 2137 } 2138 2139 mon_ndev->type = ARPHRD_IEEE80211_RADIOTAP; 2140 strscpy(mon_ndev->name, name); 2141 mon_ndev->needs_free_netdev = true; 2142 mon_ndev->priv_destructor = rtw_ndev_destructor; 2143 2144 mon_ndev->netdev_ops = &rtw_cfg80211_monitor_if_ops; 2145 2146 pnpi = netdev_priv(mon_ndev); 2147 pnpi->priv = padapter; 2148 pnpi->sizeof_priv = sizeof(struct adapter); 2149 2150 /* wdev */ 2151 mon_wdev = rtw_zmalloc(sizeof(struct wireless_dev)); 2152 if (!mon_wdev) { 2153 ret = -ENOMEM; 2154 goto out; 2155 } 2156 2157 mon_wdev->wiphy = padapter->rtw_wdev->wiphy; 2158 mon_wdev->netdev = mon_ndev; 2159 mon_wdev->iftype = NL80211_IFTYPE_MONITOR; 2160 mon_ndev->ieee80211_ptr = mon_wdev; 2161 2162 ret = cfg80211_register_netdevice(mon_ndev); 2163 if (ret) 2164 goto out; 2165 2166 *ndev = pwdev_priv->pmon_ndev = mon_ndev; 2167 memcpy(pwdev_priv->ifname_mon, name, IFNAMSIZ + 1); 2168 2169out: 2170 if (ret && mon_wdev) { 2171 kfree(mon_wdev); 2172 mon_wdev = NULL; 2173 } 2174 2175 if (ret && mon_ndev) { 2176 free_netdev(mon_ndev); 2177 *ndev = mon_ndev = NULL; 2178 } 2179 2180 return ret; 2181} 2182 2183static struct wireless_dev * 2184 cfg80211_rtw_add_virtual_intf( 2185 struct wiphy *wiphy, 2186 const char *name, 2187 unsigned char name_assign_type, 2188 enum nl80211_iftype type, struct vif_params *params) 2189{ 2190 int ret = 0; 2191 struct net_device *ndev = NULL; 2192 struct adapter *padapter = wiphy_to_adapter(wiphy); 2193 2194 switch (type) { 2195 case NL80211_IFTYPE_ADHOC: 2196 case NL80211_IFTYPE_AP_VLAN: 2197 case NL80211_IFTYPE_WDS: 2198 case NL80211_IFTYPE_MESH_POINT: 2199 ret = -ENODEV; 2200 break; 2201 case NL80211_IFTYPE_MONITOR: 2202 ret = rtw_cfg80211_add_monitor_if(padapter, (char *)name, &ndev); 2203 break; 2204 case NL80211_IFTYPE_P2P_CLIENT: 2205 case NL80211_IFTYPE_STATION: 2206 ret = -ENODEV; 2207 break; 2208 case NL80211_IFTYPE_P2P_GO: 2209 case NL80211_IFTYPE_AP: 2210 ret = -ENODEV; 2211 break; 2212 default: 2213 ret = -ENODEV; 2214 break; 2215 } 2216 2217 return ndev ? ndev->ieee80211_ptr : ERR_PTR(ret); 2218} 2219 2220static int cfg80211_rtw_del_virtual_intf(struct wiphy *wiphy, 2221 struct wireless_dev *wdev 2222) 2223{ 2224 struct net_device *ndev = wdev_to_ndev(wdev); 2225 int ret = 0; 2226 struct adapter *adapter; 2227 struct rtw_wdev_priv *pwdev_priv; 2228 2229 if (!ndev) { 2230 ret = -EINVAL; 2231 goto exit; 2232 } 2233 2234 adapter = rtw_netdev_priv(ndev); 2235 pwdev_priv = adapter_wdev_data(adapter); 2236 2237 cfg80211_unregister_netdevice(ndev); 2238 2239 if (ndev == pwdev_priv->pmon_ndev) { 2240 pwdev_priv->pmon_ndev = NULL; 2241 pwdev_priv->ifname_mon[0] = '\0'; 2242 } 2243 2244exit: 2245 return ret; 2246} 2247 2248static int rtw_add_beacon(struct adapter *adapter, const u8 *head, size_t head_len, const u8 *tail, size_t tail_len) 2249{ 2250 int ret = 0; 2251 u8 *pbuf = NULL; 2252 uint len, wps_ielen = 0; 2253 struct mlme_priv *pmlmepriv = &(adapter->mlmepriv); 2254 2255 if (check_fwstate(pmlmepriv, WIFI_AP_STATE) != true) 2256 return -EINVAL; 2257 2258 if (head_len < 24) 2259 return -EINVAL; 2260 2261 pbuf = rtw_zmalloc(head_len + tail_len); 2262 if (!pbuf) 2263 return -ENOMEM; 2264 2265 memcpy(pbuf, (void *)head + 24, head_len - 24);/* 24 =beacon header len. */ 2266 memcpy(pbuf + head_len - 24, (void *)tail, tail_len); 2267 2268 len = head_len + tail_len - 24; 2269 2270 /* check wps ie if inclued */ 2271 rtw_get_wps_ie(pbuf + _FIXED_IE_LENGTH_, len - _FIXED_IE_LENGTH_, NULL, &wps_ielen); 2272 2273 /* pbss_network->ies will not include p2p_ie, wfd ie */ 2274 rtw_ies_remove_ie(pbuf, &len, _BEACON_IE_OFFSET_, WLAN_EID_VENDOR_SPECIFIC, P2P_OUI, 4); 2275 rtw_ies_remove_ie(pbuf, &len, _BEACON_IE_OFFSET_, WLAN_EID_VENDOR_SPECIFIC, WFD_OUI, 4); 2276 2277 if (rtw_check_beacon_data(adapter, pbuf, len) == _SUCCESS) 2278 ret = 0; 2279 else 2280 ret = -EINVAL; 2281 2282 kfree(pbuf); 2283 2284 return ret; 2285} 2286 2287static int cfg80211_rtw_start_ap(struct wiphy *wiphy, struct net_device *ndev, 2288 struct cfg80211_ap_settings *settings) 2289{ 2290 int ret = 0; 2291 struct adapter *adapter = rtw_netdev_priv(ndev); 2292 2293 ret = rtw_add_beacon(adapter, settings->beacon.head, 2294 settings->beacon.head_len, settings->beacon.tail, 2295 settings->beacon.tail_len); 2296 2297 adapter->mlmeextpriv.mlmext_info.hidden_ssid_mode = settings->hidden_ssid; 2298 2299 if (settings->ssid && settings->ssid_len) { 2300 struct wlan_bssid_ex *pbss_network = &adapter->mlmepriv.cur_network.network; 2301 struct wlan_bssid_ex *pbss_network_ext = &adapter->mlmeextpriv.mlmext_info.network; 2302 2303 memcpy(pbss_network->ssid.ssid, (void *)settings->ssid, settings->ssid_len); 2304 pbss_network->ssid.ssid_length = settings->ssid_len; 2305 memcpy(pbss_network_ext->ssid.ssid, (void *)settings->ssid, settings->ssid_len); 2306 pbss_network_ext->ssid.ssid_length = settings->ssid_len; 2307 } 2308 2309 return ret; 2310} 2311 2312static int cfg80211_rtw_change_beacon(struct wiphy *wiphy, struct net_device *ndev, 2313 struct cfg80211_ap_update *info) 2314{ 2315 struct adapter *adapter = rtw_netdev_priv(ndev); 2316 2317 return rtw_add_beacon(adapter, info->beacon.head, 2318 info->beacon.head_len, info->beacon.tail, 2319 info->beacon.tail_len); 2320} 2321 2322static int cfg80211_rtw_stop_ap(struct wiphy *wiphy, struct net_device *ndev, 2323 unsigned int link_id) 2324{ 2325 return 0; 2326} 2327 2328static int cfg80211_rtw_add_station(struct wiphy *wiphy, 2329 struct net_device *ndev, 2330 const u8 *mac, 2331 struct station_parameters *params) 2332{ 2333 return 0; 2334} 2335 2336static int cfg80211_rtw_del_station(struct wiphy *wiphy, struct net_device *ndev, 2337 struct station_del_parameters *params) 2338{ 2339 int ret = 0; 2340 struct list_head *phead, *plist, *tmp; 2341 u8 updated = false; 2342 struct sta_info *psta = NULL; 2343 struct adapter *padapter = rtw_netdev_priv(ndev); 2344 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv); 2345 struct sta_priv *pstapriv = &padapter->stapriv; 2346 const u8 *mac = params->mac; 2347 2348 if (check_fwstate(pmlmepriv, (_FW_LINKED | WIFI_AP_STATE)) != true) 2349 return -EINVAL; 2350 2351 if (!mac) { 2352 flush_all_cam_entry(padapter); /* clear CAM */ 2353 2354 rtw_sta_flush(padapter); 2355 2356 return 0; 2357 } 2358 2359 if (mac[0] == 0xff && mac[1] == 0xff && 2360 mac[2] == 0xff && mac[3] == 0xff && 2361 mac[4] == 0xff && mac[5] == 0xff) { 2362 return -EINVAL; 2363 } 2364 2365 spin_lock_bh(&pstapriv->asoc_list_lock); 2366 2367 phead = &pstapriv->asoc_list; 2368 /* check asoc_queue */ 2369 list_for_each_safe(plist, tmp, phead) { 2370 psta = list_entry(plist, struct sta_info, asoc_list); 2371 2372 if (!memcmp((u8 *)mac, psta->hwaddr, ETH_ALEN)) { 2373 if (psta->dot8021xalg != 1 || psta->bpairwise_key_installed) { 2374 list_del_init(&psta->asoc_list); 2375 pstapriv->asoc_list_cnt--; 2376 2377 updated = ap_free_sta(padapter, psta, true, WLAN_REASON_DEAUTH_LEAVING); 2378 2379 psta = NULL; 2380 2381 break; 2382 } 2383 } 2384 } 2385 2386 spin_unlock_bh(&pstapriv->asoc_list_lock); 2387 2388 associated_clients_update(padapter, updated); 2389 2390 return ret; 2391} 2392 2393static int cfg80211_rtw_change_station(struct wiphy *wiphy, 2394 struct net_device *ndev, 2395 const u8 *mac, 2396 struct station_parameters *params) 2397{ 2398 return 0; 2399} 2400 2401static struct sta_info *rtw_sta_info_get_by_idx(const int idx, struct sta_priv *pstapriv) 2402 2403{ 2404 struct list_head *phead, *plist; 2405 struct sta_info *psta = NULL; 2406 int i = 0; 2407 2408 phead = &pstapriv->asoc_list; 2409 plist = get_next(phead); 2410 2411 /* check asoc_queue */ 2412 while (phead != plist) { 2413 if (idx == i) 2414 psta = container_of(plist, struct sta_info, asoc_list); 2415 plist = get_next(plist); 2416 i++; 2417 } 2418 return psta; 2419} 2420 2421static int cfg80211_rtw_dump_station(struct wiphy *wiphy, 2422 struct net_device *ndev, 2423 int idx, u8 *mac, 2424 struct station_info *sinfo) 2425{ 2426 int ret = 0; 2427 struct adapter *padapter = rtw_netdev_priv(ndev); 2428 struct sta_info *psta = NULL; 2429 struct sta_priv *pstapriv = &padapter->stapriv; 2430 2431 spin_lock_bh(&pstapriv->asoc_list_lock); 2432 psta = rtw_sta_info_get_by_idx(idx, pstapriv); 2433 spin_unlock_bh(&pstapriv->asoc_list_lock); 2434 if (psta == NULL) { 2435 ret = -ENOENT; 2436 goto exit; 2437 } 2438 memcpy(mac, psta->hwaddr, ETH_ALEN); 2439 sinfo->filled = BIT_ULL(NL80211_STA_INFO_SIGNAL); 2440 sinfo->signal = psta->rssi; 2441 2442exit: 2443 return ret; 2444} 2445 2446void rtw_cfg80211_rx_action(struct adapter *adapter, u8 *frame, uint frame_len, const char *msg) 2447{ 2448 s32 freq; 2449 int channel; 2450 u8 category, action; 2451 2452 channel = rtw_get_oper_ch(adapter); 2453 2454 rtw_action_frame_parse(frame, frame_len, &category, &action); 2455 2456 freq = rtw_ieee80211_channel_to_frequency(channel); 2457 2458 rtw_cfg80211_rx_mgmt(adapter, freq, 0, frame, frame_len, GFP_ATOMIC); 2459} 2460 2461static int _cfg80211_rtw_mgmt_tx(struct adapter *padapter, u8 tx_ch, const u8 *buf, size_t len) 2462{ 2463 struct xmit_frame *pmgntframe; 2464 struct pkt_attrib *pattrib; 2465 unsigned char *pframe; 2466 int ret = _FAIL; 2467 bool __maybe_unused ack = true; 2468 struct ieee80211_hdr *pwlanhdr; 2469 struct xmit_priv *pxmitpriv = &(padapter->xmitpriv); 2470 struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv); 2471 2472 rtw_set_scan_deny(padapter, 1000); 2473 2474 rtw_scan_abort(padapter); 2475 if (tx_ch != rtw_get_oper_ch(padapter)) { 2476 if (!check_fwstate(&padapter->mlmepriv, _FW_LINKED)) 2477 pmlmeext->cur_channel = tx_ch; 2478 set_channel_bwmode(padapter, tx_ch, HAL_PRIME_CHNL_OFFSET_DONT_CARE, CHANNEL_WIDTH_20); 2479 } 2480 2481 /* starting alloc mgmt frame to dump it */ 2482 pmgntframe = alloc_mgtxmitframe(pxmitpriv); 2483 if (!pmgntframe) { 2484 /* ret = -ENOMEM; */ 2485 ret = _FAIL; 2486 goto exit; 2487 } 2488 2489 /* update attribute */ 2490 pattrib = &pmgntframe->attrib; 2491 update_mgntframe_attrib(padapter, pattrib); 2492 pattrib->retry_ctrl = false; 2493 2494 memset(pmgntframe->buf_addr, 0, WLANHDR_OFFSET + TXDESC_OFFSET); 2495 2496 pframe = (u8 *)(pmgntframe->buf_addr) + TXDESC_OFFSET; 2497 2498 memcpy(pframe, (void *)buf, len); 2499 pattrib->pktlen = len; 2500 2501 pwlanhdr = (struct ieee80211_hdr *)pframe; 2502 /* update seq number */ 2503 pmlmeext->mgnt_seq = GetSequence(pwlanhdr); 2504 pattrib->seqnum = pmlmeext->mgnt_seq; 2505 pmlmeext->mgnt_seq++; 2506 2507 pattrib->last_txcmdsz = pattrib->pktlen; 2508 2509 if (dump_mgntframe_and_wait_ack(padapter, pmgntframe) != _SUCCESS) { 2510 ack = false; 2511 ret = _FAIL; 2512 2513 } else { 2514 msleep(50); 2515 2516 ret = _SUCCESS; 2517 } 2518 2519exit: 2520 2521 return ret; 2522} 2523 2524static int cfg80211_rtw_mgmt_tx(struct wiphy *wiphy, struct wireless_dev *wdev, 2525 struct cfg80211_mgmt_tx_params *params, 2526 u64 *cookie) 2527{ 2528 struct net_device *ndev = wdev_to_ndev(wdev); 2529 struct ieee80211_channel *chan = params->chan; 2530 const u8 *buf = params->buf; 2531 size_t len = params->len; 2532 int ret = 0; 2533 int tx_ret; 2534 u32 dump_limit = RTW_MAX_MGMT_TX_CNT; 2535 u32 dump_cnt = 0; 2536 bool ack = true; 2537 u8 tx_ch = (u8)ieee80211_frequency_to_channel(chan->center_freq); 2538 u8 category, action; 2539 struct adapter *padapter; 2540 2541 if (!ndev) { 2542 ret = -EINVAL; 2543 goto exit; 2544 } 2545 2546 padapter = rtw_netdev_priv(ndev); 2547 2548 /* cookie generation */ 2549 *cookie = (unsigned long)buf; 2550 2551 /* indicate ack before issue frame to avoid racing with rsp frame */ 2552 rtw_cfg80211_mgmt_tx_status(padapter, *cookie, buf, len, ack, GFP_KERNEL); 2553 2554 if (rtw_action_frame_parse(buf, len, &category, &action) == false) 2555 goto exit; 2556 2557 rtw_ps_deny(padapter, PS_DENY_MGNT_TX); 2558 if (rtw_pwr_wakeup(padapter) == _FAIL) { 2559 ret = -EFAULT; 2560 goto cancel_ps_deny; 2561 } 2562 2563 do { 2564 dump_cnt++; 2565 tx_ret = _cfg80211_rtw_mgmt_tx(padapter, tx_ch, buf, len); 2566 } while (dump_cnt < dump_limit && tx_ret != _SUCCESS); 2567 2568cancel_ps_deny: 2569 rtw_ps_deny_cancel(padapter, PS_DENY_MGNT_TX); 2570exit: 2571 return ret; 2572} 2573 2574static void rtw_cfg80211_init_ht_capab(struct ieee80211_sta_ht_cap *ht_cap, enum nl80211_band band) 2575{ 2576#define MAX_BIT_RATE_40MHZ_MCS7 150 /* Mbps */ 2577 2578 ht_cap->ht_supported = true; 2579 2580 ht_cap->cap = IEEE80211_HT_CAP_SUP_WIDTH_20_40 | 2581 IEEE80211_HT_CAP_SGI_40 | IEEE80211_HT_CAP_SGI_20 | 2582 IEEE80211_HT_CAP_DSSSCCK40 | IEEE80211_HT_CAP_MAX_AMSDU; 2583 2584 /* 2585 *Maximum length of AMPDU that the STA can receive. 2586 *Length = 2 ^ (13 + max_ampdu_length_exp) - 1 (octets) 2587 */ 2588 ht_cap->ampdu_factor = IEEE80211_HT_MAX_AMPDU_64K; 2589 2590 /*Minimum MPDU start spacing , */ 2591 ht_cap->ampdu_density = IEEE80211_HT_MPDU_DENSITY_16; 2592 2593 ht_cap->mcs.tx_params = IEEE80211_HT_MCS_TX_DEFINED; 2594 2595 /* 2596 *hw->wiphy->bands[NL80211_BAND_2GHZ] 2597 *base on ant_num 2598 *rx_mask: RX mask 2599 *if rx_ant = 1 rx_mask[0]= 0xff;==>MCS0-MCS7 2600 *if rx_ant =2 rx_mask[1]= 0xff;==>MCS8-MCS15 2601 *if rx_ant >=3 rx_mask[2]= 0xff; 2602 *if BW_40 rx_mask[4]= 0x01; 2603 *highest supported RX rate 2604 */ 2605 ht_cap->mcs.rx_mask[0] = 0xFF; 2606 ht_cap->mcs.rx_mask[1] = 0x00; 2607 ht_cap->mcs.rx_mask[4] = 0x01; 2608 2609 ht_cap->mcs.rx_highest = cpu_to_le16(MAX_BIT_RATE_40MHZ_MCS7); 2610} 2611 2612void rtw_cfg80211_init_wiphy(struct adapter *padapter) 2613{ 2614 struct ieee80211_supported_band *bands; 2615 struct wireless_dev *pwdev = padapter->rtw_wdev; 2616 struct wiphy *wiphy = pwdev->wiphy; 2617 2618 { 2619 bands = wiphy->bands[NL80211_BAND_2GHZ]; 2620 if (bands) 2621 rtw_cfg80211_init_ht_capab(&bands->ht_cap, NL80211_BAND_2GHZ); 2622 } 2623 2624 /* copy mac_addr to wiphy */ 2625 memcpy(wiphy->perm_addr, padapter->eeprompriv.mac_addr, ETH_ALEN); 2626} 2627 2628static void rtw_cfg80211_preinit_wiphy(struct adapter *padapter, struct wiphy *wiphy) 2629{ 2630 wiphy->signal_type = CFG80211_SIGNAL_TYPE_MBM; 2631 2632 wiphy->max_scan_ssids = RTW_SSID_SCAN_AMOUNT; 2633 wiphy->max_scan_ie_len = RTW_SCAN_IE_LEN_MAX; 2634 wiphy->max_num_pmkids = RTW_MAX_NUM_PMKIDS; 2635 2636 wiphy->max_remain_on_channel_duration = RTW_MAX_REMAIN_ON_CHANNEL_DURATION; 2637 2638 wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) 2639 | BIT(NL80211_IFTYPE_ADHOC) 2640 | BIT(NL80211_IFTYPE_AP) 2641 | BIT(NL80211_IFTYPE_MONITOR) 2642 ; 2643 2644 wiphy->mgmt_stypes = rtw_cfg80211_default_mgmt_stypes; 2645 2646 wiphy->software_iftypes |= BIT(NL80211_IFTYPE_MONITOR); 2647 2648 wiphy->cipher_suites = rtw_cipher_suites; 2649 wiphy->n_cipher_suites = ARRAY_SIZE(rtw_cipher_suites); 2650 2651 /* if (padapter->registrypriv.wireless_mode & WIRELESS_11G) */ 2652 wiphy->bands[NL80211_BAND_2GHZ] = rtw_spt_band_alloc(NL80211_BAND_2GHZ); 2653 2654 wiphy->flags |= WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL; 2655 wiphy->flags |= WIPHY_FLAG_OFFCHAN_TX | WIPHY_FLAG_HAVE_AP_SME; 2656 2657#if defined(CONFIG_PM) 2658 wiphy->max_sched_scan_reqs = 1; 2659#endif 2660 2661#if defined(CONFIG_PM) 2662 wiphy->wowlan = &wowlan_stub; 2663#endif 2664 2665 if (padapter->registrypriv.power_mgnt != PS_MODE_ACTIVE) 2666 wiphy->flags |= WIPHY_FLAG_PS_ON_BY_DEFAULT; 2667 else 2668 wiphy->flags &= ~WIPHY_FLAG_PS_ON_BY_DEFAULT; 2669} 2670 2671static struct cfg80211_ops rtw_cfg80211_ops = { 2672 .change_virtual_intf = cfg80211_rtw_change_iface, 2673 .add_key = cfg80211_rtw_add_key, 2674 .get_key = cfg80211_rtw_get_key, 2675 .del_key = cfg80211_rtw_del_key, 2676 .set_default_key = cfg80211_rtw_set_default_key, 2677 .get_station = cfg80211_rtw_get_station, 2678 .scan = cfg80211_rtw_scan, 2679 .set_wiphy_params = cfg80211_rtw_set_wiphy_params, 2680 .connect = cfg80211_rtw_connect, 2681 .disconnect = cfg80211_rtw_disconnect, 2682 .join_ibss = cfg80211_rtw_join_ibss, 2683 .leave_ibss = cfg80211_rtw_leave_ibss, 2684 .set_tx_power = cfg80211_rtw_set_txpower, 2685 .get_tx_power = cfg80211_rtw_get_txpower, 2686 .set_power_mgmt = cfg80211_rtw_set_power_mgmt, 2687 .set_pmksa = cfg80211_rtw_set_pmksa, 2688 .del_pmksa = cfg80211_rtw_del_pmksa, 2689 .flush_pmksa = cfg80211_rtw_flush_pmksa, 2690 .get_channel = cfg80211_rtw_get_channel, 2691 .add_virtual_intf = cfg80211_rtw_add_virtual_intf, 2692 .del_virtual_intf = cfg80211_rtw_del_virtual_intf, 2693 2694 .start_ap = cfg80211_rtw_start_ap, 2695 .change_beacon = cfg80211_rtw_change_beacon, 2696 .stop_ap = cfg80211_rtw_stop_ap, 2697 2698 .add_station = cfg80211_rtw_add_station, 2699 .del_station = cfg80211_rtw_del_station, 2700 .change_station = cfg80211_rtw_change_station, 2701 .dump_station = cfg80211_rtw_dump_station, 2702 2703 .mgmt_tx = cfg80211_rtw_mgmt_tx, 2704}; 2705 2706int rtw_wdev_alloc(struct adapter *padapter, struct device *dev) 2707{ 2708 int ret = 0; 2709 struct wiphy *wiphy; 2710 struct wireless_dev *wdev; 2711 struct rtw_wdev_priv *pwdev_priv; 2712 struct net_device *pnetdev = padapter->pnetdev; 2713 2714 /* wiphy */ 2715 wiphy = wiphy_new(&rtw_cfg80211_ops, sizeof(struct adapter *)); 2716 if (!wiphy) { 2717 ret = -ENOMEM; 2718 goto exit; 2719 } 2720 set_wiphy_dev(wiphy, dev); 2721 *((struct adapter **)wiphy_priv(wiphy)) = padapter; 2722 rtw_cfg80211_preinit_wiphy(padapter, wiphy); 2723 2724 /* init regulary domain */ 2725 rtw_regd_init(wiphy, rtw_reg_notifier); 2726 2727 ret = wiphy_register(wiphy); 2728 if (ret < 0) 2729 goto free_wiphy; 2730 2731 /* wdev */ 2732 wdev = rtw_zmalloc(sizeof(struct wireless_dev)); 2733 if (!wdev) { 2734 ret = -ENOMEM; 2735 goto unregister_wiphy; 2736 } 2737 wdev->wiphy = wiphy; 2738 wdev->netdev = pnetdev; 2739 2740 wdev->iftype = NL80211_IFTYPE_STATION; /* will be init in rtw_hal_init() */ 2741 /* Must sync with _rtw_init_mlme_priv() */ 2742 /* pmlmepriv->fw_state = WIFI_STATION_STATE */ 2743 padapter->rtw_wdev = wdev; 2744 pnetdev->ieee80211_ptr = wdev; 2745 2746 /* init pwdev_priv */ 2747 pwdev_priv = adapter_wdev_data(padapter); 2748 pwdev_priv->rtw_wdev = wdev; 2749 pwdev_priv->pmon_ndev = NULL; 2750 pwdev_priv->ifname_mon[0] = '\0'; 2751 pwdev_priv->padapter = padapter; 2752 pwdev_priv->scan_request = NULL; 2753 spin_lock_init(&pwdev_priv->scan_req_lock); 2754 2755 pwdev_priv->p2p_enabled = false; 2756 pwdev_priv->provdisc_req_issued = false; 2757 rtw_wdev_invit_info_init(&pwdev_priv->invit_info); 2758 rtw_wdev_nego_info_init(&pwdev_priv->nego_info); 2759 2760 pwdev_priv->bandroid_scan = false; 2761 2762 if (padapter->registrypriv.power_mgnt != PS_MODE_ACTIVE) 2763 pwdev_priv->power_mgmt = true; 2764 else 2765 pwdev_priv->power_mgmt = false; 2766 2767 return ret; 2768 2769unregister_wiphy: 2770 wiphy_unregister(wiphy); 2771 free_wiphy: 2772 wiphy_free(wiphy); 2773exit: 2774 return ret; 2775} 2776 2777void rtw_wdev_free(struct wireless_dev *wdev) 2778{ 2779 if (!wdev) 2780 return; 2781 2782 kfree(wdev->wiphy->bands[NL80211_BAND_2GHZ]); 2783 2784 wiphy_free(wdev->wiphy); 2785 2786 kfree(wdev); 2787} 2788 2789void rtw_wdev_unregister(struct wireless_dev *wdev) 2790{ 2791 struct net_device *ndev; 2792 struct adapter *adapter; 2793 struct rtw_wdev_priv *pwdev_priv; 2794 2795 if (!wdev) 2796 return; 2797 ndev = wdev_to_ndev(wdev); 2798 if (!ndev) 2799 return; 2800 2801 adapter = rtw_netdev_priv(ndev); 2802 pwdev_priv = adapter_wdev_data(adapter); 2803 2804 rtw_cfg80211_indicate_scan_done(adapter, true); 2805 2806 if (pwdev_priv->pmon_ndev) 2807 unregister_netdev(pwdev_priv->pmon_ndev); 2808 2809 wiphy_unregister(wdev->wiphy); 2810}
~/
Read-only file preview.