1 // SPDX-License-Identifier: GPL-2.0 2 /****************************************************************************** 3 * 4 * Copyright(c) 2007 - 2011 Realtek Corporation. All rights reserved. 5 * 6 ******************************************************************************/ 7 #include <linux/etherdevice.h> 8 #include <drv_types.h> 9 #include <hal_btcoex.h> 10 #include <linux/jiffies.h> 11 rtw_init_mlme_priv(struct adapter * padapter)12 int rtw_init_mlme_priv(struct adapter *padapter) 13 { 14 int i; 15 u8 *pbuf; 16 struct wlan_network *pnetwork; 17 struct mlme_priv *pmlmepriv = &padapter->mlmepriv; 18 int res = _SUCCESS; 19 20 pmlmepriv->nic_hdl = (u8 *)padapter; 21 22 pmlmepriv->pscanned = NULL; 23 pmlmepriv->fw_state = WIFI_STATION_STATE; /* Must sync with rtw_wdev_alloc() */ 24 pmlmepriv->cur_network.network.infrastructure_mode = Ndis802_11AutoUnknown; 25 pmlmepriv->scan_mode = SCAN_ACTIVE;/* 1: active, 0: passive. Maybe someday we should rename this varable to "active_mode" (Jeff) */ 26 27 spin_lock_init(&pmlmepriv->lock); 28 INIT_LIST_HEAD(&pmlmepriv->free_bss_pool.queue); 29 spin_lock_init(&pmlmepriv->free_bss_pool.lock); 30 INIT_LIST_HEAD(&pmlmepriv->scanned_queue.queue); 31 spin_lock_init(&pmlmepriv->scanned_queue.lock); 32 33 memset(&pmlmepriv->assoc_ssid, 0, sizeof(struct ndis_802_11_ssid)); 34 35 pbuf = vzalloc(array_size(MAX_BSS_CNT, sizeof(struct wlan_network))); 36 37 if (!pbuf) { 38 res = _FAIL; 39 goto exit; 40 } 41 pmlmepriv->free_bss_buf = pbuf; 42 43 pnetwork = (struct wlan_network *)pbuf; 44 45 for (i = 0; i < MAX_BSS_CNT; i++) { 46 INIT_LIST_HEAD(&pnetwork->list); 47 48 list_add_tail(&pnetwork->list, &pmlmepriv->free_bss_pool.queue); 49 50 pnetwork++; 51 } 52 53 /* allocate DMA-able/Non-Page memory for cmd_buf and rsp_buf */ 54 55 rtw_clear_scan_deny(padapter); 56 57 #define RTW_ROAM_SCAN_RESULT_EXP_MS 5000 58 #define RTW_ROAM_RSSI_DIFF_TH 10 59 #define RTW_ROAM_SCAN_INTERVAL_MS 10000 60 61 pmlmepriv->roam_flags = 0 62 | RTW_ROAM_ON_EXPIRED 63 | RTW_ROAM_ON_RESUME 64 ; 65 66 pmlmepriv->roam_scanr_exp_ms = RTW_ROAM_SCAN_RESULT_EXP_MS; 67 pmlmepriv->roam_rssi_diff_th = RTW_ROAM_RSSI_DIFF_TH; 68 pmlmepriv->roam_scan_int_ms = RTW_ROAM_SCAN_INTERVAL_MS; 69 70 rtw_init_mlme_timer(padapter); 71 72 exit: 73 74 return res; 75 } 76 rtw_free_mlme_ie_data(u8 ** ppie,u32 * plen)77 static void rtw_free_mlme_ie_data(u8 **ppie, u32 *plen) 78 { 79 if (*ppie) { 80 kfree(*ppie); 81 *plen = 0; 82 *ppie = NULL; 83 } 84 } 85 rtw_free_mlme_priv_ie_data(struct mlme_priv * pmlmepriv)86 void rtw_free_mlme_priv_ie_data(struct mlme_priv *pmlmepriv) 87 { 88 rtw_buf_free(&pmlmepriv->assoc_req, &pmlmepriv->assoc_req_len); 89 rtw_buf_free(&pmlmepriv->assoc_rsp, &pmlmepriv->assoc_rsp_len); 90 rtw_free_mlme_ie_data(&pmlmepriv->wps_beacon_ie, &pmlmepriv->wps_beacon_ie_len); 91 rtw_free_mlme_ie_data(&pmlmepriv->wps_probe_req_ie, &pmlmepriv->wps_probe_req_ie_len); 92 rtw_free_mlme_ie_data(&pmlmepriv->wps_probe_resp_ie, &pmlmepriv->wps_probe_resp_ie_len); 93 rtw_free_mlme_ie_data(&pmlmepriv->wps_assoc_resp_ie, &pmlmepriv->wps_assoc_resp_ie_len); 94 95 rtw_free_mlme_ie_data(&pmlmepriv->p2p_beacon_ie, &pmlmepriv->p2p_beacon_ie_len); 96 rtw_free_mlme_ie_data(&pmlmepriv->p2p_probe_req_ie, &pmlmepriv->p2p_probe_req_ie_len); 97 rtw_free_mlme_ie_data(&pmlmepriv->p2p_probe_resp_ie, &pmlmepriv->p2p_probe_resp_ie_len); 98 rtw_free_mlme_ie_data(&pmlmepriv->p2p_go_probe_resp_ie, &pmlmepriv->p2p_go_probe_resp_ie_len); 99 rtw_free_mlme_ie_data(&pmlmepriv->p2p_assoc_req_ie, &pmlmepriv->p2p_assoc_req_ie_len); 100 } 101 _rtw_free_mlme_priv(struct mlme_priv * pmlmepriv)102 void _rtw_free_mlme_priv(struct mlme_priv *pmlmepriv) 103 { 104 if (pmlmepriv) { 105 rtw_free_mlme_priv_ie_data(pmlmepriv); 106 vfree(pmlmepriv->free_bss_buf); 107 } 108 } 109 rtw_alloc_network(struct mlme_priv * pmlmepriv)110 struct wlan_network *rtw_alloc_network(struct mlme_priv *pmlmepriv) 111 { 112 struct wlan_network *pnetwork; 113 struct __queue *free_queue = &pmlmepriv->free_bss_pool; 114 struct list_head *plist = NULL; 115 116 spin_lock_bh(&free_queue->lock); 117 118 if (list_empty(&free_queue->queue)) { 119 pnetwork = NULL; 120 goto exit; 121 } 122 plist = get_next(&(free_queue->queue)); 123 124 pnetwork = container_of(plist, struct wlan_network, list); 125 126 list_del_init(&pnetwork->list); 127 128 pnetwork->network_type = 0; 129 pnetwork->fixed = false; 130 pnetwork->last_scanned = jiffies; 131 pnetwork->aid = 0; 132 pnetwork->join_res = 0; 133 134 exit: 135 spin_unlock_bh(&free_queue->lock); 136 137 return pnetwork; 138 } 139 _rtw_free_network(struct mlme_priv * pmlmepriv,struct wlan_network * pnetwork,u8 isfreeall)140 void _rtw_free_network(struct mlme_priv *pmlmepriv, struct wlan_network *pnetwork, u8 isfreeall) 141 { 142 unsigned int delta_time; 143 u32 lifetime = SCANQUEUE_LIFETIME; 144 struct __queue *free_queue = &(pmlmepriv->free_bss_pool); 145 146 if (!pnetwork) 147 return; 148 149 if (pnetwork->fixed) 150 return; 151 152 if ((check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE) == true) || 153 (check_fwstate(pmlmepriv, WIFI_ADHOC_STATE) == true)) 154 lifetime = 1; 155 156 if (!isfreeall) { 157 delta_time = jiffies_to_msecs(jiffies - pnetwork->last_scanned); 158 if (delta_time < lifetime)/* unit:msec */ 159 return; 160 } 161 162 spin_lock_bh(&free_queue->lock); 163 164 list_del_init(&(pnetwork->list)); 165 166 list_add_tail(&(pnetwork->list), &(free_queue->queue)); 167 168 spin_unlock_bh(&free_queue->lock); 169 } 170 _rtw_free_network_nolock(struct mlme_priv * pmlmepriv,struct wlan_network * pnetwork)171 void _rtw_free_network_nolock(struct mlme_priv *pmlmepriv, struct wlan_network *pnetwork) 172 { 173 174 struct __queue *free_queue = &(pmlmepriv->free_bss_pool); 175 176 if (!pnetwork) 177 return; 178 179 if (pnetwork->fixed) 180 return; 181 182 list_del_init(&(pnetwork->list)); 183 184 list_add_tail(&(pnetwork->list), get_list_head(free_queue)); 185 } 186 187 /* 188 return the wlan_network with the matching addr 189 190 Shall be called under atomic context... to avoid possible racing condition... 191 */ _rtw_find_network(struct __queue * scanned_queue,u8 * addr)192 struct wlan_network *_rtw_find_network(struct __queue *scanned_queue, u8 *addr) 193 { 194 struct list_head *phead, *plist; 195 struct wlan_network *pnetwork = NULL; 196 197 if (is_zero_ether_addr(addr)) { 198 pnetwork = NULL; 199 goto exit; 200 } 201 202 phead = get_list_head(scanned_queue); 203 list_for_each(plist, phead) { 204 pnetwork = list_entry(plist, struct wlan_network, list); 205 206 if (!memcmp(addr, pnetwork->network.mac_address, ETH_ALEN)) 207 break; 208 } 209 210 if (plist == phead) 211 pnetwork = NULL; 212 213 exit: 214 return pnetwork; 215 } 216 rtw_free_network_queue(struct adapter * padapter,u8 isfreeall)217 void rtw_free_network_queue(struct adapter *padapter, u8 isfreeall) 218 { 219 struct list_head *phead, *plist, *tmp; 220 struct wlan_network *pnetwork; 221 struct mlme_priv *pmlmepriv = &padapter->mlmepriv; 222 struct __queue *scanned_queue = &pmlmepriv->scanned_queue; 223 224 spin_lock_bh(&scanned_queue->lock); 225 226 phead = get_list_head(scanned_queue); 227 list_for_each_safe(plist, tmp, phead) { 228 229 pnetwork = list_entry(plist, struct wlan_network, list); 230 231 _rtw_free_network(pmlmepriv, pnetwork, isfreeall); 232 233 } 234 235 spin_unlock_bh(&scanned_queue->lock); 236 } 237 rtw_if_up(struct adapter * padapter)238 signed int rtw_if_up(struct adapter *padapter) 239 { 240 signed int res; 241 242 if (padapter->bDriverStopped || padapter->bSurpriseRemoved || 243 (check_fwstate(&padapter->mlmepriv, _FW_LINKED) == false)) 244 res = false; 245 else 246 res = true; 247 248 return res; 249 } 250 rtw_generate_random_ibss(u8 * pibss)251 void rtw_generate_random_ibss(u8 *pibss) 252 { 253 unsigned long curtime = jiffies; 254 255 pibss[0] = 0x02; /* in ad-hoc mode bit1 must set to 1 */ 256 pibss[1] = 0x11; 257 pibss[2] = 0x87; 258 pibss[3] = (u8)(curtime & 0xff) ;/* p[0]; */ 259 pibss[4] = (u8)((curtime>>8) & 0xff) ;/* p[1]; */ 260 pibss[5] = (u8)((curtime>>16) & 0xff) ;/* p[2]; */ 261 } 262 rtw_get_capability_from_ie(u8 * ie)263 u8 *rtw_get_capability_from_ie(u8 *ie) 264 { 265 return ie + 8 + 2; 266 } 267 rtw_get_capability(struct wlan_bssid_ex * bss)268 u16 rtw_get_capability(struct wlan_bssid_ex *bss) 269 { 270 __le16 val; 271 272 memcpy((u8 *)&val, rtw_get_capability_from_ie(bss->ies), 2); 273 274 return le16_to_cpu(val); 275 } 276 rtw_get_beacon_interval_from_ie(u8 * ie)277 u8 *rtw_get_beacon_interval_from_ie(u8 *ie) 278 { 279 return ie + 8; 280 } 281 rtw_free_mlme_priv(struct mlme_priv * pmlmepriv)282 void rtw_free_mlme_priv(struct mlme_priv *pmlmepriv) 283 { 284 _rtw_free_mlme_priv(pmlmepriv); 285 } 286 287 void rtw_free_network_nolock(struct adapter *padapter, struct wlan_network *pnetwork); rtw_free_network_nolock(struct adapter * padapter,struct wlan_network * pnetwork)288 void rtw_free_network_nolock(struct adapter *padapter, struct wlan_network *pnetwork) 289 { 290 _rtw_free_network_nolock(&(padapter->mlmepriv), pnetwork); 291 rtw_cfg80211_unlink_bss(padapter, pnetwork); 292 } 293 294 /* 295 return the wlan_network with the matching addr 296 297 Shall be called under atomic context... to avoid possible racing condition... 298 */ rtw_find_network(struct __queue * scanned_queue,u8 * addr)299 struct wlan_network *rtw_find_network(struct __queue *scanned_queue, u8 *addr) 300 { 301 struct wlan_network *pnetwork = _rtw_find_network(scanned_queue, addr); 302 303 return pnetwork; 304 } 305 rtw_is_same_ibss(struct adapter * adapter,struct wlan_network * pnetwork)306 int rtw_is_same_ibss(struct adapter *adapter, struct wlan_network *pnetwork) 307 { 308 int ret = true; 309 struct security_priv *psecuritypriv = &adapter->securitypriv; 310 311 if ((psecuritypriv->dot11PrivacyAlgrthm != _NO_PRIVACY_) && 312 (pnetwork->network.privacy == 0)) 313 ret = false; 314 else if ((psecuritypriv->dot11PrivacyAlgrthm == _NO_PRIVACY_) && 315 (pnetwork->network.privacy == 1)) 316 ret = false; 317 else 318 ret = true; 319 320 return ret; 321 322 } 323 is_same_ess(struct wlan_bssid_ex * a,struct wlan_bssid_ex * b)324 inline int is_same_ess(struct wlan_bssid_ex *a, struct wlan_bssid_ex *b) 325 { 326 return (a->ssid.ssid_length == b->ssid.ssid_length) 327 && !memcmp(a->ssid.ssid, b->ssid.ssid, a->ssid.ssid_length); 328 } 329 is_same_network(struct wlan_bssid_ex * src,struct wlan_bssid_ex * dst,u8 feature)330 int is_same_network(struct wlan_bssid_ex *src, struct wlan_bssid_ex *dst, u8 feature) 331 { 332 u16 s_cap, d_cap; 333 __le16 tmps, tmpd; 334 335 if (rtw_bug_check(dst, src, &s_cap, &d_cap) == false) 336 return false; 337 338 memcpy((u8 *)&tmps, rtw_get_capability_from_ie(src->ies), 2); 339 memcpy((u8 *)&tmpd, rtw_get_capability_from_ie(dst->ies), 2); 340 341 s_cap = le16_to_cpu(tmps); 342 d_cap = le16_to_cpu(tmpd); 343 344 return (src->ssid.ssid_length == dst->ssid.ssid_length) && 345 ((!memcmp(src->mac_address, dst->mac_address, ETH_ALEN))) && 346 ((!memcmp(src->ssid.ssid, dst->ssid.ssid, src->ssid.ssid_length))) && 347 ((s_cap & WLAN_CAPABILITY_IBSS) == 348 (d_cap & WLAN_CAPABILITY_IBSS)) && 349 ((s_cap & WLAN_CAPABILITY_ESS) == 350 (d_cap & WLAN_CAPABILITY_ESS)); 351 352 } 353 _rtw_find_same_network(struct __queue * scanned_queue,struct wlan_network * network)354 struct wlan_network *_rtw_find_same_network(struct __queue *scanned_queue, struct wlan_network *network) 355 { 356 struct list_head *phead, *plist; 357 struct wlan_network *found = NULL; 358 359 phead = get_list_head(scanned_queue); 360 list_for_each(plist, phead) { 361 found = list_entry(plist, struct wlan_network, list); 362 363 if (is_same_network(&network->network, &found->network, 0)) 364 break; 365 } 366 367 if (plist == phead) 368 found = NULL; 369 370 return found; 371 } 372 rtw_get_oldest_wlan_network(struct __queue * scanned_queue)373 struct wlan_network *rtw_get_oldest_wlan_network(struct __queue *scanned_queue) 374 { 375 struct list_head *plist, *phead; 376 377 struct wlan_network *pwlan = NULL; 378 struct wlan_network *oldest = NULL; 379 380 phead = get_list_head(scanned_queue); 381 382 list_for_each(plist, phead) { 383 384 pwlan = list_entry(plist, struct wlan_network, list); 385 386 if (!pwlan->fixed) { 387 if (!oldest || time_after(oldest->last_scanned, pwlan->last_scanned)) 388 oldest = pwlan; 389 } 390 } 391 return oldest; 392 393 } 394 update_network(struct wlan_bssid_ex * dst,struct wlan_bssid_ex * src,struct adapter * padapter,bool update_ie)395 void update_network(struct wlan_bssid_ex *dst, struct wlan_bssid_ex *src, 396 struct adapter *padapter, bool update_ie) 397 { 398 long rssi_ori = dst->rssi; 399 400 u8 sq_smp = src->phy_info.signal_quality; 401 402 u8 ss_final; 403 u8 sq_final; 404 long rssi_final; 405 406 /* The rule below is 1/5 for sample value, 4/5 for history value */ 407 if (check_fwstate(&padapter->mlmepriv, _FW_LINKED) && is_same_network(&(padapter->mlmepriv.cur_network.network), src, 0)) { 408 /* Take the recvpriv's value for the connected AP*/ 409 ss_final = padapter->recvpriv.signal_strength; 410 sq_final = padapter->recvpriv.signal_qual; 411 /* the rssi value here is undecorated, and will be used for antenna diversity */ 412 if (sq_smp != 101) /* from the right channel */ 413 rssi_final = (src->rssi+dst->rssi*4)/5; 414 else 415 rssi_final = rssi_ori; 416 } else { 417 if (sq_smp != 101) { /* from the right channel */ 418 ss_final = ((u32)(src->phy_info.signal_strength)+(u32)(dst->phy_info.signal_strength)*4)/5; 419 sq_final = ((u32)(src->phy_info.signal_quality)+(u32)(dst->phy_info.signal_quality)*4)/5; 420 rssi_final = (src->rssi+dst->rssi*4)/5; 421 } else { 422 /* bss info not receiving from the right channel, use the original RX signal infos */ 423 ss_final = dst->phy_info.signal_strength; 424 sq_final = dst->phy_info.signal_quality; 425 rssi_final = dst->rssi; 426 } 427 428 } 429 430 if (update_ie) { 431 dst->reserved[0] = src->reserved[0]; 432 dst->reserved[1] = src->reserved[1]; 433 memcpy((u8 *)dst, (u8 *)src, get_wlan_bssid_ex_sz(src)); 434 } 435 436 dst->phy_info.signal_strength = ss_final; 437 dst->phy_info.signal_quality = sq_final; 438 dst->rssi = rssi_final; 439 } 440 update_current_network(struct adapter * adapter,struct wlan_bssid_ex * pnetwork)441 static void update_current_network(struct adapter *adapter, struct wlan_bssid_ex *pnetwork) 442 { 443 struct mlme_priv *pmlmepriv = &(adapter->mlmepriv); 444 445 rtw_bug_check(&(pmlmepriv->cur_network.network), 446 &(pmlmepriv->cur_network.network), 447 &(pmlmepriv->cur_network.network), 448 &(pmlmepriv->cur_network.network)); 449 450 if ((check_fwstate(pmlmepriv, _FW_LINKED) == true) && (is_same_network(&(pmlmepriv->cur_network.network), pnetwork, 0))) { 451 update_network(&(pmlmepriv->cur_network.network), pnetwork, adapter, true); 452 rtw_update_protection(adapter, (pmlmepriv->cur_network.network.ies) + sizeof(struct ndis_802_11_fix_ie), 453 pmlmepriv->cur_network.network.ie_length); 454 } 455 } 456 457 /* 458 Caller must hold pmlmepriv->lock first. 459 */ rtw_update_scanned_network(struct adapter * adapter,struct wlan_bssid_ex * target)460 void rtw_update_scanned_network(struct adapter *adapter, struct wlan_bssid_ex *target) 461 { 462 struct list_head *plist, *phead; 463 u32 bssid_ex_sz; 464 struct mlme_priv *pmlmepriv = &(adapter->mlmepriv); 465 struct __queue *queue = &(pmlmepriv->scanned_queue); 466 struct wlan_network *pnetwork = NULL; 467 struct wlan_network *oldest = NULL; 468 int target_find = 0; 469 u8 feature = 0; 470 471 spin_lock_bh(&queue->lock); 472 phead = get_list_head(queue); 473 list_for_each(plist, phead) { 474 pnetwork = list_entry(plist, struct wlan_network, list); 475 476 rtw_bug_check(pnetwork, pnetwork, pnetwork, pnetwork); 477 478 if (is_same_network(&(pnetwork->network), target, feature)) { 479 target_find = 1; 480 break; 481 } 482 483 if (rtw_roam_flags(adapter)) { 484 /* TODO: don't select network in the same ess as oldest if it's new enough*/ 485 } 486 487 if (!oldest || time_after(oldest->last_scanned, pnetwork->last_scanned)) 488 oldest = pnetwork; 489 490 } 491 492 /* If we didn't find a match, then get a new network slot to initialize 493 * with this beacon's information */ 494 if (!target_find) { 495 if (list_empty(&pmlmepriv->free_bss_pool.queue)) { 496 /* If there are no more slots, expire the oldest */ 497 /* list_del_init(&oldest->list); */ 498 pnetwork = oldest; 499 if (!pnetwork) 500 goto exit; 501 502 memcpy(&(pnetwork->network), target, get_wlan_bssid_ex_sz(target)); 503 /* variable initialize */ 504 pnetwork->fixed = false; 505 pnetwork->last_scanned = jiffies; 506 507 pnetwork->network_type = 0; 508 pnetwork->aid = 0; 509 pnetwork->join_res = 0; 510 511 /* bss info not receiving from the right channel */ 512 if (pnetwork->network.phy_info.signal_quality == 101) 513 pnetwork->network.phy_info.signal_quality = 0; 514 } else { 515 /* Otherwise just pull from the free list */ 516 517 pnetwork = rtw_alloc_network(pmlmepriv); /* will update scan_time */ 518 519 if (!pnetwork) 520 goto exit; 521 522 bssid_ex_sz = get_wlan_bssid_ex_sz(target); 523 target->length = bssid_ex_sz; 524 memcpy(&(pnetwork->network), target, bssid_ex_sz); 525 526 pnetwork->last_scanned = jiffies; 527 528 /* bss info not receiving from the right channel */ 529 if (pnetwork->network.phy_info.signal_quality == 101) 530 pnetwork->network.phy_info.signal_quality = 0; 531 532 list_add_tail(&(pnetwork->list), &(queue->queue)); 533 534 } 535 } else { 536 /* we have an entry and we are going to update it. But this entry may 537 * be already expired. In this case we do the same as we found a new 538 * net and call the new_net handler 539 */ 540 bool update_ie = true; 541 542 pnetwork->last_scanned = jiffies; 543 544 /* target.reserved[0]== 1, means that scanned network is a bcn frame. */ 545 if (pnetwork->network.ie_length > target->ie_length && target->reserved[0] == 1) 546 update_ie = false; 547 548 /* probe resp(3) > beacon(1) > probe req(2) */ 549 if (target->reserved[0] != 2 && 550 target->reserved[0] >= pnetwork->network.reserved[0]) { 551 update_ie = true; 552 } else { 553 update_ie = false; 554 } 555 556 update_network(&(pnetwork->network), target, adapter, update_ie); 557 } 558 559 exit: 560 spin_unlock_bh(&queue->lock); 561 } 562 563 void rtw_add_network(struct adapter *adapter, struct wlan_bssid_ex *pnetwork); rtw_add_network(struct adapter * adapter,struct wlan_bssid_ex * pnetwork)564 void rtw_add_network(struct adapter *adapter, struct wlan_bssid_ex *pnetwork) 565 { 566 update_current_network(adapter, pnetwork); 567 rtw_update_scanned_network(adapter, pnetwork); 568 } 569 570 /* select the desired network based on the capability of the (i)bss. */ 571 /* check items: (1) security */ 572 /* (2) network_type */ 573 /* (3) WMM */ 574 /* (4) HT */ 575 /* (5) others */ 576 int rtw_is_desired_network(struct adapter *adapter, struct wlan_network *pnetwork); rtw_is_desired_network(struct adapter * adapter,struct wlan_network * pnetwork)577 int rtw_is_desired_network(struct adapter *adapter, struct wlan_network *pnetwork) 578 { 579 struct security_priv *psecuritypriv = &adapter->securitypriv; 580 struct mlme_priv *pmlmepriv = &adapter->mlmepriv; 581 u32 desired_encmode; 582 u32 privacy; 583 uint wps_ielen; 584 int bselected = true; 585 586 desired_encmode = psecuritypriv->ndisencryptstatus; 587 privacy = pnetwork->network.privacy; 588 589 if (check_fwstate(pmlmepriv, WIFI_UNDER_WPS)) { 590 if (rtw_get_wps_ie(pnetwork->network.ies+_FIXED_IE_LENGTH_, pnetwork->network.ie_length-_FIXED_IE_LENGTH_, NULL, &wps_ielen)) 591 return true; 592 else 593 return false; 594 595 } 596 if (adapter->registrypriv.wifi_spec == 1) { /* for correct flow of 8021X to do.... */ 597 u8 *p = NULL; 598 uint ie_len = 0; 599 600 if ((desired_encmode == Ndis802_11EncryptionDisabled) && (privacy != 0)) 601 bselected = false; 602 603 if (psecuritypriv->ndisauthtype == Ndis802_11AuthModeWPA2PSK) { 604 p = rtw_get_ie(pnetwork->network.ies + _BEACON_IE_OFFSET_, WLAN_EID_RSN, &ie_len, (pnetwork->network.ie_length - _BEACON_IE_OFFSET_)); 605 if (p && ie_len > 0) 606 bselected = true; 607 else 608 bselected = false; 609 } 610 } 611 612 if ((desired_encmode != Ndis802_11EncryptionDisabled) && (privacy == 0)) 613 bselected = false; 614 615 if (check_fwstate(pmlmepriv, WIFI_ADHOC_STATE) == true) { 616 if (pnetwork->network.infrastructure_mode != pmlmepriv->cur_network.network.infrastructure_mode) 617 bselected = false; 618 } 619 620 return bselected; 621 } 622 623 /* TODO: Perry : For Power Management */ rtw_atimdone_event_callback(struct adapter * adapter,u8 * pbuf)624 void rtw_atimdone_event_callback(struct adapter *adapter, u8 *pbuf) 625 { 626 } 627 rtw_survey_event_callback(struct adapter * adapter,u8 * pbuf)628 void rtw_survey_event_callback(struct adapter *adapter, u8 *pbuf) 629 { 630 u32 len; 631 struct wlan_bssid_ex *pnetwork; 632 struct mlme_priv *pmlmepriv = &(adapter->mlmepriv); 633 634 pnetwork = (struct wlan_bssid_ex *)pbuf; 635 636 len = get_wlan_bssid_ex_sz(pnetwork); 637 if (len > (sizeof(struct wlan_bssid_ex))) 638 return; 639 640 spin_lock_bh(&pmlmepriv->lock); 641 642 /* update IBSS_network 's timestamp */ 643 if ((check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE)) == true) { 644 if (!memcmp(&(pmlmepriv->cur_network.network.mac_address), pnetwork->mac_address, ETH_ALEN)) { 645 struct wlan_network *ibss_wlan = NULL; 646 647 memcpy(pmlmepriv->cur_network.network.ies, pnetwork->ies, 8); 648 spin_lock_bh(&(pmlmepriv->scanned_queue.lock)); 649 ibss_wlan = rtw_find_network(&pmlmepriv->scanned_queue, pnetwork->mac_address); 650 if (ibss_wlan) { 651 memcpy(ibss_wlan->network.ies, pnetwork->ies, 8); 652 spin_unlock_bh(&(pmlmepriv->scanned_queue.lock)); 653 goto exit; 654 } 655 spin_unlock_bh(&(pmlmepriv->scanned_queue.lock)); 656 } 657 } 658 659 /* lock pmlmepriv->lock when you accessing network_q */ 660 if ((check_fwstate(pmlmepriv, _FW_UNDER_LINKING)) == false) { 661 if (pnetwork->ssid.ssid[0] == 0) 662 pnetwork->ssid.ssid_length = 0; 663 rtw_add_network(adapter, pnetwork); 664 } 665 666 exit: 667 668 spin_unlock_bh(&pmlmepriv->lock); 669 } 670 rtw_surveydone_event_callback(struct adapter * adapter,u8 * pbuf)671 void rtw_surveydone_event_callback(struct adapter *adapter, u8 *pbuf) 672 { 673 struct mlme_priv *pmlmepriv = &(adapter->mlmepriv); 674 675 spin_lock_bh(&pmlmepriv->lock); 676 if (pmlmepriv->wps_probe_req_ie) { 677 pmlmepriv->wps_probe_req_ie_len = 0; 678 kfree(pmlmepriv->wps_probe_req_ie); 679 pmlmepriv->wps_probe_req_ie = NULL; 680 } 681 682 if (check_fwstate(pmlmepriv, _FW_UNDER_SURVEY)) { 683 spin_unlock_bh(&pmlmepriv->lock); 684 del_timer_sync(&pmlmepriv->scan_to_timer); 685 spin_lock_bh(&pmlmepriv->lock); 686 _clr_fwstate_(pmlmepriv, _FW_UNDER_SURVEY); 687 } 688 689 rtw_set_signal_stat_timer(&adapter->recvpriv); 690 691 if (pmlmepriv->to_join) { 692 if ((check_fwstate(pmlmepriv, WIFI_ADHOC_STATE) == true)) { 693 if (check_fwstate(pmlmepriv, _FW_LINKED) == false) { 694 set_fwstate(pmlmepriv, _FW_UNDER_LINKING); 695 696 if (rtw_select_and_join_from_scanned_queue(pmlmepriv) == _SUCCESS) { 697 _set_timer(&pmlmepriv->assoc_timer, MAX_JOIN_TIMEOUT); 698 } else { 699 u8 ret = _SUCCESS; 700 struct wlan_bssid_ex *pdev_network = &(adapter->registrypriv.dev_network); 701 u8 *pibss = adapter->registrypriv.dev_network.mac_address; 702 703 /* pmlmepriv->fw_state ^= _FW_UNDER_SURVEY;because don't set assoc_timer */ 704 _clr_fwstate_(pmlmepriv, _FW_UNDER_SURVEY); 705 706 memcpy(&pdev_network->ssid, &pmlmepriv->assoc_ssid, sizeof(struct ndis_802_11_ssid)); 707 708 rtw_update_registrypriv_dev_network(adapter); 709 rtw_generate_random_ibss(pibss); 710 711 pmlmepriv->fw_state = WIFI_ADHOC_MASTER_STATE; 712 713 pmlmepriv->to_join = false; 714 715 ret = rtw_createbss_cmd(adapter); 716 if (ret != _SUCCESS) 717 goto unlock; 718 } 719 } 720 } else { 721 int s_ret; 722 723 set_fwstate(pmlmepriv, _FW_UNDER_LINKING); 724 pmlmepriv->to_join = false; 725 s_ret = rtw_select_and_join_from_scanned_queue(pmlmepriv); 726 if (s_ret == _SUCCESS) { 727 _set_timer(&pmlmepriv->assoc_timer, MAX_JOIN_TIMEOUT); 728 } else if (s_ret == 2) {/* there is no need to wait for join */ 729 _clr_fwstate_(pmlmepriv, _FW_UNDER_LINKING); 730 rtw_indicate_connect(adapter); 731 } else { 732 if (rtw_to_roam(adapter) != 0) { 733 if (rtw_dec_to_roam(adapter) == 0 734 || _SUCCESS != rtw_sitesurvey_cmd(adapter, &pmlmepriv->assoc_ssid, 1, NULL, 0) 735 ) { 736 rtw_set_to_roam(adapter, 0); 737 rtw_free_assoc_resources(adapter, 1); 738 rtw_indicate_disconnect(adapter); 739 } else { 740 pmlmepriv->to_join = true; 741 } 742 } else 743 rtw_indicate_disconnect(adapter); 744 745 _clr_fwstate_(pmlmepriv, _FW_UNDER_LINKING); 746 } 747 } 748 } else { 749 if (rtw_chk_roam_flags(adapter, RTW_ROAM_ACTIVE)) { 750 if (check_fwstate(pmlmepriv, WIFI_STATION_STATE) 751 && check_fwstate(pmlmepriv, _FW_LINKED)) { 752 if (rtw_select_roaming_candidate(pmlmepriv) == _SUCCESS) { 753 receive_disconnect(adapter, pmlmepriv->cur_network.network.mac_address 754 , WLAN_REASON_ACTIVE_ROAM); 755 } 756 } 757 } 758 } 759 760 unlock: 761 spin_unlock_bh(&pmlmepriv->lock); 762 763 rtw_os_xmit_schedule(adapter); 764 765 rtw_cfg80211_surveydone_event_callback(adapter); 766 767 rtw_indicate_scan_done(adapter, false); 768 } 769 rtw_dummy_event_callback(struct adapter * adapter,u8 * pbuf)770 void rtw_dummy_event_callback(struct adapter *adapter, u8 *pbuf) 771 { 772 } 773 rtw_fwdbg_event_callback(struct adapter * adapter,u8 * pbuf)774 void rtw_fwdbg_event_callback(struct adapter *adapter, u8 *pbuf) 775 { 776 } 777 free_scanqueue(struct mlme_priv * pmlmepriv)778 static void free_scanqueue(struct mlme_priv *pmlmepriv) 779 { 780 struct __queue *free_queue = &pmlmepriv->free_bss_pool; 781 struct __queue *scan_queue = &pmlmepriv->scanned_queue; 782 struct list_head *plist, *phead, *ptemp; 783 784 spin_lock_bh(&scan_queue->lock); 785 spin_lock_bh(&free_queue->lock); 786 787 phead = get_list_head(scan_queue); 788 plist = get_next(phead); 789 790 while (plist != phead) { 791 ptemp = get_next(plist); 792 list_del_init(plist); 793 list_add_tail(plist, &free_queue->queue); 794 plist = ptemp; 795 } 796 797 spin_unlock_bh(&free_queue->lock); 798 spin_unlock_bh(&scan_queue->lock); 799 } 800 rtw_reset_rx_info(struct debug_priv * pdbgpriv)801 static void rtw_reset_rx_info(struct debug_priv *pdbgpriv) 802 { 803 pdbgpriv->dbg_rx_ampdu_drop_count = 0; 804 pdbgpriv->dbg_rx_ampdu_forced_indicate_count = 0; 805 pdbgpriv->dbg_rx_ampdu_loss_count = 0; 806 pdbgpriv->dbg_rx_dup_mgt_frame_drop_count = 0; 807 pdbgpriv->dbg_rx_ampdu_window_shift_cnt = 0; 808 } 809 find_network(struct adapter * adapter)810 static void find_network(struct adapter *adapter) 811 { 812 struct wlan_network *pwlan = NULL; 813 struct mlme_priv *pmlmepriv = &adapter->mlmepriv; 814 struct wlan_network *tgt_network = &pmlmepriv->cur_network; 815 816 pwlan = rtw_find_network(&pmlmepriv->scanned_queue, tgt_network->network.mac_address); 817 if (pwlan) 818 pwlan->fixed = false; 819 820 if (check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE) && 821 (adapter->stapriv.asoc_sta_count == 1)) 822 rtw_free_network_nolock(adapter, pwlan); 823 } 824 825 /* 826 *rtw_free_assoc_resources: the caller has to lock pmlmepriv->lock 827 */ rtw_free_assoc_resources(struct adapter * adapter,int lock_scanned_queue)828 void rtw_free_assoc_resources(struct adapter *adapter, int lock_scanned_queue) 829 { 830 struct mlme_priv *pmlmepriv = &adapter->mlmepriv; 831 struct wlan_network *tgt_network = &pmlmepriv->cur_network; 832 struct dvobj_priv *psdpriv = adapter->dvobj; 833 struct debug_priv *pdbgpriv = &psdpriv->drv_dbg; 834 835 if (check_fwstate(pmlmepriv, WIFI_STATION_STATE|WIFI_AP_STATE)) { 836 struct sta_info *psta; 837 838 psta = rtw_get_stainfo(&adapter->stapriv, tgt_network->network.mac_address); 839 rtw_free_stainfo(adapter, psta); 840 } 841 842 if (check_fwstate(pmlmepriv, WIFI_ADHOC_STATE|WIFI_ADHOC_MASTER_STATE|WIFI_AP_STATE)) { 843 struct sta_info *psta; 844 845 rtw_free_all_stainfo(adapter); 846 847 psta = rtw_get_bcmc_stainfo(adapter); 848 rtw_free_stainfo(adapter, psta); 849 850 rtw_init_bcmc_stainfo(adapter); 851 } 852 853 find_network(adapter); 854 855 if (lock_scanned_queue) 856 adapter->securitypriv.key_mask = 0; 857 858 rtw_reset_rx_info(pdbgpriv); 859 } 860 861 /* 862 *rtw_indicate_connect: the caller has to lock pmlmepriv->lock 863 */ rtw_indicate_connect(struct adapter * padapter)864 void rtw_indicate_connect(struct adapter *padapter) 865 { 866 struct mlme_priv *pmlmepriv = &padapter->mlmepriv; 867 868 pmlmepriv->to_join = false; 869 870 if (!check_fwstate(&padapter->mlmepriv, _FW_LINKED)) { 871 872 set_fwstate(pmlmepriv, _FW_LINKED); 873 874 rtw_os_indicate_connect(padapter); 875 } 876 877 rtw_set_to_roam(padapter, 0); 878 rtw_set_scan_deny(padapter, 3000); 879 880 } 881 882 /* 883 *rtw_indicate_disconnect: the caller has to lock pmlmepriv->lock 884 */ rtw_indicate_disconnect(struct adapter * padapter)885 void rtw_indicate_disconnect(struct adapter *padapter) 886 { 887 struct mlme_priv *pmlmepriv = &padapter->mlmepriv; 888 889 _clr_fwstate_(pmlmepriv, _FW_UNDER_LINKING|WIFI_UNDER_WPS); 890 891 if (rtw_to_roam(padapter) > 0) 892 _clr_fwstate_(pmlmepriv, _FW_LINKED); 893 894 if (check_fwstate(&padapter->mlmepriv, _FW_LINKED) 895 || (rtw_to_roam(padapter) <= 0) 896 ) { 897 rtw_os_indicate_disconnect(padapter); 898 899 /* set ips_deny_time to avoid enter IPS before LPS leave */ 900 rtw_set_ips_deny(padapter, 3000); 901 902 _clr_fwstate_(pmlmepriv, _FW_LINKED); 903 904 rtw_clear_scan_deny(padapter); 905 } 906 907 rtw_lps_ctrl_wk_cmd(padapter, LPS_CTRL_DISCONNECT, 1); 908 } 909 rtw_indicate_scan_done(struct adapter * padapter,bool aborted)910 inline void rtw_indicate_scan_done(struct adapter *padapter, bool aborted) 911 { 912 rtw_os_indicate_scan_done(padapter, aborted); 913 914 if (is_primary_adapter(padapter) && 915 (!adapter_to_pwrctl(padapter)->bInSuspend) && 916 (!check_fwstate(&padapter->mlmepriv, 917 WIFI_ASOC_STATE|WIFI_UNDER_LINKING))) { 918 rtw_set_ips_deny(padapter, 0); 919 _set_timer(&padapter->mlmepriv.dynamic_chk_timer, 1); 920 } 921 } 922 rtw_scan_abort(struct adapter * adapter)923 void rtw_scan_abort(struct adapter *adapter) 924 { 925 unsigned long start; 926 struct mlme_priv *pmlmepriv = &(adapter->mlmepriv); 927 struct mlme_ext_priv *pmlmeext = &(adapter->mlmeextpriv); 928 929 start = jiffies; 930 pmlmeext->scan_abort = true; 931 while (check_fwstate(pmlmepriv, _FW_UNDER_SURVEY) 932 && jiffies_to_msecs(start) <= 200) { 933 934 if (adapter->bDriverStopped || adapter->bSurpriseRemoved) 935 break; 936 937 msleep(20); 938 } 939 940 if (check_fwstate(pmlmepriv, _FW_UNDER_SURVEY)) 941 rtw_indicate_scan_done(adapter, true); 942 943 pmlmeext->scan_abort = false; 944 } 945 rtw_joinbss_update_stainfo(struct adapter * padapter,struct wlan_network * pnetwork)946 static struct sta_info *rtw_joinbss_update_stainfo(struct adapter *padapter, struct wlan_network *pnetwork) 947 { 948 int i; 949 struct sta_info *bmc_sta, *psta = NULL; 950 struct recv_reorder_ctrl *preorder_ctrl; 951 struct sta_priv *pstapriv = &padapter->stapriv; 952 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv; 953 954 psta = rtw_get_stainfo(pstapriv, pnetwork->network.mac_address); 955 if (!psta) 956 psta = rtw_alloc_stainfo(pstapriv, pnetwork->network.mac_address); 957 958 if (psta) { /* update ptarget_sta */ 959 960 psta->aid = pnetwork->join_res; 961 962 update_sta_info(padapter, psta); 963 964 /* update station supportRate */ 965 psta->bssratelen = rtw_get_rateset_len(pnetwork->network.supported_rates); 966 memcpy(psta->bssrateset, pnetwork->network.supported_rates, psta->bssratelen); 967 rtw_hal_update_sta_rate_mask(padapter, psta); 968 969 psta->wireless_mode = pmlmeext->cur_wireless_mode; 970 psta->raid = networktype_to_raid_ex(padapter, psta); 971 972 /* sta mode */ 973 rtw_hal_set_odm_var(padapter, HAL_ODM_STA_INFO, psta, true); 974 975 /* security related */ 976 if (padapter->securitypriv.dot11AuthAlgrthm == dot11AuthAlgrthm_8021X) { 977 padapter->securitypriv.binstallGrpkey = false; 978 padapter->securitypriv.busetkipkey = false; 979 padapter->securitypriv.bgrpkey_handshake = false; 980 981 psta->ieee8021x_blocked = true; 982 psta->dot118021XPrivacy = padapter->securitypriv.dot11PrivacyAlgrthm; 983 984 memset((u8 *)&psta->dot118021x_UncstKey, 0, sizeof(union Keytype)); 985 986 memset((u8 *)&psta->dot11tkiprxmickey, 0, sizeof(union Keytype)); 987 memset((u8 *)&psta->dot11tkiptxmickey, 0, sizeof(union Keytype)); 988 989 memset((u8 *)&psta->dot11txpn, 0, sizeof(union pn48)); 990 psta->dot11txpn.val = psta->dot11txpn.val + 1; 991 memset((u8 *)&psta->dot11wtxpn, 0, sizeof(union pn48)); 992 memset((u8 *)&psta->dot11rxpn, 0, sizeof(union pn48)); 993 } 994 995 /* When doing the WPS, the wps_ie_len won't equal to 0 */ 996 /* And the Wi-Fi driver shouldn't allow the data packet to be transmitted. */ 997 if (padapter->securitypriv.wps_ie_len != 0) { 998 psta->ieee8021x_blocked = true; 999 padapter->securitypriv.wps_ie_len = 0; 1000 } 1001 1002 /* for A-MPDU Rx reordering buffer control for bmc_sta & sta_info */ 1003 /* if A-MPDU Rx is enabled, resetting rx_ordering_ctrl wstart_b(indicate_seq) to default value = 0xffff */ 1004 /* todo: check if AP can send A-MPDU packets */ 1005 for (i = 0; i < 16 ; i++) { 1006 preorder_ctrl = &psta->recvreorder_ctrl[i]; 1007 preorder_ctrl->enable = false; 1008 preorder_ctrl->indicate_seq = 0xffff; 1009 preorder_ctrl->wend_b = 0xffff; 1010 preorder_ctrl->wsize_b = 64;/* max_ampdu_sz;ex. 32(kbytes) -> wsize_b =32 */ 1011 } 1012 1013 bmc_sta = rtw_get_bcmc_stainfo(padapter); 1014 if (bmc_sta) { 1015 for (i = 0; i < 16 ; i++) { 1016 preorder_ctrl = &bmc_sta->recvreorder_ctrl[i]; 1017 preorder_ctrl->enable = false; 1018 preorder_ctrl->indicate_seq = 0xffff; 1019 preorder_ctrl->wend_b = 0xffff; 1020 preorder_ctrl->wsize_b = 64;/* max_ampdu_sz;ex. 32(kbytes) -> wsize_b =32 */ 1021 } 1022 } 1023 } 1024 1025 return psta; 1026 1027 } 1028 1029 /* pnetwork : returns from rtw_joinbss_event_callback */ 1030 /* ptarget_wlan: found from scanned_queue */ rtw_joinbss_update_network(struct adapter * padapter,struct wlan_network * ptarget_wlan,struct wlan_network * pnetwork)1031 static void rtw_joinbss_update_network(struct adapter *padapter, struct wlan_network *ptarget_wlan, struct wlan_network *pnetwork) 1032 { 1033 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv); 1034 struct wlan_network *cur_network = &(pmlmepriv->cur_network); 1035 1036 /* why not use ptarget_wlan?? */ 1037 memcpy(&cur_network->network, &pnetwork->network, pnetwork->network.length); 1038 /* some ies in pnetwork is wrong, so we should use ptarget_wlan ies */ 1039 cur_network->network.ie_length = ptarget_wlan->network.ie_length; 1040 memcpy(&cur_network->network.ies[0], &ptarget_wlan->network.ies[0], MAX_IE_SZ); 1041 1042 cur_network->aid = pnetwork->join_res; 1043 1044 rtw_set_signal_stat_timer(&padapter->recvpriv); 1045 1046 padapter->recvpriv.signal_strength = ptarget_wlan->network.phy_info.signal_strength; 1047 padapter->recvpriv.signal_qual = ptarget_wlan->network.phy_info.signal_quality; 1048 /* the ptarget_wlan->network.rssi is raw data, we use ptarget_wlan->network.phy_info.signal_strength instead (has scaled) */ 1049 padapter->recvpriv.rssi = translate_percentage_to_dbm(ptarget_wlan->network.phy_info.signal_strength); 1050 1051 rtw_set_signal_stat_timer(&padapter->recvpriv); 1052 1053 /* update fw_state will clr _FW_UNDER_LINKING here indirectly */ 1054 switch (pnetwork->network.infrastructure_mode) { 1055 case Ndis802_11Infrastructure: 1056 1057 if (pmlmepriv->fw_state&WIFI_UNDER_WPS) 1058 pmlmepriv->fw_state = WIFI_STATION_STATE|WIFI_UNDER_WPS; 1059 else 1060 pmlmepriv->fw_state = WIFI_STATION_STATE; 1061 1062 break; 1063 case Ndis802_11IBSS: 1064 pmlmepriv->fw_state = WIFI_ADHOC_STATE; 1065 break; 1066 default: 1067 pmlmepriv->fw_state = WIFI_NULL_STATE; 1068 break; 1069 } 1070 1071 rtw_update_protection(padapter, (cur_network->network.ies) + sizeof(struct ndis_802_11_fix_ie), 1072 (cur_network->network.ie_length)); 1073 1074 rtw_update_ht_cap(padapter, cur_network->network.ies, cur_network->network.ie_length, (u8) cur_network->network.configuration.ds_config); 1075 } 1076 1077 /* Notes: the function could be > passive_level (the same context as Rx tasklet) */ 1078 /* pnetwork : returns from rtw_joinbss_event_callback */ 1079 /* ptarget_wlan: found from scanned_queue */ 1080 /* if join_res > 0, for (fw_state ==WIFI_STATION_STATE), we check if "ptarget_sta" & "ptarget_wlan" exist. */ 1081 /* if join_res > 0, for (fw_state ==WIFI_ADHOC_STATE), we only check if "ptarget_wlan" exist. */ 1082 /* if join_res > 0, update "cur_network->network" from "pnetwork->network" if (ptarget_wlan != NULL). */ 1083 /* */ 1084 /* define REJOIN */ rtw_joinbss_event_prehandle(struct adapter * adapter,u8 * pbuf)1085 void rtw_joinbss_event_prehandle(struct adapter *adapter, u8 *pbuf) 1086 { 1087 static u8 __maybe_unused retry; 1088 struct sta_info *ptarget_sta = NULL, *pcur_sta = NULL; 1089 struct sta_priv *pstapriv = &adapter->stapriv; 1090 struct mlme_priv *pmlmepriv = &(adapter->mlmepriv); 1091 struct wlan_network *pnetwork = (struct wlan_network *)pbuf; 1092 struct wlan_network *cur_network = &(pmlmepriv->cur_network); 1093 struct wlan_network *pcur_wlan = NULL, *ptarget_wlan = NULL; 1094 unsigned int the_same_macaddr = false; 1095 1096 rtw_get_encrypt_decrypt_from_registrypriv(adapter); 1097 1098 the_same_macaddr = !memcmp(pnetwork->network.mac_address, cur_network->network.mac_address, ETH_ALEN); 1099 1100 pnetwork->network.length = get_wlan_bssid_ex_sz(&pnetwork->network); 1101 if (pnetwork->network.length > sizeof(struct wlan_bssid_ex)) 1102 return; 1103 1104 spin_lock_bh(&pmlmepriv->lock); 1105 1106 pmlmepriv->LinkDetectInfo.TrafficTransitionCount = 0; 1107 pmlmepriv->LinkDetectInfo.LowPowerTransitionCount = 0; 1108 1109 if (pnetwork->join_res > 0) { 1110 spin_lock_bh(&(pmlmepriv->scanned_queue.lock)); 1111 retry = 0; 1112 if (check_fwstate(pmlmepriv, _FW_UNDER_LINKING)) { 1113 /* s1. find ptarget_wlan */ 1114 if (check_fwstate(pmlmepriv, _FW_LINKED)) { 1115 if (the_same_macaddr) { 1116 ptarget_wlan = rtw_find_network(&pmlmepriv->scanned_queue, cur_network->network.mac_address); 1117 } else { 1118 pcur_wlan = rtw_find_network(&pmlmepriv->scanned_queue, cur_network->network.mac_address); 1119 if (pcur_wlan) 1120 pcur_wlan->fixed = false; 1121 1122 pcur_sta = rtw_get_stainfo(pstapriv, cur_network->network.mac_address); 1123 if (pcur_sta) 1124 rtw_free_stainfo(adapter, pcur_sta); 1125 1126 ptarget_wlan = rtw_find_network(&pmlmepriv->scanned_queue, pnetwork->network.mac_address); 1127 if (check_fwstate(pmlmepriv, WIFI_STATION_STATE) == true) { 1128 if (ptarget_wlan) 1129 ptarget_wlan->fixed = true; 1130 } 1131 } 1132 1133 } else { 1134 ptarget_wlan = _rtw_find_same_network(&pmlmepriv->scanned_queue, pnetwork); 1135 if (check_fwstate(pmlmepriv, WIFI_STATION_STATE) == true) { 1136 if (ptarget_wlan) 1137 ptarget_wlan->fixed = true; 1138 } 1139 } 1140 1141 /* s2. update cur_network */ 1142 if (ptarget_wlan) { 1143 rtw_joinbss_update_network(adapter, ptarget_wlan, pnetwork); 1144 } else { 1145 netdev_dbg(adapter->pnetdev, 1146 "Can't find ptarget_wlan when joinbss_event callback\n"); 1147 spin_unlock_bh(&(pmlmepriv->scanned_queue.lock)); 1148 goto ignore_joinbss_callback; 1149 } 1150 1151 /* s3. find ptarget_sta & update ptarget_sta after update cur_network only for station mode */ 1152 if (check_fwstate(pmlmepriv, WIFI_STATION_STATE) == true) { 1153 ptarget_sta = rtw_joinbss_update_stainfo(adapter, pnetwork); 1154 if (!ptarget_sta) { 1155 spin_unlock_bh(&(pmlmepriv->scanned_queue.lock)); 1156 goto ignore_joinbss_callback; 1157 } 1158 } 1159 1160 /* s4. indicate connect */ 1161 if (check_fwstate(pmlmepriv, WIFI_STATION_STATE) == true) { 1162 pmlmepriv->cur_network_scanned = ptarget_wlan; 1163 rtw_indicate_connect(adapter); 1164 } 1165 1166 spin_unlock_bh(&pmlmepriv->scanned_queue.lock); 1167 1168 spin_unlock_bh(&pmlmepriv->lock); 1169 /* s5. Cancel assoc_timer */ 1170 del_timer_sync(&pmlmepriv->assoc_timer); 1171 spin_lock_bh(&pmlmepriv->lock); 1172 } else { 1173 spin_unlock_bh(&(pmlmepriv->scanned_queue.lock)); 1174 } 1175 } else if (pnetwork->join_res == -4) { 1176 rtw_reset_securitypriv(adapter); 1177 _set_timer(&pmlmepriv->assoc_timer, 1); 1178 1179 if ((check_fwstate(pmlmepriv, _FW_UNDER_LINKING)) == true) 1180 _clr_fwstate_(pmlmepriv, _FW_UNDER_LINKING); 1181 1182 } else {/* if join_res < 0 (join fails), then try again */ 1183 1184 #ifdef REJOIN 1185 res = _FAIL; 1186 if (retry < 2) 1187 res = rtw_select_and_join_from_scanned_queue(pmlmepriv); 1188 1189 if (res == _SUCCESS) { 1190 /* extend time of assoc_timer */ 1191 _set_timer(&pmlmepriv->assoc_timer, MAX_JOIN_TIMEOUT); 1192 retry++; 1193 } else if (res == 2) {/* there is no need to wait for join */ 1194 _clr_fwstate_(pmlmepriv, _FW_UNDER_LINKING); 1195 rtw_indicate_connect(adapter); 1196 } else { 1197 #endif 1198 1199 _set_timer(&pmlmepriv->assoc_timer, 1); 1200 _clr_fwstate_(pmlmepriv, _FW_UNDER_LINKING); 1201 1202 #ifdef REJOIN 1203 retry = 0; 1204 } 1205 #endif 1206 } 1207 1208 ignore_joinbss_callback: 1209 1210 spin_unlock_bh(&pmlmepriv->lock); 1211 } 1212 rtw_joinbss_event_callback(struct adapter * adapter,u8 * pbuf)1213 void rtw_joinbss_event_callback(struct adapter *adapter, u8 *pbuf) 1214 { 1215 struct wlan_network *pnetwork = (struct wlan_network *)pbuf; 1216 1217 mlmeext_joinbss_event_callback(adapter, pnetwork->join_res); 1218 1219 rtw_os_xmit_schedule(adapter); 1220 } 1221 1222 /* FOR STA, AP , AD-HOC mode */ rtw_sta_media_status_rpt(struct adapter * adapter,struct sta_info * psta,u32 mstatus)1223 void rtw_sta_media_status_rpt(struct adapter *adapter, struct sta_info *psta, u32 mstatus) 1224 { 1225 u16 media_status_rpt; 1226 1227 if (!psta) 1228 return; 1229 1230 media_status_rpt = (u16)((psta->mac_id<<8)|mstatus); /* MACID|OPMODE:1 connect */ 1231 rtw_hal_set_hwreg(adapter, HW_VAR_H2C_MEDIA_STATUS_RPT, (u8 *)&media_status_rpt); 1232 } 1233 rtw_stassoc_event_callback(struct adapter * adapter,u8 * pbuf)1234 void rtw_stassoc_event_callback(struct adapter *adapter, u8 *pbuf) 1235 { 1236 struct sta_info *psta; 1237 struct mlme_priv *pmlmepriv = &(adapter->mlmepriv); 1238 struct stassoc_event *pstassoc = (struct stassoc_event *)pbuf; 1239 struct wlan_network *cur_network = &(pmlmepriv->cur_network); 1240 struct wlan_network *ptarget_wlan = NULL; 1241 1242 if (rtw_access_ctrl(adapter, pstassoc->macaddr) == false) 1243 return; 1244 1245 if (check_fwstate(pmlmepriv, WIFI_AP_STATE)) { 1246 psta = rtw_get_stainfo(&adapter->stapriv, pstassoc->macaddr); 1247 if (psta) { 1248 u8 *passoc_req = NULL; 1249 u32 assoc_req_len = 0; 1250 1251 rtw_sta_media_status_rpt(adapter, psta, 1); 1252 1253 ap_sta_info_defer_update(adapter, psta); 1254 1255 /* report to upper layer */ 1256 spin_lock_bh(&psta->lock); 1257 if (psta->passoc_req && psta->assoc_req_len > 0) { 1258 passoc_req = rtw_zmalloc(psta->assoc_req_len); 1259 if (passoc_req) { 1260 assoc_req_len = psta->assoc_req_len; 1261 memcpy(passoc_req, psta->passoc_req, assoc_req_len); 1262 1263 kfree(psta->passoc_req); 1264 psta->passoc_req = NULL; 1265 psta->assoc_req_len = 0; 1266 } 1267 } 1268 spin_unlock_bh(&psta->lock); 1269 1270 if (passoc_req && assoc_req_len > 0) { 1271 rtw_cfg80211_indicate_sta_assoc(adapter, passoc_req, assoc_req_len); 1272 1273 kfree(passoc_req); 1274 } 1275 } 1276 return; 1277 } 1278 1279 /* for AD-HOC mode */ 1280 psta = rtw_get_stainfo(&adapter->stapriv, pstassoc->macaddr); 1281 if (psta) { 1282 /* the sta have been in sta_info_queue => do nothing */ 1283 1284 return; /* between drv has received this event before and fw have not yet to set key to CAM_ENTRY) */ 1285 } 1286 1287 psta = rtw_alloc_stainfo(&adapter->stapriv, pstassoc->macaddr); 1288 if (!psta) 1289 return; 1290 1291 /* to do : init sta_info variable */ 1292 psta->qos_option = 0; 1293 psta->mac_id = (uint)pstassoc->cam_id; 1294 1295 /* for ad-hoc mode */ 1296 rtw_hal_set_odm_var(adapter, HAL_ODM_STA_INFO, psta, true); 1297 1298 rtw_sta_media_status_rpt(adapter, psta, 1); 1299 1300 if (adapter->securitypriv.dot11AuthAlgrthm == dot11AuthAlgrthm_8021X) 1301 psta->dot118021XPrivacy = adapter->securitypriv.dot11PrivacyAlgrthm; 1302 1303 psta->ieee8021x_blocked = false; 1304 1305 spin_lock_bh(&pmlmepriv->lock); 1306 1307 if ((check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE) == true) || 1308 (check_fwstate(pmlmepriv, WIFI_ADHOC_STATE) == true)) { 1309 if (adapter->stapriv.asoc_sta_count == 2) { 1310 spin_lock_bh(&(pmlmepriv->scanned_queue.lock)); 1311 ptarget_wlan = rtw_find_network(&pmlmepriv->scanned_queue, cur_network->network.mac_address); 1312 pmlmepriv->cur_network_scanned = ptarget_wlan; 1313 if (ptarget_wlan) 1314 ptarget_wlan->fixed = true; 1315 spin_unlock_bh(&(pmlmepriv->scanned_queue.lock)); 1316 /* a sta + bc/mc_stainfo (not Ibss_stainfo) */ 1317 rtw_indicate_connect(adapter); 1318 } 1319 } 1320 1321 spin_unlock_bh(&pmlmepriv->lock); 1322 1323 mlmeext_sta_add_event_callback(adapter, psta); 1324 } 1325 rtw_stadel_event_callback(struct adapter * adapter,u8 * pbuf)1326 void rtw_stadel_event_callback(struct adapter *adapter, u8 *pbuf) 1327 { 1328 int mac_id = (-1); 1329 struct sta_info *psta; 1330 struct wlan_network *pwlan = NULL; 1331 struct wlan_bssid_ex *pdev_network = NULL; 1332 u8 *pibss = NULL; 1333 struct mlme_priv *pmlmepriv = &(adapter->mlmepriv); 1334 struct stadel_event *pstadel = (struct stadel_event *)pbuf; 1335 struct wlan_network *tgt_network = &(pmlmepriv->cur_network); 1336 struct mlme_ext_priv *pmlmeext = &adapter->mlmeextpriv; 1337 struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info); 1338 1339 psta = rtw_get_stainfo(&adapter->stapriv, pstadel->macaddr); 1340 if (psta) 1341 mac_id = psta->mac_id; 1342 else 1343 mac_id = pstadel->mac_id; 1344 1345 if (mac_id >= 0) { 1346 u16 media_status; 1347 1348 media_status = (mac_id<<8)|0; /* MACID|OPMODE:0 means disconnect */ 1349 /* for STA, AP, ADHOC mode, report disconnect stauts to FW */ 1350 rtw_hal_set_hwreg(adapter, HW_VAR_H2C_MEDIA_STATUS_RPT, (u8 *)&media_status); 1351 } 1352 1353 /* if (check_fwstate(pmlmepriv, WIFI_AP_STATE)) */ 1354 if ((pmlmeinfo->state&0x03) == WIFI_FW_AP_STATE) 1355 return; 1356 1357 mlmeext_sta_del_event_callback(adapter); 1358 1359 spin_lock_bh(&pmlmepriv->lock); 1360 1361 if (check_fwstate(pmlmepriv, WIFI_STATION_STATE)) { 1362 u16 reason = *((unsigned short *)(pstadel->rsvd)); 1363 bool roam = false; 1364 struct wlan_network *roam_target = NULL; 1365 1366 if (adapter->registrypriv.wifi_spec == 1) { 1367 roam = false; 1368 } else if (reason == WLAN_REASON_EXPIRATION_CHK && rtw_chk_roam_flags(adapter, RTW_ROAM_ON_EXPIRED)) { 1369 roam = true; 1370 } else if (reason == WLAN_REASON_ACTIVE_ROAM && rtw_chk_roam_flags(adapter, RTW_ROAM_ACTIVE)) { 1371 roam = true; 1372 roam_target = pmlmepriv->roam_network; 1373 } 1374 1375 if (roam) { 1376 if (rtw_to_roam(adapter) > 0) 1377 rtw_dec_to_roam(adapter); /* this stadel_event is caused by roaming, decrease to_roam */ 1378 else if (rtw_to_roam(adapter) == 0) 1379 rtw_set_to_roam(adapter, adapter->registrypriv.max_roaming_times); 1380 } else { 1381 rtw_set_to_roam(adapter, 0); 1382 } 1383 1384 rtw_free_uc_swdec_pending_queue(adapter); 1385 1386 rtw_free_assoc_resources(adapter, 1); 1387 rtw_indicate_disconnect(adapter); 1388 1389 spin_lock_bh(&(pmlmepriv->scanned_queue.lock)); 1390 /* remove the network entry in scanned_queue */ 1391 pwlan = rtw_find_network(&pmlmepriv->scanned_queue, tgt_network->network.mac_address); 1392 if (pwlan) { 1393 pwlan->fixed = false; 1394 rtw_free_network_nolock(adapter, pwlan); 1395 } 1396 spin_unlock_bh(&(pmlmepriv->scanned_queue.lock)); 1397 1398 _rtw_roaming(adapter, roam_target); 1399 } 1400 1401 if (check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE) || 1402 check_fwstate(pmlmepriv, WIFI_ADHOC_STATE)) { 1403 1404 rtw_free_stainfo(adapter, psta); 1405 1406 if (adapter->stapriv.asoc_sta_count == 1) {/* a sta + bc/mc_stainfo (not Ibss_stainfo) */ 1407 u8 ret = _SUCCESS; 1408 spin_lock_bh(&(pmlmepriv->scanned_queue.lock)); 1409 /* free old ibss network */ 1410 pwlan = rtw_find_network(&pmlmepriv->scanned_queue, tgt_network->network.mac_address); 1411 if (pwlan) { 1412 pwlan->fixed = false; 1413 rtw_free_network_nolock(adapter, pwlan); 1414 } 1415 spin_unlock_bh(&(pmlmepriv->scanned_queue.lock)); 1416 /* re-create ibss */ 1417 pdev_network = &(adapter->registrypriv.dev_network); 1418 pibss = adapter->registrypriv.dev_network.mac_address; 1419 1420 memcpy(pdev_network, &tgt_network->network, get_wlan_bssid_ex_sz(&tgt_network->network)); 1421 1422 memcpy(&pdev_network->ssid, &pmlmepriv->assoc_ssid, sizeof(struct ndis_802_11_ssid)); 1423 1424 rtw_update_registrypriv_dev_network(adapter); 1425 1426 rtw_generate_random_ibss(pibss); 1427 1428 if (check_fwstate(pmlmepriv, WIFI_ADHOC_STATE)) { 1429 set_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE); 1430 _clr_fwstate_(pmlmepriv, WIFI_ADHOC_STATE); 1431 } 1432 1433 ret = rtw_createbss_cmd(adapter); 1434 if (ret != _SUCCESS) 1435 goto unlock; 1436 } 1437 1438 } 1439 1440 unlock: 1441 spin_unlock_bh(&pmlmepriv->lock); 1442 } 1443 rtw_cpwm_event_callback(struct adapter * padapter,u8 * pbuf)1444 void rtw_cpwm_event_callback(struct adapter *padapter, u8 *pbuf) 1445 { 1446 struct reportpwrstate_parm *preportpwrstate; 1447 1448 preportpwrstate = (struct reportpwrstate_parm *)pbuf; 1449 preportpwrstate->state |= (u8)(adapter_to_pwrctl(padapter)->cpwm_tog + 0x80); 1450 cpwm_int_hdl(padapter, preportpwrstate); 1451 } 1452 rtw_wmm_event_callback(struct adapter * padapter,u8 * pbuf)1453 void rtw_wmm_event_callback(struct adapter *padapter, u8 *pbuf) 1454 { 1455 WMMOnAssocRsp(padapter); 1456 } 1457 1458 /* 1459 * _rtw_join_timeout_handler - Timeout/failure handler for CMD JoinBss 1460 * @adapter: pointer to struct adapter structure 1461 */ _rtw_join_timeout_handler(struct timer_list * t)1462 void _rtw_join_timeout_handler(struct timer_list *t) 1463 { 1464 struct adapter *adapter = from_timer(adapter, t, 1465 mlmepriv.assoc_timer); 1466 struct mlme_priv *pmlmepriv = &adapter->mlmepriv; 1467 1468 if (adapter->bDriverStopped || adapter->bSurpriseRemoved) 1469 return; 1470 1471 spin_lock_bh(&pmlmepriv->lock); 1472 1473 if (rtw_to_roam(adapter) > 0) { /* join timeout caused by roaming */ 1474 while (1) { 1475 rtw_dec_to_roam(adapter); 1476 if (rtw_to_roam(adapter) != 0) { /* try another */ 1477 int do_join_r; 1478 1479 do_join_r = rtw_do_join(adapter); 1480 if (do_join_r != _SUCCESS) 1481 continue; 1482 1483 break; 1484 } else { 1485 rtw_indicate_disconnect(adapter); 1486 break; 1487 } 1488 } 1489 1490 } else { 1491 rtw_indicate_disconnect(adapter); 1492 free_scanqueue(pmlmepriv);/* */ 1493 1494 /* indicate disconnect for the case that join_timeout and check_fwstate != FW_LINKED */ 1495 rtw_cfg80211_indicate_disconnect(adapter); 1496 1497 } 1498 1499 spin_unlock_bh(&pmlmepriv->lock); 1500 } 1501 1502 /* 1503 * rtw_scan_timeout_handler - Timeout/Failure handler for CMD SiteSurvey 1504 * @adapter: pointer to struct adapter structure 1505 */ rtw_scan_timeout_handler(struct timer_list * t)1506 void rtw_scan_timeout_handler(struct timer_list *t) 1507 { 1508 struct adapter *adapter = from_timer(adapter, t, 1509 mlmepriv.scan_to_timer); 1510 struct mlme_priv *pmlmepriv = &adapter->mlmepriv; 1511 1512 spin_lock_bh(&pmlmepriv->lock); 1513 1514 _clr_fwstate_(pmlmepriv, _FW_UNDER_SURVEY); 1515 1516 spin_unlock_bh(&pmlmepriv->lock); 1517 1518 rtw_indicate_scan_done(adapter, true); 1519 } 1520 rtw_mlme_reset_auto_scan_int(struct adapter * adapter)1521 void rtw_mlme_reset_auto_scan_int(struct adapter *adapter) 1522 { 1523 struct mlme_priv *mlme = &adapter->mlmepriv; 1524 struct mlme_ext_priv *pmlmeext = &adapter->mlmeextpriv; 1525 struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info); 1526 1527 if (pmlmeinfo->VHT_enable) /* disable auto scan when connect to 11AC AP */ 1528 mlme->auto_scan_int_ms = 0; 1529 else if (adapter->registrypriv.wifi_spec && is_client_associated_to_ap(adapter) == true) 1530 mlme->auto_scan_int_ms = 60*1000; 1531 else if (rtw_chk_roam_flags(adapter, RTW_ROAM_ACTIVE)) { 1532 if (check_fwstate(mlme, WIFI_STATION_STATE) && check_fwstate(mlme, _FW_LINKED)) 1533 mlme->auto_scan_int_ms = mlme->roam_scan_int_ms; 1534 } else 1535 mlme->auto_scan_int_ms = 0; /* disabled */ 1536 } 1537 rtw_auto_scan_handler(struct adapter * padapter)1538 static void rtw_auto_scan_handler(struct adapter *padapter) 1539 { 1540 struct mlme_priv *pmlmepriv = &padapter->mlmepriv; 1541 1542 rtw_mlme_reset_auto_scan_int(padapter); 1543 1544 if (pmlmepriv->auto_scan_int_ms != 0 1545 && jiffies_to_msecs(jiffies - pmlmepriv->scan_start_time) > pmlmepriv->auto_scan_int_ms) { 1546 1547 if (!padapter->registrypriv.wifi_spec) { 1548 if (check_fwstate(pmlmepriv, _FW_UNDER_SURVEY | _FW_UNDER_LINKING) == true) 1549 goto exit; 1550 1551 if (pmlmepriv->LinkDetectInfo.bBusyTraffic) 1552 goto exit; 1553 } 1554 1555 rtw_set_802_11_bssid_list_scan(padapter, NULL, 0); 1556 } 1557 1558 exit: 1559 return; 1560 } 1561 rtw_dynamic_check_timer_handler(struct adapter * adapter)1562 void rtw_dynamic_check_timer_handler(struct adapter *adapter) 1563 { 1564 if (!adapter) 1565 return; 1566 1567 if (!adapter->hw_init_completed) 1568 return; 1569 1570 if (adapter->bDriverStopped || adapter->bSurpriseRemoved) 1571 return; 1572 1573 if (adapter->net_closed) 1574 return; 1575 1576 if ((adapter_to_pwrctl(adapter)->fw_current_in_ps_mode) 1577 && !(hal_btcoex_IsBtControlLps(adapter)) 1578 ) { 1579 u8 bEnterPS; 1580 1581 linked_status_chk(adapter); 1582 1583 bEnterPS = traffic_status_watchdog(adapter, 1); 1584 if (bEnterPS) { 1585 /* rtw_lps_ctrl_wk_cmd(adapter, LPS_CTRL_ENTER, 1); */ 1586 rtw_hal_dm_watchdog_in_lps(adapter); 1587 } else { 1588 /* call rtw_lps_ctrl_wk_cmd(padapter, LPS_CTRL_LEAVE, 1) in traffic_status_watchdog() */ 1589 } 1590 1591 } else { 1592 if (is_primary_adapter(adapter)) 1593 rtw_dynamic_chk_wk_cmd(adapter); 1594 } 1595 1596 /* auto site survey */ 1597 rtw_auto_scan_handler(adapter); 1598 } 1599 rtw_is_scan_deny(struct adapter * adapter)1600 inline bool rtw_is_scan_deny(struct adapter *adapter) 1601 { 1602 struct mlme_priv *mlmepriv = &adapter->mlmepriv; 1603 1604 return (atomic_read(&mlmepriv->set_scan_deny) != 0) ? true : false; 1605 } 1606 rtw_clear_scan_deny(struct adapter * adapter)1607 inline void rtw_clear_scan_deny(struct adapter *adapter) 1608 { 1609 struct mlme_priv *mlmepriv = &adapter->mlmepriv; 1610 1611 atomic_set(&mlmepriv->set_scan_deny, 0); 1612 } 1613 rtw_set_scan_deny(struct adapter * adapter,u32 ms)1614 void rtw_set_scan_deny(struct adapter *adapter, u32 ms) 1615 { 1616 struct mlme_priv *mlmepriv = &adapter->mlmepriv; 1617 1618 atomic_set(&mlmepriv->set_scan_deny, 1); 1619 _set_timer(&mlmepriv->set_scan_deny_timer, ms); 1620 } 1621 1622 /* 1623 * Select a new roaming candidate from the original @param candidate and @param competitor 1624 * @return true: candidate is updated 1625 * @return false: candidate is not updated 1626 */ rtw_check_roaming_candidate(struct mlme_priv * mlme,struct wlan_network ** candidate,struct wlan_network * competitor)1627 static int rtw_check_roaming_candidate(struct mlme_priv *mlme 1628 , struct wlan_network **candidate, struct wlan_network *competitor) 1629 { 1630 int updated = false; 1631 struct adapter *adapter = container_of(mlme, struct adapter, mlmepriv); 1632 1633 if (is_same_ess(&competitor->network, &mlme->cur_network.network) == false) 1634 goto exit; 1635 1636 if (rtw_is_desired_network(adapter, competitor) == false) 1637 goto exit; 1638 1639 /* got specific addr to roam */ 1640 if (!is_zero_mac_addr(mlme->roam_tgt_addr)) { 1641 if (!memcmp(mlme->roam_tgt_addr, competitor->network.mac_address, ETH_ALEN)) 1642 goto update; 1643 else 1644 goto exit; 1645 } 1646 if (jiffies_to_msecs(jiffies - competitor->last_scanned) >= mlme->roam_scanr_exp_ms) 1647 goto exit; 1648 1649 if (competitor->network.rssi - mlme->cur_network_scanned->network.rssi < mlme->roam_rssi_diff_th) 1650 goto exit; 1651 1652 if (*candidate && (*candidate)->network.rssi >= competitor->network.rssi) 1653 goto exit; 1654 1655 update: 1656 *candidate = competitor; 1657 updated = true; 1658 1659 exit: 1660 return updated; 1661 } 1662 rtw_select_roaming_candidate(struct mlme_priv * mlme)1663 int rtw_select_roaming_candidate(struct mlme_priv *mlme) 1664 { 1665 int ret = _FAIL; 1666 struct list_head *phead; 1667 struct __queue *queue = &(mlme->scanned_queue); 1668 struct wlan_network *pnetwork = NULL; 1669 struct wlan_network *candidate = NULL; 1670 1671 if (!mlme->cur_network_scanned) { 1672 rtw_warn_on(1); 1673 return ret; 1674 } 1675 1676 spin_lock_bh(&(mlme->scanned_queue.lock)); 1677 phead = get_list_head(queue); 1678 1679 list_for_each(mlme->pscanned, phead) { 1680 1681 pnetwork = list_entry(mlme->pscanned, struct wlan_network, 1682 list); 1683 1684 rtw_check_roaming_candidate(mlme, &candidate, pnetwork); 1685 1686 } 1687 1688 if (!candidate) { 1689 ret = _FAIL; 1690 goto exit; 1691 } else { 1692 mlme->roam_network = candidate; 1693 1694 if (!memcmp(candidate->network.mac_address, mlme->roam_tgt_addr, ETH_ALEN)) 1695 eth_zero_addr(mlme->roam_tgt_addr); 1696 } 1697 1698 ret = _SUCCESS; 1699 exit: 1700 spin_unlock_bh(&(mlme->scanned_queue.lock)); 1701 1702 return ret; 1703 } 1704 1705 /* 1706 * Select a new join candidate from the original @param candidate and @param competitor 1707 * @return true: candidate is updated 1708 * @return false: candidate is not updated 1709 */ rtw_check_join_candidate(struct mlme_priv * mlme,struct wlan_network ** candidate,struct wlan_network * competitor)1710 static int rtw_check_join_candidate(struct mlme_priv *mlme 1711 , struct wlan_network **candidate, struct wlan_network *competitor) 1712 { 1713 int updated = false; 1714 struct adapter *adapter = container_of(mlme, struct adapter, mlmepriv); 1715 1716 /* check bssid, if needed */ 1717 if (mlme->assoc_by_bssid) { 1718 if (memcmp(competitor->network.mac_address, mlme->assoc_bssid, ETH_ALEN)) 1719 goto exit; 1720 } 1721 1722 /* check ssid, if needed */ 1723 if (mlme->assoc_ssid.ssid[0] && mlme->assoc_ssid.ssid_length) { 1724 if (competitor->network.ssid.ssid_length != mlme->assoc_ssid.ssid_length 1725 || memcmp(competitor->network.ssid.ssid, mlme->assoc_ssid.ssid, mlme->assoc_ssid.ssid_length) 1726 ) 1727 goto exit; 1728 } 1729 1730 if (rtw_is_desired_network(adapter, competitor) == false) 1731 goto exit; 1732 1733 if (rtw_to_roam(adapter) > 0) { 1734 if (jiffies_to_msecs(jiffies - competitor->last_scanned) >= mlme->roam_scanr_exp_ms 1735 || is_same_ess(&competitor->network, &mlme->cur_network.network) == false 1736 ) 1737 goto exit; 1738 } 1739 1740 if (!*candidate || (*candidate)->network.rssi < competitor->network.rssi) { 1741 *candidate = competitor; 1742 updated = true; 1743 } 1744 1745 exit: 1746 return updated; 1747 } 1748 1749 /* 1750 Calling context: 1751 The caller of the sub-routine will be in critical section... 1752 The caller must hold the following spinlock 1753 pmlmepriv->lock 1754 */ 1755 rtw_select_and_join_from_scanned_queue(struct mlme_priv * pmlmepriv)1756 int rtw_select_and_join_from_scanned_queue(struct mlme_priv *pmlmepriv) 1757 { 1758 int ret; 1759 struct list_head *phead; 1760 struct adapter *adapter; 1761 struct __queue *queue = &(pmlmepriv->scanned_queue); 1762 struct wlan_network *pnetwork = NULL; 1763 struct wlan_network *candidate = NULL; 1764 1765 adapter = (struct adapter *)pmlmepriv->nic_hdl; 1766 1767 spin_lock_bh(&(pmlmepriv->scanned_queue.lock)); 1768 1769 if (pmlmepriv->roam_network) { 1770 candidate = pmlmepriv->roam_network; 1771 pmlmepriv->roam_network = NULL; 1772 goto candidate_exist; 1773 } 1774 1775 phead = get_list_head(queue); 1776 list_for_each(pmlmepriv->pscanned, phead) { 1777 1778 pnetwork = list_entry(pmlmepriv->pscanned, 1779 struct wlan_network, list); 1780 1781 rtw_check_join_candidate(pmlmepriv, &candidate, pnetwork); 1782 1783 } 1784 1785 if (!candidate) { 1786 ret = _FAIL; 1787 goto exit; 1788 } else { 1789 goto candidate_exist; 1790 } 1791 1792 candidate_exist: 1793 1794 /* check for situation of _FW_LINKED */ 1795 if (check_fwstate(pmlmepriv, _FW_LINKED) == true) { 1796 rtw_disassoc_cmd(adapter, 0, true); 1797 rtw_indicate_disconnect(adapter); 1798 rtw_free_assoc_resources(adapter, 0); 1799 } 1800 1801 set_fwstate(pmlmepriv, _FW_UNDER_LINKING); 1802 ret = rtw_joinbss_cmd(adapter, candidate); 1803 1804 exit: 1805 spin_unlock_bh(&(pmlmepriv->scanned_queue.lock)); 1806 return ret; 1807 } 1808 rtw_set_auth(struct adapter * adapter,struct security_priv * psecuritypriv)1809 signed int rtw_set_auth(struct adapter *adapter, struct security_priv *psecuritypriv) 1810 { 1811 struct cmd_obj *pcmd; 1812 struct setauth_parm *psetauthparm; 1813 struct cmd_priv *pcmdpriv = &(adapter->cmdpriv); 1814 signed int res = _SUCCESS; 1815 1816 pcmd = rtw_zmalloc(sizeof(struct cmd_obj)); 1817 if (!pcmd) { 1818 res = _FAIL; /* try again */ 1819 goto exit; 1820 } 1821 1822 psetauthparm = rtw_zmalloc(sizeof(struct setauth_parm)); 1823 if (!psetauthparm) { 1824 kfree(pcmd); 1825 res = _FAIL; 1826 goto exit; 1827 } 1828 1829 psetauthparm->mode = (unsigned char)psecuritypriv->dot11AuthAlgrthm; 1830 1831 pcmd->cmdcode = _SetAuth_CMD_; 1832 pcmd->parmbuf = (unsigned char *)psetauthparm; 1833 pcmd->cmdsz = (sizeof(struct setauth_parm)); 1834 pcmd->rsp = NULL; 1835 pcmd->rspsz = 0; 1836 1837 INIT_LIST_HEAD(&pcmd->list); 1838 1839 res = rtw_enqueue_cmd(pcmdpriv, pcmd); 1840 1841 exit: 1842 return res; 1843 } 1844 rtw_set_key(struct adapter * adapter,struct security_priv * psecuritypriv,signed int keyid,u8 set_tx,bool enqueue)1845 signed int rtw_set_key(struct adapter *adapter, struct security_priv *psecuritypriv, signed int keyid, u8 set_tx, bool enqueue) 1846 { 1847 u8 keylen; 1848 struct cmd_obj *pcmd; 1849 struct setkey_parm *psetkeyparm; 1850 struct cmd_priv *pcmdpriv = &(adapter->cmdpriv); 1851 signed int res = _SUCCESS; 1852 1853 psetkeyparm = rtw_zmalloc(sizeof(struct setkey_parm)); 1854 if (!psetkeyparm) { 1855 res = _FAIL; 1856 goto exit; 1857 } 1858 1859 if (psecuritypriv->dot11AuthAlgrthm == dot11AuthAlgrthm_8021X) 1860 psetkeyparm->algorithm = (unsigned char)psecuritypriv->dot118021XGrpPrivacy; 1861 else 1862 psetkeyparm->algorithm = (u8)psecuritypriv->dot11PrivacyAlgrthm; 1863 1864 psetkeyparm->keyid = (u8)keyid;/* 0~3 */ 1865 psetkeyparm->set_tx = set_tx; 1866 if (is_wep_enc(psetkeyparm->algorithm)) 1867 adapter->securitypriv.key_mask |= BIT(psetkeyparm->keyid); 1868 1869 switch (psetkeyparm->algorithm) { 1870 1871 case _WEP40_: 1872 keylen = 5; 1873 memcpy(&(psetkeyparm->key[0]), &(psecuritypriv->dot11DefKey[keyid].skey[0]), keylen); 1874 break; 1875 case _WEP104_: 1876 keylen = 13; 1877 memcpy(&(psetkeyparm->key[0]), &(psecuritypriv->dot11DefKey[keyid].skey[0]), keylen); 1878 break; 1879 case _TKIP_: 1880 keylen = 16; 1881 memcpy(&psetkeyparm->key, &psecuritypriv->dot118021XGrpKey[keyid], keylen); 1882 psetkeyparm->grpkey = 1; 1883 break; 1884 case _AES_: 1885 keylen = 16; 1886 memcpy(&psetkeyparm->key, &psecuritypriv->dot118021XGrpKey[keyid], keylen); 1887 psetkeyparm->grpkey = 1; 1888 break; 1889 default: 1890 res = _FAIL; 1891 kfree(psetkeyparm); 1892 goto exit; 1893 } 1894 1895 if (enqueue) { 1896 pcmd = rtw_zmalloc(sizeof(struct cmd_obj)); 1897 if (!pcmd) { 1898 kfree(psetkeyparm); 1899 res = _FAIL; /* try again */ 1900 goto exit; 1901 } 1902 1903 pcmd->cmdcode = _SetKey_CMD_; 1904 pcmd->parmbuf = (u8 *)psetkeyparm; 1905 pcmd->cmdsz = (sizeof(struct setkey_parm)); 1906 pcmd->rsp = NULL; 1907 pcmd->rspsz = 0; 1908 1909 INIT_LIST_HEAD(&pcmd->list); 1910 1911 res = rtw_enqueue_cmd(pcmdpriv, pcmd); 1912 } else { 1913 setkey_hdl(adapter, (u8 *)psetkeyparm); 1914 kfree(psetkeyparm); 1915 } 1916 exit: 1917 return res; 1918 } 1919 1920 /* adjust ies for rtw_joinbss_cmd in WMM */ rtw_restruct_wmm_ie(struct adapter * adapter,u8 * in_ie,u8 * out_ie,uint in_len,uint initial_out_len)1921 int rtw_restruct_wmm_ie(struct adapter *adapter, u8 *in_ie, u8 *out_ie, uint in_len, uint initial_out_len) 1922 { 1923 unsigned int ielength = 0; 1924 unsigned int i, j; 1925 1926 i = 12; /* after the fixed IE */ 1927 while (i < in_len) { 1928 ielength = initial_out_len; 1929 1930 if (in_ie[i] == 0xDD && in_ie[i+2] == 0x00 && in_ie[i+3] == 0x50 && in_ie[i+4] == 0xF2 && in_ie[i+5] == 0x02 && i+5 < in_len) { /* WMM element ID and OUI */ 1931 for (j = i; j < i + 9; j++) { 1932 out_ie[ielength] = in_ie[j]; 1933 ielength++; 1934 } 1935 out_ie[initial_out_len + 1] = 0x07; 1936 out_ie[initial_out_len + 6] = 0x00; 1937 out_ie[initial_out_len + 8] = 0x00; 1938 1939 break; 1940 } 1941 1942 i += (in_ie[i+1]+2); /* to the next IE element */ 1943 } 1944 1945 return ielength; 1946 1947 } 1948 1949 /* */ 1950 /* Ported from 8185: IsInPreAuthKeyList(). (Renamed from SecIsInPreAuthKeyList(), 2006-10-13.) */ 1951 /* Added by Annie, 2006-05-07. */ 1952 /* */ 1953 /* Search by BSSID, */ 1954 /* Return Value: */ 1955 /* -1 :if there is no pre-auth key in the table */ 1956 /* >= 0 :if there is pre-auth key, and return the entry id */ 1957 /* */ 1958 /* */ 1959 SecIsInPMKIDList(struct adapter * Adapter,u8 * bssid)1960 static int SecIsInPMKIDList(struct adapter *Adapter, u8 *bssid) 1961 { 1962 struct security_priv *p = &Adapter->securitypriv; 1963 int i; 1964 1965 for (i = 0; i < NUM_PMKID_CACHE; i++) 1966 if ((p->PMKIDList[i].bUsed) && 1967 (!memcmp(p->PMKIDList[i].Bssid, bssid, ETH_ALEN))) 1968 return i; 1969 return -1; 1970 } 1971 1972 /* */ 1973 /* Check the RSN IE length */ 1974 /* If the RSN IE length <= 20, the RSN IE didn't include the PMKID information */ 1975 /* 0-11th element in the array are the fixed IE */ 1976 /* 12th element in the array is the IE */ 1977 /* 13th element in the array is the IE length */ 1978 /* */ 1979 rtw_append_pmkid(struct adapter * Adapter,int iEntry,u8 * ie,uint ie_len)1980 static int rtw_append_pmkid(struct adapter *Adapter, int iEntry, u8 *ie, uint ie_len) 1981 { 1982 struct security_priv *psecuritypriv = &Adapter->securitypriv; 1983 1984 if (ie[13] <= 20) { 1985 /* The RSN IE didn't include the PMK ID, append the PMK information */ 1986 ie[ie_len] = 1; 1987 ie_len++; 1988 ie[ie_len] = 0; /* PMKID count = 0x0100 */ 1989 ie_len++; 1990 memcpy(&ie[ie_len], &psecuritypriv->PMKIDList[iEntry].PMKID, 16); 1991 ie_len += 16; 1992 ie[13] += 18;/* PMKID length = 2+16 */ 1993 } 1994 return ie_len; 1995 } 1996 rtw_restruct_sec_ie(struct adapter * adapter,u8 * in_ie,u8 * out_ie,uint in_len)1997 signed int rtw_restruct_sec_ie(struct adapter *adapter, u8 *in_ie, u8 *out_ie, uint in_len) 1998 { 1999 u8 authmode = 0x0; 2000 uint ielength; 2001 int iEntry; 2002 2003 struct mlme_priv *pmlmepriv = &adapter->mlmepriv; 2004 struct security_priv *psecuritypriv = &adapter->securitypriv; 2005 uint ndisauthmode = psecuritypriv->ndisauthtype; 2006 2007 /* copy fixed ie only */ 2008 memcpy(out_ie, in_ie, 12); 2009 ielength = 12; 2010 if ((ndisauthmode == Ndis802_11AuthModeWPA) || (ndisauthmode == Ndis802_11AuthModeWPAPSK)) 2011 authmode = WLAN_EID_VENDOR_SPECIFIC; 2012 if ((ndisauthmode == Ndis802_11AuthModeWPA2) || (ndisauthmode == Ndis802_11AuthModeWPA2PSK)) 2013 authmode = WLAN_EID_RSN; 2014 2015 if (check_fwstate(pmlmepriv, WIFI_UNDER_WPS)) { 2016 memcpy(out_ie+ielength, psecuritypriv->wps_ie, psecuritypriv->wps_ie_len); 2017 2018 ielength += psecuritypriv->wps_ie_len; 2019 } else if ((authmode == WLAN_EID_VENDOR_SPECIFIC) || (authmode == WLAN_EID_RSN)) { 2020 /* copy RSN or SSN */ 2021 memcpy(&out_ie[ielength], &psecuritypriv->supplicant_ie[0], psecuritypriv->supplicant_ie[1]+2); 2022 ielength += psecuritypriv->supplicant_ie[1]+2; 2023 rtw_report_sec_ie(adapter, authmode, psecuritypriv->supplicant_ie); 2024 } 2025 2026 iEntry = SecIsInPMKIDList(adapter, pmlmepriv->assoc_bssid); 2027 if (iEntry < 0) { 2028 return ielength; 2029 } else { 2030 if (authmode == WLAN_EID_RSN) 2031 ielength = rtw_append_pmkid(adapter, iEntry, out_ie, ielength); 2032 } 2033 return ielength; 2034 } 2035 rtw_init_registrypriv_dev_network(struct adapter * adapter)2036 void rtw_init_registrypriv_dev_network(struct adapter *adapter) 2037 { 2038 struct registry_priv *pregistrypriv = &adapter->registrypriv; 2039 struct eeprom_priv *peepriv = &adapter->eeprompriv; 2040 struct wlan_bssid_ex *pdev_network = &pregistrypriv->dev_network; 2041 u8 *myhwaddr = myid(peepriv); 2042 2043 memcpy(pdev_network->mac_address, myhwaddr, ETH_ALEN); 2044 2045 memcpy(&pdev_network->ssid, &pregistrypriv->ssid, sizeof(struct ndis_802_11_ssid)); 2046 2047 pdev_network->configuration.length = sizeof(struct ndis_802_11_conf); 2048 pdev_network->configuration.beacon_period = 100; 2049 } 2050 rtw_update_registrypriv_dev_network(struct adapter * adapter)2051 void rtw_update_registrypriv_dev_network(struct adapter *adapter) 2052 { 2053 int sz = 0; 2054 struct registry_priv *pregistrypriv = &adapter->registrypriv; 2055 struct wlan_bssid_ex *pdev_network = &pregistrypriv->dev_network; 2056 struct security_priv *psecuritypriv = &adapter->securitypriv; 2057 struct wlan_network *cur_network = &adapter->mlmepriv.cur_network; 2058 2059 pdev_network->privacy = (psecuritypriv->dot11PrivacyAlgrthm > 0 ? 1 : 0) ; /* adhoc no 802.1x */ 2060 2061 pdev_network->rssi = 0; 2062 2063 switch (pregistrypriv->wireless_mode) { 2064 case WIRELESS_11B: 2065 pdev_network->network_type_in_use = (Ndis802_11DS); 2066 break; 2067 case WIRELESS_11G: 2068 case WIRELESS_11BG: 2069 case WIRELESS_11_24N: 2070 case WIRELESS_11G_24N: 2071 case WIRELESS_11BG_24N: 2072 pdev_network->network_type_in_use = (Ndis802_11OFDM24); 2073 break; 2074 default: 2075 /* TODO */ 2076 break; 2077 } 2078 2079 pdev_network->configuration.ds_config = (pregistrypriv->channel); 2080 2081 if (cur_network->network.infrastructure_mode == Ndis802_11IBSS) 2082 pdev_network->configuration.atim_window = (0); 2083 2084 pdev_network->infrastructure_mode = (cur_network->network.infrastructure_mode); 2085 2086 /* 1. Supported rates */ 2087 /* 2. IE */ 2088 2089 /* rtw_set_supported_rate(pdev_network->supported_rates, pregistrypriv->wireless_mode) ; will be called in rtw_generate_ie */ 2090 sz = rtw_generate_ie(pregistrypriv); 2091 2092 pdev_network->ie_length = sz; 2093 2094 pdev_network->length = get_wlan_bssid_ex_sz((struct wlan_bssid_ex *)pdev_network); 2095 2096 /* notes: translate ie_length & length after assign the length to cmdsz in createbss_cmd(); */ 2097 /* pdev_network->ie_length = cpu_to_le32(sz); */ 2098 } 2099 rtw_get_encrypt_decrypt_from_registrypriv(struct adapter * adapter)2100 void rtw_get_encrypt_decrypt_from_registrypriv(struct adapter *adapter) 2101 { 2102 } 2103 2104 /* the function is at passive_level */ rtw_joinbss_reset(struct adapter * padapter)2105 void rtw_joinbss_reset(struct adapter *padapter) 2106 { 2107 u8 threshold; 2108 struct mlme_priv *pmlmepriv = &padapter->mlmepriv; 2109 2110 struct ht_priv *phtpriv = &pmlmepriv->htpriv; 2111 2112 /* todo: if you want to do something io/reg/hw setting before join_bss, please add code here */ 2113 2114 pmlmepriv->num_FortyMHzIntolerant = 0; 2115 2116 pmlmepriv->num_sta_no_ht = 0; 2117 2118 phtpriv->ampdu_enable = false;/* reset to disabled */ 2119 2120 /* TH = 1 => means that invalidate usb rx aggregation */ 2121 /* TH = 0 => means that validate usb rx aggregation, use init value. */ 2122 if (phtpriv->ht_option) { 2123 if (padapter->registrypriv.wifi_spec == 1) 2124 threshold = 1; 2125 else 2126 threshold = 0; 2127 rtw_hal_set_hwreg(padapter, HW_VAR_RXDMA_AGG_PG_TH, (u8 *)(&threshold)); 2128 } else { 2129 threshold = 1; 2130 rtw_hal_set_hwreg(padapter, HW_VAR_RXDMA_AGG_PG_TH, (u8 *)(&threshold)); 2131 } 2132 } 2133 rtw_ht_use_default_setting(struct adapter * padapter)2134 void rtw_ht_use_default_setting(struct adapter *padapter) 2135 { 2136 struct mlme_priv *pmlmepriv = &padapter->mlmepriv; 2137 struct ht_priv *phtpriv = &pmlmepriv->htpriv; 2138 struct registry_priv *pregistrypriv = &padapter->registrypriv; 2139 bool bHwLDPCSupport = false, bHwSTBCSupport = false; 2140 bool bHwSupportBeamformer = false, bHwSupportBeamformee = false; 2141 2142 if (pregistrypriv->wifi_spec) 2143 phtpriv->bss_coexist = 1; 2144 else 2145 phtpriv->bss_coexist = 0; 2146 2147 phtpriv->sgi_40m = TEST_FLAG(pregistrypriv->short_gi, BIT1) ? true : false; 2148 phtpriv->sgi_20m = TEST_FLAG(pregistrypriv->short_gi, BIT0) ? true : false; 2149 2150 /* LDPC support */ 2151 rtw_hal_get_def_var(padapter, HAL_DEF_RX_LDPC, (u8 *)&bHwLDPCSupport); 2152 CLEAR_FLAGS(phtpriv->ldpc_cap); 2153 if (bHwLDPCSupport) { 2154 if (TEST_FLAG(pregistrypriv->ldpc_cap, BIT4)) 2155 SET_FLAG(phtpriv->ldpc_cap, LDPC_HT_ENABLE_RX); 2156 } 2157 rtw_hal_get_def_var(padapter, HAL_DEF_TX_LDPC, (u8 *)&bHwLDPCSupport); 2158 if (bHwLDPCSupport) { 2159 if (TEST_FLAG(pregistrypriv->ldpc_cap, BIT5)) 2160 SET_FLAG(phtpriv->ldpc_cap, LDPC_HT_ENABLE_TX); 2161 } 2162 2163 /* STBC */ 2164 rtw_hal_get_def_var(padapter, HAL_DEF_TX_STBC, (u8 *)&bHwSTBCSupport); 2165 CLEAR_FLAGS(phtpriv->stbc_cap); 2166 if (bHwSTBCSupport) { 2167 if (TEST_FLAG(pregistrypriv->stbc_cap, BIT5)) 2168 SET_FLAG(phtpriv->stbc_cap, STBC_HT_ENABLE_TX); 2169 } 2170 rtw_hal_get_def_var(padapter, HAL_DEF_RX_STBC, (u8 *)&bHwSTBCSupport); 2171 if (bHwSTBCSupport) { 2172 if (TEST_FLAG(pregistrypriv->stbc_cap, BIT4)) 2173 SET_FLAG(phtpriv->stbc_cap, STBC_HT_ENABLE_RX); 2174 } 2175 2176 /* Beamforming setting */ 2177 rtw_hal_get_def_var(padapter, HAL_DEF_EXPLICIT_BEAMFORMER, (u8 *)&bHwSupportBeamformer); 2178 rtw_hal_get_def_var(padapter, HAL_DEF_EXPLICIT_BEAMFORMEE, (u8 *)&bHwSupportBeamformee); 2179 CLEAR_FLAGS(phtpriv->beamform_cap); 2180 if (TEST_FLAG(pregistrypriv->beamform_cap, BIT4) && bHwSupportBeamformer) 2181 SET_FLAG(phtpriv->beamform_cap, BEAMFORMING_HT_BEAMFORMER_ENABLE); 2182 2183 if (TEST_FLAG(pregistrypriv->beamform_cap, BIT5) && bHwSupportBeamformee) 2184 SET_FLAG(phtpriv->beamform_cap, BEAMFORMING_HT_BEAMFORMEE_ENABLE); 2185 } 2186 rtw_build_wmm_ie_ht(struct adapter * padapter,u8 * out_ie,uint * pout_len)2187 void rtw_build_wmm_ie_ht(struct adapter *padapter, u8 *out_ie, uint *pout_len) 2188 { 2189 unsigned char WMM_IE[] = {0x00, 0x50, 0xf2, 0x02, 0x00, 0x01, 0x00}; 2190 int out_len; 2191 2192 if (padapter->mlmepriv.qospriv.qos_option == 0) { 2193 out_len = *pout_len; 2194 rtw_set_ie(out_ie+out_len, WLAN_EID_VENDOR_SPECIFIC, 2195 _WMM_IE_Length_, WMM_IE, pout_len); 2196 2197 padapter->mlmepriv.qospriv.qos_option = 1; 2198 } 2199 } 2200 2201 /* the function is >= passive_level */ rtw_restructure_ht_ie(struct adapter * padapter,u8 * in_ie,u8 * out_ie,uint in_len,uint * pout_len,u8 channel)2202 unsigned int rtw_restructure_ht_ie(struct adapter *padapter, u8 *in_ie, u8 *out_ie, uint in_len, uint *pout_len, u8 channel) 2203 { 2204 u32 ielen, out_len; 2205 enum ieee80211_max_ampdu_length_exp max_rx_ampdu_factor; 2206 unsigned char *p; 2207 struct ieee80211_ht_cap ht_capie; 2208 u8 cbw40_enable = 0, stbc_rx_enable = 0, operation_bw = 0; 2209 struct registry_priv *pregistrypriv = &padapter->registrypriv; 2210 struct mlme_priv *pmlmepriv = &padapter->mlmepriv; 2211 struct ht_priv *phtpriv = &pmlmepriv->htpriv; 2212 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv; 2213 2214 phtpriv->ht_option = false; 2215 2216 out_len = *pout_len; 2217 2218 memset(&ht_capie, 0, sizeof(struct ieee80211_ht_cap)); 2219 2220 ht_capie.cap_info = cpu_to_le16(IEEE80211_HT_CAP_DSSSCCK40); 2221 2222 if (phtpriv->sgi_20m) 2223 ht_capie.cap_info |= cpu_to_le16(IEEE80211_HT_CAP_SGI_20); 2224 2225 /* Get HT BW */ 2226 if (!in_ie) { 2227 /* TDLS: TODO 20/40 issue */ 2228 if (check_fwstate(pmlmepriv, WIFI_STATION_STATE)) { 2229 operation_bw = padapter->mlmeextpriv.cur_bwmode; 2230 if (operation_bw > CHANNEL_WIDTH_40) 2231 operation_bw = CHANNEL_WIDTH_40; 2232 } else 2233 /* TDLS: TODO 40? */ 2234 operation_bw = CHANNEL_WIDTH_40; 2235 } else { 2236 p = rtw_get_ie(in_ie, WLAN_EID_HT_OPERATION, &ielen, in_len); 2237 if (p && (ielen == sizeof(struct ieee80211_ht_addt_info))) { 2238 struct HT_info_element *pht_info = (struct HT_info_element *)(p+2); 2239 2240 if (pht_info->infos[0] & BIT(2)) { 2241 switch (pht_info->infos[0] & 0x3) { 2242 case 1: 2243 case 3: 2244 operation_bw = CHANNEL_WIDTH_40; 2245 break; 2246 default: 2247 operation_bw = CHANNEL_WIDTH_20; 2248 break; 2249 } 2250 } else { 2251 operation_bw = CHANNEL_WIDTH_20; 2252 } 2253 } 2254 } 2255 2256 /* to disable 40M Hz support while gd_bw_40MHz_en = 0 */ 2257 if (channel > 14) { 2258 if ((pregistrypriv->bw_mode & 0xf0) > 0) 2259 cbw40_enable = 1; 2260 } else { 2261 if ((pregistrypriv->bw_mode & 0x0f) > 0) 2262 cbw40_enable = 1; 2263 } 2264 2265 if ((cbw40_enable == 1) && (operation_bw == CHANNEL_WIDTH_40)) { 2266 ht_capie.cap_info |= cpu_to_le16(IEEE80211_HT_CAP_SUP_WIDTH); 2267 if (phtpriv->sgi_40m) 2268 ht_capie.cap_info |= cpu_to_le16(IEEE80211_HT_CAP_SGI_40); 2269 } 2270 2271 if (TEST_FLAG(phtpriv->stbc_cap, STBC_HT_ENABLE_TX)) 2272 ht_capie.cap_info |= cpu_to_le16(IEEE80211_HT_CAP_TX_STBC); 2273 2274 /* todo: disable SM power save mode */ 2275 ht_capie.cap_info |= cpu_to_le16(IEEE80211_HT_CAP_SM_PS); 2276 2277 if (TEST_FLAG(phtpriv->stbc_cap, STBC_HT_ENABLE_RX)) { 2278 if ((channel <= 14 && pregistrypriv->rx_stbc == 0x1) || /* enable for 2.4GHz */ 2279 (pregistrypriv->wifi_spec == 1)) 2280 stbc_rx_enable = 1; 2281 } 2282 2283 /* fill default supported_mcs_set */ 2284 memcpy(&ht_capie.mcs, pmlmeext->default_supported_mcs_set, 16); 2285 2286 /* update default supported_mcs_set */ 2287 if (stbc_rx_enable) 2288 ht_capie.cap_info |= cpu_to_le16(IEEE80211_HT_CAP_RX_STBC_1R);/* RX STBC One spatial stream */ 2289 2290 set_mcs_rate_by_mask(ht_capie.mcs.rx_mask, MCS_RATE_1R); 2291 2292 { 2293 u32 rx_packet_offset, max_recvbuf_sz; 2294 2295 rtw_hal_get_def_var(padapter, HAL_DEF_RX_PACKET_OFFSET, &rx_packet_offset); 2296 rtw_hal_get_def_var(padapter, HAL_DEF_MAX_RECVBUF_SZ, &max_recvbuf_sz); 2297 } 2298 2299 if (padapter->driver_rx_ampdu_factor != 0xFF) 2300 max_rx_ampdu_factor = 2301 (enum ieee80211_max_ampdu_length_exp)padapter->driver_rx_ampdu_factor; 2302 else 2303 rtw_hal_get_def_var(padapter, HW_VAR_MAX_RX_AMPDU_FACTOR, 2304 &max_rx_ampdu_factor); 2305 2306 ht_capie.ampdu_params_info = (max_rx_ampdu_factor&0x03); 2307 2308 if (padapter->securitypriv.dot11PrivacyAlgrthm == _AES_) 2309 ht_capie.ampdu_params_info |= (IEEE80211_HT_CAP_AMPDU_DENSITY&(0x07<<2)); 2310 else 2311 ht_capie.ampdu_params_info |= (IEEE80211_HT_CAP_AMPDU_DENSITY&0x00); 2312 2313 rtw_set_ie(out_ie+out_len, WLAN_EID_HT_CAPABILITY, 2314 sizeof(struct ieee80211_ht_cap), (unsigned char *)&ht_capie, pout_len); 2315 2316 phtpriv->ht_option = true; 2317 2318 if (in_ie) { 2319 p = rtw_get_ie(in_ie, WLAN_EID_HT_OPERATION, &ielen, in_len); 2320 if (p && (ielen == sizeof(struct ieee80211_ht_addt_info))) { 2321 out_len = *pout_len; 2322 rtw_set_ie(out_ie+out_len, WLAN_EID_HT_OPERATION, ielen, p+2, pout_len); 2323 } 2324 } 2325 2326 return phtpriv->ht_option; 2327 2328 } 2329 2330 /* the function is > passive_level (in critical_section) */ rtw_update_ht_cap(struct adapter * padapter,u8 * pie,uint ie_len,u8 channel)2331 void rtw_update_ht_cap(struct adapter *padapter, u8 *pie, uint ie_len, u8 channel) 2332 { 2333 u8 *p, max_ampdu_sz; 2334 int len; 2335 struct ieee80211_ht_cap *pht_capie; 2336 struct mlme_priv *pmlmepriv = &padapter->mlmepriv; 2337 struct ht_priv *phtpriv = &pmlmepriv->htpriv; 2338 struct registry_priv *pregistrypriv = &padapter->registrypriv; 2339 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv; 2340 struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info); 2341 u8 cbw40_enable = 0; 2342 2343 if (!phtpriv->ht_option) 2344 return; 2345 2346 if ((!pmlmeinfo->HT_info_enable) || (!pmlmeinfo->HT_caps_enable)) 2347 return; 2348 2349 /* maybe needs check if ap supports rx ampdu. */ 2350 if (!(phtpriv->ampdu_enable) && pregistrypriv->ampdu_enable == 1) 2351 phtpriv->ampdu_enable = true; 2352 2353 /* check Max Rx A-MPDU Size */ 2354 len = 0; 2355 p = rtw_get_ie(pie+sizeof(struct ndis_802_11_fix_ie), WLAN_EID_HT_CAPABILITY, &len, ie_len-sizeof(struct ndis_802_11_fix_ie)); 2356 if (p && len > 0) { 2357 pht_capie = (struct ieee80211_ht_cap *)(p+2); 2358 max_ampdu_sz = (pht_capie->ampdu_params_info & IEEE80211_HT_CAP_AMPDU_FACTOR); 2359 max_ampdu_sz = 1 << (max_ampdu_sz+3); /* max_ampdu_sz (kbytes); */ 2360 2361 phtpriv->rx_ampdu_maxlen = max_ampdu_sz; 2362 2363 } 2364 2365 len = 0; 2366 p = rtw_get_ie(pie+sizeof(struct ndis_802_11_fix_ie), WLAN_EID_HT_OPERATION, &len, ie_len-sizeof(struct ndis_802_11_fix_ie)); 2367 if (p && len > 0) { 2368 /* todo: */ 2369 } 2370 2371 if (channel > 14) { 2372 if ((pregistrypriv->bw_mode & 0xf0) > 0) 2373 cbw40_enable = 1; 2374 } else { 2375 if ((pregistrypriv->bw_mode & 0x0f) > 0) 2376 cbw40_enable = 1; 2377 } 2378 2379 /* update cur_bwmode & cur_ch_offset */ 2380 if ((cbw40_enable) && 2381 (le16_to_cpu(pmlmeinfo->HT_caps.u.HT_cap_element.HT_caps_info) & 2382 BIT(1)) && (pmlmeinfo->HT_info.infos[0] & BIT(2))) { 2383 int i; 2384 2385 /* update the MCS set */ 2386 for (i = 0; i < 16; i++) 2387 pmlmeinfo->HT_caps.u.HT_cap_element.MCS_rate[i] &= pmlmeext->default_supported_mcs_set[i]; 2388 2389 /* update the MCS rates */ 2390 set_mcs_rate_by_mask(pmlmeinfo->HT_caps.u.HT_cap_element.MCS_rate, MCS_RATE_1R); 2391 2392 /* switch to the 40M Hz mode according to the AP */ 2393 /* pmlmeext->cur_bwmode = CHANNEL_WIDTH_40; */ 2394 switch ((pmlmeinfo->HT_info.infos[0] & 0x3)) { 2395 case EXTCHNL_OFFSET_UPPER: 2396 pmlmeext->cur_ch_offset = HAL_PRIME_CHNL_OFFSET_LOWER; 2397 break; 2398 2399 case EXTCHNL_OFFSET_LOWER: 2400 pmlmeext->cur_ch_offset = HAL_PRIME_CHNL_OFFSET_UPPER; 2401 break; 2402 2403 default: 2404 pmlmeext->cur_ch_offset = HAL_PRIME_CHNL_OFFSET_DONT_CARE; 2405 break; 2406 } 2407 } 2408 2409 /* */ 2410 /* Config SM Power Save setting */ 2411 /* */ 2412 pmlmeinfo->SM_PS = 2413 (le16_to_cpu(pmlmeinfo->HT_caps.u.HT_cap_element.HT_caps_info) & 2414 0x0C) >> 2; 2415 2416 /* */ 2417 /* Config current HT Protection mode. */ 2418 /* */ 2419 pmlmeinfo->HT_protection = pmlmeinfo->HT_info.infos[1] & 0x3; 2420 } 2421 rtw_issue_addbareq_cmd(struct adapter * padapter,struct xmit_frame * pxmitframe)2422 void rtw_issue_addbareq_cmd(struct adapter *padapter, struct xmit_frame *pxmitframe) 2423 { 2424 u8 issued; 2425 int priority; 2426 struct sta_info *psta; 2427 struct ht_priv *phtpriv; 2428 struct pkt_attrib *pattrib = &pxmitframe->attrib; 2429 s32 bmcst = is_multicast_ether_addr(pattrib->ra); 2430 2431 /* if (bmcst || (padapter->mlmepriv.LinkDetectInfo.bTxBusyTraffic == false)) */ 2432 if (bmcst || (padapter->mlmepriv.LinkDetectInfo.NumTxOkInPeriod < 100)) 2433 return; 2434 2435 priority = pattrib->priority; 2436 2437 psta = rtw_get_stainfo(&padapter->stapriv, pattrib->ra); 2438 if (pattrib->psta != psta) 2439 return; 2440 2441 if (!psta) 2442 return; 2443 2444 if (!(psta->state & _FW_LINKED)) 2445 return; 2446 2447 phtpriv = &psta->htpriv; 2448 2449 if (phtpriv->ht_option && phtpriv->ampdu_enable) { 2450 issued = (phtpriv->agg_enable_bitmap>>priority)&0x1; 2451 issued |= (phtpriv->candidate_tid_bitmap>>priority)&0x1; 2452 2453 if (issued == 0) { 2454 psta->htpriv.candidate_tid_bitmap |= BIT((u8)priority); 2455 rtw_addbareq_cmd(padapter, (u8) priority, pattrib->ra); 2456 } 2457 } 2458 2459 } 2460 rtw_append_exented_cap(struct adapter * padapter,u8 * out_ie,uint * pout_len)2461 void rtw_append_exented_cap(struct adapter *padapter, u8 *out_ie, uint *pout_len) 2462 { 2463 struct mlme_priv *pmlmepriv = &padapter->mlmepriv; 2464 struct ht_priv *phtpriv = &pmlmepriv->htpriv; 2465 u8 cap_content[8] = {0}; 2466 2467 if (phtpriv->bss_coexist) 2468 SET_EXT_CAPABILITY_ELE_BSS_COEXIST(cap_content, 1); 2469 2470 rtw_set_ie(out_ie + *pout_len, WLAN_EID_EXT_CAPABILITY, 8, cap_content, pout_len); 2471 } 2472 rtw_set_to_roam(struct adapter * adapter,u8 to_roam)2473 inline void rtw_set_to_roam(struct adapter *adapter, u8 to_roam) 2474 { 2475 if (to_roam == 0) 2476 adapter->mlmepriv.to_join = false; 2477 adapter->mlmepriv.to_roam = to_roam; 2478 } 2479 rtw_dec_to_roam(struct adapter * adapter)2480 inline u8 rtw_dec_to_roam(struct adapter *adapter) 2481 { 2482 adapter->mlmepriv.to_roam--; 2483 return adapter->mlmepriv.to_roam; 2484 } 2485 rtw_to_roam(struct adapter * adapter)2486 inline u8 rtw_to_roam(struct adapter *adapter) 2487 { 2488 return adapter->mlmepriv.to_roam; 2489 } 2490 rtw_roaming(struct adapter * padapter,struct wlan_network * tgt_network)2491 void rtw_roaming(struct adapter *padapter, struct wlan_network *tgt_network) 2492 { 2493 struct mlme_priv *pmlmepriv = &padapter->mlmepriv; 2494 2495 spin_lock_bh(&pmlmepriv->lock); 2496 _rtw_roaming(padapter, tgt_network); 2497 spin_unlock_bh(&pmlmepriv->lock); 2498 } _rtw_roaming(struct adapter * padapter,struct wlan_network * tgt_network)2499 void _rtw_roaming(struct adapter *padapter, struct wlan_network *tgt_network) 2500 { 2501 struct mlme_priv *pmlmepriv = &padapter->mlmepriv; 2502 struct wlan_network *cur_network = &pmlmepriv->cur_network; 2503 2504 if (rtw_to_roam(padapter) > 0) { 2505 memcpy(&pmlmepriv->assoc_ssid, &cur_network->network.ssid, sizeof(struct ndis_802_11_ssid)); 2506 2507 pmlmepriv->assoc_by_bssid = false; 2508 2509 while (rtw_do_join(padapter) != _SUCCESS) { 2510 rtw_dec_to_roam(padapter); 2511 if (rtw_to_roam(padapter) <= 0) { 2512 rtw_indicate_disconnect(padapter); 2513 break; 2514 } 2515 } 2516 } 2517 } 2518 rtw_linked_check(struct adapter * padapter)2519 signed int rtw_linked_check(struct adapter *padapter) 2520 { 2521 if ((check_fwstate(&padapter->mlmepriv, WIFI_AP_STATE) == true) || 2522 (check_fwstate(&padapter->mlmepriv, WIFI_ADHOC_STATE|WIFI_ADHOC_MASTER_STATE) == true)) { 2523 if (padapter->stapriv.asoc_sta_count > 2) 2524 return true; 2525 } else { /* Station mode */ 2526 if (check_fwstate(&padapter->mlmepriv, _FW_LINKED) == true) 2527 return true; 2528 } 2529 return false; 2530 } 2531