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: pasive. 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 del_timer_sync(&pmlmepriv->scan_to_timer); 755 _clr_fwstate_(pmlmepriv, _FW_UNDER_SURVEY); 756 } 757 758 rtw_set_signal_stat_timer(&adapter->recvpriv); 759 760 if (pmlmepriv->to_join) { 761 if ((check_fwstate(pmlmepriv, WIFI_ADHOC_STATE) == true)) { 762 if (check_fwstate(pmlmepriv, _FW_LINKED) == false) { 763 set_fwstate(pmlmepriv, _FW_UNDER_LINKING); 764 765 if (rtw_select_and_join_from_scanned_queue(pmlmepriv) == _SUCCESS) { 766 _set_timer(&pmlmepriv->assoc_timer, MAX_JOIN_TIMEOUT); 767 } else { 768 u8 ret = _SUCCESS; 769 struct wlan_bssid_ex *pdev_network = &(adapter->registrypriv.dev_network); 770 u8 *pibss = adapter->registrypriv.dev_network.mac_address; 771 772 /* pmlmepriv->fw_state ^= _FW_UNDER_SURVEY;because don't set assoc_timer */ 773 _clr_fwstate_(pmlmepriv, _FW_UNDER_SURVEY); 774 775 memcpy(&pdev_network->ssid, &pmlmepriv->assoc_ssid, sizeof(struct ndis_802_11_ssid)); 776 777 rtw_update_registrypriv_dev_network(adapter); 778 rtw_generate_random_ibss(pibss); 779 780 pmlmepriv->fw_state = WIFI_ADHOC_MASTER_STATE; 781 782 pmlmepriv->to_join = false; 783 784 ret = rtw_createbss_cmd(adapter); 785 if (ret != _SUCCESS) 786 goto unlock; 787 } 788 } 789 } else { 790 int s_ret; 791 792 set_fwstate(pmlmepriv, _FW_UNDER_LINKING); 793 pmlmepriv->to_join = false; 794 s_ret = rtw_select_and_join_from_scanned_queue(pmlmepriv); 795 if (_SUCCESS == s_ret) { 796 _set_timer(&pmlmepriv->assoc_timer, MAX_JOIN_TIMEOUT); 797 } else if (s_ret == 2) {/* there is no need to wait for join */ 798 _clr_fwstate_(pmlmepriv, _FW_UNDER_LINKING); 799 rtw_indicate_connect(adapter); 800 } else { 801 if (rtw_to_roam(adapter) != 0) { 802 if (rtw_dec_to_roam(adapter) == 0 803 || _SUCCESS != rtw_sitesurvey_cmd(adapter, &pmlmepriv->assoc_ssid, 1, NULL, 0) 804 ) { 805 rtw_set_to_roam(adapter, 0); 806 rtw_free_assoc_resources(adapter, 1); 807 rtw_indicate_disconnect(adapter); 808 } else { 809 pmlmepriv->to_join = true; 810 } 811 } else 812 rtw_indicate_disconnect(adapter); 813 814 _clr_fwstate_(pmlmepriv, _FW_UNDER_LINKING); 815 } 816 } 817 } else { 818 if (rtw_chk_roam_flags(adapter, RTW_ROAM_ACTIVE)) { 819 if (check_fwstate(pmlmepriv, WIFI_STATION_STATE) 820 && check_fwstate(pmlmepriv, _FW_LINKED)) { 821 if (rtw_select_roaming_candidate(pmlmepriv) == _SUCCESS) { 822 receive_disconnect(adapter, pmlmepriv->cur_network.network.mac_address 823 , WLAN_REASON_ACTIVE_ROAM); 824 } 825 } 826 } 827 } 828 829 unlock: 830 spin_unlock_bh(&pmlmepriv->lock); 831 832 rtw_os_xmit_schedule(adapter); 833 834 rtw_cfg80211_surveydone_event_callback(adapter); 835 836 rtw_indicate_scan_done(adapter, false); 837 } 838 839 void rtw_dummy_event_callback(struct adapter *adapter, u8 *pbuf) 840 { 841 } 842 843 void rtw_fwdbg_event_callback(struct adapter *adapter, u8 *pbuf) 844 { 845 } 846 847 static void free_scanqueue(struct mlme_priv *pmlmepriv) 848 { 849 struct __queue *free_queue = &pmlmepriv->free_bss_pool; 850 struct __queue *scan_queue = &pmlmepriv->scanned_queue; 851 struct list_head *plist, *phead, *ptemp; 852 853 spin_lock_bh(&scan_queue->lock); 854 spin_lock_bh(&free_queue->lock); 855 856 phead = get_list_head(scan_queue); 857 plist = get_next(phead); 858 859 while (plist != phead) { 860 ptemp = get_next(plist); 861 list_del_init(plist); 862 list_add_tail(plist, &free_queue->queue); 863 plist = ptemp; 864 pmlmepriv->num_of_scanned--; 865 } 866 867 spin_unlock_bh(&free_queue->lock); 868 spin_unlock_bh(&scan_queue->lock); 869 } 870 871 static void rtw_reset_rx_info(struct debug_priv *pdbgpriv) 872 { 873 pdbgpriv->dbg_rx_ampdu_drop_count = 0; 874 pdbgpriv->dbg_rx_ampdu_forced_indicate_count = 0; 875 pdbgpriv->dbg_rx_ampdu_loss_count = 0; 876 pdbgpriv->dbg_rx_dup_mgt_frame_drop_count = 0; 877 pdbgpriv->dbg_rx_ampdu_window_shift_cnt = 0; 878 } 879 880 static void find_network(struct adapter *adapter) 881 { 882 struct wlan_network *pwlan = NULL; 883 struct mlme_priv *pmlmepriv = &adapter->mlmepriv; 884 struct wlan_network *tgt_network = &pmlmepriv->cur_network; 885 886 pwlan = rtw_find_network(&pmlmepriv->scanned_queue, tgt_network->network.mac_address); 887 if (pwlan) 888 pwlan->fixed = false; 889 890 if (check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE) && 891 (adapter->stapriv.asoc_sta_count == 1)) 892 rtw_free_network_nolock(adapter, pwlan); 893 } 894 895 /* 896 *rtw_free_assoc_resources: the caller has to lock pmlmepriv->lock 897 */ 898 void rtw_free_assoc_resources(struct adapter *adapter, int lock_scanned_queue) 899 { 900 struct mlme_priv *pmlmepriv = &adapter->mlmepriv; 901 struct wlan_network *tgt_network = &pmlmepriv->cur_network; 902 struct dvobj_priv *psdpriv = adapter->dvobj; 903 struct debug_priv *pdbgpriv = &psdpriv->drv_dbg; 904 905 if (check_fwstate(pmlmepriv, WIFI_STATION_STATE|WIFI_AP_STATE)) { 906 struct sta_info *psta; 907 908 psta = rtw_get_stainfo(&adapter->stapriv, tgt_network->network.mac_address); 909 rtw_free_stainfo(adapter, psta); 910 } 911 912 if (check_fwstate(pmlmepriv, WIFI_ADHOC_STATE|WIFI_ADHOC_MASTER_STATE|WIFI_AP_STATE)) { 913 struct sta_info *psta; 914 915 rtw_free_all_stainfo(adapter); 916 917 psta = rtw_get_bcmc_stainfo(adapter); 918 rtw_free_stainfo(adapter, psta); 919 920 rtw_init_bcmc_stainfo(adapter); 921 } 922 923 find_network(adapter); 924 925 if (lock_scanned_queue) 926 adapter->securitypriv.key_mask = 0; 927 928 rtw_reset_rx_info(pdbgpriv); 929 } 930 931 /* 932 *rtw_indicate_connect: the caller has to lock pmlmepriv->lock 933 */ 934 void rtw_indicate_connect(struct adapter *padapter) 935 { 936 struct mlme_priv *pmlmepriv = &padapter->mlmepriv; 937 938 pmlmepriv->to_join = false; 939 940 if (!check_fwstate(&padapter->mlmepriv, _FW_LINKED)) { 941 942 set_fwstate(pmlmepriv, _FW_LINKED); 943 944 rtw_os_indicate_connect(padapter); 945 } 946 947 rtw_set_to_roam(padapter, 0); 948 rtw_set_scan_deny(padapter, 3000); 949 950 } 951 952 /* 953 *rtw_indicate_disconnect: the caller has to lock pmlmepriv->lock 954 */ 955 void rtw_indicate_disconnect(struct adapter *padapter) 956 { 957 struct mlme_priv *pmlmepriv = &padapter->mlmepriv; 958 959 _clr_fwstate_(pmlmepriv, _FW_UNDER_LINKING|WIFI_UNDER_WPS); 960 961 if (rtw_to_roam(padapter) > 0) 962 _clr_fwstate_(pmlmepriv, _FW_LINKED); 963 964 if (check_fwstate(&padapter->mlmepriv, _FW_LINKED) 965 || (rtw_to_roam(padapter) <= 0) 966 ) { 967 rtw_os_indicate_disconnect(padapter); 968 969 /* set ips_deny_time to avoid enter IPS before LPS leave */ 970 rtw_set_ips_deny(padapter, 3000); 971 972 _clr_fwstate_(pmlmepriv, _FW_LINKED); 973 974 rtw_clear_scan_deny(padapter); 975 } 976 977 rtw_lps_ctrl_wk_cmd(padapter, LPS_CTRL_DISCONNECT, 1); 978 } 979 980 inline void rtw_indicate_scan_done(struct adapter *padapter, bool aborted) 981 { 982 rtw_os_indicate_scan_done(padapter, aborted); 983 984 if (is_primary_adapter(padapter) && 985 (!adapter_to_pwrctl(padapter)->bInSuspend) && 986 (!check_fwstate(&padapter->mlmepriv, 987 WIFI_ASOC_STATE|WIFI_UNDER_LINKING))) { 988 rtw_set_ips_deny(padapter, 0); 989 _set_timer(&padapter->mlmepriv.dynamic_chk_timer, 1); 990 } 991 } 992 993 void rtw_scan_abort(struct adapter *adapter) 994 { 995 unsigned long start; 996 struct mlme_priv *pmlmepriv = &(adapter->mlmepriv); 997 struct mlme_ext_priv *pmlmeext = &(adapter->mlmeextpriv); 998 999 start = jiffies; 1000 pmlmeext->scan_abort = true; 1001 while (check_fwstate(pmlmepriv, _FW_UNDER_SURVEY) 1002 && jiffies_to_msecs(start) <= 200) { 1003 1004 if (adapter->bDriverStopped || adapter->bSurpriseRemoved) 1005 break; 1006 1007 msleep(20); 1008 } 1009 1010 if (check_fwstate(pmlmepriv, _FW_UNDER_SURVEY)) 1011 rtw_indicate_scan_done(adapter, true); 1012 1013 pmlmeext->scan_abort = false; 1014 } 1015 1016 static struct sta_info *rtw_joinbss_update_stainfo(struct adapter *padapter, struct wlan_network *pnetwork) 1017 { 1018 int i; 1019 struct sta_info *bmc_sta, *psta = NULL; 1020 struct recv_reorder_ctrl *preorder_ctrl; 1021 struct sta_priv *pstapriv = &padapter->stapriv; 1022 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv; 1023 1024 psta = rtw_get_stainfo(pstapriv, pnetwork->network.mac_address); 1025 if (!psta) 1026 psta = rtw_alloc_stainfo(pstapriv, pnetwork->network.mac_address); 1027 1028 if (psta) { /* update ptarget_sta */ 1029 1030 psta->aid = pnetwork->join_res; 1031 1032 update_sta_info(padapter, psta); 1033 1034 /* update station supportRate */ 1035 psta->bssratelen = rtw_get_rateset_len(pnetwork->network.supported_rates); 1036 memcpy(psta->bssrateset, pnetwork->network.supported_rates, psta->bssratelen); 1037 rtw_hal_update_sta_rate_mask(padapter, psta); 1038 1039 psta->wireless_mode = pmlmeext->cur_wireless_mode; 1040 psta->raid = networktype_to_raid_ex(padapter, psta); 1041 1042 /* sta mode */ 1043 rtw_hal_set_odm_var(padapter, HAL_ODM_STA_INFO, psta, true); 1044 1045 /* security related */ 1046 if (padapter->securitypriv.dot11AuthAlgrthm == dot11AuthAlgrthm_8021X) { 1047 padapter->securitypriv.binstallGrpkey = false; 1048 padapter->securitypriv.busetkipkey = false; 1049 padapter->securitypriv.bgrpkey_handshake = false; 1050 1051 psta->ieee8021x_blocked = true; 1052 psta->dot118021XPrivacy = padapter->securitypriv.dot11PrivacyAlgrthm; 1053 1054 memset((u8 *)&psta->dot118021x_UncstKey, 0, sizeof(union Keytype)); 1055 1056 memset((u8 *)&psta->dot11tkiprxmickey, 0, sizeof(union Keytype)); 1057 memset((u8 *)&psta->dot11tkiptxmickey, 0, sizeof(union Keytype)); 1058 1059 memset((u8 *)&psta->dot11txpn, 0, sizeof(union pn48)); 1060 psta->dot11txpn.val = psta->dot11txpn.val + 1; 1061 memset((u8 *)&psta->dot11wtxpn, 0, sizeof(union pn48)); 1062 memset((u8 *)&psta->dot11rxpn, 0, sizeof(union pn48)); 1063 } 1064 1065 /* Commented by Albert 2012/07/21 */ 1066 /* When doing the WPS, the wps_ie_len won't equal to 0 */ 1067 /* And the Wi-Fi driver shouldn't allow the data packet to be transmitted. */ 1068 if (padapter->securitypriv.wps_ie_len != 0) { 1069 psta->ieee8021x_blocked = true; 1070 padapter->securitypriv.wps_ie_len = 0; 1071 } 1072 1073 /* for A-MPDU Rx reordering buffer control for bmc_sta & sta_info */ 1074 /* if A-MPDU Rx is enabled, resetting rx_ordering_ctrl wstart_b(indicate_seq) to default value = 0xffff */ 1075 /* todo: check if AP can send A-MPDU packets */ 1076 for (i = 0; i < 16 ; i++) { 1077 /* preorder_ctrl = &precvpriv->recvreorder_ctrl[i]; */ 1078 preorder_ctrl = &psta->recvreorder_ctrl[i]; 1079 preorder_ctrl->enable = false; 1080 preorder_ctrl->indicate_seq = 0xffff; 1081 preorder_ctrl->wend_b = 0xffff; 1082 preorder_ctrl->wsize_b = 64;/* max_ampdu_sz;ex. 32(kbytes) -> wsize_b =32 */ 1083 } 1084 1085 bmc_sta = rtw_get_bcmc_stainfo(padapter); 1086 if (bmc_sta) { 1087 for (i = 0; i < 16 ; i++) { 1088 /* preorder_ctrl = &precvpriv->recvreorder_ctrl[i]; */ 1089 preorder_ctrl = &bmc_sta->recvreorder_ctrl[i]; 1090 preorder_ctrl->enable = false; 1091 preorder_ctrl->indicate_seq = 0xffff; 1092 preorder_ctrl->wend_b = 0xffff; 1093 preorder_ctrl->wsize_b = 64;/* max_ampdu_sz;ex. 32(kbytes) -> wsize_b =32 */ 1094 } 1095 } 1096 } 1097 1098 return psta; 1099 1100 } 1101 1102 /* pnetwork : returns from rtw_joinbss_event_callback */ 1103 /* ptarget_wlan: found from scanned_queue */ 1104 static void rtw_joinbss_update_network(struct adapter *padapter, struct wlan_network *ptarget_wlan, struct wlan_network *pnetwork) 1105 { 1106 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv); 1107 struct wlan_network *cur_network = &(pmlmepriv->cur_network); 1108 1109 /* why not use ptarget_wlan?? */ 1110 memcpy(&cur_network->network, &pnetwork->network, pnetwork->network.length); 1111 /* some ies in pnetwork is wrong, so we should use ptarget_wlan ies */ 1112 cur_network->network.ie_length = ptarget_wlan->network.ie_length; 1113 memcpy(&cur_network->network.ies[0], &ptarget_wlan->network.ies[0], MAX_IE_SZ); 1114 1115 cur_network->aid = pnetwork->join_res; 1116 1117 rtw_set_signal_stat_timer(&padapter->recvpriv); 1118 1119 padapter->recvpriv.signal_strength = ptarget_wlan->network.phy_info.signal_strength; 1120 padapter->recvpriv.signal_qual = ptarget_wlan->network.phy_info.signal_quality; 1121 /* the ptarget_wlan->network.rssi is raw data, we use ptarget_wlan->network.phy_info.signal_strength instead (has scaled) */ 1122 padapter->recvpriv.rssi = translate_percentage_to_dbm(ptarget_wlan->network.phy_info.signal_strength); 1123 1124 rtw_set_signal_stat_timer(&padapter->recvpriv); 1125 1126 /* update fw_state will clr _FW_UNDER_LINKING here indirectly */ 1127 switch (pnetwork->network.infrastructure_mode) { 1128 case Ndis802_11Infrastructure: 1129 1130 if (pmlmepriv->fw_state&WIFI_UNDER_WPS) 1131 pmlmepriv->fw_state = WIFI_STATION_STATE|WIFI_UNDER_WPS; 1132 else 1133 pmlmepriv->fw_state = WIFI_STATION_STATE; 1134 1135 break; 1136 case Ndis802_11IBSS: 1137 pmlmepriv->fw_state = WIFI_ADHOC_STATE; 1138 break; 1139 default: 1140 pmlmepriv->fw_state = WIFI_NULL_STATE; 1141 break; 1142 } 1143 1144 rtw_update_protection(padapter, (cur_network->network.ies) + sizeof(struct ndis_802_11_fix_ie), 1145 (cur_network->network.ie_length)); 1146 1147 rtw_update_ht_cap(padapter, cur_network->network.ies, cur_network->network.ie_length, (u8) cur_network->network.configuration.ds_config); 1148 } 1149 1150 /* Notes: the function could be > passive_level (the same context as Rx tasklet) */ 1151 /* pnetwork : returns from rtw_joinbss_event_callback */ 1152 /* ptarget_wlan: found from scanned_queue */ 1153 /* if join_res > 0, for (fw_state ==WIFI_STATION_STATE), we check if "ptarget_sta" & "ptarget_wlan" exist. */ 1154 /* if join_res > 0, for (fw_state ==WIFI_ADHOC_STATE), we only check if "ptarget_wlan" exist. */ 1155 /* if join_res > 0, update "cur_network->network" from "pnetwork->network" if (ptarget_wlan != NULL). */ 1156 /* */ 1157 /* define REJOIN */ 1158 void rtw_joinbss_event_prehandle(struct adapter *adapter, u8 *pbuf) 1159 { 1160 static u8 __maybe_unused retry; 1161 struct sta_info *ptarget_sta = NULL, *pcur_sta = NULL; 1162 struct sta_priv *pstapriv = &adapter->stapriv; 1163 struct mlme_priv *pmlmepriv = &(adapter->mlmepriv); 1164 struct wlan_network *pnetwork = (struct wlan_network *)pbuf; 1165 struct wlan_network *cur_network = &(pmlmepriv->cur_network); 1166 struct wlan_network *pcur_wlan = NULL, *ptarget_wlan = NULL; 1167 unsigned int the_same_macaddr = false; 1168 1169 rtw_get_encrypt_decrypt_from_registrypriv(adapter); 1170 1171 the_same_macaddr = !memcmp(pnetwork->network.mac_address, cur_network->network.mac_address, ETH_ALEN); 1172 1173 pnetwork->network.length = get_wlan_bssid_ex_sz(&pnetwork->network); 1174 if (pnetwork->network.length > sizeof(struct wlan_bssid_ex)) 1175 return; 1176 1177 spin_lock_bh(&pmlmepriv->lock); 1178 1179 pmlmepriv->LinkDetectInfo.TrafficTransitionCount = 0; 1180 pmlmepriv->LinkDetectInfo.LowPowerTransitionCount = 0; 1181 1182 if (pnetwork->join_res > 0) { 1183 spin_lock_bh(&(pmlmepriv->scanned_queue.lock)); 1184 retry = 0; 1185 if (check_fwstate(pmlmepriv, _FW_UNDER_LINKING)) { 1186 /* s1. find ptarget_wlan */ 1187 if (check_fwstate(pmlmepriv, _FW_LINKED)) { 1188 if (the_same_macaddr) { 1189 ptarget_wlan = rtw_find_network(&pmlmepriv->scanned_queue, cur_network->network.mac_address); 1190 } else { 1191 pcur_wlan = rtw_find_network(&pmlmepriv->scanned_queue, cur_network->network.mac_address); 1192 if (pcur_wlan) 1193 pcur_wlan->fixed = false; 1194 1195 pcur_sta = rtw_get_stainfo(pstapriv, cur_network->network.mac_address); 1196 if (pcur_sta) 1197 rtw_free_stainfo(adapter, pcur_sta); 1198 1199 ptarget_wlan = rtw_find_network(&pmlmepriv->scanned_queue, pnetwork->network.mac_address); 1200 if (check_fwstate(pmlmepriv, WIFI_STATION_STATE) == true) { 1201 if (ptarget_wlan) 1202 ptarget_wlan->fixed = true; 1203 } 1204 } 1205 1206 } else { 1207 ptarget_wlan = _rtw_find_same_network(&pmlmepriv->scanned_queue, pnetwork); 1208 if (check_fwstate(pmlmepriv, WIFI_STATION_STATE) == true) { 1209 if (ptarget_wlan) 1210 ptarget_wlan->fixed = true; 1211 } 1212 } 1213 1214 /* s2. update cur_network */ 1215 if (ptarget_wlan) { 1216 rtw_joinbss_update_network(adapter, ptarget_wlan, pnetwork); 1217 } else { 1218 netdev_dbg(adapter->pnetdev, 1219 "Can't find ptarget_wlan when joinbss_event callback\n"); 1220 spin_unlock_bh(&(pmlmepriv->scanned_queue.lock)); 1221 goto ignore_joinbss_callback; 1222 } 1223 1224 /* s3. find ptarget_sta & update ptarget_sta after update cur_network only for station mode */ 1225 if (check_fwstate(pmlmepriv, WIFI_STATION_STATE) == true) { 1226 ptarget_sta = rtw_joinbss_update_stainfo(adapter, pnetwork); 1227 if (!ptarget_sta) { 1228 spin_unlock_bh(&(pmlmepriv->scanned_queue.lock)); 1229 goto ignore_joinbss_callback; 1230 } 1231 } 1232 1233 /* s4. indicate connect */ 1234 if (check_fwstate(pmlmepriv, WIFI_STATION_STATE) == true) { 1235 pmlmepriv->cur_network_scanned = ptarget_wlan; 1236 rtw_indicate_connect(adapter); 1237 } 1238 1239 spin_unlock_bh(&pmlmepriv->scanned_queue.lock); 1240 1241 /* s5. Cancel assoc_timer */ 1242 del_timer_sync(&pmlmepriv->assoc_timer); 1243 } else { 1244 spin_unlock_bh(&(pmlmepriv->scanned_queue.lock)); 1245 } 1246 } else if (pnetwork->join_res == -4) { 1247 rtw_reset_securitypriv(adapter); 1248 _set_timer(&pmlmepriv->assoc_timer, 1); 1249 1250 /* rtw_free_assoc_resources(adapter, 1); */ 1251 1252 if ((check_fwstate(pmlmepriv, _FW_UNDER_LINKING)) == true) 1253 _clr_fwstate_(pmlmepriv, _FW_UNDER_LINKING); 1254 1255 } else {/* if join_res < 0 (join fails), then try again */ 1256 1257 #ifdef REJOIN 1258 res = _FAIL; 1259 if (retry < 2) 1260 res = rtw_select_and_join_from_scanned_queue(pmlmepriv); 1261 1262 if (res == _SUCCESS) { 1263 /* extend time of assoc_timer */ 1264 _set_timer(&pmlmepriv->assoc_timer, MAX_JOIN_TIMEOUT); 1265 retry++; 1266 } else if (res == 2) {/* there is no need to wait for join */ 1267 _clr_fwstate_(pmlmepriv, _FW_UNDER_LINKING); 1268 rtw_indicate_connect(adapter); 1269 } else { 1270 #endif 1271 1272 _set_timer(&pmlmepriv->assoc_timer, 1); 1273 /* rtw_free_assoc_resources(adapter, 1); */ 1274 _clr_fwstate_(pmlmepriv, _FW_UNDER_LINKING); 1275 1276 #ifdef REJOIN 1277 retry = 0; 1278 } 1279 #endif 1280 } 1281 1282 ignore_joinbss_callback: 1283 1284 spin_unlock_bh(&pmlmepriv->lock); 1285 } 1286 1287 void rtw_joinbss_event_callback(struct adapter *adapter, u8 *pbuf) 1288 { 1289 struct wlan_network *pnetwork = (struct wlan_network *)pbuf; 1290 1291 mlmeext_joinbss_event_callback(adapter, pnetwork->join_res); 1292 1293 rtw_os_xmit_schedule(adapter); 1294 } 1295 1296 /* FOR STA, AP , AD-HOC mode */ 1297 void rtw_sta_media_status_rpt(struct adapter *adapter, struct sta_info *psta, u32 mstatus) 1298 { 1299 u16 media_status_rpt; 1300 1301 if (!psta) 1302 return; 1303 1304 media_status_rpt = (u16)((psta->mac_id<<8)|mstatus); /* MACID|OPMODE:1 connect */ 1305 rtw_hal_set_hwreg(adapter, HW_VAR_H2C_MEDIA_STATUS_RPT, (u8 *)&media_status_rpt); 1306 } 1307 1308 void rtw_stassoc_event_callback(struct adapter *adapter, u8 *pbuf) 1309 { 1310 struct sta_info *psta; 1311 struct mlme_priv *pmlmepriv = &(adapter->mlmepriv); 1312 struct stassoc_event *pstassoc = (struct stassoc_event *)pbuf; 1313 struct wlan_network *cur_network = &(pmlmepriv->cur_network); 1314 struct wlan_network *ptarget_wlan = NULL; 1315 1316 if (rtw_access_ctrl(adapter, pstassoc->macaddr) == false) 1317 return; 1318 1319 if (check_fwstate(pmlmepriv, WIFI_AP_STATE)) { 1320 psta = rtw_get_stainfo(&adapter->stapriv, pstassoc->macaddr); 1321 if (psta) { 1322 u8 *passoc_req = NULL; 1323 u32 assoc_req_len = 0; 1324 1325 rtw_sta_media_status_rpt(adapter, psta, 1); 1326 1327 ap_sta_info_defer_update(adapter, psta); 1328 1329 /* report to upper layer */ 1330 spin_lock_bh(&psta->lock); 1331 if (psta->passoc_req && psta->assoc_req_len > 0) { 1332 passoc_req = rtw_zmalloc(psta->assoc_req_len); 1333 if (passoc_req) { 1334 assoc_req_len = psta->assoc_req_len; 1335 memcpy(passoc_req, psta->passoc_req, assoc_req_len); 1336 1337 kfree(psta->passoc_req); 1338 psta->passoc_req = NULL; 1339 psta->assoc_req_len = 0; 1340 } 1341 } 1342 spin_unlock_bh(&psta->lock); 1343 1344 if (passoc_req && assoc_req_len > 0) { 1345 rtw_cfg80211_indicate_sta_assoc(adapter, passoc_req, assoc_req_len); 1346 1347 kfree(passoc_req); 1348 } 1349 } 1350 return; 1351 } 1352 1353 /* for AD-HOC mode */ 1354 psta = rtw_get_stainfo(&adapter->stapriv, pstassoc->macaddr); 1355 if (psta) { 1356 /* the sta have been in sta_info_queue => do nothing */ 1357 1358 return; /* between drv has received this event before and fw have not yet to set key to CAM_ENTRY) */ 1359 } 1360 1361 psta = rtw_alloc_stainfo(&adapter->stapriv, pstassoc->macaddr); 1362 if (!psta) 1363 return; 1364 1365 /* to do : init sta_info variable */ 1366 psta->qos_option = 0; 1367 psta->mac_id = (uint)pstassoc->cam_id; 1368 /* psta->aid = (uint)pstassoc->cam_id; */ 1369 1370 /* for ad-hoc mode */ 1371 rtw_hal_set_odm_var(adapter, HAL_ODM_STA_INFO, psta, true); 1372 1373 rtw_sta_media_status_rpt(adapter, psta, 1); 1374 1375 if (adapter->securitypriv.dot11AuthAlgrthm == dot11AuthAlgrthm_8021X) 1376 psta->dot118021XPrivacy = adapter->securitypriv.dot11PrivacyAlgrthm; 1377 1378 psta->ieee8021x_blocked = false; 1379 1380 spin_lock_bh(&pmlmepriv->lock); 1381 1382 if ((check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE) == true) || 1383 (check_fwstate(pmlmepriv, WIFI_ADHOC_STATE) == true)) { 1384 if (adapter->stapriv.asoc_sta_count == 2) { 1385 spin_lock_bh(&(pmlmepriv->scanned_queue.lock)); 1386 ptarget_wlan = rtw_find_network(&pmlmepriv->scanned_queue, cur_network->network.mac_address); 1387 pmlmepriv->cur_network_scanned = ptarget_wlan; 1388 if (ptarget_wlan) 1389 ptarget_wlan->fixed = true; 1390 spin_unlock_bh(&(pmlmepriv->scanned_queue.lock)); 1391 /* a sta + bc/mc_stainfo (not Ibss_stainfo) */ 1392 rtw_indicate_connect(adapter); 1393 } 1394 } 1395 1396 spin_unlock_bh(&pmlmepriv->lock); 1397 1398 mlmeext_sta_add_event_callback(adapter, psta); 1399 } 1400 1401 void rtw_stadel_event_callback(struct adapter *adapter, u8 *pbuf) 1402 { 1403 int mac_id = (-1); 1404 struct sta_info *psta; 1405 struct wlan_network *pwlan = NULL; 1406 struct wlan_bssid_ex *pdev_network = NULL; 1407 u8 *pibss = NULL; 1408 struct mlme_priv *pmlmepriv = &(adapter->mlmepriv); 1409 struct stadel_event *pstadel = (struct stadel_event *)pbuf; 1410 struct wlan_network *tgt_network = &(pmlmepriv->cur_network); 1411 struct mlme_ext_priv *pmlmeext = &adapter->mlmeextpriv; 1412 struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info); 1413 1414 psta = rtw_get_stainfo(&adapter->stapriv, pstadel->macaddr); 1415 if (psta) 1416 mac_id = psta->mac_id; 1417 else 1418 mac_id = pstadel->mac_id; 1419 1420 if (mac_id >= 0) { 1421 u16 media_status; 1422 1423 media_status = (mac_id<<8)|0; /* MACID|OPMODE:0 means disconnect */ 1424 /* for STA, AP, ADHOC mode, report disconnect stauts to FW */ 1425 rtw_hal_set_hwreg(adapter, HW_VAR_H2C_MEDIA_STATUS_RPT, (u8 *)&media_status); 1426 } 1427 1428 /* if (check_fwstate(pmlmepriv, WIFI_AP_STATE)) */ 1429 if ((pmlmeinfo->state&0x03) == WIFI_FW_AP_STATE) 1430 return; 1431 1432 mlmeext_sta_del_event_callback(adapter); 1433 1434 spin_lock_bh(&pmlmepriv->lock); 1435 1436 if (check_fwstate(pmlmepriv, WIFI_STATION_STATE)) { 1437 u16 reason = *((unsigned short *)(pstadel->rsvd)); 1438 bool roam = false; 1439 struct wlan_network *roam_target = NULL; 1440 1441 if (adapter->registrypriv.wifi_spec == 1) { 1442 roam = false; 1443 } else if (reason == WLAN_REASON_EXPIRATION_CHK && rtw_chk_roam_flags(adapter, RTW_ROAM_ON_EXPIRED)) { 1444 roam = true; 1445 } else if (reason == WLAN_REASON_ACTIVE_ROAM && rtw_chk_roam_flags(adapter, RTW_ROAM_ACTIVE)) { 1446 roam = true; 1447 roam_target = pmlmepriv->roam_network; 1448 } 1449 1450 if (roam) { 1451 if (rtw_to_roam(adapter) > 0) 1452 rtw_dec_to_roam(adapter); /* this stadel_event is caused by roaming, decrease to_roam */ 1453 else if (rtw_to_roam(adapter) == 0) 1454 rtw_set_to_roam(adapter, adapter->registrypriv.max_roaming_times); 1455 } else { 1456 rtw_set_to_roam(adapter, 0); 1457 } 1458 1459 rtw_free_uc_swdec_pending_queue(adapter); 1460 1461 rtw_free_assoc_resources(adapter, 1); 1462 rtw_indicate_disconnect(adapter); 1463 1464 spin_lock_bh(&(pmlmepriv->scanned_queue.lock)); 1465 /* remove the network entry in scanned_queue */ 1466 pwlan = rtw_find_network(&pmlmepriv->scanned_queue, tgt_network->network.mac_address); 1467 if (pwlan) { 1468 pwlan->fixed = false; 1469 rtw_free_network_nolock(adapter, pwlan); 1470 } 1471 spin_unlock_bh(&(pmlmepriv->scanned_queue.lock)); 1472 1473 _rtw_roaming(adapter, roam_target); 1474 } 1475 1476 if (check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE) || 1477 check_fwstate(pmlmepriv, WIFI_ADHOC_STATE)) { 1478 1479 rtw_free_stainfo(adapter, psta); 1480 1481 if (adapter->stapriv.asoc_sta_count == 1) {/* a sta + bc/mc_stainfo (not Ibss_stainfo) */ 1482 u8 ret = _SUCCESS; 1483 /* rtw_indicate_disconnect(adapter);removed@20091105 */ 1484 spin_lock_bh(&(pmlmepriv->scanned_queue.lock)); 1485 /* free old ibss network */ 1486 /* pwlan = rtw_find_network(&pmlmepriv->scanned_queue, pstadel->macaddr); */ 1487 pwlan = rtw_find_network(&pmlmepriv->scanned_queue, tgt_network->network.mac_address); 1488 if (pwlan) { 1489 pwlan->fixed = false; 1490 rtw_free_network_nolock(adapter, pwlan); 1491 } 1492 spin_unlock_bh(&(pmlmepriv->scanned_queue.lock)); 1493 /* re-create ibss */ 1494 pdev_network = &(adapter->registrypriv.dev_network); 1495 pibss = adapter->registrypriv.dev_network.mac_address; 1496 1497 memcpy(pdev_network, &tgt_network->network, get_wlan_bssid_ex_sz(&tgt_network->network)); 1498 1499 memcpy(&pdev_network->ssid, &pmlmepriv->assoc_ssid, sizeof(struct ndis_802_11_ssid)); 1500 1501 rtw_update_registrypriv_dev_network(adapter); 1502 1503 rtw_generate_random_ibss(pibss); 1504 1505 if (check_fwstate(pmlmepriv, WIFI_ADHOC_STATE)) { 1506 set_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE); 1507 _clr_fwstate_(pmlmepriv, WIFI_ADHOC_STATE); 1508 } 1509 1510 ret = rtw_createbss_cmd(adapter); 1511 if (ret != _SUCCESS) 1512 goto unlock; 1513 } 1514 1515 } 1516 1517 unlock: 1518 spin_unlock_bh(&pmlmepriv->lock); 1519 } 1520 1521 void rtw_cpwm_event_callback(struct adapter *padapter, u8 *pbuf) 1522 { 1523 struct reportpwrstate_parm *preportpwrstate; 1524 1525 preportpwrstate = (struct reportpwrstate_parm *)pbuf; 1526 preportpwrstate->state |= (u8)(adapter_to_pwrctl(padapter)->cpwm_tog + 0x80); 1527 cpwm_int_hdl(padapter, preportpwrstate); 1528 } 1529 1530 void rtw_wmm_event_callback(struct adapter *padapter, u8 *pbuf) 1531 { 1532 WMMOnAssocRsp(padapter); 1533 } 1534 1535 /* 1536 * _rtw_join_timeout_handler - Timeout/failure handler for CMD JoinBss 1537 * @adapter: pointer to struct adapter structure 1538 */ 1539 void _rtw_join_timeout_handler(struct timer_list *t) 1540 { 1541 struct adapter *adapter = from_timer(adapter, t, 1542 mlmepriv.assoc_timer); 1543 struct mlme_priv *pmlmepriv = &adapter->mlmepriv; 1544 1545 if (adapter->bDriverStopped || adapter->bSurpriseRemoved) 1546 return; 1547 1548 spin_lock_bh(&pmlmepriv->lock); 1549 1550 if (rtw_to_roam(adapter) > 0) { /* join timeout caused by roaming */ 1551 while (1) { 1552 rtw_dec_to_roam(adapter); 1553 if (rtw_to_roam(adapter) != 0) { /* try another */ 1554 int do_join_r; 1555 1556 do_join_r = rtw_do_join(adapter); 1557 if (_SUCCESS != do_join_r) { 1558 continue; 1559 } 1560 break; 1561 } else { 1562 rtw_indicate_disconnect(adapter); 1563 break; 1564 } 1565 } 1566 1567 } else { 1568 rtw_indicate_disconnect(adapter); 1569 free_scanqueue(pmlmepriv);/* */ 1570 1571 /* indicate disconnect for the case that join_timeout and check_fwstate != FW_LINKED */ 1572 rtw_cfg80211_indicate_disconnect(adapter); 1573 1574 } 1575 1576 spin_unlock_bh(&pmlmepriv->lock); 1577 } 1578 1579 /* 1580 * rtw_scan_timeout_handler - Timeout/Failure handler for CMD SiteSurvey 1581 * @adapter: pointer to struct adapter structure 1582 */ 1583 void rtw_scan_timeout_handler(struct timer_list *t) 1584 { 1585 struct adapter *adapter = from_timer(adapter, t, 1586 mlmepriv.scan_to_timer); 1587 struct mlme_priv *pmlmepriv = &adapter->mlmepriv; 1588 1589 spin_lock_bh(&pmlmepriv->lock); 1590 1591 _clr_fwstate_(pmlmepriv, _FW_UNDER_SURVEY); 1592 1593 spin_unlock_bh(&pmlmepriv->lock); 1594 1595 rtw_indicate_scan_done(adapter, true); 1596 } 1597 1598 void rtw_mlme_reset_auto_scan_int(struct adapter *adapter) 1599 { 1600 struct mlme_priv *mlme = &adapter->mlmepriv; 1601 struct mlme_ext_priv *pmlmeext = &adapter->mlmeextpriv; 1602 struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info); 1603 1604 if (pmlmeinfo->VHT_enable) /* disable auto scan when connect to 11AC AP */ 1605 mlme->auto_scan_int_ms = 0; 1606 else if (adapter->registrypriv.wifi_spec && is_client_associated_to_ap(adapter) == true) 1607 mlme->auto_scan_int_ms = 60*1000; 1608 else if (rtw_chk_roam_flags(adapter, RTW_ROAM_ACTIVE)) { 1609 if (check_fwstate(mlme, WIFI_STATION_STATE) && check_fwstate(mlme, _FW_LINKED)) 1610 mlme->auto_scan_int_ms = mlme->roam_scan_int_ms; 1611 } else 1612 mlme->auto_scan_int_ms = 0; /* disabled */ 1613 } 1614 1615 static void rtw_auto_scan_handler(struct adapter *padapter) 1616 { 1617 struct mlme_priv *pmlmepriv = &padapter->mlmepriv; 1618 1619 rtw_mlme_reset_auto_scan_int(padapter); 1620 1621 if (pmlmepriv->auto_scan_int_ms != 0 1622 && jiffies_to_msecs(jiffies - pmlmepriv->scan_start_time) > pmlmepriv->auto_scan_int_ms) { 1623 1624 if (!padapter->registrypriv.wifi_spec) { 1625 if (check_fwstate(pmlmepriv, _FW_UNDER_SURVEY | _FW_UNDER_LINKING) == true) 1626 goto exit; 1627 1628 if (pmlmepriv->LinkDetectInfo.bBusyTraffic) 1629 goto exit; 1630 } 1631 1632 rtw_set_802_11_bssid_list_scan(padapter, NULL, 0); 1633 } 1634 1635 exit: 1636 return; 1637 } 1638 1639 void rtw_dynamic_check_timer_handler(struct adapter *adapter) 1640 { 1641 if (!adapter) 1642 return; 1643 1644 if (!adapter->hw_init_completed) 1645 return; 1646 1647 if (adapter->bDriverStopped || adapter->bSurpriseRemoved) 1648 return; 1649 1650 if (adapter->net_closed) 1651 return; 1652 1653 if ((adapter_to_pwrctl(adapter)->fw_current_in_ps_mode) 1654 && !(hal_btcoex_IsBtControlLps(adapter)) 1655 ) { 1656 u8 bEnterPS; 1657 1658 linked_status_chk(adapter); 1659 1660 bEnterPS = traffic_status_watchdog(adapter, 1); 1661 if (bEnterPS) { 1662 /* rtw_lps_ctrl_wk_cmd(adapter, LPS_CTRL_ENTER, 1); */ 1663 rtw_hal_dm_watchdog_in_lps(adapter); 1664 } else { 1665 /* call rtw_lps_ctrl_wk_cmd(padapter, LPS_CTRL_LEAVE, 1) in traffic_status_watchdog() */ 1666 } 1667 1668 } else { 1669 if (is_primary_adapter(adapter)) 1670 rtw_dynamic_chk_wk_cmd(adapter); 1671 } 1672 1673 /* auto site survey */ 1674 rtw_auto_scan_handler(adapter); 1675 } 1676 1677 inline bool rtw_is_scan_deny(struct adapter *adapter) 1678 { 1679 struct mlme_priv *mlmepriv = &adapter->mlmepriv; 1680 1681 return (atomic_read(&mlmepriv->set_scan_deny) != 0) ? true : false; 1682 } 1683 1684 inline void rtw_clear_scan_deny(struct adapter *adapter) 1685 { 1686 struct mlme_priv *mlmepriv = &adapter->mlmepriv; 1687 1688 atomic_set(&mlmepriv->set_scan_deny, 0); 1689 } 1690 1691 void rtw_set_scan_deny(struct adapter *adapter, u32 ms) 1692 { 1693 struct mlme_priv *mlmepriv = &adapter->mlmepriv; 1694 1695 atomic_set(&mlmepriv->set_scan_deny, 1); 1696 _set_timer(&mlmepriv->set_scan_deny_timer, ms); 1697 } 1698 1699 /* 1700 * Select a new roaming candidate from the original @param candidate and @param competitor 1701 * @return true: candidate is updated 1702 * @return false: candidate is not updated 1703 */ 1704 static int rtw_check_roaming_candidate(struct mlme_priv *mlme 1705 , struct wlan_network **candidate, struct wlan_network *competitor) 1706 { 1707 int updated = false; 1708 struct adapter *adapter = container_of(mlme, struct adapter, mlmepriv); 1709 1710 if (is_same_ess(&competitor->network, &mlme->cur_network.network) == false) 1711 goto exit; 1712 1713 if (rtw_is_desired_network(adapter, competitor) == false) 1714 goto exit; 1715 1716 /* got specific addr to roam */ 1717 if (!is_zero_mac_addr(mlme->roam_tgt_addr)) { 1718 if (!memcmp(mlme->roam_tgt_addr, competitor->network.mac_address, ETH_ALEN)) 1719 goto update; 1720 else 1721 goto exit; 1722 } 1723 if (jiffies_to_msecs(jiffies - competitor->last_scanned) >= mlme->roam_scanr_exp_ms) 1724 goto exit; 1725 1726 if (competitor->network.rssi - mlme->cur_network_scanned->network.rssi < mlme->roam_rssi_diff_th) 1727 goto exit; 1728 1729 if (*candidate && (*candidate)->network.rssi >= competitor->network.rssi) 1730 goto exit; 1731 1732 update: 1733 *candidate = competitor; 1734 updated = true; 1735 1736 exit: 1737 return updated; 1738 } 1739 1740 int rtw_select_roaming_candidate(struct mlme_priv *mlme) 1741 { 1742 int ret = _FAIL; 1743 struct list_head *phead; 1744 struct __queue *queue = &(mlme->scanned_queue); 1745 struct wlan_network *pnetwork = NULL; 1746 struct wlan_network *candidate = NULL; 1747 1748 if (!mlme->cur_network_scanned) { 1749 rtw_warn_on(1); 1750 return ret; 1751 } 1752 1753 spin_lock_bh(&(mlme->scanned_queue.lock)); 1754 phead = get_list_head(queue); 1755 1756 list_for_each(mlme->pscanned, phead) { 1757 1758 pnetwork = list_entry(mlme->pscanned, struct wlan_network, 1759 list); 1760 1761 rtw_check_roaming_candidate(mlme, &candidate, pnetwork); 1762 1763 } 1764 1765 if (!candidate) { 1766 ret = _FAIL; 1767 goto exit; 1768 } else { 1769 mlme->roam_network = candidate; 1770 1771 if (!memcmp(candidate->network.mac_address, mlme->roam_tgt_addr, ETH_ALEN)) 1772 eth_zero_addr(mlme->roam_tgt_addr); 1773 } 1774 1775 ret = _SUCCESS; 1776 exit: 1777 spin_unlock_bh(&(mlme->scanned_queue.lock)); 1778 1779 return ret; 1780 } 1781 1782 /* 1783 * Select a new join candidate from the original @param candidate and @param competitor 1784 * @return true: candidate is updated 1785 * @return false: candidate is not updated 1786 */ 1787 static int rtw_check_join_candidate(struct mlme_priv *mlme 1788 , struct wlan_network **candidate, struct wlan_network *competitor) 1789 { 1790 int updated = false; 1791 struct adapter *adapter = container_of(mlme, struct adapter, mlmepriv); 1792 1793 /* check bssid, if needed */ 1794 if (mlme->assoc_by_bssid) { 1795 if (memcmp(competitor->network.mac_address, mlme->assoc_bssid, ETH_ALEN)) 1796 goto exit; 1797 } 1798 1799 /* check ssid, if needed */ 1800 if (mlme->assoc_ssid.ssid[0] && mlme->assoc_ssid.ssid_length) { 1801 if (competitor->network.ssid.ssid_length != mlme->assoc_ssid.ssid_length 1802 || memcmp(competitor->network.ssid.ssid, mlme->assoc_ssid.ssid, mlme->assoc_ssid.ssid_length) 1803 ) 1804 goto exit; 1805 } 1806 1807 if (rtw_is_desired_network(adapter, competitor) == false) 1808 goto exit; 1809 1810 if (rtw_to_roam(adapter) > 0) { 1811 if (jiffies_to_msecs(jiffies - competitor->last_scanned) >= mlme->roam_scanr_exp_ms 1812 || is_same_ess(&competitor->network, &mlme->cur_network.network) == false 1813 ) 1814 goto exit; 1815 } 1816 1817 if (!*candidate || (*candidate)->network.rssi < competitor->network.rssi) { 1818 *candidate = competitor; 1819 updated = true; 1820 } 1821 1822 exit: 1823 return updated; 1824 } 1825 1826 /* 1827 Calling context: 1828 The caller of the sub-routine will be in critical section... 1829 The caller must hold the following spinlock 1830 pmlmepriv->lock 1831 */ 1832 1833 int rtw_select_and_join_from_scanned_queue(struct mlme_priv *pmlmepriv) 1834 { 1835 int ret; 1836 struct list_head *phead; 1837 struct adapter *adapter; 1838 struct __queue *queue = &(pmlmepriv->scanned_queue); 1839 struct wlan_network *pnetwork = NULL; 1840 struct wlan_network *candidate = NULL; 1841 1842 adapter = (struct adapter *)pmlmepriv->nic_hdl; 1843 1844 spin_lock_bh(&(pmlmepriv->scanned_queue.lock)); 1845 1846 if (pmlmepriv->roam_network) { 1847 candidate = pmlmepriv->roam_network; 1848 pmlmepriv->roam_network = NULL; 1849 goto candidate_exist; 1850 } 1851 1852 phead = get_list_head(queue); 1853 list_for_each(pmlmepriv->pscanned, phead) { 1854 1855 pnetwork = list_entry(pmlmepriv->pscanned, 1856 struct wlan_network, list); 1857 1858 rtw_check_join_candidate(pmlmepriv, &candidate, pnetwork); 1859 1860 } 1861 1862 if (!candidate) { 1863 ret = _FAIL; 1864 goto exit; 1865 } else { 1866 goto candidate_exist; 1867 } 1868 1869 candidate_exist: 1870 1871 /* check for situation of _FW_LINKED */ 1872 if (check_fwstate(pmlmepriv, _FW_LINKED) == true) { 1873 rtw_disassoc_cmd(adapter, 0, true); 1874 rtw_indicate_disconnect(adapter); 1875 rtw_free_assoc_resources(adapter, 0); 1876 } 1877 1878 set_fwstate(pmlmepriv, _FW_UNDER_LINKING); 1879 ret = rtw_joinbss_cmd(adapter, candidate); 1880 1881 exit: 1882 spin_unlock_bh(&(pmlmepriv->scanned_queue.lock)); 1883 return ret; 1884 } 1885 1886 signed int rtw_set_auth(struct adapter *adapter, struct security_priv *psecuritypriv) 1887 { 1888 struct cmd_obj *pcmd; 1889 struct setauth_parm *psetauthparm; 1890 struct cmd_priv *pcmdpriv = &(adapter->cmdpriv); 1891 signed int res = _SUCCESS; 1892 1893 pcmd = rtw_zmalloc(sizeof(struct cmd_obj)); 1894 if (!pcmd) { 1895 res = _FAIL; /* try again */ 1896 goto exit; 1897 } 1898 1899 psetauthparm = rtw_zmalloc(sizeof(struct setauth_parm)); 1900 if (!psetauthparm) { 1901 kfree(pcmd); 1902 res = _FAIL; 1903 goto exit; 1904 } 1905 1906 psetauthparm->mode = (unsigned char)psecuritypriv->dot11AuthAlgrthm; 1907 1908 pcmd->cmdcode = _SetAuth_CMD_; 1909 pcmd->parmbuf = (unsigned char *)psetauthparm; 1910 pcmd->cmdsz = (sizeof(struct setauth_parm)); 1911 pcmd->rsp = NULL; 1912 pcmd->rspsz = 0; 1913 1914 INIT_LIST_HEAD(&pcmd->list); 1915 1916 res = rtw_enqueue_cmd(pcmdpriv, pcmd); 1917 1918 exit: 1919 return res; 1920 } 1921 1922 signed int rtw_set_key(struct adapter *adapter, struct security_priv *psecuritypriv, signed int keyid, u8 set_tx, bool enqueue) 1923 { 1924 u8 keylen; 1925 struct cmd_obj *pcmd; 1926 struct setkey_parm *psetkeyparm; 1927 struct cmd_priv *pcmdpriv = &(adapter->cmdpriv); 1928 signed int res = _SUCCESS; 1929 1930 psetkeyparm = rtw_zmalloc(sizeof(struct setkey_parm)); 1931 if (!psetkeyparm) { 1932 res = _FAIL; 1933 goto exit; 1934 } 1935 1936 if (psecuritypriv->dot11AuthAlgrthm == dot11AuthAlgrthm_8021X) 1937 psetkeyparm->algorithm = (unsigned char)psecuritypriv->dot118021XGrpPrivacy; 1938 else 1939 psetkeyparm->algorithm = (u8)psecuritypriv->dot11PrivacyAlgrthm; 1940 1941 psetkeyparm->keyid = (u8)keyid;/* 0~3 */ 1942 psetkeyparm->set_tx = set_tx; 1943 if (is_wep_enc(psetkeyparm->algorithm)) 1944 adapter->securitypriv.key_mask |= BIT(psetkeyparm->keyid); 1945 1946 switch (psetkeyparm->algorithm) { 1947 1948 case _WEP40_: 1949 keylen = 5; 1950 memcpy(&(psetkeyparm->key[0]), &(psecuritypriv->dot11DefKey[keyid].skey[0]), keylen); 1951 break; 1952 case _WEP104_: 1953 keylen = 13; 1954 memcpy(&(psetkeyparm->key[0]), &(psecuritypriv->dot11DefKey[keyid].skey[0]), keylen); 1955 break; 1956 case _TKIP_: 1957 keylen = 16; 1958 memcpy(&psetkeyparm->key, &psecuritypriv->dot118021XGrpKey[keyid], keylen); 1959 psetkeyparm->grpkey = 1; 1960 break; 1961 case _AES_: 1962 keylen = 16; 1963 memcpy(&psetkeyparm->key, &psecuritypriv->dot118021XGrpKey[keyid], keylen); 1964 psetkeyparm->grpkey = 1; 1965 break; 1966 default: 1967 res = _FAIL; 1968 kfree(psetkeyparm); 1969 goto exit; 1970 } 1971 1972 if (enqueue) { 1973 pcmd = rtw_zmalloc(sizeof(struct cmd_obj)); 1974 if (!pcmd) { 1975 kfree(psetkeyparm); 1976 res = _FAIL; /* try again */ 1977 goto exit; 1978 } 1979 1980 pcmd->cmdcode = _SetKey_CMD_; 1981 pcmd->parmbuf = (u8 *)psetkeyparm; 1982 pcmd->cmdsz = (sizeof(struct setkey_parm)); 1983 pcmd->rsp = NULL; 1984 pcmd->rspsz = 0; 1985 1986 INIT_LIST_HEAD(&pcmd->list); 1987 1988 res = rtw_enqueue_cmd(pcmdpriv, pcmd); 1989 } else { 1990 setkey_hdl(adapter, (u8 *)psetkeyparm); 1991 kfree(psetkeyparm); 1992 } 1993 exit: 1994 return res; 1995 } 1996 1997 /* adjust ies for rtw_joinbss_cmd in WMM */ 1998 int rtw_restruct_wmm_ie(struct adapter *adapter, u8 *in_ie, u8 *out_ie, uint in_len, uint initial_out_len) 1999 { 2000 unsigned int ielength = 0; 2001 unsigned int i, j; 2002 2003 i = 12; /* after the fixed IE */ 2004 while (i < in_len) { 2005 ielength = initial_out_len; 2006 2007 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 */ 2008 for (j = i; j < i + 9; j++) { 2009 out_ie[ielength] = in_ie[j]; 2010 ielength++; 2011 } 2012 out_ie[initial_out_len + 1] = 0x07; 2013 out_ie[initial_out_len + 6] = 0x00; 2014 out_ie[initial_out_len + 8] = 0x00; 2015 2016 break; 2017 } 2018 2019 i += (in_ie[i+1]+2); /* to the next IE element */ 2020 } 2021 2022 return ielength; 2023 2024 } 2025 2026 /* */ 2027 /* Ported from 8185: IsInPreAuthKeyList(). (Renamed from SecIsInPreAuthKeyList(), 2006-10-13.) */ 2028 /* Added by Annie, 2006-05-07. */ 2029 /* */ 2030 /* Search by BSSID, */ 2031 /* Return Value: */ 2032 /* -1 :if there is no pre-auth key in the table */ 2033 /* >= 0 :if there is pre-auth key, and return the entry id */ 2034 /* */ 2035 /* */ 2036 2037 static int SecIsInPMKIDList(struct adapter *Adapter, u8 *bssid) 2038 { 2039 struct security_priv *psecuritypriv = &Adapter->securitypriv; 2040 int i = 0; 2041 2042 do { 2043 if ((psecuritypriv->PMKIDList[i].bUsed) && 2044 (!memcmp(psecuritypriv->PMKIDList[i].Bssid, bssid, ETH_ALEN))) { 2045 break; 2046 } else { 2047 i++; 2048 /* continue; */ 2049 } 2050 2051 } while (i < NUM_PMKID_CACHE); 2052 2053 if (i == NUM_PMKID_CACHE) { 2054 i = -1;/* Could not find. */ 2055 } else { 2056 /* There is one Pre-Authentication Key for the specific BSSID. */ 2057 } 2058 2059 return i; 2060 2061 } 2062 2063 /* */ 2064 /* Check the RSN IE length */ 2065 /* If the RSN IE length <= 20, the RSN IE didn't include the PMKID information */ 2066 /* 0-11th element in the array are the fixed IE */ 2067 /* 12th element in the array is the IE */ 2068 /* 13th element in the array is the IE length */ 2069 /* */ 2070 2071 static int rtw_append_pmkid(struct adapter *Adapter, int iEntry, u8 *ie, uint ie_len) 2072 { 2073 struct security_priv *psecuritypriv = &Adapter->securitypriv; 2074 2075 if (ie[13] <= 20) { 2076 /* The RSN IE didn't include the PMK ID, append the PMK information */ 2077 ie[ie_len] = 1; 2078 ie_len++; 2079 ie[ie_len] = 0; /* PMKID count = 0x0100 */ 2080 ie_len++; 2081 memcpy(&ie[ie_len], &psecuritypriv->PMKIDList[iEntry].PMKID, 16); 2082 2083 ie_len += 16; 2084 ie[13] += 18;/* PMKID length = 2+16 */ 2085 2086 } 2087 return ie_len; 2088 } 2089 2090 signed int rtw_restruct_sec_ie(struct adapter *adapter, u8 *in_ie, u8 *out_ie, uint in_len) 2091 { 2092 u8 authmode = 0x0; 2093 uint ielength; 2094 int iEntry; 2095 2096 struct mlme_priv *pmlmepriv = &adapter->mlmepriv; 2097 struct security_priv *psecuritypriv = &adapter->securitypriv; 2098 uint ndisauthmode = psecuritypriv->ndisauthtype; 2099 2100 /* copy fixed ie only */ 2101 memcpy(out_ie, in_ie, 12); 2102 ielength = 12; 2103 if ((ndisauthmode == Ndis802_11AuthModeWPA) || (ndisauthmode == Ndis802_11AuthModeWPAPSK)) 2104 authmode = WLAN_EID_VENDOR_SPECIFIC; 2105 if ((ndisauthmode == Ndis802_11AuthModeWPA2) || (ndisauthmode == Ndis802_11AuthModeWPA2PSK)) 2106 authmode = WLAN_EID_RSN; 2107 2108 if (check_fwstate(pmlmepriv, WIFI_UNDER_WPS)) { 2109 memcpy(out_ie+ielength, psecuritypriv->wps_ie, psecuritypriv->wps_ie_len); 2110 2111 ielength += psecuritypriv->wps_ie_len; 2112 } else if ((authmode == WLAN_EID_VENDOR_SPECIFIC) || (authmode == WLAN_EID_RSN)) { 2113 /* copy RSN or SSN */ 2114 memcpy(&out_ie[ielength], &psecuritypriv->supplicant_ie[0], psecuritypriv->supplicant_ie[1]+2); 2115 /* debug for CONFIG_IEEE80211W 2116 { 2117 int jj; 2118 printk("supplicant_ie_length =%d &&&&&&&&&&&&&&&&&&&\n", psecuritypriv->supplicant_ie[1]+2); 2119 for (jj = 0; jj < psecuritypriv->supplicant_ie[1]+2; jj++) 2120 printk(" %02x ", psecuritypriv->supplicant_ie[jj]); 2121 printk("\n"); 2122 }*/ 2123 ielength += psecuritypriv->supplicant_ie[1]+2; 2124 rtw_report_sec_ie(adapter, authmode, psecuritypriv->supplicant_ie); 2125 } 2126 2127 iEntry = SecIsInPMKIDList(adapter, pmlmepriv->assoc_bssid); 2128 if (iEntry < 0) { 2129 return ielength; 2130 } else { 2131 if (authmode == WLAN_EID_RSN) 2132 ielength = rtw_append_pmkid(adapter, iEntry, out_ie, ielength); 2133 } 2134 return ielength; 2135 } 2136 2137 void rtw_init_registrypriv_dev_network(struct adapter *adapter) 2138 { 2139 struct registry_priv *pregistrypriv = &adapter->registrypriv; 2140 struct eeprom_priv *peepriv = &adapter->eeprompriv; 2141 struct wlan_bssid_ex *pdev_network = &pregistrypriv->dev_network; 2142 u8 *myhwaddr = myid(peepriv); 2143 2144 memcpy(pdev_network->mac_address, myhwaddr, ETH_ALEN); 2145 2146 memcpy(&pdev_network->ssid, &pregistrypriv->ssid, sizeof(struct ndis_802_11_ssid)); 2147 2148 pdev_network->configuration.length = sizeof(struct ndis_802_11_conf); 2149 pdev_network->configuration.beacon_period = 100; 2150 } 2151 2152 void rtw_update_registrypriv_dev_network(struct adapter *adapter) 2153 { 2154 int sz = 0; 2155 struct registry_priv *pregistrypriv = &adapter->registrypriv; 2156 struct wlan_bssid_ex *pdev_network = &pregistrypriv->dev_network; 2157 struct security_priv *psecuritypriv = &adapter->securitypriv; 2158 struct wlan_network *cur_network = &adapter->mlmepriv.cur_network; 2159 /* struct xmit_priv *pxmitpriv = &adapter->xmitpriv; */ 2160 2161 pdev_network->privacy = (psecuritypriv->dot11PrivacyAlgrthm > 0 ? 1 : 0) ; /* adhoc no 802.1x */ 2162 2163 pdev_network->rssi = 0; 2164 2165 switch (pregistrypriv->wireless_mode) { 2166 case WIRELESS_11B: 2167 pdev_network->network_type_in_use = (Ndis802_11DS); 2168 break; 2169 case WIRELESS_11G: 2170 case WIRELESS_11BG: 2171 case WIRELESS_11_24N: 2172 case WIRELESS_11G_24N: 2173 case WIRELESS_11BG_24N: 2174 pdev_network->network_type_in_use = (Ndis802_11OFDM24); 2175 break; 2176 default: 2177 /* TODO */ 2178 break; 2179 } 2180 2181 pdev_network->configuration.ds_config = (pregistrypriv->channel); 2182 2183 if (cur_network->network.infrastructure_mode == Ndis802_11IBSS) 2184 pdev_network->configuration.atim_window = (0); 2185 2186 pdev_network->infrastructure_mode = (cur_network->network.infrastructure_mode); 2187 2188 /* 1. Supported rates */ 2189 /* 2. IE */ 2190 2191 /* rtw_set_supported_rate(pdev_network->supported_rates, pregistrypriv->wireless_mode) ; will be called in rtw_generate_ie */ 2192 sz = rtw_generate_ie(pregistrypriv); 2193 2194 pdev_network->ie_length = sz; 2195 2196 pdev_network->length = get_wlan_bssid_ex_sz((struct wlan_bssid_ex *)pdev_network); 2197 2198 /* notes: translate ie_length & length after assign the length to cmdsz in createbss_cmd(); */ 2199 /* pdev_network->ie_length = cpu_to_le32(sz); */ 2200 } 2201 2202 void rtw_get_encrypt_decrypt_from_registrypriv(struct adapter *adapter) 2203 { 2204 } 2205 2206 /* the function is at passive_level */ 2207 void rtw_joinbss_reset(struct adapter *padapter) 2208 { 2209 u8 threshold; 2210 struct mlme_priv *pmlmepriv = &padapter->mlmepriv; 2211 2212 struct ht_priv *phtpriv = &pmlmepriv->htpriv; 2213 2214 /* todo: if you want to do something io/reg/hw setting before join_bss, please add code here */ 2215 2216 pmlmepriv->num_FortyMHzIntolerant = 0; 2217 2218 pmlmepriv->num_sta_no_ht = 0; 2219 2220 phtpriv->ampdu_enable = false;/* reset to disabled */ 2221 2222 /* TH = 1 => means that invalidate usb rx aggregation */ 2223 /* TH = 0 => means that validate usb rx aggregation, use init value. */ 2224 if (phtpriv->ht_option) { 2225 if (padapter->registrypriv.wifi_spec == 1) 2226 threshold = 1; 2227 else 2228 threshold = 0; 2229 rtw_hal_set_hwreg(padapter, HW_VAR_RXDMA_AGG_PG_TH, (u8 *)(&threshold)); 2230 } else { 2231 threshold = 1; 2232 rtw_hal_set_hwreg(padapter, HW_VAR_RXDMA_AGG_PG_TH, (u8 *)(&threshold)); 2233 } 2234 } 2235 2236 void rtw_ht_use_default_setting(struct adapter *padapter) 2237 { 2238 struct mlme_priv *pmlmepriv = &padapter->mlmepriv; 2239 struct ht_priv *phtpriv = &pmlmepriv->htpriv; 2240 struct registry_priv *pregistrypriv = &padapter->registrypriv; 2241 bool bHwLDPCSupport = false, bHwSTBCSupport = false; 2242 bool bHwSupportBeamformer = false, bHwSupportBeamformee = false; 2243 2244 if (pregistrypriv->wifi_spec) 2245 phtpriv->bss_coexist = 1; 2246 else 2247 phtpriv->bss_coexist = 0; 2248 2249 phtpriv->sgi_40m = TEST_FLAG(pregistrypriv->short_gi, BIT1) ? true : false; 2250 phtpriv->sgi_20m = TEST_FLAG(pregistrypriv->short_gi, BIT0) ? true : false; 2251 2252 /* LDPC support */ 2253 rtw_hal_get_def_var(padapter, HAL_DEF_RX_LDPC, (u8 *)&bHwLDPCSupport); 2254 CLEAR_FLAGS(phtpriv->ldpc_cap); 2255 if (bHwLDPCSupport) { 2256 if (TEST_FLAG(pregistrypriv->ldpc_cap, BIT4)) 2257 SET_FLAG(phtpriv->ldpc_cap, LDPC_HT_ENABLE_RX); 2258 } 2259 rtw_hal_get_def_var(padapter, HAL_DEF_TX_LDPC, (u8 *)&bHwLDPCSupport); 2260 if (bHwLDPCSupport) { 2261 if (TEST_FLAG(pregistrypriv->ldpc_cap, BIT5)) 2262 SET_FLAG(phtpriv->ldpc_cap, LDPC_HT_ENABLE_TX); 2263 } 2264 2265 /* STBC */ 2266 rtw_hal_get_def_var(padapter, HAL_DEF_TX_STBC, (u8 *)&bHwSTBCSupport); 2267 CLEAR_FLAGS(phtpriv->stbc_cap); 2268 if (bHwSTBCSupport) { 2269 if (TEST_FLAG(pregistrypriv->stbc_cap, BIT5)) 2270 SET_FLAG(phtpriv->stbc_cap, STBC_HT_ENABLE_TX); 2271 } 2272 rtw_hal_get_def_var(padapter, HAL_DEF_RX_STBC, (u8 *)&bHwSTBCSupport); 2273 if (bHwSTBCSupport) { 2274 if (TEST_FLAG(pregistrypriv->stbc_cap, BIT4)) 2275 SET_FLAG(phtpriv->stbc_cap, STBC_HT_ENABLE_RX); 2276 } 2277 2278 /* Beamforming setting */ 2279 rtw_hal_get_def_var(padapter, HAL_DEF_EXPLICIT_BEAMFORMER, (u8 *)&bHwSupportBeamformer); 2280 rtw_hal_get_def_var(padapter, HAL_DEF_EXPLICIT_BEAMFORMEE, (u8 *)&bHwSupportBeamformee); 2281 CLEAR_FLAGS(phtpriv->beamform_cap); 2282 if (TEST_FLAG(pregistrypriv->beamform_cap, BIT4) && bHwSupportBeamformer) 2283 SET_FLAG(phtpriv->beamform_cap, BEAMFORMING_HT_BEAMFORMER_ENABLE); 2284 2285 if (TEST_FLAG(pregistrypriv->beamform_cap, BIT5) && bHwSupportBeamformee) 2286 SET_FLAG(phtpriv->beamform_cap, BEAMFORMING_HT_BEAMFORMEE_ENABLE); 2287 } 2288 2289 void rtw_build_wmm_ie_ht(struct adapter *padapter, u8 *out_ie, uint *pout_len) 2290 { 2291 unsigned char WMM_IE[] = {0x00, 0x50, 0xf2, 0x02, 0x00, 0x01, 0x00}; 2292 int out_len; 2293 2294 if (padapter->mlmepriv.qospriv.qos_option == 0) { 2295 out_len = *pout_len; 2296 rtw_set_ie(out_ie+out_len, WLAN_EID_VENDOR_SPECIFIC, 2297 _WMM_IE_Length_, WMM_IE, pout_len); 2298 2299 padapter->mlmepriv.qospriv.qos_option = 1; 2300 } 2301 } 2302 2303 /* the function is >= passive_level */ 2304 unsigned int rtw_restructure_ht_ie(struct adapter *padapter, u8 *in_ie, u8 *out_ie, uint in_len, uint *pout_len, u8 channel) 2305 { 2306 u32 ielen, out_len; 2307 enum ieee80211_max_ampdu_length_exp max_rx_ampdu_factor; 2308 unsigned char *p; 2309 struct ieee80211_ht_cap ht_capie; 2310 u8 cbw40_enable = 0, stbc_rx_enable = 0, operation_bw = 0; 2311 struct registry_priv *pregistrypriv = &padapter->registrypriv; 2312 struct mlme_priv *pmlmepriv = &padapter->mlmepriv; 2313 struct ht_priv *phtpriv = &pmlmepriv->htpriv; 2314 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv; 2315 2316 phtpriv->ht_option = false; 2317 2318 out_len = *pout_len; 2319 2320 memset(&ht_capie, 0, sizeof(struct ieee80211_ht_cap)); 2321 2322 ht_capie.cap_info = cpu_to_le16(IEEE80211_HT_CAP_DSSSCCK40); 2323 2324 if (phtpriv->sgi_20m) 2325 ht_capie.cap_info |= cpu_to_le16(IEEE80211_HT_CAP_SGI_20); 2326 2327 /* Get HT BW */ 2328 if (!in_ie) { 2329 /* TDLS: TODO 20/40 issue */ 2330 if (check_fwstate(pmlmepriv, WIFI_STATION_STATE)) { 2331 operation_bw = padapter->mlmeextpriv.cur_bwmode; 2332 if (operation_bw > CHANNEL_WIDTH_40) 2333 operation_bw = CHANNEL_WIDTH_40; 2334 } else 2335 /* TDLS: TODO 40? */ 2336 operation_bw = CHANNEL_WIDTH_40; 2337 } else { 2338 p = rtw_get_ie(in_ie, WLAN_EID_HT_OPERATION, &ielen, in_len); 2339 if (p && (ielen == sizeof(struct ieee80211_ht_addt_info))) { 2340 struct HT_info_element *pht_info = (struct HT_info_element *)(p+2); 2341 2342 if (pht_info->infos[0] & BIT(2)) { 2343 switch (pht_info->infos[0] & 0x3) { 2344 case 1: 2345 case 3: 2346 operation_bw = CHANNEL_WIDTH_40; 2347 break; 2348 default: 2349 operation_bw = CHANNEL_WIDTH_20; 2350 break; 2351 } 2352 } else { 2353 operation_bw = CHANNEL_WIDTH_20; 2354 } 2355 } 2356 } 2357 2358 /* to disable 40M Hz support while gd_bw_40MHz_en = 0 */ 2359 if (channel > 14) { 2360 if ((pregistrypriv->bw_mode & 0xf0) > 0) 2361 cbw40_enable = 1; 2362 } else { 2363 if ((pregistrypriv->bw_mode & 0x0f) > 0) 2364 cbw40_enable = 1; 2365 } 2366 2367 if ((cbw40_enable == 1) && (operation_bw == CHANNEL_WIDTH_40)) { 2368 ht_capie.cap_info |= cpu_to_le16(IEEE80211_HT_CAP_SUP_WIDTH); 2369 if (phtpriv->sgi_40m) 2370 ht_capie.cap_info |= cpu_to_le16(IEEE80211_HT_CAP_SGI_40); 2371 } 2372 2373 if (TEST_FLAG(phtpriv->stbc_cap, STBC_HT_ENABLE_TX)) 2374 ht_capie.cap_info |= cpu_to_le16(IEEE80211_HT_CAP_TX_STBC); 2375 2376 /* todo: disable SM power save mode */ 2377 ht_capie.cap_info |= cpu_to_le16(IEEE80211_HT_CAP_SM_PS); 2378 2379 if (TEST_FLAG(phtpriv->stbc_cap, STBC_HT_ENABLE_RX)) { 2380 if ((channel <= 14 && pregistrypriv->rx_stbc == 0x1) || /* enable for 2.4GHz */ 2381 (pregistrypriv->wifi_spec == 1)) 2382 stbc_rx_enable = 1; 2383 } 2384 2385 /* fill default supported_mcs_set */ 2386 memcpy(&ht_capie.mcs, pmlmeext->default_supported_mcs_set, 16); 2387 2388 /* update default supported_mcs_set */ 2389 if (stbc_rx_enable) 2390 ht_capie.cap_info |= cpu_to_le16(IEEE80211_HT_CAP_RX_STBC_1R);/* RX STBC One spatial stream */ 2391 2392 set_mcs_rate_by_mask(ht_capie.mcs.rx_mask, MCS_RATE_1R); 2393 2394 { 2395 u32 rx_packet_offset, max_recvbuf_sz; 2396 2397 rtw_hal_get_def_var(padapter, HAL_DEF_RX_PACKET_OFFSET, &rx_packet_offset); 2398 rtw_hal_get_def_var(padapter, HAL_DEF_MAX_RECVBUF_SZ, &max_recvbuf_sz); 2399 } 2400 2401 if (padapter->driver_rx_ampdu_factor != 0xFF) 2402 max_rx_ampdu_factor = 2403 (enum ieee80211_max_ampdu_length_exp)padapter->driver_rx_ampdu_factor; 2404 else 2405 rtw_hal_get_def_var(padapter, HW_VAR_MAX_RX_AMPDU_FACTOR, 2406 &max_rx_ampdu_factor); 2407 2408 /* rtw_hal_get_def_var(padapter, HW_VAR_MAX_RX_AMPDU_FACTOR, &max_rx_ampdu_factor); */ 2409 ht_capie.ampdu_params_info = (max_rx_ampdu_factor&0x03); 2410 2411 if (padapter->securitypriv.dot11PrivacyAlgrthm == _AES_) 2412 ht_capie.ampdu_params_info |= (IEEE80211_HT_CAP_AMPDU_DENSITY&(0x07<<2)); 2413 else 2414 ht_capie.ampdu_params_info |= (IEEE80211_HT_CAP_AMPDU_DENSITY&0x00); 2415 2416 rtw_set_ie(out_ie+out_len, WLAN_EID_HT_CAPABILITY, 2417 sizeof(struct ieee80211_ht_cap), (unsigned char *)&ht_capie, pout_len); 2418 2419 phtpriv->ht_option = true; 2420 2421 if (in_ie) { 2422 p = rtw_get_ie(in_ie, WLAN_EID_HT_OPERATION, &ielen, in_len); 2423 if (p && (ielen == sizeof(struct ieee80211_ht_addt_info))) { 2424 out_len = *pout_len; 2425 rtw_set_ie(out_ie+out_len, WLAN_EID_HT_OPERATION, ielen, p+2, pout_len); 2426 } 2427 } 2428 2429 return phtpriv->ht_option; 2430 2431 } 2432 2433 /* the function is > passive_level (in critical_section) */ 2434 void rtw_update_ht_cap(struct adapter *padapter, u8 *pie, uint ie_len, u8 channel) 2435 { 2436 u8 *p, max_ampdu_sz; 2437 int len; 2438 /* struct sta_info *bmc_sta, *psta; */ 2439 struct ieee80211_ht_cap *pht_capie; 2440 /* struct recv_reorder_ctrl *preorder_ctrl; */ 2441 struct mlme_priv *pmlmepriv = &padapter->mlmepriv; 2442 struct ht_priv *phtpriv = &pmlmepriv->htpriv; 2443 /* struct recv_priv *precvpriv = &padapter->recvpriv; */ 2444 struct registry_priv *pregistrypriv = &padapter->registrypriv; 2445 /* struct wlan_network *pcur_network = &(pmlmepriv->cur_network);; */ 2446 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv; 2447 struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info); 2448 u8 cbw40_enable = 0; 2449 2450 if (!phtpriv->ht_option) 2451 return; 2452 2453 if ((!pmlmeinfo->HT_info_enable) || (!pmlmeinfo->HT_caps_enable)) 2454 return; 2455 2456 /* maybe needs check if ap supports rx ampdu. */ 2457 if (!(phtpriv->ampdu_enable) && pregistrypriv->ampdu_enable == 1) { 2458 phtpriv->ampdu_enable = true; 2459 } 2460 2461 /* check Max Rx A-MPDU Size */ 2462 len = 0; 2463 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)); 2464 if (p && len > 0) { 2465 pht_capie = (struct ieee80211_ht_cap *)(p+2); 2466 max_ampdu_sz = (pht_capie->ampdu_params_info & IEEE80211_HT_CAP_AMPDU_FACTOR); 2467 max_ampdu_sz = 1 << (max_ampdu_sz+3); /* max_ampdu_sz (kbytes); */ 2468 2469 phtpriv->rx_ampdu_maxlen = max_ampdu_sz; 2470 2471 } 2472 2473 len = 0; 2474 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)); 2475 if (p && len > 0) { 2476 /* todo: */ 2477 } 2478 2479 if (channel > 14) { 2480 if ((pregistrypriv->bw_mode & 0xf0) > 0) 2481 cbw40_enable = 1; 2482 } else { 2483 if ((pregistrypriv->bw_mode & 0x0f) > 0) 2484 cbw40_enable = 1; 2485 } 2486 2487 /* update cur_bwmode & cur_ch_offset */ 2488 if ((cbw40_enable) && 2489 (le16_to_cpu(pmlmeinfo->HT_caps.u.HT_cap_element.HT_caps_info) & 2490 BIT(1)) && (pmlmeinfo->HT_info.infos[0] & BIT(2))) { 2491 int i; 2492 2493 /* update the MCS set */ 2494 for (i = 0; i < 16; i++) 2495 pmlmeinfo->HT_caps.u.HT_cap_element.MCS_rate[i] &= pmlmeext->default_supported_mcs_set[i]; 2496 2497 /* update the MCS rates */ 2498 set_mcs_rate_by_mask(pmlmeinfo->HT_caps.u.HT_cap_element.MCS_rate, MCS_RATE_1R); 2499 2500 /* switch to the 40M Hz mode according to the AP */ 2501 /* pmlmeext->cur_bwmode = CHANNEL_WIDTH_40; */ 2502 switch ((pmlmeinfo->HT_info.infos[0] & 0x3)) { 2503 case EXTCHNL_OFFSET_UPPER: 2504 pmlmeext->cur_ch_offset = HAL_PRIME_CHNL_OFFSET_LOWER; 2505 break; 2506 2507 case EXTCHNL_OFFSET_LOWER: 2508 pmlmeext->cur_ch_offset = HAL_PRIME_CHNL_OFFSET_UPPER; 2509 break; 2510 2511 default: 2512 pmlmeext->cur_ch_offset = HAL_PRIME_CHNL_OFFSET_DONT_CARE; 2513 break; 2514 } 2515 } 2516 2517 /* */ 2518 /* Config SM Power Save setting */ 2519 /* */ 2520 pmlmeinfo->SM_PS = 2521 (le16_to_cpu(pmlmeinfo->HT_caps.u.HT_cap_element.HT_caps_info) & 2522 0x0C) >> 2; 2523 2524 /* */ 2525 /* Config current HT Protection mode. */ 2526 /* */ 2527 pmlmeinfo->HT_protection = pmlmeinfo->HT_info.infos[1] & 0x3; 2528 } 2529 2530 void rtw_issue_addbareq_cmd(struct adapter *padapter, struct xmit_frame *pxmitframe) 2531 { 2532 u8 issued; 2533 int priority; 2534 struct sta_info *psta = NULL; 2535 struct ht_priv *phtpriv; 2536 struct pkt_attrib *pattrib = &pxmitframe->attrib; 2537 s32 bmcst = IS_MCAST(pattrib->ra); 2538 2539 /* if (bmcst || (padapter->mlmepriv.LinkDetectInfo.bTxBusyTraffic == false)) */ 2540 if (bmcst || (padapter->mlmepriv.LinkDetectInfo.NumTxOkInPeriod < 100)) 2541 return; 2542 2543 priority = pattrib->priority; 2544 2545 psta = rtw_get_stainfo(&padapter->stapriv, pattrib->ra); 2546 if (pattrib->psta != psta) 2547 return; 2548 2549 if (!psta) 2550 return; 2551 2552 if (!(psta->state & _FW_LINKED)) 2553 return; 2554 2555 phtpriv = &psta->htpriv; 2556 2557 if (phtpriv->ht_option && phtpriv->ampdu_enable) { 2558 issued = (phtpriv->agg_enable_bitmap>>priority)&0x1; 2559 issued |= (phtpriv->candidate_tid_bitmap>>priority)&0x1; 2560 2561 if (0 == issued) { 2562 psta->htpriv.candidate_tid_bitmap |= BIT((u8)priority); 2563 rtw_addbareq_cmd(padapter, (u8) priority, pattrib->ra); 2564 } 2565 } 2566 2567 } 2568 2569 void rtw_append_exented_cap(struct adapter *padapter, u8 *out_ie, uint *pout_len) 2570 { 2571 struct mlme_priv *pmlmepriv = &padapter->mlmepriv; 2572 struct ht_priv *phtpriv = &pmlmepriv->htpriv; 2573 u8 cap_content[8] = {0}; 2574 2575 if (phtpriv->bss_coexist) 2576 SET_EXT_CAPABILITY_ELE_BSS_COEXIST(cap_content, 1); 2577 2578 rtw_set_ie(out_ie + *pout_len, WLAN_EID_EXT_CAPABILITY, 8, cap_content, pout_len); 2579 } 2580 2581 inline void rtw_set_to_roam(struct adapter *adapter, u8 to_roam) 2582 { 2583 if (to_roam == 0) 2584 adapter->mlmepriv.to_join = false; 2585 adapter->mlmepriv.to_roam = to_roam; 2586 } 2587 2588 inline u8 rtw_dec_to_roam(struct adapter *adapter) 2589 { 2590 adapter->mlmepriv.to_roam--; 2591 return adapter->mlmepriv.to_roam; 2592 } 2593 2594 inline u8 rtw_to_roam(struct adapter *adapter) 2595 { 2596 return adapter->mlmepriv.to_roam; 2597 } 2598 2599 void rtw_roaming(struct adapter *padapter, struct wlan_network *tgt_network) 2600 { 2601 struct mlme_priv *pmlmepriv = &padapter->mlmepriv; 2602 2603 spin_lock_bh(&pmlmepriv->lock); 2604 _rtw_roaming(padapter, tgt_network); 2605 spin_unlock_bh(&pmlmepriv->lock); 2606 } 2607 void _rtw_roaming(struct adapter *padapter, struct wlan_network *tgt_network) 2608 { 2609 struct mlme_priv *pmlmepriv = &padapter->mlmepriv; 2610 struct wlan_network *cur_network = &pmlmepriv->cur_network; 2611 int do_join_r; 2612 2613 if (0 < rtw_to_roam(padapter)) { 2614 memcpy(&pmlmepriv->assoc_ssid, &cur_network->network.ssid, sizeof(struct ndis_802_11_ssid)); 2615 2616 pmlmepriv->assoc_by_bssid = false; 2617 2618 while (1) { 2619 do_join_r = rtw_do_join(padapter); 2620 if (_SUCCESS == do_join_r) { 2621 break; 2622 } else { 2623 rtw_dec_to_roam(padapter); 2624 2625 if (rtw_to_roam(padapter) > 0) { 2626 continue; 2627 } else { 2628 rtw_indicate_disconnect(padapter); 2629 break; 2630 } 2631 } 2632 } 2633 } 2634 2635 } 2636 2637 signed int rtw_linked_check(struct adapter *padapter) 2638 { 2639 if ((check_fwstate(&padapter->mlmepriv, WIFI_AP_STATE) == true) || 2640 (check_fwstate(&padapter->mlmepriv, WIFI_ADHOC_STATE|WIFI_ADHOC_MASTER_STATE) == true)) { 2641 if (padapter->stapriv.asoc_sta_count > 2) 2642 return true; 2643 } else { /* Station mode */ 2644 if (check_fwstate(&padapter->mlmepriv, _FW_LINKED) == true) 2645 return true; 2646 } 2647 return false; 2648 } 2649