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