drivers/staging/rtl8723bs/core/rtw_mlme.c

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