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