drivers/staging/rtl8723au/core/rtw_mlme.c

   1 /******************************************************************************
   2  *
   3  * Copyright(c) 2007 - 2011 Realtek Corporation. All rights reserved.
   4  *
   5  * This program is free software; you can redistribute it and/or modify it
   6  * under the terms of version 2 of the GNU General Public License as
   7  * published by the Free Software Foundation.
   8  *
   9  * This program is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
  12  * more details.
  13  *
  14  ******************************************************************************/
  15 #define _RTW_MLME_C_
  16
  17 #include <osdep_service.h>
  18 #include <drv_types.h>
  19 #include <recv_osdep.h>
  20 #include <xmit_osdep.h>
  21 #include <hal_intf.h>
  22 #include <mlme_osdep.h>
  23 #include <sta_info.h>
  24 #include <linux/ieee80211.h>
  25 #include <wifi.h>
  26 #include <wlan_bssdef.h>
  27 #include <rtw_sreset.h>
  28
  29 static struct wlan_network *
  30 rtw_select_candidate_from_queue(struct mlme_priv *pmlmepriv);
  31 static int rtw_do_join(struct rtw_adapter *padapter);
  32
  33 static void rtw_init_mlme_timer(struct rtw_adapter *padapter)
  34 {
  35         struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
  36
  37         setup_timer(&pmlmepriv->assoc_timer, rtw23a_join_to_handler,
  38                     (unsigned long)padapter);
  39
  40         setup_timer(&pmlmepriv->scan_to_timer, rtw_scan_timeout_handler23a,
  41                     (unsigned long)padapter);
  42
  43         setup_timer(&pmlmepriv->dynamic_chk_timer,
  44                     rtw_dynamic_check_timer_handler, (unsigned long)padapter);
  45
  46         setup_timer(&pmlmepriv->set_scan_deny_timer,
  47                     rtw_set_scan_deny_timer_hdl, (unsigned long)padapter);
  48 }
  49
  50 int rtw_init_mlme_priv23a(struct rtw_adapter *padapter)
  51 {
  52         struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
  53         int res = _SUCCESS;
  54
  55         pmlmepriv->nic_hdl = padapter;
  56
  57         pmlmepriv->fw_state = 0;
  58         pmlmepriv->cur_network.network.ifmode = NL80211_IFTYPE_UNSPECIFIED;
  59         /*  1: active, 0: pasive. Maybe someday we should rename this
  60             varable to "active_mode" (Jeff) */
  61         pmlmepriv->scan_mode = SCAN_ACTIVE;
  62
  63         spin_lock_init(&pmlmepriv->lock);
  64         _rtw_init_queue23a(&pmlmepriv->scanned_queue);
  65
  66         memset(&pmlmepriv->assoc_ssid, 0, sizeof(struct cfg80211_ssid));
  67
  68         rtw_clear_scan_deny(padapter);
  69
  70         rtw_init_mlme_timer(padapter);
  71         return res;
  72 }
  73
  74 #ifdef CONFIG_8723AU_AP_MODE
  75 static void rtw_free_mlme_ie_data(u8 **ppie, u32 *plen)
  76 {
  77         if (*ppie) {
  78                 kfree(*ppie);
  79                 *plen = 0;
  80                 *ppie = NULL;
  81         }
  82 }
  83 #endif
  84
  85 void rtw23a_free_mlme_priv_ie_data(struct mlme_priv *pmlmepriv)
  86 {
  87 #ifdef CONFIG_8723AU_AP_MODE
  88         kfree(pmlmepriv->assoc_req);
  89         kfree(pmlmepriv->assoc_rsp);
  90         rtw_free_mlme_ie_data(&pmlmepriv->wps_probe_req_ie,
  91                               &pmlmepriv->wps_probe_req_ie_len);
  92 #endif
  93 }
  94
  95 void rtw_free_mlme_priv23a(struct mlme_priv *pmlmepriv)
  96 {
  97         RT_TRACE(_module_rtl871x_mlme_c_, _drv_err_,
  98                  ("rtw_free_mlme_priv23a\n"));
  99
 100         rtw23a_free_mlme_priv_ie_data(pmlmepriv);
 101 }
 102
 103 struct wlan_network *rtw_alloc_network(struct mlme_priv *pmlmepriv, gfp_t gfp)
 104 {
 105         struct wlan_network *pnetwork;
 106
 107         pnetwork = kzalloc(sizeof(struct wlan_network), gfp);
 108         if (pnetwork) {
 109                 INIT_LIST_HEAD(&pnetwork->list);
 110                 pnetwork->network_type = 0;
 111                 pnetwork->fixed = false;
 112                 pnetwork->last_scanned = jiffies;
 113                 pnetwork->aid = 0;
 114                 pnetwork->join_res = 0;
 115         }
 116
 117         return pnetwork;
 118 }
 119
 120 static void _rtw_free_network23a(struct mlme_priv *pmlmepriv,
 121                                  struct wlan_network *pnetwork)
 122 {
 123         if (!pnetwork)
 124                 return;
 125
 126         if (pnetwork->fixed == true)
 127                 return;
 128
 129         list_del_init(&pnetwork->list);
 130
 131         kfree(pnetwork);
 132 }
 133
 134 /*
 135  return the wlan_network with the matching addr
 136
 137  Shall be called under atomic context... to avoid possible racing condition...
 138 */
 139 struct wlan_network *
 140 rtw_find_network23a(struct rtw_queue *scanned_queue, u8 *addr)
 141 {
 142         struct list_head *phead, *plist;
 143         struct wlan_network *pnetwork = NULL;
 144
 145         if (is_zero_ether_addr(addr)) {
 146                 pnetwork = NULL;
 147                 goto exit;
 148         }
 149
 150         /* spin_lock_bh(&scanned_queue->lock); */
 151
 152         phead = get_list_head(scanned_queue);
 153         plist = phead->next;
 154
 155         while (plist != phead) {
 156                 pnetwork = container_of(plist, struct wlan_network, list);
 157
 158                 if (ether_addr_equal(addr, pnetwork->network.MacAddress))
 159                         break;
 160
 161                 plist = plist->next;
 162         }
 163
 164         if (plist == phead)
 165                 pnetwork = NULL;
 166
 167         /* spin_unlock_bh(&scanned_queue->lock); */
 168
 169 exit:
 170
 171         return pnetwork;
 172 }
 173
 174 void rtw_free_network_queue23a(struct rtw_adapter *padapter)
 175 {
 176         struct list_head *phead, *plist, *ptmp;
 177         struct wlan_network *pnetwork;
 178         struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
 179         struct rtw_queue *scanned_queue = &pmlmepriv->scanned_queue;
 180
 181         spin_lock_bh(&scanned_queue->lock);
 182
 183         phead = get_list_head(scanned_queue);
 184
 185         list_for_each_safe(plist, ptmp, phead) {
 186                 pnetwork = container_of(plist, struct wlan_network, list);
 187
 188                 _rtw_free_network23a(pmlmepriv, pnetwork);
 189         }
 190
 191         spin_unlock_bh(&scanned_queue->lock);
 192 }
 193
 194 int rtw_if_up23a(struct rtw_adapter *padapter)
 195 {
 196         int res;
 197
 198         if (padapter->bDriverStopped || padapter->bSurpriseRemoved ||
 199             !check_fwstate(&padapter->mlmepriv, _FW_LINKED)) {
 200                 RT_TRACE(_module_rtl871x_mlme_c_, _drv_info_,
 201                          ("rtw_if_up23a:bDriverStopped(%d) OR "
 202                           "bSurpriseRemoved(%d)", padapter->bDriverStopped,
 203                           padapter->bSurpriseRemoved));
 204                 res = false;
 205         } else
 206                 res =  true;
 207
 208         return res;
 209 }
 210
 211 void rtw_generate_random_ibss23a(u8 *pibss)
 212 {
 213         unsigned long curtime = jiffies;
 214
 215         pibss[0] = 0x02;  /* in ad-hoc mode bit1 must set to 1 */
 216         pibss[1] = 0x11;
 217         pibss[2] = 0x87;
 218         pibss[3] = curtime & 0xff;/* p[0]; */
 219         pibss[4] = (curtime >> 8) & 0xff;/* p[1]; */
 220         pibss[5] = (curtime >> 16) & 0xff;/* p[2]; */
 221
 222         return;
 223 }
 224
 225 void rtw_set_roaming(struct rtw_adapter *adapter, u8 to_roaming)
 226 {
 227         if (to_roaming == 0)
 228                 adapter->mlmepriv.to_join = false;
 229         adapter->mlmepriv.to_roaming = to_roaming;
 230 }
 231
 232 static void _rtw_roaming(struct rtw_adapter *padapter,
 233                          struct wlan_network *tgt_network)
 234 {
 235         struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
 236         struct wlan_network *pnetwork;
 237         int do_join_r;
 238
 239         if (tgt_network)
 240                 pnetwork = tgt_network;
 241         else
 242                 pnetwork = &pmlmepriv->cur_network;
 243
 244         if (padapter->mlmepriv.to_roaming > 0) {
 245                 DBG_8723A("roaming from %s("MAC_FMT"), length:%d\n",
 246                           pnetwork->network.Ssid.ssid,
 247                           MAC_ARG(pnetwork->network.MacAddress),
 248                           pnetwork->network.Ssid.ssid_len);
 249                 memcpy(&pmlmepriv->assoc_ssid, &pnetwork->network.Ssid,
 250                        sizeof(struct cfg80211_ssid));
 251
 252                 pmlmepriv->assoc_by_bssid = false;
 253
 254                 while (1) {
 255                         do_join_r = rtw_do_join(padapter);
 256                         if (do_join_r == _SUCCESS)
 257                                 break;
 258                         else {
 259                                 DBG_8723A("roaming do_join return %d\n",
 260                                           do_join_r);
 261                                 pmlmepriv->to_roaming--;
 262
 263                                 if (padapter->mlmepriv.to_roaming > 0)
 264                                         continue;
 265                                 else {
 266                                         DBG_8723A("%s(%d) -to roaming fail, "
 267                                                   "indicate_disconnect\n",
 268                                                   __func__, __LINE__);
 269                                         rtw_indicate_disconnect23a(padapter);
 270                                         break;
 271                                 }
 272                         }
 273                 }
 274         }
 275 }
 276
 277 void rtw23a_roaming(struct rtw_adapter *padapter,
 278                     struct wlan_network *tgt_network)
 279 {
 280         struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
 281
 282         spin_lock_bh(&pmlmepriv->lock);
 283         _rtw_roaming(padapter, tgt_network);
 284         spin_unlock_bh(&pmlmepriv->lock);
 285 }
 286
 287 static void rtw_free_network_nolock(struct mlme_priv *pmlmepriv,
 288                                     struct wlan_network *pnetwork)
 289 {
 290         _rtw_free_network23a(pmlmepriv, pnetwork);
 291 }
 292
 293 bool rtw_is_same_ibss23a(struct rtw_adapter *adapter,
 294                          struct wlan_network *pnetwork)
 295 {
 296         int ret;
 297         struct security_priv *psecuritypriv = &adapter->securitypriv;
 298
 299         if (psecuritypriv->dot11PrivacyAlgrthm != 0 &&
 300             pnetwork->network.Privacy == 0)
 301                 ret = false;
 302         else if (psecuritypriv->dot11PrivacyAlgrthm == 0 &&
 303                  pnetwork->network.Privacy == 1)
 304                 ret = false;
 305         else
 306                 ret = true;
 307
 308         return ret;
 309 }
 310
 311 inline int is_same_ess(struct wlan_bssid_ex *a, struct wlan_bssid_ex *b);
 312 inline int is_same_ess(struct wlan_bssid_ex *a, struct wlan_bssid_ex *b)
 313 {
 314         return (a->Ssid.ssid_len == b->Ssid.ssid_len) &&
 315                 !memcmp(a->Ssid.ssid, b->Ssid.ssid, a->Ssid.ssid_len);
 316 }
 317
 318 int is_same_network23a(struct wlan_bssid_ex *src, struct wlan_bssid_ex *dst)
 319 {
 320         u16 s_cap, d_cap;
 321
 322         s_cap = src->capability;
 323         d_cap = dst->capability;
 324
 325         return ((src->Ssid.ssid_len == dst->Ssid.ssid_len) &&
 326                 /*      (src->DSConfig == dst->DSConfig) && */
 327                 ether_addr_equal(src->MacAddress, dst->MacAddress) &&
 328                 !memcmp(src->Ssid.ssid, dst->Ssid.ssid, src->Ssid.ssid_len) &&
 329                 (s_cap & WLAN_CAPABILITY_IBSS) ==
 330                 (d_cap & WLAN_CAPABILITY_IBSS) &&
 331                 (s_cap & WLAN_CAPABILITY_ESS) == (d_cap & WLAN_CAPABILITY_ESS));
 332 }
 333
 334 struct wlan_network *
 335 rtw_get_oldest_wlan_network23a(struct rtw_queue *scanned_queue)
 336 {
 337         struct list_head *plist, *phead;
 338         struct wlan_network *pwlan;
 339         struct wlan_network *oldest = NULL;
 340
 341         phead = get_list_head(scanned_queue);
 342
 343         list_for_each(plist, phead) {
 344                 pwlan = container_of(plist, struct wlan_network, list);
 345
 346                 if (pwlan->fixed != true) {
 347                         if (!oldest || time_after(oldest->last_scanned,
 348                                                   pwlan->last_scanned))
 349                                 oldest = pwlan;
 350                 }
 351         }
 352
 353         return oldest;
 354 }
 355
 356 void update_network23a(struct wlan_bssid_ex *dst, struct wlan_bssid_ex *src,
 357                        struct rtw_adapter *padapter, bool update_ie)
 358 {
 359         u8 ss_ori = dst->PhyInfo.SignalStrength;
 360         u8 sq_ori = dst->PhyInfo.SignalQuality;
 361         long rssi_ori = dst->Rssi;
 362
 363         u8 ss_smp = src->PhyInfo.SignalStrength;
 364         u8 sq_smp = src->PhyInfo.SignalQuality;
 365         long rssi_smp = src->Rssi;
 366
 367         u8 ss_final;
 368         u8 sq_final;
 369         long rssi_final;
 370
 371         DBG_8723A("%s %s(%pM, ch%u) ss_ori:%3u, sq_ori:%3u, rssi_ori:%3ld, "
 372                   "ss_smp:%3u, sq_smp:%3u, rssi_smp:%3ld\n",
 373                   __func__, src->Ssid.ssid, src->MacAddress,
 374                   src->DSConfig, ss_ori, sq_ori, rssi_ori,
 375                   ss_smp, sq_smp, rssi_smp
 376         );
 377
 378         /* The rule below is 1/5 for sample value, 4/5 for history value */
 379         if (check_fwstate(&padapter->mlmepriv, _FW_LINKED) &&
 380             is_same_network23a(&padapter->mlmepriv.cur_network.network, src)) {
 381                 /* Take the recvpriv's value for the connected AP*/
 382                 ss_final = padapter->recvpriv.signal_strength;
 383                 sq_final = padapter->recvpriv.signal_qual;
 384                 /* the rssi value here is undecorated, and will be
 385                    used for antenna diversity */
 386                 if (sq_smp != 101) /* from the right channel */
 387                         rssi_final = (src->Rssi+dst->Rssi*4)/5;
 388                 else
 389                         rssi_final = rssi_ori;
 390         } else {
 391                 if (sq_smp != 101) { /* from the right channel */
 392                         ss_final = ((u32)src->PhyInfo.SignalStrength +
 393                                     (u32)dst->PhyInfo.SignalStrength * 4) / 5;
 394                         sq_final = ((u32)src->PhyInfo.SignalQuality +
 395                                     (u32)dst->PhyInfo.SignalQuality * 4) / 5;
 396                         rssi_final = src->Rssi+dst->Rssi * 4 / 5;
 397                 } else {
 398                         /* bss info not receiving from the right channel, use
 399                            the original RX signal infos */
 400                         ss_final = dst->PhyInfo.SignalStrength;
 401                         sq_final = dst->PhyInfo.SignalQuality;
 402                         rssi_final = dst->Rssi;
 403                 }
 404
 405         }
 406
 407         if (update_ie)
 408                 memcpy(dst, src, get_wlan_bssid_ex_sz(src));
 409
 410         dst->PhyInfo.SignalStrength = ss_final;
 411         dst->PhyInfo.SignalQuality = sq_final;
 412         dst->Rssi = rssi_final;
 413
 414         DBG_8723A("%s %s(%pM), SignalStrength:%u, SignalQuality:%u, "
 415                   "RawRSSI:%ld\n",  __func__, dst->Ssid.ssid, dst->MacAddress,
 416                   dst->PhyInfo.SignalStrength,
 417                   dst->PhyInfo.SignalQuality, dst->Rssi);
 418 }
 419
 420 static void update_current_network(struct rtw_adapter *adapter,
 421                                    struct wlan_bssid_ex *pnetwork)
 422 {
 423         struct mlme_priv *pmlmepriv = &adapter->mlmepriv;
 424
 425         if (check_fwstate(pmlmepriv, _FW_LINKED) &&
 426             is_same_network23a(&pmlmepriv->cur_network.network, pnetwork)) {
 427                 update_network23a(&pmlmepriv->cur_network.network,
 428                                   pnetwork, adapter, true);
 429
 430                 rtw_update_protection23a(adapter,
 431                                          pmlmepriv->cur_network.network.IEs,
 432                                          pmlmepriv->cur_network.network.IELength);
 433         }
 434 }
 435
 436 /*
 437
 438 Caller must hold pmlmepriv->lock first.
 439
 440 */
 441 static void rtw_update_scanned_network(struct rtw_adapter *adapter,
 442                                        struct wlan_bssid_ex *target)
 443 {
 444         struct list_head *plist, *phead;
 445         struct mlme_priv *pmlmepriv = &adapter->mlmepriv;
 446         struct wlan_network *pnetwork = NULL;
 447         struct wlan_network *oldest = NULL;
 448         struct rtw_queue *queue = &pmlmepriv->scanned_queue;
 449         u32 bssid_ex_sz;
 450         int found = 0;
 451
 452         spin_lock_bh(&queue->lock);
 453         phead = get_list_head(queue);
 454
 455         list_for_each(plist, phead) {
 456                 pnetwork = container_of(plist, struct wlan_network, list);
 457
 458                 if (is_same_network23a(&pnetwork->network, target)) {
 459                         found = 1;
 460                         break;
 461                 }
 462                 if (!oldest || time_after(oldest->last_scanned,
 463                                           pnetwork->last_scanned))
 464                         oldest = pnetwork;
 465         }
 466
 467         /* If we didn't find a match, then get a new network slot to initialize
 468          * with this beacon's information */
 469         if (!found) {
 470                 pnetwork = rtw_alloc_network(pmlmepriv, GFP_ATOMIC);
 471                 if (!pnetwork) {
 472                         if (!oldest) {
 473                                 RT_TRACE(_module_rtl871x_mlme_c_, _drv_err_,
 474                                          ("\n\n\nsomething wrong here\n\n\n"));
 475                                 goto exit;
 476                         }
 477                         pnetwork = oldest;
 478                 } else
 479                         list_add_tail(&pnetwork->list, &queue->queue);
 480
 481                 bssid_ex_sz = get_wlan_bssid_ex_sz(target);
 482                 target->Length = bssid_ex_sz;
 483                 memcpy(&pnetwork->network, target, bssid_ex_sz);
 484
 485                 /*  variable initialize */
 486                 pnetwork->fixed = false;
 487                 pnetwork->last_scanned = jiffies;
 488
 489                 pnetwork->network_type = 0;
 490                 pnetwork->aid = 0;
 491                 pnetwork->join_res = 0;
 492
 493                 /* bss info not receiving from the right channel */
 494                 if (pnetwork->network.PhyInfo.SignalQuality == 101)
 495                         pnetwork->network.PhyInfo.SignalQuality = 0;
 496         } else {
 497                 /*
 498                  * we have an entry and we are going to update it. But
 499                  * this entry may be already expired. In this case we
 500                  * do the same as we found a new net and call the
 501                  * new_net handler
 502                  */
 503                 bool update_ie = true;
 504
 505                 pnetwork->last_scanned = jiffies;
 506
 507                 /* target.reserved == 1, means that scanned network is
 508                  * a bcn frame. */
 509                 if (pnetwork->network.IELength > target->IELength &&
 510                     target->reserved == 1)
 511                         update_ie = false;
 512
 513                 update_network23a(&pnetwork->network, target, adapter,
 514                                   update_ie);
 515         }
 516
 517 exit:
 518         spin_unlock_bh(&queue->lock);
 519 }
 520
 521 static void rtw_add_network(struct rtw_adapter *adapter,
 522                             struct wlan_bssid_ex *pnetwork)
 523 {
 524         update_current_network(adapter, pnetwork);
 525         rtw_update_scanned_network(adapter, pnetwork);
 526 }
 527
 528 /* select the desired network based on the capability of the (i)bss. */
 529 /*  check items: (1) security */
 530 /*                         (2) network_type */
 531 /*                         (3) WMM */
 532 /*                         (4) HT */
 533 /*                      (5) others */
 534 static int rtw_is_desired_network(struct rtw_adapter *adapter,
 535                                   struct wlan_network *pnetwork)
 536 {
 537         struct security_priv *psecuritypriv = &adapter->securitypriv;
 538         struct mlme_priv *pmlmepriv = &adapter->mlmepriv;
 539         u32 desired_encmode;
 540         u32 privacy;
 541         int bselected = true;
 542
 543         desired_encmode = psecuritypriv->ndisencryptstatus;
 544         privacy = pnetwork->network.Privacy;
 545
 546         if (check_fwstate(pmlmepriv, WIFI_UNDER_WPS)) {
 547                 if (cfg80211_find_vendor_ie(WLAN_OUI_MICROSOFT,
 548                                             WLAN_OUI_TYPE_MICROSOFT_WPA,
 549                                             pnetwork->network.IEs,
 550                                             pnetwork->network.IELength))
 551                         return true;
 552                 else
 553                         return false;
 554         }
 555         if (adapter->registrypriv.wifi_spec == 1) {
 556                 /* for  correct flow of 8021X  to do.... */
 557                 if (desired_encmode == Ndis802_11EncryptionDisabled &&
 558                     privacy != 0)
 559                         bselected = false;
 560         }
 561
 562         if (desired_encmode != Ndis802_11EncryptionDisabled && privacy == 0) {
 563                 DBG_8723A("desired_encmode: %d, privacy: %d\n",
 564                           desired_encmode, privacy);
 565                 bselected = false;
 566         }
 567
 568         if (check_fwstate(pmlmepriv, WIFI_ADHOC_STATE)) {
 569                 if (pnetwork->network.ifmode !=
 570                     pmlmepriv->cur_network.network.ifmode)
 571                         bselected = false;
 572         }
 573
 574         return bselected;
 575 }
 576
 577 /* TODO: Perry : For Power Management */
 578 void rtw_atimdone_event_callback23a(struct rtw_adapter *adapter, const u8 *pbuf)
 579 {
 580         RT_TRACE(_module_rtl871x_mlme_c_, _drv_err_,
 581                  ("receive atimdone_evet\n"));
 582
 583         return;
 584 }
 585
 586 void rtw_survey_event_cb23a(struct rtw_adapter *adapter, const u8 *pbuf)
 587 {
 588         u32 len;
 589         struct wlan_bssid_ex *pnetwork;
 590         struct mlme_priv *pmlmepriv = &adapter->mlmepriv;
 591         struct survey_event *survey = (struct survey_event *)pbuf;
 592
 593         pnetwork = survey->bss;
 594
 595         RT_TRACE(_module_rtl871x_mlme_c_, _drv_info_,
 596                  ("rtw_survey_event_cb23a, ssid=%s\n", pnetwork->Ssid.ssid));
 597
 598         len = get_wlan_bssid_ex_sz(pnetwork);
 599         if (len > (sizeof(struct wlan_bssid_ex))) {
 600                 RT_TRACE(_module_rtl871x_mlme_c_, _drv_err_,
 601                          ("\n ****rtw_survey_event_cb23a: return a wrong "
 602                           "bss ***\n"));
 603                 return;
 604         }
 605
 606         spin_lock_bh(&pmlmepriv->lock);
 607
 608         /*  update IBSS_network 's timestamp */
 609         if (check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE)) {
 610                 /* RT_TRACE(_module_rtl871x_mlme_c_, _drv_err_,
 611                    "rtw_survey_event_cb23a : WIFI_ADHOC_MASTER_STATE\n\n"); */
 612                 if (ether_addr_equal(pmlmepriv->cur_network.network.MacAddress,
 613                                      pnetwork->MacAddress)) {
 614                         struct wlan_network *ibss_wlan;
 615
 616                         pmlmepriv->cur_network.network.beacon_interval =
 617                                 pnetwork->beacon_interval;
 618                         pmlmepriv->cur_network.network.capability =
 619                                 pnetwork->capability;
 620                         pmlmepriv->cur_network.network.tsf = pnetwork->tsf;
 621                         spin_lock_bh(&pmlmepriv->scanned_queue.lock);
 622                         ibss_wlan = rtw_find_network23a(
 623                                 &pmlmepriv->scanned_queue,
 624                                 pnetwork->MacAddress);
 625                         if (ibss_wlan) {
 626                                 pmlmepriv->cur_network.network.beacon_interval =
 627                                         ibss_wlan->network.beacon_interval;
 628                                 pmlmepriv->cur_network.network.capability =
 629                                         ibss_wlan->network.capability;
 630                                 pmlmepriv->cur_network.network.tsf =
 631                                         ibss_wlan->network.tsf;
 632                                 spin_unlock_bh(&pmlmepriv->scanned_queue.lock);
 633                                 goto exit;
 634                         }
 635                         spin_unlock_bh(&pmlmepriv->scanned_queue.lock);
 636                 }
 637         }
 638
 639         /*  lock pmlmepriv->lock when you accessing network_q */
 640         if (!check_fwstate(pmlmepriv, _FW_UNDER_LINKING)) {
 641                 if (pnetwork->Ssid.ssid[0] == 0)
 642                         pnetwork->Ssid.ssid_len = 0;
 643
 644                 rtw_add_network(adapter, pnetwork);
 645         }
 646
 647 exit:
 648
 649         spin_unlock_bh(&pmlmepriv->lock);
 650
 651         kfree(survey->bss);
 652         survey->bss = NULL;
 653
 654         return;
 655 }
 656
 657 void
 658 rtw_surveydone_event_callback23a(struct rtw_adapter *adapter, const u8 *pbuf)
 659 {
 660         struct mlme_priv *pmlmepriv = &adapter->mlmepriv;
 661         struct mlme_ext_priv *pmlmeext = &adapter->mlmeextpriv;
 662         int ret;
 663
 664         spin_lock_bh(&pmlmepriv->lock);
 665
 666         if (pmlmepriv->wps_probe_req_ie) {
 667                 pmlmepriv->wps_probe_req_ie_len = 0;
 668                 kfree(pmlmepriv->wps_probe_req_ie);
 669                 pmlmepriv->wps_probe_req_ie = NULL;
 670         }
 671
 672         RT_TRACE(_module_rtl871x_mlme_c_, _drv_info_,
 673                  ("rtw_surveydone_event_callback23a: fw_state:%x\n\n",
 674                   get_fwstate(pmlmepriv)));
 675
 676         if (check_fwstate(pmlmepriv, _FW_UNDER_SURVEY)) {
 677                 del_timer_sync(&pmlmepriv->scan_to_timer);
 678
 679                 _clr_fwstate_(pmlmepriv, _FW_UNDER_SURVEY);
 680         } else {
 681                 RT_TRACE(_module_rtl871x_mlme_c_, _drv_err_,
 682                          ("nic status =%x, survey done event comes too late!\n",
 683                           get_fwstate(pmlmepriv)));
 684         }
 685
 686         rtw_set_signal_stat_timer(&adapter->recvpriv);
 687
 688         if (pmlmepriv->to_join == true) {
 689                 set_fwstate(pmlmepriv, _FW_UNDER_LINKING);
 690                 if (check_fwstate(pmlmepriv, WIFI_ADHOC_STATE)) {
 691                         ret = rtw_select_and_join_from_scanned_queue23a(
 692                                 pmlmepriv);
 693                         if (ret != _SUCCESS)
 694                                 rtw_do_join_adhoc(adapter);
 695                 } else {
 696                         pmlmepriv->to_join = false;
 697                         ret = rtw_select_and_join_from_scanned_queue23a(
 698                                 pmlmepriv);
 699                         if (ret != _SUCCESS) {
 700                                 DBG_8723A("try_to_join, but select scanning "
 701                                           "queue fail, to_roaming:%d\n",
 702                                           adapter->mlmepriv.to_roaming);
 703                                 if (adapter->mlmepriv.to_roaming) {
 704                                         if (--pmlmepriv->to_roaming == 0 ||
 705                                             rtw_sitesurvey_cmd23a(
 706                                                     adapter,
 707                                                     &pmlmepriv->assoc_ssid, 1,
 708                                                     NULL, 0) != _SUCCESS) {
 709                                                 rtw_set_roaming(adapter, 0);
 710                                                 rtw_free_assoc_resources23a(
 711                                                         adapter, 1);
 712                                                 rtw_indicate_disconnect23a(
 713                                                         adapter);
 714                                         } else
 715                                                 pmlmepriv->to_join = true;
 716                                 }
 717                                 _clr_fwstate_(pmlmepriv, _FW_UNDER_LINKING);
 718                         }
 719                 }
 720         }
 721
 722         spin_unlock_bh(&pmlmepriv->lock);
 723
 724         rtw_os_xmit_schedule23a(adapter);
 725
 726         if (pmlmeext->sitesurvey_res.bss_cnt == 0)
 727                 rtw_sreset_reset(adapter);
 728
 729         rtw_cfg80211_surveydone_event_callback(adapter);
 730 }
 731
 732 static void free_scanqueue(struct mlme_priv *pmlmepriv)
 733 {
 734         struct wlan_network *pnetwork;
 735         struct rtw_queue *scan_queue = &pmlmepriv->scanned_queue;
 736         struct list_head *plist, *phead, *ptemp;
 737
 738         RT_TRACE(_module_rtl871x_mlme_c_, _drv_notice_, ("+free_scanqueue\n"));
 739         spin_lock_bh(&scan_queue->lock);
 740
 741         phead = get_list_head(scan_queue);
 742
 743         list_for_each_safe(plist, ptemp, phead) {
 744                 pnetwork = container_of(plist, struct wlan_network, list);
 745                 pnetwork->fixed = false;
 746                 _rtw_free_network23a(pmlmepriv, pnetwork);
 747         }
 748
 749         spin_unlock_bh(&scan_queue->lock);
 750 }
 751
 752 /*
 753  *rtw_free_assoc_resources23a: the caller has to lock pmlmepriv->lock
 754  */
 755 void rtw_free_assoc_resources23a(struct rtw_adapter *adapter,
 756                                  int lock_scanned_queue)
 757 {
 758         struct wlan_network *pwlan;
 759         struct mlme_priv *pmlmepriv = &adapter->mlmepriv;
 760         struct sta_priv *pstapriv = &adapter->stapriv;
 761         struct wlan_network *tgt_network = &pmlmepriv->cur_network;
 762         struct sta_info *psta;
 763
 764         RT_TRACE(_module_rtl871x_mlme_c_, _drv_notice_,
 765                  ("+rtw_free_assoc_resources23a\n"));
 766         RT_TRACE(_module_rtl871x_mlme_c_, _drv_info_,
 767                  ("tgt_network->network.MacAddress="MAC_FMT" ssid=%s\n",
 768                   MAC_ARG(tgt_network->network.MacAddress),
 769                   tgt_network->network.Ssid.ssid));
 770
 771         if (check_fwstate(pmlmepriv, WIFI_STATION_STATE|WIFI_AP_STATE)) {
 772                 psta = rtw_get_stainfo23a(&adapter->stapriv,
 773                                           tgt_network->network.MacAddress);
 774
 775                 spin_lock_bh(&pstapriv->sta_hash_lock);
 776                 rtw_free_stainfo23a(adapter,  psta);
 777                 spin_unlock_bh(&pstapriv->sta_hash_lock);
 778         }
 779
 780         if (check_fwstate(pmlmepriv, WIFI_ADHOC_STATE |
 781                           WIFI_ADHOC_MASTER_STATE|WIFI_AP_STATE)) {
 782                 rtw_free_all_stainfo23a(adapter);
 783
 784                 psta = rtw_get_bcmc_stainfo23a(adapter);
 785                 spin_lock_bh(&pstapriv->sta_hash_lock);
 786                 rtw_free_stainfo23a(adapter, psta);
 787                 spin_unlock_bh(&pstapriv->sta_hash_lock);
 788
 789                 rtw_init_bcmc_stainfo23a(adapter);
 790         }
 791
 792         if (lock_scanned_queue)
 793                 spin_lock_bh(&pmlmepriv->scanned_queue.lock);
 794
 795         pwlan = rtw_find_network23a(&pmlmepriv->scanned_queue,
 796                                     tgt_network->network.MacAddress);
 797         if (pwlan)
 798                 pwlan->fixed = false;
 799         else
 800                 RT_TRACE(_module_rtl871x_mlme_c_, _drv_err_,
 801                          ("rtw_free_assoc_resources23a : pwlan== NULL\n"));
 802
 803         if (check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE) &&
 804             adapter->stapriv.asoc_sta_count == 1)
 805                 rtw_free_network_nolock(pmlmepriv, pwlan);
 806
 807         if (lock_scanned_queue)
 808                 spin_unlock_bh(&pmlmepriv->scanned_queue.lock);
 809
 810         pmlmepriv->key_mask = 0;
 811 }
 812
 813 /*
 814 *rtw_indicate_connect23a: the caller has to lock pmlmepriv->lock
 815 */
 816 void rtw_indicate_connect23a(struct rtw_adapter *padapter)
 817 {
 818         struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
 819
 820         RT_TRACE(_module_rtl871x_mlme_c_, _drv_err_,
 821                  ("+rtw_indicate_connect23a\n"));
 822
 823         pmlmepriv->to_join = false;
 824
 825         if (!check_fwstate(&padapter->mlmepriv, _FW_LINKED)) {
 826                 set_fwstate(pmlmepriv, _FW_LINKED);
 827
 828                 rtw_led_control(padapter, LED_CTL_LINK);
 829
 830                 rtw_cfg80211_indicate_connect(padapter);
 831
 832                 netif_carrier_on(padapter->pnetdev);
 833
 834                 if (padapter->pid[2] != 0)
 835                         kill_pid(find_vpid(padapter->pid[2]), SIGALRM, 1);
 836         }
 837
 838         rtw_set_roaming(padapter, 0);
 839
 840         rtw_set_scan_deny(padapter, 3000);
 841
 842         RT_TRACE(_module_rtl871x_mlme_c_, _drv_err_,
 843                  ("-rtw_indicate_connect23a: fw_state=0x%08x\n",
 844                   get_fwstate(pmlmepriv)));
 845 }
 846
 847 /*
 848  *rtw_indicate_disconnect23a: the caller has to lock pmlmepriv->lock
 849  */
 850 void rtw_indicate_disconnect23a(struct rtw_adapter *padapter)
 851 {
 852         struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
 853
 854         RT_TRACE(_module_rtl871x_mlme_c_, _drv_err_,
 855                  ("+rtw_indicate_disconnect23a\n"));
 856
 857         _clr_fwstate_(pmlmepriv, _FW_UNDER_LINKING|WIFI_UNDER_WPS);
 858
 859         /* DBG_8723A("clear wps when %s\n", __func__); */
 860
 861         if (padapter->mlmepriv.to_roaming > 0)
 862                 _clr_fwstate_(pmlmepriv, _FW_LINKED);
 863
 864         if (check_fwstate(&padapter->mlmepriv, _FW_LINKED) ||
 865             padapter->mlmepriv.to_roaming <= 0) {
 866                 rtw_os_indicate_disconnect23a(padapter);
 867
 868                 /* set ips_deny_time to avoid enter IPS before LPS leave */
 869                 padapter->pwrctrlpriv.ips_deny_time =
 870                         jiffies + msecs_to_jiffies(3000);
 871
 872                 _clr_fwstate_(pmlmepriv, _FW_LINKED);
 873
 874                 rtw_led_control(padapter, LED_CTL_NO_LINK);
 875
 876                 rtw_clear_scan_deny(padapter);
 877
 878         }
 879
 880         rtw_lps_ctrl_wk_cmd23a(padapter, LPS_CTRL_DISCONNECT, 1);
 881 }
 882
 883 void rtw_scan_abort23a(struct rtw_adapter *adapter)
 884 {
 885         unsigned long start;
 886         struct mlme_priv *pmlmepriv = &adapter->mlmepriv;
 887         struct mlme_ext_priv *pmlmeext = &adapter->mlmeextpriv;
 888
 889         start = jiffies;
 890         pmlmeext->scan_abort = true;
 891         while (check_fwstate(pmlmepriv, _FW_UNDER_SURVEY) &&
 892                jiffies_to_msecs(jiffies - start) <= 200) {
 893                 if (adapter->bDriverStopped || adapter->bSurpriseRemoved)
 894                         break;
 895
 896                 DBG_8723A("%s(%s): fw_state = _FW_UNDER_SURVEY!\n",
 897                           __func__, adapter->pnetdev->name);
 898                 msleep(20);
 899         }
 900
 901         if (check_fwstate(pmlmepriv, _FW_UNDER_SURVEY)) {
 902                 if (!adapter->bDriverStopped && !adapter->bSurpriseRemoved)
 903                         DBG_8723A("%s(%s): waiting for scan_abort time out!\n",
 904                                   __func__, adapter->pnetdev->name);
 905                 rtw_cfg80211_indicate_scan_done(wdev_to_priv(adapter->rtw_wdev),
 906                                                 true);
 907         }
 908         pmlmeext->scan_abort = false;
 909 }
 910
 911 static struct sta_info *
 912 rtw_joinbss_update_stainfo(struct rtw_adapter *padapter,
 913                            struct wlan_network *pnetwork)
 914 {
 915         int i;
 916         struct sta_info *bmc_sta, *psta;
 917         struct recv_reorder_ctrl *preorder_ctrl;
 918         struct sta_priv *pstapriv = &padapter->stapriv;
 919
 920         psta = rtw_get_stainfo23a(pstapriv, pnetwork->network.MacAddress);
 921         if (!psta)
 922                 psta = rtw_alloc_stainfo23a(pstapriv,
 923                                             pnetwork->network.MacAddress,
 924                                             GFP_ATOMIC);
 925
 926         if (psta) { /* update ptarget_sta */
 927                 DBG_8723A("%s\n", __func__);
 928
 929                 psta->aid  = pnetwork->join_res;
 930                 psta->mac_id = 0;
 931
 932                 /* sta mode */
 933                 rtl8723a_SetHalODMVar(padapter, HAL_ODM_STA_INFO, psta, true);
 934
 935                 /* security related */
 936                 if (padapter->securitypriv.dot11AuthAlgrthm ==
 937                     dot11AuthAlgrthm_8021X) {
 938                         padapter->securitypriv.binstallGrpkey = 0;
 939                         padapter->securitypriv.busetkipkey = 0;
 940
 941                         psta->ieee8021x_blocked = true;
 942                         psta->dot118021XPrivacy =
 943                                 padapter->securitypriv.dot11PrivacyAlgrthm;
 944
 945                         memset(&psta->dot118021x_UncstKey, 0,
 946                                sizeof (union Keytype));
 947
 948                         memset(&psta->dot11tkiprxmickey, 0,
 949                                sizeof (union Keytype));
 950                         memset(&psta->dot11tkiptxmickey, 0,
 951                                sizeof (union Keytype));
 952
 953                         memset(&psta->dot11txpn, 0, sizeof (union pn48));
 954                         memset(&psta->dot11rxpn, 0, sizeof (union pn48));
 955                 }
 956
 957                 /*      Commented by Albert 2012/07/21 */
 958                 /*      When doing the WPS, the wps_ie_len won't equal to 0 */
 959                 /*      And the Wi-Fi driver shouldn't allow the data packet
 960                         to be transmitted. */
 961                 if (padapter->securitypriv.wps_ie_len != 0) {
 962                         psta->ieee8021x_blocked = true;
 963                         padapter->securitypriv.wps_ie_len = 0;
 964                 }
 965
 966                 /* for A-MPDU Rx reordering buffer control for bmc_sta &
 967                  * sta_info */
 968                 /* if A-MPDU Rx is enabled, resetting
 969                    rx_ordering_ctrl wstart_b(indicate_seq) to default
 970                    value = 0xffff */
 971                 /* todo: check if AP can send A-MPDU packets */
 972                 for (i = 0; i < 16 ; i++) {
 973                         /* preorder_ctrl = &precvpriv->recvreorder_ctrl[i]; */
 974                         preorder_ctrl = &psta->recvreorder_ctrl[i];
 975                         preorder_ctrl->enable = false;
 976                         preorder_ctrl->indicate_seq = 0xffff;
 977                         preorder_ctrl->wend_b = 0xffff;
 978                         /* max_ampdu_sz; ex. 32(kbytes) -> wsize_b = 32 */
 979                         preorder_ctrl->wsize_b = 64;
 980                 }
 981
 982                 bmc_sta = rtw_get_bcmc_stainfo23a(padapter);
 983                 if (bmc_sta) {
 984                         for (i = 0; i < 16 ; i++) {
 985                                 preorder_ctrl = &bmc_sta->recvreorder_ctrl[i];
 986                                 preorder_ctrl->enable = false;
 987                                 preorder_ctrl->indicate_seq = 0xffff;
 988                                 preorder_ctrl->wend_b = 0xffff;
 989                                 /* max_ampdu_sz; ex. 32(kbytes) ->
 990                                    wsize_b = 32 */
 991                                 preorder_ctrl->wsize_b = 64;
 992                         }
 993                 }
 994
 995                 /* misc. */
 996                 update_sta_info23a(padapter, psta);
 997
 998         }
 999
1000         return psta;
1001 }
1002
1003 /* pnetwork : returns from rtw23a_joinbss_event_cb */
1004 /* ptarget_wlan: found from scanned_queue */
1005 static void
1006 rtw_joinbss_update_network23a(struct rtw_adapter *padapter,
1007                               struct wlan_network *ptarget_wlan,
1008                               struct wlan_network  *pnetwork)
1009 {
1010         struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
1011         struct wlan_network *cur_network = &pmlmepriv->cur_network;
1012
1013         DBG_8723A("%s\n", __func__);
1014
1015         RT_TRACE(_module_rtl871x_mlme_c_, _drv_info_,
1016                  ("\nfw_state:%x, BSSID:"MAC_FMT"\n", get_fwstate(pmlmepriv),
1017                   MAC_ARG(pnetwork->network.MacAddress)));
1018
1019         /*  why not use ptarget_wlan?? */
1020         memcpy(&cur_network->network, &pnetwork->network,
1021                pnetwork->network.Length);
1022         /*  some IEs in pnetwork is wrong, so we should use ptarget_wlan IEs */
1023         cur_network->network.IELength = ptarget_wlan->network.IELength;
1024         memcpy(&cur_network->network.IEs[0], &ptarget_wlan->network.IEs[0],
1025                MAX_IE_SZ);
1026
1027         cur_network->network.capability = ptarget_wlan->network.capability;
1028         cur_network->network.beacon_interval =
1029                 ptarget_wlan->network.beacon_interval;
1030         cur_network->network.tsf = ptarget_wlan->network.tsf;
1031         cur_network->aid = pnetwork->join_res;
1032
1033         rtw_set_signal_stat_timer(&padapter->recvpriv);
1034         padapter->recvpriv.signal_strength =
1035                 ptarget_wlan->network.PhyInfo.SignalStrength;
1036         padapter->recvpriv.signal_qual =
1037                 ptarget_wlan->network.PhyInfo.SignalQuality;
1038         /*
1039          * the ptarget_wlan->network.Rssi is raw data, we use
1040          * ptarget_wlan->network.PhyInfo.SignalStrength instead (has scaled)
1041          */
1042         padapter->recvpriv.rssi = translate_percentage_to_dbm(
1043                 ptarget_wlan->network.PhyInfo.SignalStrength);
1044         DBG_8723A("%s signal_strength:%3u, rssi:%3d, signal_qual:%3u\n",
1045                   __func__, padapter->recvpriv.signal_strength,
1046                   padapter->recvpriv.rssi, padapter->recvpriv.signal_qual);
1047         rtw_set_signal_stat_timer(&padapter->recvpriv);
1048
1049         /* update fw_state will clr _FW_UNDER_LINKING here indirectly */
1050         switch (pnetwork->network.ifmode) {
1051         case NL80211_IFTYPE_P2P_CLIENT:
1052         case NL80211_IFTYPE_STATION:
1053                 if (pmlmepriv->fw_state & WIFI_UNDER_WPS)
1054                         pmlmepriv->fw_state = WIFI_STATION_STATE|WIFI_UNDER_WPS;
1055                 else
1056                         pmlmepriv->fw_state = WIFI_STATION_STATE;
1057                 break;
1058         case NL80211_IFTYPE_ADHOC:
1059                 pmlmepriv->fw_state = WIFI_ADHOC_STATE;
1060                 break;
1061         default:
1062                 pmlmepriv->fw_state = WIFI_NULL_STATE;
1063                 RT_TRACE(_module_rtl871x_mlme_c_, _drv_err_,
1064                          ("Invalid network_mode\n"));
1065                 break;
1066         }
1067
1068         rtw_update_protection23a(padapter, cur_network->network.IEs,
1069                                  cur_network->network.IELength);
1070
1071         rtw_update_ht_cap23a(padapter, cur_network->network.IEs,
1072                              cur_network->network.IELength);
1073 }
1074
1075 /*
1076  * Notes:
1077  * the function could be > passive_level (the same context as Rx tasklet)
1078  * pnetwork : returns from rtw23a_joinbss_event_cb
1079  * ptarget_wlan: found from scanned_queue
1080  * if join_res > 0, for (fw_state==WIFI_STATION_STATE),
1081  * we check if  "ptarget_sta" & "ptarget_wlan" exist.
1082  * if join_res > 0, for (fw_state==WIFI_ADHOC_STATE),
1083  * we only check if "ptarget_wlan" exist.
1084  * if join_res > 0, update "cur_network->network" from "pnetwork->network"
1085  * if (ptarget_wlan !=NULL).
1086  */
1087
1088 void rtw_joinbss_event_prehandle23a(struct rtw_adapter *adapter, u8 *pbuf)
1089 {
1090         struct sta_info *ptarget_sta, *pcur_sta;
1091         struct sta_priv *pstapriv = &adapter->stapriv;
1092         struct mlme_priv *pmlmepriv = &adapter->mlmepriv;
1093         struct wlan_network *pnetwork = (struct wlan_network *)pbuf;
1094         struct wlan_network *cur_network = &pmlmepriv->cur_network;
1095         struct wlan_network *pcur_wlan, *ptarget_wlan = NULL;
1096         bool the_same_macaddr;
1097
1098         RT_TRACE(_module_rtl871x_mlme_c_, _drv_info_,
1099                  ("joinbss event call back received with res=%d\n",
1100                   pnetwork->join_res));
1101
1102         if (pmlmepriv->assoc_ssid.ssid_len == 0) {
1103                 RT_TRACE(_module_rtl871x_mlme_c_, _drv_err_,
1104                          ("@@@@@   joinbss event call back  for Any SSid\n"));
1105         } else {
1106                 RT_TRACE(_module_rtl871x_mlme_c_, _drv_err_,
1107                          ("@@@@@   rtw23a_joinbss_event_cb for SSid:%s\n",
1108                           pmlmepriv->assoc_ssid.ssid));
1109         }
1110
1111         if (ether_addr_equal(pnetwork->network.MacAddress,
1112                              cur_network->network.MacAddress))
1113                 the_same_macaddr = true;
1114         else
1115                 the_same_macaddr = false;
1116
1117         pnetwork->network.Length = get_wlan_bssid_ex_sz(&pnetwork->network);
1118         if (pnetwork->network.Length > sizeof(struct wlan_bssid_ex)) {
1119                 RT_TRACE(_module_rtl871x_mlme_c_, _drv_err_,
1120                          ("\n\n ***joinbss_evt_callback return a wrong bss "
1121                           "***\n\n"));
1122                 return;
1123         }
1124
1125         spin_lock_bh(&pmlmepriv->lock);
1126
1127         RT_TRACE(_module_rtl871x_mlme_c_, _drv_info_,
1128                  ("\n rtw23a_joinbss_event_cb !! _enter_critical\n"));
1129
1130         if (pnetwork->join_res > 0) {
1131                 spin_lock_bh(&pmlmepriv->scanned_queue.lock);
1132                 if (check_fwstate(pmlmepriv, _FW_UNDER_LINKING)) {
1133                         /* s1. find ptarget_wlan */
1134                         if (check_fwstate(pmlmepriv, _FW_LINKED)) {
1135                                 if (the_same_macaddr == true) {
1136                                         ptarget_wlan = rtw_find_network23a(&pmlmepriv->scanned_queue, cur_network->network.MacAddress);
1137                                 } else {
1138                                         pcur_wlan = rtw_find_network23a(&pmlmepriv->scanned_queue, cur_network->network.MacAddress);
1139                                         if (pcur_wlan)
1140                                                 pcur_wlan->fixed = false;
1141
1142                                         pcur_sta = rtw_get_stainfo23a(pstapriv, cur_network->network.MacAddress);
1143                                         if (pcur_sta) {
1144                                                 spin_lock_bh(&pstapriv->sta_hash_lock);
1145                                                 rtw_free_stainfo23a(adapter,
1146                                                                     pcur_sta);
1147                                                 spin_unlock_bh(&pstapriv->sta_hash_lock);
1148                                         }
1149
1150                                         ptarget_wlan = rtw_find_network23a(&pmlmepriv->scanned_queue, pnetwork->network.MacAddress);
1151                                         if (check_fwstate(pmlmepriv,
1152                                                           WIFI_STATION_STATE)) {
1153                                                 if (ptarget_wlan)
1154                                                         ptarget_wlan->fixed =
1155                                                                 true;
1156                                         }
1157                                 }
1158
1159                         } else {
1160                                 ptarget_wlan = rtw_find_network23a(
1161                                         &pmlmepriv->scanned_queue,
1162                                         pnetwork->network.MacAddress);
1163                                 if (check_fwstate(pmlmepriv,
1164                                                   WIFI_STATION_STATE)) {
1165                                         if (ptarget_wlan)
1166                                                 ptarget_wlan->fixed = true;
1167                                 }
1168                         }
1169
1170                         /* s2. update cur_network */
1171                         if (ptarget_wlan)
1172                                 rtw_joinbss_update_network23a(adapter,
1173                                                               ptarget_wlan,
1174                                                               pnetwork);
1175                         else {
1176                                 RT_TRACE(_module_rtl871x_mlme_c_, _drv_err_,
1177                                          ("Can't find ptarget_wlan when "
1178                                           "joinbss_event callback\n"));
1179                                 spin_unlock_bh(&pmlmepriv->scanned_queue.lock);
1180                                 goto ignore_joinbss_callback;
1181                         }
1182
1183                         /* s3. find ptarget_sta & update ptarget_sta after
1184                            update cur_network only for station mode */
1185                         if (check_fwstate(pmlmepriv, WIFI_STATION_STATE)) {
1186                                 ptarget_sta = rtw_joinbss_update_stainfo(
1187                                         adapter, pnetwork);
1188                                 if (!ptarget_sta) {
1189                                         RT_TRACE(_module_rtl871x_mlme_c_,
1190                                                  _drv_err_,
1191                                                  ("Can't update stainfo when "
1192                                                   "joinbss_event callback\n"));
1193                                         spin_unlock_bh(&pmlmepriv->scanned_queue.lock);
1194                                         goto ignore_joinbss_callback;
1195                                 }
1196                         }
1197
1198                         /* s4. indicate connect */
1199                         if (check_fwstate(pmlmepriv, WIFI_STATION_STATE))
1200                                 rtw_indicate_connect23a(adapter);
1201                         else {
1202                                 /* adhoc mode will rtw_indicate_connect23a
1203                                    when rtw_stassoc_event_callback23a */
1204                                 RT_TRACE(_module_rtl871x_mlme_c_, _drv_info_,
1205                                          ("adhoc mode, fw_state:%x",
1206                                           get_fwstate(pmlmepriv)));
1207                         }
1208
1209                         /* s5. Cancle assoc_timer */
1210                         del_timer_sync(&pmlmepriv->assoc_timer);
1211
1212                         RT_TRACE(_module_rtl871x_mlme_c_, _drv_info_,
1213                                  ("Cancle assoc_timer\n"));
1214                 } else {
1215                         RT_TRACE(_module_rtl871x_mlme_c_, _drv_err_,
1216                                  ("rtw23a_joinbss_event_cb err: fw_state:%x",
1217                                  get_fwstate(pmlmepriv)));
1218                         spin_unlock_bh(&pmlmepriv->scanned_queue.lock);
1219                         goto ignore_joinbss_callback;
1220                 }
1221                 spin_unlock_bh(&pmlmepriv->scanned_queue.lock);
1222         } else if (pnetwork->join_res == -4) {
1223                 rtw_reset_securitypriv23a(adapter);
1224                 mod_timer(&pmlmepriv->assoc_timer,
1225                           jiffies + msecs_to_jiffies(1));
1226
1227                 /* rtw_free_assoc_resources23a(adapter, 1); */
1228
1229                 if (check_fwstate(pmlmepriv, _FW_UNDER_LINKING)) {
1230                         RT_TRACE(_module_rtl871x_mlme_c_, _drv_err_,
1231                                  ("fail! clear _FW_UNDER_LINKING ^^^fw_state="
1232                                   "%x\n", get_fwstate(pmlmepriv)));
1233                         _clr_fwstate_(pmlmepriv, _FW_UNDER_LINKING);
1234                 }
1235         } else {
1236                 /* if join_res < 0 (join fails), then try again */
1237                 mod_timer(&pmlmepriv->assoc_timer,
1238                           jiffies + msecs_to_jiffies(1));
1239                 _clr_fwstate_(pmlmepriv, _FW_UNDER_LINKING);
1240         }
1241
1242 ignore_joinbss_callback:
1243
1244         spin_unlock_bh(&pmlmepriv->lock);
1245 }
1246
1247 void rtw23a_joinbss_event_cb(struct rtw_adapter *adapter, const u8 *pbuf)
1248 {
1249         struct wlan_network *pnetwork = (struct wlan_network *)pbuf;
1250
1251         mlmeext_joinbss_event_callback23a(adapter, pnetwork->join_res);
1252
1253         rtw_os_xmit_schedule23a(adapter);
1254 }
1255
1256 void rtw_stassoc_event_callback23a(struct rtw_adapter *adapter, const u8 *pbuf)
1257 {
1258         struct sta_info *psta;
1259         struct mlme_priv *pmlmepriv = &adapter->mlmepriv;
1260         struct stassoc_event *pstassoc = (struct stassoc_event *)pbuf;
1261         struct wlan_network *cur_network = &pmlmepriv->cur_network;
1262         struct wlan_network *ptarget_wlan;
1263
1264         if (rtw_access_ctrl23a(adapter, pstassoc->macaddr) == false)
1265                 return;
1266
1267 #ifdef CONFIG_8723AU_AP_MODE
1268         if (check_fwstate(pmlmepriv, WIFI_AP_STATE)) {
1269                 psta = rtw_get_stainfo23a(&adapter->stapriv, pstassoc->macaddr);
1270                 if (psta) {
1271                         /* bss_cap_update_on_sta_join23a(adapter, psta); */
1272                         /* sta_info_update23a(adapter, psta); */
1273                         ap_sta_info_defer_update23a(adapter, psta);
1274                 }
1275                 return;
1276         }
1277 #endif
1278         /* for AD-HOC mode */
1279         psta = rtw_get_stainfo23a(&adapter->stapriv, pstassoc->macaddr);
1280         if (psta != NULL) {
1281                 /* the sta have been in sta_info_queue => do nothing */
1282                 RT_TRACE(_module_rtl871x_mlme_c_, _drv_err_,
1283                          ("Error: rtw_stassoc_event_callback23a: sta has "
1284                           "been in sta_hash_queue\n"));
1285                 /* between drv has received this event before and
1286                    fw have not yet to set key to CAM_ENTRY) */
1287                 return;
1288         }
1289
1290         psta = rtw_alloc_stainfo23a(&adapter->stapriv, pstassoc->macaddr,
1291                 GFP_KERNEL);
1292         if (!psta) {
1293                 RT_TRACE(_module_rtl871x_mlme_c_, _drv_err_,
1294                          ("Can't alloc sta_info when "
1295                           "rtw_stassoc_event_callback23a\n"));
1296                 return;
1297         }
1298
1299         /* to do : init sta_info variable */
1300         psta->qos_option = 0;
1301         psta->mac_id = (uint)pstassoc->cam_id;
1302         /* psta->aid = (uint)pstassoc->cam_id; */
1303         DBG_8723A("%s\n", __func__);
1304         /* for ad-hoc mode */
1305         rtl8723a_SetHalODMVar(adapter, HAL_ODM_STA_INFO, psta, true);
1306
1307         if (adapter->securitypriv.dot11AuthAlgrthm == dot11AuthAlgrthm_8021X)
1308                 psta->dot118021XPrivacy =
1309                         adapter->securitypriv.dot11PrivacyAlgrthm;
1310
1311         psta->ieee8021x_blocked = false;
1312
1313         spin_lock_bh(&pmlmepriv->lock);
1314
1315         if (check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE) ||
1316             check_fwstate(pmlmepriv, WIFI_ADHOC_STATE)) {
1317                 if (adapter->stapriv.asoc_sta_count == 2) {
1318                         spin_lock_bh(&pmlmepriv->scanned_queue.lock);
1319                         ptarget_wlan =
1320                                 rtw_find_network23a(&pmlmepriv->scanned_queue,
1321                                                     cur_network->network.MacAddress);
1322                         if (ptarget_wlan)
1323                                 ptarget_wlan->fixed = true;
1324                         spin_unlock_bh(&pmlmepriv->scanned_queue.lock);
1325                         /*  a sta + bc/mc_stainfo (not Ibss_stainfo) */
1326                         rtw_indicate_connect23a(adapter);
1327                 }
1328         }
1329
1330         spin_unlock_bh(&pmlmepriv->lock);
1331
1332         mlmeext_sta_add_event_callback23a(adapter, psta);
1333 }
1334
1335 void rtw_stadel_event_callback23a(struct rtw_adapter *adapter, const u8 *pbuf)
1336 {
1337         int mac_id;
1338         struct sta_info *psta;
1339         struct wlan_network *pwlan;
1340         struct wlan_bssid_ex *pdev_network;
1341         struct mlme_priv *pmlmepriv = &adapter->mlmepriv;
1342         struct stadel_event *pstadel = (struct stadel_event *)pbuf;
1343         struct sta_priv *pstapriv = &adapter->stapriv;
1344         struct wlan_network *tgt_network = &pmlmepriv->cur_network;
1345
1346         psta = rtw_get_stainfo23a(&adapter->stapriv, pstadel->macaddr);
1347         if (psta)
1348                 mac_id = psta->mac_id;
1349         else
1350                 mac_id = pstadel->mac_id;
1351
1352         DBG_8723A("%s(mac_id=%d)=" MAC_FMT "\n", __func__, mac_id,
1353                   MAC_ARG(pstadel->macaddr));
1354
1355         if (check_fwstate(pmlmepriv, WIFI_AP_STATE))
1356                 return;
1357
1358         mlmeext_sta_del_event_callback23a(adapter);
1359
1360         spin_lock_bh(&pmlmepriv->lock);
1361
1362         if (check_fwstate(pmlmepriv, WIFI_STATION_STATE)) {
1363                 if (adapter->mlmepriv.to_roaming > 0) {
1364                         /* this stadel_event is caused by roaming,
1365                            decrease to_roaming */
1366                         pmlmepriv->to_roaming--;
1367                 } else if (adapter->mlmepriv.to_roaming == 0)
1368                         rtw_set_roaming(adapter, adapter->registrypriv.max_roaming_times);
1369                 if (*((u16 *)pstadel->rsvd) != WLAN_REASON_EXPIRATION_CHK)
1370                         rtw_set_roaming(adapter, 0); /* don't roam */
1371
1372                 rtw_free_uc_swdec_pending_queue23a(adapter);
1373
1374                 rtw_free_assoc_resources23a(adapter, 1);
1375                 rtw_indicate_disconnect23a(adapter);
1376                 spin_lock_bh(&pmlmepriv->scanned_queue.lock);
1377                 /*  remove the network entry in scanned_queue */
1378                 pwlan = rtw_find_network23a(&pmlmepriv->scanned_queue,
1379                                             tgt_network->network.MacAddress);
1380                 if (pwlan) {
1381                         pwlan->fixed = false;
1382                         rtw_free_network_nolock(pmlmepriv, pwlan);
1383                 }
1384                 spin_unlock_bh(&pmlmepriv->scanned_queue.lock);
1385
1386                 _rtw_roaming(adapter, tgt_network);
1387         }
1388
1389         if (check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE) ||
1390             check_fwstate(pmlmepriv, WIFI_ADHOC_STATE)) {
1391
1392                 spin_lock_bh(&pstapriv->sta_hash_lock);
1393                 rtw_free_stainfo23a(adapter,  psta);
1394                 spin_unlock_bh(&pstapriv->sta_hash_lock);
1395
1396                 /* a sta + bc/mc_stainfo (not Ibss_stainfo) */
1397                 if (adapter->stapriv.asoc_sta_count == 1) {
1398                         spin_lock_bh(&pmlmepriv->scanned_queue.lock);
1399                         /* free old ibss network */
1400                         /* pwlan = rtw_find_network23a(
1401                            &pmlmepriv->scanned_queue, pstadel->macaddr); */
1402                         pwlan = rtw_find_network23a(&pmlmepriv->scanned_queue,
1403                                                     tgt_network->network.MacAddress);
1404                         if (pwlan) {
1405                                 pwlan->fixed = false;
1406                                 rtw_free_network_nolock(pmlmepriv, pwlan);
1407                         }
1408                         spin_unlock_bh(&pmlmepriv->scanned_queue.lock);
1409                         /* re-create ibss */
1410                         pdev_network = &adapter->registrypriv.dev_network;
1411
1412                         memcpy(pdev_network, &tgt_network->network,
1413                                get_wlan_bssid_ex_sz(&tgt_network->network));
1414
1415                         rtw_do_join_adhoc(adapter);
1416                 }
1417         }
1418
1419         spin_unlock_bh(&pmlmepriv->lock);
1420 }
1421
1422 /*
1423 * rtw23a_join_to_handler - Timeout/failure handler for CMD JoinBss
1424 * @adapter: pointer to _adapter structure
1425 */
1426 void rtw23a_join_to_handler (unsigned long data)
1427 {
1428         struct rtw_adapter *adapter = (struct rtw_adapter *)data;
1429         struct mlme_priv *pmlmepriv = &adapter->mlmepriv;
1430         int do_join_r;
1431
1432         DBG_8723A("%s, fw_state=%x\n", __func__, get_fwstate(pmlmepriv));
1433
1434         if (adapter->bDriverStopped || adapter->bSurpriseRemoved)
1435                 return;
1436
1437         spin_lock_bh(&pmlmepriv->lock);
1438
1439         if (adapter->mlmepriv.to_roaming > 0) {
1440                 /* join timeout caused by roaming */
1441                 while (1) {
1442                         pmlmepriv->to_roaming--;
1443                         if (adapter->mlmepriv.to_roaming != 0) {
1444                                 /* try another */
1445                                 DBG_8723A("%s try another roaming\n", __func__);
1446                                 do_join_r = rtw_do_join(adapter);
1447                                 if (do_join_r != _SUCCESS) {
1448                                         DBG_8723A("%s roaming do_join return "
1449                                                   "%d\n", __func__ , do_join_r);
1450                                         continue;
1451                                 }
1452                                 break;
1453                         } else {
1454                                 DBG_8723A("%s We've try roaming but fail\n",
1455                                           __func__);
1456                                 rtw_indicate_disconnect23a(adapter);
1457                                 break;
1458                         }
1459                 }
1460         } else {
1461                 rtw_indicate_disconnect23a(adapter);
1462                 free_scanqueue(pmlmepriv);/*  */
1463
1464                 /* indicate disconnect for the case that join_timeout and
1465                    check_fwstate != FW_LINKED */
1466                 rtw_cfg80211_indicate_disconnect(adapter);
1467         }
1468
1469         spin_unlock_bh(&pmlmepriv->lock);
1470
1471 }
1472
1473 /*
1474 * rtw_scan_timeout_handler23a - Timeout/Failure handler for CMD SiteSurvey
1475 * @data: pointer to _adapter structure
1476 */
1477 void rtw_scan_timeout_handler23a(unsigned long data)
1478 {
1479         struct rtw_adapter *adapter = (struct rtw_adapter *)data;
1480         struct mlme_priv *pmlmepriv = &adapter->mlmepriv;
1481
1482         DBG_8723A("%s(%s): fw_state =%x\n", __func__, adapter->pnetdev->name,
1483                   get_fwstate(pmlmepriv));
1484
1485         spin_lock_bh(&pmlmepriv->lock);
1486
1487         _clr_fwstate_(pmlmepriv, _FW_UNDER_SURVEY);
1488
1489         spin_unlock_bh(&pmlmepriv->lock);
1490
1491         rtw_cfg80211_indicate_scan_done(wdev_to_priv(adapter->rtw_wdev), true);
1492 }
1493
1494 void rtw_dynamic_check_timer_handler(unsigned long data)
1495 {
1496         struct rtw_adapter *adapter = (struct rtw_adapter *)data;
1497
1498         if (adapter->hw_init_completed == false)
1499                 goto out;
1500
1501         if (adapter->bDriverStopped == true ||
1502             adapter->bSurpriseRemoved == true)
1503                 goto out;
1504
1505         if (adapter->net_closed == true)
1506                 goto out;
1507
1508         rtw_dynamic_chk_wk_cmd23a(adapter);
1509
1510 out:
1511         mod_timer(&adapter->mlmepriv.dynamic_chk_timer,
1512                   jiffies + msecs_to_jiffies(2000));
1513 }
1514
1515 inline bool rtw_is_scan_deny(struct rtw_adapter *adapter)
1516 {
1517         struct mlme_priv *mlmepriv = &adapter->mlmepriv;
1518         return (atomic_read(&mlmepriv->set_scan_deny) != 0) ? true : false;
1519 }
1520
1521 void rtw_clear_scan_deny(struct rtw_adapter *adapter)
1522 {
1523         struct mlme_priv *mlmepriv = &adapter->mlmepriv;
1524         atomic_set(&mlmepriv->set_scan_deny, 0);
1525 }
1526
1527 void rtw_set_scan_deny_timer_hdl(unsigned long data)
1528 {
1529         struct rtw_adapter *adapter = (struct rtw_adapter *)data;
1530         rtw_clear_scan_deny(adapter);
1531 }
1532
1533 void rtw_set_scan_deny(struct rtw_adapter *adapter, u32 ms)
1534 {
1535         struct mlme_priv *mlmepriv = &adapter->mlmepriv;
1536
1537         atomic_set(&mlmepriv->set_scan_deny, 1);
1538         mod_timer(&mlmepriv->set_scan_deny_timer,
1539                   jiffies + msecs_to_jiffies(ms));
1540 }
1541
1542 #if defined(IEEE80211_SCAN_RESULT_EXPIRE)
1543 #define RTW_SCAN_RESULT_EXPIRE IEEE80211_SCAN_RESULT_EXPIRE/HZ*1000 -1000 /* 3000 -1000 */
1544 #else
1545 #define RTW_SCAN_RESULT_EXPIRE 2000
1546 #endif
1547
1548 /*
1549 * Select a new join candidate from the original @param candidate and
1550 *     @param competitor
1551 * @return true: candidate is updated
1552 * @return false: candidate is not updated
1553 */
1554 static int rtw_check_join_candidate(struct mlme_priv *pmlmepriv,
1555                                     struct wlan_network **candidate,
1556                                     struct wlan_network *competitor)
1557 {
1558         int updated = false;
1559         struct rtw_adapter *adapter;
1560
1561         adapter = container_of(pmlmepriv, struct rtw_adapter, mlmepriv);
1562
1563         /* check bssid, if needed */
1564         if (pmlmepriv->assoc_by_bssid == true) {
1565                 if (!ether_addr_equal(competitor->network.MacAddress,
1566                                       pmlmepriv->assoc_bssid))
1567                         goto exit;
1568         }
1569
1570         /* check ssid, if needed */
1571         if (pmlmepriv->assoc_ssid.ssid_len) {
1572                 if (competitor->network.Ssid.ssid_len !=
1573                     pmlmepriv->assoc_ssid.ssid_len ||
1574                     memcmp(competitor->network.Ssid.ssid,
1575                            pmlmepriv->assoc_ssid.ssid,
1576                            pmlmepriv->assoc_ssid.ssid_len))
1577                         goto exit;
1578         }
1579
1580         if (rtw_is_desired_network(adapter, competitor) == false)
1581                 goto exit;
1582
1583         if (adapter->mlmepriv.to_roaming > 0) {
1584                 unsigned int passed;
1585
1586                 passed = jiffies_to_msecs(jiffies - competitor->last_scanned);
1587                 if (passed >= RTW_SCAN_RESULT_EXPIRE ||
1588                     is_same_ess(&competitor->network,
1589                                 &pmlmepriv->cur_network.network) == false)
1590                         goto exit;
1591         }
1592
1593         if (!*candidate ||
1594             (*candidate)->network.Rssi<competitor->network.Rssi) {
1595                 *candidate = competitor;
1596                 updated = true;
1597         }
1598
1599         if (updated) {
1600                 DBG_8723A("[by_bssid:%u][assoc_ssid:%s][to_roaming:%u] "
1601                           "new candidate: %s("MAC_FMT") rssi:%d\n",
1602                           pmlmepriv->assoc_by_bssid,
1603                           pmlmepriv->assoc_ssid.ssid,
1604                           adapter->mlmepriv.to_roaming,
1605                           (*candidate)->network.Ssid.ssid,
1606                           MAC_ARG((*candidate)->network.MacAddress),
1607                           (int)(*candidate)->network.Rssi);
1608         }
1609
1610 exit:
1611         return updated;
1612 }
1613
1614 /*
1615 Calling context:
1616 The caller of the sub-routine will be in critical section...
1617
1618 The caller must hold the following spinlock
1619
1620 pmlmepriv->lock
1621
1622 */
1623
1624 static int rtw_do_join(struct rtw_adapter *padapter)
1625 {
1626         struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
1627         int ret;
1628
1629         pmlmepriv->cur_network.join_res = -2;
1630
1631         set_fwstate(pmlmepriv, _FW_UNDER_LINKING);
1632
1633         pmlmepriv->to_join = true;
1634
1635         ret = rtw_select_and_join_from_scanned_queue23a(pmlmepriv);
1636         if (ret == _SUCCESS) {
1637                 pmlmepriv->to_join = false;
1638         } else {
1639                 if (check_fwstate(pmlmepriv, WIFI_ADHOC_STATE)) {
1640                         /* switch to ADHOC_MASTER */
1641                         ret = rtw_do_join_adhoc(padapter);
1642                         if (ret != _SUCCESS)
1643                                 goto exit;
1644                 } else {
1645                         /*  can't associate ; reset under-linking */
1646                         _clr_fwstate_(pmlmepriv, _FW_UNDER_LINKING);
1647
1648                         ret = _FAIL;
1649                         pmlmepriv->to_join = false;
1650                 }
1651         }
1652
1653 exit:
1654         return ret;
1655 }
1656
1657 static struct wlan_network *
1658 rtw_select_candidate_from_queue(struct mlme_priv *pmlmepriv)
1659 {
1660         struct wlan_network *pnetwork, *candidate = NULL;
1661         struct rtw_queue *queue = &pmlmepriv->scanned_queue;
1662         struct list_head *phead, *plist, *ptmp;
1663
1664         spin_lock_bh(&pmlmepriv->scanned_queue.lock);
1665         phead = get_list_head(queue);
1666
1667         list_for_each_safe(plist, ptmp, phead) {
1668                 pnetwork = container_of(plist, struct wlan_network, list);
1669                 if (!pnetwork) {
1670                         RT_TRACE(_module_rtl871x_mlme_c_, _drv_err_,
1671                                  ("%s: return _FAIL:(pnetwork == NULL)\n",
1672                                   __func__));
1673                         goto exit;
1674                 }
1675
1676                 rtw_check_join_candidate(pmlmepriv, &candidate, pnetwork);
1677         }
1678
1679 exit:
1680         spin_unlock_bh(&pmlmepriv->scanned_queue.lock);
1681         return candidate;
1682 }
1683
1684
1685 int rtw_do_join_adhoc(struct rtw_adapter *adapter)
1686 {
1687         struct mlme_priv *pmlmepriv = &adapter->mlmepriv;
1688         struct wlan_bssid_ex *pdev_network;
1689         u8 *ibss;
1690         int ret;
1691
1692         pdev_network = &adapter->registrypriv.dev_network;
1693         ibss = adapter->registrypriv.dev_network.MacAddress;
1694
1695         _clr_fwstate_(pmlmepriv, _FW_UNDER_SURVEY);
1696
1697         RT_TRACE(_module_rtl871x_mlme_c_, _drv_err_,
1698                  ("switching to adhoc master\n"));
1699
1700         memcpy(&pdev_network->Ssid, &pmlmepriv->assoc_ssid,
1701                sizeof(struct cfg80211_ssid));
1702
1703         rtw_update_registrypriv_dev_network23a(adapter);
1704         rtw_generate_random_ibss23a(ibss);
1705
1706         pmlmepriv->fw_state = WIFI_ADHOC_MASTER_STATE;
1707
1708         ret = rtw_createbss_cmd23a(adapter);
1709         if (ret != _SUCCESS) {
1710                 RT_TRACE(_module_rtl871x_mlme_c_, _drv_err_,
1711                          ("Error =>rtw_createbss_cmd23a status FAIL\n"));
1712         } else  {
1713                 pmlmepriv->to_join = false;
1714         }
1715
1716         return ret;
1717 }
1718
1719 int rtw_do_join_network(struct rtw_adapter *adapter,
1720                         struct wlan_network *candidate)
1721 {
1722         int ret;
1723
1724         /*  check for situation of  _FW_LINKED */
1725         if (check_fwstate(&adapter->mlmepriv, _FW_LINKED)) {
1726                 DBG_8723A("%s: _FW_LINKED while ask_for_joinbss!\n", __func__);
1727
1728                 rtw_disassoc_cmd23a(adapter, 0, true);
1729                 rtw_indicate_disconnect23a(adapter);
1730                 rtw_free_assoc_resources23a(adapter, 0);
1731         }
1732         set_fwstate(&adapter->mlmepriv, _FW_UNDER_LINKING);
1733
1734         ret = rtw_joinbss_cmd23a(adapter, candidate);
1735
1736         if (ret == _SUCCESS)
1737                 mod_timer(&adapter->mlmepriv.assoc_timer,
1738                           jiffies + msecs_to_jiffies(MAX_JOIN_TIMEOUT));
1739
1740         return ret;
1741 }
1742
1743 int rtw_select_and_join_from_scanned_queue23a(struct mlme_priv *pmlmepriv)
1744 {
1745         struct rtw_adapter *adapter;
1746         struct wlan_network *candidate = NULL;
1747         int ret;
1748
1749         adapter = pmlmepriv->nic_hdl;
1750
1751         candidate = rtw_select_candidate_from_queue(pmlmepriv);
1752         if (!candidate) {
1753                 DBG_8723A("%s: return _FAIL(candidate == NULL)\n", __func__);
1754                 ret = _FAIL;
1755                 goto exit;
1756         } else {
1757                 DBG_8723A("%s: candidate: %s("MAC_FMT", ch:%u)\n", __func__,
1758                           candidate->network.Ssid.ssid,
1759                           MAC_ARG(candidate->network.MacAddress),
1760                           candidate->network.DSConfig);
1761         }
1762
1763         ret = rtw_do_join_network(adapter, candidate);
1764
1765 exit:
1766         return ret;
1767 }
1768
1769 int rtw_set_auth23a(struct rtw_adapter * adapter,
1770                     struct security_priv *psecuritypriv)
1771 {
1772         struct cmd_obj *pcmd;
1773         struct setauth_parm *psetauthparm;
1774         struct cmd_priv *pcmdpriv = &adapter->cmdpriv;
1775         int res = _SUCCESS;
1776
1777         pcmd = kzalloc(sizeof(struct cmd_obj), GFP_KERNEL);
1778         if (!pcmd) {
1779                 res = _FAIL;  /* try again */
1780                 goto exit;
1781         }
1782
1783         psetauthparm = kzalloc(sizeof(struct setauth_parm), GFP_KERNEL);
1784         if (!psetauthparm) {
1785                 kfree(pcmd);
1786                 res = _FAIL;
1787                 goto exit;
1788         }
1789
1790         psetauthparm->mode = (unsigned char)psecuritypriv->dot11AuthAlgrthm;
1791
1792         pcmd->cmdcode = _SetAuth_CMD_;
1793         pcmd->parmbuf = (unsigned char *)psetauthparm;
1794         pcmd->cmdsz =  (sizeof(struct setauth_parm));
1795         pcmd->rsp = NULL;
1796         pcmd->rspsz = 0;
1797
1798         RT_TRACE(_module_rtl871x_mlme_c_, _drv_err_,
1799                  ("after enqueue set_auth_cmd, auth_mode=%x\n",
1800                   psecuritypriv->dot11AuthAlgrthm));
1801
1802         res = rtw_enqueue_cmd23a(pcmdpriv, pcmd);
1803
1804 exit:
1805
1806         return res;
1807 }
1808
1809 int rtw_set_key23a(struct rtw_adapter *adapter,
1810                    struct security_priv *psecuritypriv, int keyid, u8 set_tx)
1811 {
1812         u8 keylen;
1813         struct cmd_obj *pcmd;
1814         struct setkey_parm *psetkeyparm;
1815         struct cmd_priv *pcmdpriv = &adapter->cmdpriv;
1816         struct mlme_priv *pmlmepriv = &adapter->mlmepriv;
1817         int res = _SUCCESS;
1818
1819         if (keyid >= 4) {
1820                 res = _FAIL;
1821                 goto exit;
1822         }
1823
1824         pcmd = kzalloc(sizeof(struct cmd_obj), GFP_KERNEL);
1825         if (!pcmd) {
1826                 res = _FAIL;  /* try again */
1827                 goto exit;
1828         }
1829         psetkeyparm = kzalloc(sizeof(struct setkey_parm), GFP_KERNEL);
1830         if (!psetkeyparm) {
1831                 kfree(pcmd);
1832                 res = _FAIL;
1833                 goto exit;
1834         }
1835
1836         if (psecuritypriv->dot11AuthAlgrthm == dot11AuthAlgrthm_8021X) {
1837                 psetkeyparm->algorithm = (unsigned char)
1838                         psecuritypriv->dot118021XGrpPrivacy;
1839                 RT_TRACE(_module_rtl871x_mlme_c_, _drv_err_,
1840                          ("\n rtw_set_key23a: psetkeyparm->algorithm = "
1841                           "(unsigned char)psecuritypriv->dot118021XGrpPrivacy "
1842                           "=%d\n", psetkeyparm->algorithm));
1843         } else {
1844                 psetkeyparm->algorithm = (u8)psecuritypriv->dot11PrivacyAlgrthm;
1845                 RT_TRACE(_module_rtl871x_mlme_c_, _drv_err_,
1846                          ("\n rtw_set_key23a: psetkeyparm->algorithm = (u8)"
1847                           "psecuritypriv->dot11PrivacyAlgrthm =%d\n",
1848                           psetkeyparm->algorithm));
1849         }
1850         psetkeyparm->keyid = keyid;/* 0~3 */
1851         psetkeyparm->set_tx = set_tx;
1852         if (is_wep_enc(psetkeyparm->algorithm))
1853                 pmlmepriv->key_mask |= BIT(psetkeyparm->keyid);
1854
1855         DBG_8723A("==> rtw_set_key23a algorithm(%x), keyid(%x), key_mask(%x)\n",
1856                   psetkeyparm->algorithm, psetkeyparm->keyid,
1857                   pmlmepriv->key_mask);
1858         RT_TRACE(_module_rtl871x_mlme_c_, _drv_err_,
1859                  ("\n rtw_set_key23a: psetkeyparm->algorithm =%d psetkeyparm->"
1860                   "keyid = (u8)keyid =%d\n", psetkeyparm->algorithm, keyid));
1861
1862         switch (psetkeyparm->algorithm) {
1863         case WLAN_CIPHER_SUITE_WEP40:
1864                 keylen = 5;
1865                 memcpy(&psetkeyparm->key[0],
1866                        &psecuritypriv->wep_key[keyid].key, keylen);
1867                 break;
1868         case WLAN_CIPHER_SUITE_WEP104:
1869                 keylen = 13;
1870                 memcpy(&psetkeyparm->key[0],
1871                        &psecuritypriv->wep_key[keyid].key, keylen);
1872                 break;
1873         case WLAN_CIPHER_SUITE_TKIP:
1874                 keylen = 16;
1875                 memcpy(&psetkeyparm->key,
1876                        &psecuritypriv->dot118021XGrpKey[keyid], keylen);
1877                 psetkeyparm->grpkey = 1;
1878                 break;
1879         case WLAN_CIPHER_SUITE_CCMP:
1880                 keylen = 16;
1881                 memcpy(&psetkeyparm->key,
1882                        &psecuritypriv->dot118021XGrpKey[keyid], keylen);
1883                 psetkeyparm->grpkey = 1;
1884                 break;
1885         default:
1886                 RT_TRACE(_module_rtl871x_mlme_c_, _drv_err_,
1887                          ("\n rtw_set_key23a:psecuritypriv->dot11PrivacyAlgrthm"
1888                           " = %x (must be 1 or 2 or 4 or 5)\n",
1889                           psecuritypriv->dot11PrivacyAlgrthm));
1890                 res = _FAIL;
1891                 kfree(pcmd);
1892                 kfree(psetkeyparm);
1893                 goto exit;
1894         }
1895
1896         pcmd->cmdcode = _SetKey_CMD_;
1897         pcmd->parmbuf = (u8 *)psetkeyparm;
1898         pcmd->cmdsz =  (sizeof(struct setkey_parm));
1899         pcmd->rsp = NULL;
1900         pcmd->rspsz = 0;
1901
1902         /* sema_init(&pcmd->cmd_sem, 0); */
1903
1904         res = rtw_enqueue_cmd23a(pcmdpriv, pcmd);
1905
1906 exit:
1907
1908         return res;
1909 }
1910
1911 /* adjust IEs for rtw_joinbss_cmd23a in WMM */
1912 int rtw_restruct_wmm_ie23a(struct rtw_adapter *adapter, u8 *in_ie,
1913                            u8 *out_ie, uint in_len, uint initial_out_len)
1914 {
1915         int ielength;
1916         const u8 *p;
1917
1918         ielength = initial_out_len;
1919
1920         p = cfg80211_find_vendor_ie(WLAN_OUI_MICROSOFT,
1921                                     WLAN_OUI_TYPE_MICROSOFT_WMM,
1922                                     in_ie, in_len);
1923
1924         if (p && p[1]) {
1925                 memcpy(out_ie + initial_out_len, p, 9);
1926
1927                 out_ie[initial_out_len + 1] = 7;
1928                 out_ie[initial_out_len + 6] = 0;
1929                 out_ie[initial_out_len + 8] = 0;
1930
1931                 ielength += 9;
1932         }
1933
1934         return ielength;
1935 }
1936
1937 /*  */
1938 /*  Ported from 8185: IsInPreAuthKeyList().
1939     (Renamed from SecIsInPreAuthKeyList(), 2006-10-13.) */
1940 /*  Added by Annie, 2006-05-07. */
1941 /*  */
1942 /*  Search by BSSID, */
1943 /*  Return Value: */
1944 /*              -1      :if there is no pre-auth key in the  table */
1945 /*              >= 0    :if there is pre-auth key, and   return the entry id */
1946 /*  */
1947 /*  */
1948
1949 static int SecIsInPMKIDList(struct rtw_adapter *Adapter, u8 *bssid)
1950 {
1951         struct security_priv *psecuritypriv = &Adapter->securitypriv;
1952         int i = 0;
1953
1954         do {
1955                 if (psecuritypriv->PMKIDList[i].bUsed &&
1956                     ether_addr_equal(psecuritypriv->PMKIDList[i].Bssid, bssid)) {
1957                         break;
1958                 } else {
1959                         i++;
1960                         /* continue; */
1961                 }
1962         } while (i < NUM_PMKID_CACHE);
1963
1964         if (i == NUM_PMKID_CACHE)
1965                 i = -1;/*  Could not find. */
1966         else {
1967                 /*  There is one Pre-Authentication Key for
1968                     the specific BSSID. */
1969         }
1970
1971         return i;
1972 }
1973
1974 /*  */
1975 /*  Check the RSN IE length */
1976 /*  If the RSN IE length <= 20, the RSN IE didn't include
1977     the PMKID information */
1978 /*  0-11th element in the array are the fixed IE */
1979 /*  12th element in the array is the IE */
1980 /*  13th element in the array is the IE length */
1981 /*  */
1982
1983 static int rtw_append_pmkid(struct rtw_adapter *Adapter, int iEntry,
1984                             u8 *ie, uint ie_len)
1985 {
1986         struct security_priv *psecuritypriv = &Adapter->securitypriv;
1987
1988         if (ie[1] <= 20) {
1989                 /*  The RSN IE didn't include the PMK ID,
1990                     append the PMK information */
1991                         ie[ie_len] = 1;
1992                         ie_len++;
1993                         ie[ie_len] = 0; /* PMKID count = 0x0100 */
1994                         ie_len++;
1995                         memcpy(&ie[ie_len],
1996                                &psecuritypriv->PMKIDList[iEntry].PMKID, 16);
1997
1998                         ie_len += 16;
1999                         ie[1] += 18;/* PMKID length = 2+16 */
2000         }
2001         return ie_len;
2002 }
2003
2004 int rtw_restruct_sec_ie23a(struct rtw_adapter *adapter, u8 *in_ie, u8 *out_ie,
2005                            uint in_len)
2006 {
2007         u8 authmode;
2008         uint ielength;
2009         int iEntry;
2010         struct mlme_priv *pmlmepriv = &adapter->mlmepriv;
2011         struct security_priv *psecuritypriv = &adapter->securitypriv;
2012         uint ndisauthmode = psecuritypriv->ndisauthtype;
2013         uint ndissecuritytype = psecuritypriv->ndisencryptstatus;
2014
2015         RT_TRACE(_module_rtl871x_mlme_c_, _drv_notice_,
2016                  ("+rtw_restruct_sec_ie23a: ndisauthmode=%d "
2017                   "ndissecuritytype=%d\n", ndisauthmode, ndissecuritytype));
2018
2019         ielength = 0;
2020         if (ndisauthmode == Ndis802_11AuthModeWPA ||
2021             ndisauthmode == Ndis802_11AuthModeWPAPSK)
2022                 authmode = WLAN_EID_VENDOR_SPECIFIC;
2023         if (ndisauthmode == Ndis802_11AuthModeWPA2 ||
2024             ndisauthmode == Ndis802_11AuthModeWPA2PSK)
2025                 authmode = WLAN_EID_RSN;
2026
2027         if (check_fwstate(pmlmepriv, WIFI_UNDER_WPS)) {
2028                 memcpy(out_ie + ielength, psecuritypriv->wps_ie,
2029                        psecuritypriv->wps_ie_len);
2030
2031                 ielength += psecuritypriv->wps_ie_len;
2032         } else if (authmode == WLAN_EID_VENDOR_SPECIFIC ||
2033                    authmode == WLAN_EID_RSN) {
2034                 /* copy RSN or SSN */
2035                 memcpy(&out_ie[ielength], &psecuritypriv->supplicant_ie[0],
2036                        psecuritypriv->supplicant_ie[1] + 2);
2037                 ielength += psecuritypriv->supplicant_ie[1] + 2;
2038         }
2039
2040         iEntry = SecIsInPMKIDList(adapter, pmlmepriv->assoc_bssid);
2041         if (iEntry < 0)
2042                 return ielength;
2043         else {
2044                 if (authmode == WLAN_EID_RSN)
2045                         ielength = rtw_append_pmkid(adapter, iEntry,
2046                                                     out_ie, ielength);
2047         }
2048
2049         return ielength;
2050 }
2051
2052 void rtw_init_registrypriv_dev_network23a(struct rtw_adapter *adapter)
2053 {
2054         struct registry_priv *pregistrypriv = &adapter->registrypriv;
2055         struct eeprom_priv *peepriv = &adapter->eeprompriv;
2056         struct wlan_bssid_ex    *pdev_network = &pregistrypriv->dev_network;
2057         u8 *myhwaddr = myid(peepriv);
2058
2059         ether_addr_copy(pdev_network->MacAddress, myhwaddr);
2060
2061         memcpy(&pdev_network->Ssid, &pregistrypriv->ssid,
2062                sizeof(struct cfg80211_ssid));
2063
2064         pdev_network->beacon_interval = 100;
2065 }
2066
2067 void rtw_update_registrypriv_dev_network23a(struct rtw_adapter *adapter)
2068 {
2069         int sz = 0;
2070         struct registry_priv *pregistrypriv = &adapter->registrypriv;
2071         struct wlan_bssid_ex *pdev_network = &pregistrypriv->dev_network;
2072         struct security_priv *psecuritypriv = &adapter->securitypriv;
2073         struct wlan_network *cur_network = &adapter->mlmepriv.cur_network;
2074         /* struct       xmit_priv       *pxmitpriv = &adapter->xmitpriv; */
2075
2076         pdev_network->Privacy =
2077                 (psecuritypriv->dot11PrivacyAlgrthm > 0 ? 1 : 0);
2078
2079         pdev_network->Rssi = 0;
2080
2081         pdev_network->DSConfig = pregistrypriv->channel;
2082         RT_TRACE(_module_rtl871x_mlme_c_, _drv_info_,
2083                  ("pregistrypriv->channel =%d, pdev_network->DSConfig = 0x%x\n",
2084                   pregistrypriv->channel, pdev_network->DSConfig));
2085
2086         if (cur_network->network.ifmode == NL80211_IFTYPE_ADHOC)
2087                 pdev_network->ATIMWindow = 0;
2088
2089         pdev_network->ifmode = cur_network->network.ifmode;
2090
2091         /*  1. Supported rates */
2092         /*  2. IE */
2093
2094         sz = rtw_generate_ie23a(pregistrypriv);
2095
2096         pdev_network->IELength = sz;
2097
2098         pdev_network->Length =
2099                 get_wlan_bssid_ex_sz(pdev_network);
2100
2101         /* notes: translate IELength & Length after assign the
2102            Length to cmdsz in createbss_cmd(); */
2103         /* pdev_network->IELength = cpu_to_le32(sz); */
2104 }
2105
2106 /* the function is at passive_level */
2107 void rtw_joinbss_reset23a(struct rtw_adapter *padapter)
2108 {
2109         u8 threshold;
2110         struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
2111         struct ht_priv *phtpriv = &pmlmepriv->htpriv;
2112
2113         /* todo: if you want to do something io/reg/hw setting
2114            before join_bss, please add code here */
2115
2116         pmlmepriv->num_FortyMHzIntolerant = 0;
2117
2118         pmlmepriv->num_sta_no_ht = 0;
2119
2120         phtpriv->ampdu_enable = false;/* reset to disabled */
2121
2122         /*  TH = 1 => means that invalidate usb rx aggregation */
2123         /*  TH = 0 => means that validate usb rx aggregation, use init value. */
2124         if (phtpriv->ht_option) {
2125                 if (padapter->registrypriv.wifi_spec == 1)
2126                         threshold = 1;
2127                 else
2128                         threshold = 0;
2129         } else
2130                 threshold = 1;
2131
2132         rtl8723a_set_rxdma_agg_pg_th(padapter, threshold);
2133 }
2134
2135 /* the function is >= passive_level */
2136 bool rtw_restructure_ht_ie23a(struct rtw_adapter *padapter, u8 *in_ie,
2137                               u8 *out_ie, uint in_len, uint *pout_len)
2138 {
2139         u32 out_len;
2140         int max_rx_ampdu_factor;
2141         unsigned char *pframe;
2142         const u8 *p;
2143         struct ieee80211_ht_cap ht_capie;
2144         u8 WMM_IE[7] = {0x00, 0x50, 0xf2, 0x02, 0x00, 0x01, 0x00};
2145         struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
2146         struct ht_priv *phtpriv = &pmlmepriv->htpriv;
2147
2148         phtpriv->ht_option = false;
2149
2150         p = cfg80211_find_ie(WLAN_EID_HT_CAPABILITY, in_ie, in_len);
2151
2152         if (p && p[1] > 0) {
2153                 u32 rx_packet_offset, max_recvbuf_sz;
2154                 if (pmlmepriv->qos_option == 0) {
2155                         out_len = *pout_len;
2156                         pframe = rtw_set_ie23a(out_ie + out_len,
2157                                                WLAN_EID_VENDOR_SPECIFIC,
2158                                                sizeof(WMM_IE), WMM_IE,
2159                                                pout_len);
2160
2161                         pmlmepriv->qos_option = 1;
2162                 }
2163
2164                 out_len = *pout_len;
2165
2166                 memset(&ht_capie, 0, sizeof(struct ieee80211_ht_cap));
2167
2168                 ht_capie.cap_info = IEEE80211_HT_CAP_SUP_WIDTH_20_40 |
2169                         IEEE80211_HT_CAP_SGI_20 | IEEE80211_HT_CAP_SGI_40 |
2170                         IEEE80211_HT_CAP_TX_STBC | IEEE80211_HT_CAP_DSSSCCK40;
2171
2172                 GetHalDefVar8192CUsb(padapter, HAL_DEF_RX_PACKET_OFFSET,
2173                                      &rx_packet_offset);
2174                 GetHalDefVar8192CUsb(padapter, HAL_DEF_MAX_RECVBUF_SZ,
2175                                      &max_recvbuf_sz);
2176
2177                 GetHalDefVar8192CUsb(padapter, HW_VAR_MAX_RX_AMPDU_FACTOR,
2178                                      &max_rx_ampdu_factor);
2179                 ht_capie.ampdu_params_info = max_rx_ampdu_factor & 0x03;
2180
2181                 if (padapter->securitypriv.dot11PrivacyAlgrthm ==
2182                     WLAN_CIPHER_SUITE_CCMP)
2183                         ht_capie.ampdu_params_info |=
2184                                 (IEEE80211_HT_AMPDU_PARM_DENSITY& (0x07 << 2));
2185                 else
2186                         ht_capie.ampdu_params_info |=
2187                                 (IEEE80211_HT_AMPDU_PARM_DENSITY & 0x00);
2188
2189                 pframe = rtw_set_ie23a(out_ie + out_len, WLAN_EID_HT_CAPABILITY,
2190                                     sizeof(struct ieee80211_ht_cap),
2191                                     (unsigned char *)&ht_capie, pout_len);
2192
2193                 phtpriv->ht_option = true;
2194
2195                 p = cfg80211_find_ie(WLAN_EID_HT_OPERATION, in_ie, in_len);
2196                 if (p && (p[1] == sizeof(struct ieee80211_ht_operation))) {
2197                         out_len = *pout_len;
2198                         pframe = rtw_set_ie23a(out_ie + out_len,
2199                                                WLAN_EID_HT_OPERATION,
2200                                                p[1], p + 2 , pout_len);
2201                 }
2202         }
2203
2204         return phtpriv->ht_option;
2205 }
2206
2207 /* the function is > passive_level (in critical_section) */
2208 void rtw_update_ht_cap23a(struct rtw_adapter *padapter, u8 *pie, uint ie_len)
2209 {
2210         u8 max_ampdu_sz;
2211         const u8 *p;
2212         struct ieee80211_ht_cap *pht_capie;
2213         struct ieee80211_ht_operation *pht_addtinfo;
2214         struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
2215         struct ht_priv *phtpriv = &pmlmepriv->htpriv;
2216         struct registry_priv *pregistrypriv = &padapter->registrypriv;
2217         struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
2218         struct mlme_ext_info *pmlmeinfo = &pmlmeext->mlmext_info;
2219
2220         if (!phtpriv->ht_option)
2221                 return;
2222
2223         if ((!pmlmeinfo->HT_info_enable) || (!pmlmeinfo->HT_caps_enable))
2224                 return;
2225
2226         DBG_8723A("+rtw_update_ht_cap23a()\n");
2227
2228         /* maybe needs check if ap supports rx ampdu. */
2229         if (!phtpriv->ampdu_enable && pregistrypriv->ampdu_enable == 1) {
2230                 if (pregistrypriv->wifi_spec == 1)
2231                         phtpriv->ampdu_enable = false;
2232                 else
2233                         phtpriv->ampdu_enable = true;
2234         } else if (pregistrypriv->ampdu_enable == 2)
2235                 phtpriv->ampdu_enable = true;
2236
2237         /* check Max Rx A-MPDU Size */
2238         p = cfg80211_find_ie(WLAN_EID_HT_CAPABILITY, pie, ie_len);
2239
2240         if (p && p[1] > 0) {
2241                 pht_capie = (struct ieee80211_ht_cap *)(p + 2);
2242                 max_ampdu_sz = pht_capie->ampdu_params_info &
2243                         IEEE80211_HT_AMPDU_PARM_FACTOR;
2244                 /*  max_ampdu_sz (kbytes); */
2245                 max_ampdu_sz = 1 << (max_ampdu_sz + 3);
2246
2247                 phtpriv->rx_ampdu_maxlen = max_ampdu_sz;
2248         }
2249
2250         p = cfg80211_find_ie(WLAN_EID_HT_OPERATION, pie, ie_len);
2251         if (p && p[1] > 0) {
2252                 pht_addtinfo = (struct ieee80211_ht_operation *)(p + 2);
2253                 /* todo: */
2254         }
2255
2256         /* update cur_bwmode & cur_ch_offset */
2257         if (pregistrypriv->cbw40_enable &&
2258             pmlmeinfo->ht_cap.cap_info &
2259             cpu_to_le16(IEEE80211_HT_CAP_SUP_WIDTH_20_40) &&
2260             pmlmeinfo->HT_info.ht_param & IEEE80211_HT_PARAM_CHAN_WIDTH_ANY) {
2261                 int i;
2262                 u8 rf_type;
2263
2264                 rf_type = rtl8723a_get_rf_type(padapter);
2265
2266                 /* update the MCS rates */
2267                 for (i = 0; i < IEEE80211_HT_MCS_MASK_LEN; i++) {
2268                         if (rf_type == RF_1T1R || rf_type == RF_1T2R)
2269                                 pmlmeinfo->ht_cap.mcs.rx_mask[i] &=
2270                                         MCS_rate_1R23A[i];
2271                         else
2272                                 pmlmeinfo->ht_cap.mcs.rx_mask[i] &=
2273                                         MCS_rate_2R23A[i];
2274                 }
2275                 /* switch to the 40M Hz mode according to the AP */
2276                 pmlmeext->cur_bwmode = HT_CHANNEL_WIDTH_40;
2277                 switch (pmlmeinfo->HT_info.ht_param &
2278                         IEEE80211_HT_PARAM_CHA_SEC_OFFSET) {
2279                 case IEEE80211_HT_PARAM_CHA_SEC_ABOVE:
2280                         pmlmeext->cur_ch_offset = HAL_PRIME_CHNL_OFFSET_LOWER;
2281                         break;
2282
2283                 case IEEE80211_HT_PARAM_CHA_SEC_BELOW:
2284                         pmlmeext->cur_ch_offset = HAL_PRIME_CHNL_OFFSET_UPPER;
2285                         break;
2286
2287                 default:
2288                         pmlmeext->cur_ch_offset =
2289                                 HAL_PRIME_CHNL_OFFSET_DONT_CARE;
2290                         break;
2291                 }
2292         }
2293
2294         /*  */
2295         /*  Config SM Power Save setting */
2296         /*  */
2297         pmlmeinfo->SM_PS =
2298                 (le16_to_cpu(pmlmeinfo->ht_cap.cap_info) &
2299                  IEEE80211_HT_CAP_SM_PS) >> IEEE80211_HT_CAP_SM_PS_SHIFT;
2300         if (pmlmeinfo->SM_PS == WLAN_HT_CAP_SM_PS_STATIC)
2301                 DBG_8723A("%s(): WLAN_HT_CAP_SM_PS_STATIC\n", __func__);
2302
2303         /*  */
2304         /*  Config current HT Protection mode. */
2305         /*  */
2306         pmlmeinfo->HT_protection =
2307                 le16_to_cpu(pmlmeinfo->HT_info.operation_mode) &
2308                 IEEE80211_HT_OP_MODE_PROTECTION;
2309 }
2310
2311 void rtw_issue_addbareq_cmd23a(struct rtw_adapter *padapter,
2312                                struct xmit_frame *pxmitframe)
2313 {
2314         u8 issued;
2315         int priority;
2316         struct sta_info *psta;
2317         struct ht_priv  *phtpriv;
2318         struct pkt_attrib *pattrib = &pxmitframe->attrib;
2319         s32 bmcst = is_multicast_ether_addr(pattrib->ra);
2320
2321         if (bmcst || padapter->mlmepriv.LinkDetectInfo.NumTxOkInPeriod < 100)
2322                 return;
2323
2324         priority = pattrib->priority;
2325
2326         if (pattrib->psta)
2327                 psta = pattrib->psta;
2328         else {
2329                 DBG_8723A("%s, call rtw_get_stainfo23a()\n", __func__);
2330                 psta = rtw_get_stainfo23a(&padapter->stapriv, pattrib->ra);
2331         }
2332
2333         if (!psta) {
2334                 DBG_8723A("%s, psta == NUL\n", __func__);
2335                 return;
2336         }
2337
2338         if (!(psta->state &_FW_LINKED)) {
2339                 DBG_8723A("%s, psta->state(0x%x) != _FW_LINKED\n",
2340                           __func__, psta->state);
2341                 return;
2342         }
2343
2344         phtpriv = &psta->htpriv;
2345
2346         if (phtpriv->ht_option && phtpriv->ampdu_enable) {
2347                 issued = (phtpriv->agg_enable_bitmap>>priority)&0x1;
2348                 issued |= (phtpriv->candidate_tid_bitmap>>priority)&0x1;
2349
2350                 if (issued == 0) {
2351                         DBG_8723A("rtw_issue_addbareq_cmd23a, p =%d\n",
2352                                   priority);
2353                         psta->htpriv.candidate_tid_bitmap |= BIT(priority);
2354                         rtw_addbareq_cmd23a(padapter, (u8) priority,
2355                                             pattrib->ra);
2356                 }
2357         }
2358 }
2359
2360 int rtw_linked_check(struct rtw_adapter *padapter)
2361 {
2362         if (check_fwstate(&padapter->mlmepriv, WIFI_AP_STATE) ||
2363             check_fwstate(&padapter->mlmepriv,
2364                           WIFI_ADHOC_STATE|WIFI_ADHOC_MASTER_STATE)) {
2365                 if (padapter->stapriv.asoc_sta_count > 2)
2366                         return true;
2367         } else {        /* Station mode */
2368                 if (check_fwstate(&padapter->mlmepriv, _FW_LINKED))
2369                         return true;
2370         }
2371         return false;
2372 }