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