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_,("receive atimdone_evet\n"));
 581
 582         return;
 583 }
 584
 585 void rtw_survey_event_cb23a(struct rtw_adapter *adapter, const u8 *pbuf)
 586 {
 587         u32 len;
 588         struct wlan_bssid_ex *pnetwork;
 589         struct mlme_priv *pmlmepriv = &adapter->mlmepriv;
 590         struct survey_event *survey = (struct survey_event *)pbuf;
 591
 592         pnetwork = survey->bss;
 593
 594         RT_TRACE(_module_rtl871x_mlme_c_,_drv_info_,
 595                  ("rtw_survey_event_cb23a, ssid=%s\n", pnetwork->Ssid.ssid));
 596
 597         len = get_wlan_bssid_ex_sz(pnetwork);
 598         if (len > (sizeof(struct wlan_bssid_ex))) {
 599                 RT_TRACE(_module_rtl871x_mlme_c_,_drv_err_,
 600                          ("\n ****rtw_survey_event_cb23a: return a wrong "
 601                           "bss ***\n"));
 602                 return;
 603         }
 604
 605         spin_lock_bh(&pmlmepriv->lock);
 606
 607         /*  update IBSS_network 's timestamp */
 608         if (check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE)) {
 609                 /* RT_TRACE(_module_rtl871x_mlme_c_, _drv_err_,
 610                    "rtw_survey_event_cb23a : WIFI_ADHOC_MASTER_STATE\n\n"); */
 611                 if (ether_addr_equal(pmlmepriv->cur_network.network.MacAddress,
 612                                      pnetwork->MacAddress)) {
 613                         struct wlan_network* ibss_wlan;
 614
 615                         pmlmepriv->cur_network.network.beacon_interval =
 616                                 pnetwork->beacon_interval;
 617                         pmlmepriv->cur_network.network.capability =
 618                                 pnetwork->capability;
 619                         pmlmepriv->cur_network.network.tsf = pnetwork->tsf;
 620                         spin_lock_bh(&pmlmepriv->scanned_queue.lock);
 621                         ibss_wlan = rtw_find_network23a(
 622                                 &pmlmepriv->scanned_queue,
 623                                 pnetwork->MacAddress);
 624                         if (ibss_wlan) {
 625                                 pmlmepriv->cur_network.network.beacon_interval =
 626                                         ibss_wlan->network.beacon_interval;
 627                                 pmlmepriv->cur_network.network.capability =
 628                                         ibss_wlan->network.capability;
 629                                 pmlmepriv->cur_network.network.tsf =
 630                                         ibss_wlan->network.tsf;
 631                                 spin_unlock_bh(&pmlmepriv->scanned_queue.lock);
 632                                 goto exit;
 633                         }
 634                         spin_unlock_bh(&pmlmepriv->scanned_queue.lock);
 635                 }
 636         }
 637
 638         /*  lock pmlmepriv->lock when you accessing network_q */
 639         if (!check_fwstate(pmlmepriv, _FW_UNDER_LINKING)) {
 640                 if (pnetwork->Ssid.ssid[0] == 0)
 641                         pnetwork->Ssid.ssid_len = 0;
 642
 643                 rtw_add_network(adapter, pnetwork);
 644         }
 645
 646 exit:
 647
 648         spin_unlock_bh(&pmlmepriv->lock);
 649
 650         kfree(survey->bss);
 651         survey->bss = NULL;
 652
 653         return;
 654 }
 655
 656 void
 657 rtw_surveydone_event_callback23a(struct rtw_adapter *adapter, const u8 *pbuf)
 658 {
 659         struct mlme_priv *pmlmepriv = &adapter->mlmepriv;
 660         struct mlme_ext_priv *pmlmeext = &adapter->mlmeextpriv;
 661         int ret;
 662
 663         spin_lock_bh(&pmlmepriv->lock);
 664
 665         if (pmlmepriv->wps_probe_req_ie) {
 666                 pmlmepriv->wps_probe_req_ie_len = 0;
 667                 kfree(pmlmepriv->wps_probe_req_ie);
 668                 pmlmepriv->wps_probe_req_ie = NULL;
 669         }
 670
 671         RT_TRACE(_module_rtl871x_mlme_c_, _drv_info_,
 672                  ("rtw_surveydone_event_callback23a: fw_state:%x\n\n",
 673                   get_fwstate(pmlmepriv)));
 674
 675         if (check_fwstate(pmlmepriv, _FW_UNDER_SURVEY)) {
 676                 del_timer_sync(&pmlmepriv->scan_to_timer);
 677
 678                 _clr_fwstate_(pmlmepriv, _FW_UNDER_SURVEY);
 679         } else {
 680                 RT_TRACE(_module_rtl871x_mlme_c_, _drv_err_,
 681                          ("nic status =%x, survey done event comes too late!\n",
 682                           get_fwstate(pmlmepriv)));
 683         }
 684
 685         rtw_set_signal_stat_timer(&adapter->recvpriv);
 686
 687         if (pmlmepriv->to_join == true) {
 688                 set_fwstate(pmlmepriv, _FW_UNDER_LINKING);
 689                 if (check_fwstate(pmlmepriv, WIFI_ADHOC_STATE)) {
 690                         ret = rtw_select_and_join_from_scanned_queue23a(
 691                                 pmlmepriv);
 692                         if (ret != _SUCCESS)
 693                                 rtw_do_join_adhoc(adapter);
 694                 } else {
 695                         pmlmepriv->to_join = false;
 696                         ret = rtw_select_and_join_from_scanned_queue23a(
 697                                 pmlmepriv);
 698                         if (ret != _SUCCESS) {
 699                                 DBG_8723A("try_to_join, but select scanning "
 700                                           "queue fail, to_roaming:%d\n",
 701                                           adapter->mlmepriv.to_roaming);
 702                                 if (adapter->mlmepriv.to_roaming) {
 703                                         if (--pmlmepriv->to_roaming == 0 ||
 704                                             rtw_sitesurvey_cmd23a(
 705                                                     adapter,
 706                                                     &pmlmepriv->assoc_ssid, 1,
 707                                                     NULL, 0) != _SUCCESS) {
 708                                                 rtw_set_roaming(adapter, 0);
 709                                                 rtw_free_assoc_resources23a(
 710                                                         adapter, 1);
 711                                                 rtw_indicate_disconnect23a(
 712                                                         adapter);
 713                                         } else
 714                                                 pmlmepriv->to_join = true;
 715                                 }
 716                                 _clr_fwstate_(pmlmepriv, _FW_UNDER_LINKING);
 717                         }
 718                 }
 719         }
 720
 721         spin_unlock_bh(&pmlmepriv->lock);
 722
 723         rtw_os_xmit_schedule23a(adapter);
 724
 725         if (pmlmeext->sitesurvey_res.bss_cnt == 0)
 726                 rtw_sreset_reset(adapter);
 727
 728         rtw_cfg80211_surveydone_event_callback(adapter);
 729 }
 730
 731 static void free_scanqueue(struct mlme_priv *pmlmepriv)
 732 {
 733         struct wlan_network *pnetwork;
 734         struct rtw_queue *scan_queue = &pmlmepriv->scanned_queue;
 735         struct list_head *plist, *phead, *ptemp;
 736
 737         RT_TRACE(_module_rtl871x_mlme_c_, _drv_notice_, ("+free_scanqueue\n"));
 738         spin_lock_bh(&scan_queue->lock);
 739
 740         phead = get_list_head(scan_queue);
 741
 742         list_for_each_safe(plist, ptemp, phead) {
 743                 pnetwork = container_of(plist, struct wlan_network, list);
 744                 pnetwork->fixed = false;
 745                 _rtw_free_network23a(pmlmepriv, pnetwork);
 746         }
 747
 748         spin_unlock_bh(&scan_queue->lock);
 749 }
 750
 751 /*
 752  *rtw_free_assoc_resources23a: the caller has to lock pmlmepriv->lock
 753  */
 754 void rtw_free_assoc_resources23a(struct rtw_adapter *adapter,
 755                                  int lock_scanned_queue)
 756 {
 757         struct wlan_network* pwlan;
 758         struct mlme_priv *pmlmepriv = &adapter->mlmepriv;
 759         struct sta_priv *pstapriv = &adapter->stapriv;
 760         struct wlan_network *tgt_network = &pmlmepriv->cur_network;
 761         struct sta_info* psta;
 762
 763         RT_TRACE(_module_rtl871x_mlme_c_, _drv_notice_,
 764                  ("+rtw_free_assoc_resources23a\n"));
 765         RT_TRACE(_module_rtl871x_mlme_c_, _drv_info_,
 766                  ("tgt_network->network.MacAddress="MAC_FMT" ssid=%s\n",
 767                   MAC_ARG(tgt_network->network.MacAddress),
 768                   tgt_network->network.Ssid.ssid));
 769
 770         if (check_fwstate(pmlmepriv, WIFI_STATION_STATE|WIFI_AP_STATE)) {
 771                 psta = rtw_get_stainfo23a(&adapter->stapriv,
 772                                           tgt_network->network.MacAddress);
 773
 774                 spin_lock_bh(&pstapriv->sta_hash_lock);
 775                 rtw_free_stainfo23a(adapter,  psta);
 776                 spin_unlock_bh(&pstapriv->sta_hash_lock);
 777         }
 778
 779         if (check_fwstate(pmlmepriv, WIFI_ADHOC_STATE |
 780                           WIFI_ADHOC_MASTER_STATE|WIFI_AP_STATE)) {
 781                 rtw_free_all_stainfo23a(adapter);
 782
 783                 psta = rtw_get_bcmc_stainfo23a(adapter);
 784                 spin_lock_bh(&pstapriv->sta_hash_lock);
 785                 rtw_free_stainfo23a(adapter, psta);
 786                 spin_unlock_bh(&pstapriv->sta_hash_lock);
 787
 788                 rtw_init_bcmc_stainfo23a(adapter);
 789         }
 790
 791         if (lock_scanned_queue)
 792                 spin_lock_bh(&pmlmepriv->scanned_queue.lock);
 793
 794         pwlan = rtw_find_network23a(&pmlmepriv->scanned_queue,
 795                                     tgt_network->network.MacAddress);
 796         if (pwlan)
 797                 pwlan->fixed = false;
 798         else
 799                 RT_TRACE(_module_rtl871x_mlme_c_,_drv_err_,
 800                          ("rtw_free_assoc_resources23a : pwlan== NULL\n"));
 801
 802         if (check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE) &&
 803             adapter->stapriv.asoc_sta_count == 1)
 804                 rtw_free_network_nolock(pmlmepriv, pwlan);
 805
 806         if (lock_scanned_queue)
 807                 spin_unlock_bh(&pmlmepriv->scanned_queue.lock);
 808
 809         pmlmepriv->key_mask = 0;
 810 }
 811
 812 /*
 813 *rtw_indicate_connect23a: the caller has to lock pmlmepriv->lock
 814 */
 815 void rtw_indicate_connect23a(struct rtw_adapter *padapter)
 816 {
 817         struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
 818
 819         RT_TRACE(_module_rtl871x_mlme_c_, _drv_err_,
 820                  ("+rtw_indicate_connect23a\n"));
 821
 822         pmlmepriv->to_join = false;
 823
 824         if (!check_fwstate(&padapter->mlmepriv, _FW_LINKED)) {
 825                 set_fwstate(pmlmepriv, _FW_LINKED);
 826
 827                 rtw_led_control(padapter, LED_CTL_LINK);
 828
 829                 rtw_cfg80211_indicate_connect(padapter);
 830
 831                 netif_carrier_on(padapter->pnetdev);
 832
 833                 if (padapter->pid[2] != 0)
 834                         kill_pid(find_vpid(padapter->pid[2]), SIGALRM, 1);
 835         }
 836
 837         rtw_set_roaming(padapter, 0);
 838
 839         rtw_set_scan_deny(padapter, 3000);
 840
 841         RT_TRACE(_module_rtl871x_mlme_c_, _drv_err_,
 842                  ("-rtw_indicate_connect23a: fw_state=0x%08x\n",
 843                   get_fwstate(pmlmepriv)));
 844 }
 845
 846 /*
 847  *rtw_indicate_disconnect23a: the caller has to lock pmlmepriv->lock
 848  */
 849 void rtw_indicate_disconnect23a(struct rtw_adapter *padapter)
 850 {
 851         struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
 852
 853         RT_TRACE(_module_rtl871x_mlme_c_, _drv_err_,
 854                  ("+rtw_indicate_disconnect23a\n"));
 855
 856         _clr_fwstate_(pmlmepriv, _FW_UNDER_LINKING|WIFI_UNDER_WPS);
 857
 858         /* DBG_8723A("clear wps when %s\n", __func__); */
 859
 860         if (padapter->mlmepriv.to_roaming > 0)
 861                 _clr_fwstate_(pmlmepriv, _FW_LINKED);
 862
 863         if (check_fwstate(&padapter->mlmepriv, _FW_LINKED) ||
 864             padapter->mlmepriv.to_roaming <= 0) {
 865                 rtw_os_indicate_disconnect23a(padapter);
 866
 867                 /* set ips_deny_time to avoid enter IPS before LPS leave */
 868                 padapter->pwrctrlpriv.ips_deny_time =
 869                         jiffies + msecs_to_jiffies(3000);
 870
 871                 _clr_fwstate_(pmlmepriv, _FW_LINKED);
 872
 873                 rtw_led_control(padapter, LED_CTL_NO_LINK);
 874
 875                 rtw_clear_scan_deny(padapter);
 876
 877         }
 878
 879         rtw_lps_ctrl_wk_cmd23a(padapter, LPS_CTRL_DISCONNECT, 1);
 880 }
 881
 882 void rtw_scan_abort23a(struct rtw_adapter *adapter)
 883 {
 884         unsigned long start;
 885         struct mlme_priv *pmlmepriv = &adapter->mlmepriv;
 886         struct mlme_ext_priv *pmlmeext = &adapter->mlmeextpriv;
 887
 888         start = jiffies;
 889         pmlmeext->scan_abort = true;
 890         while (check_fwstate(pmlmepriv, _FW_UNDER_SURVEY) &&
 891                jiffies_to_msecs(jiffies - start) <= 200) {
 892                 if (adapter->bDriverStopped || adapter->bSurpriseRemoved)
 893                         break;
 894
 895                 DBG_8723A("%s(%s): fw_state = _FW_UNDER_SURVEY!\n",
 896                           __func__, adapter->pnetdev->name);
 897                 msleep(20);
 898         }
 899
 900         if (check_fwstate(pmlmepriv, _FW_UNDER_SURVEY)) {
 901                 if (!adapter->bDriverStopped && !adapter->bSurpriseRemoved)
 902                         DBG_8723A("%s(%s): waiting for scan_abort time out!\n",
 903                                   __func__, adapter->pnetdev->name);
 904                 rtw_cfg80211_indicate_scan_done(wdev_to_priv(adapter->rtw_wdev),
 905                                                 true);
 906         }
 907         pmlmeext->scan_abort = false;
 908 }
 909
 910 static struct sta_info *
 911 rtw_joinbss_update_stainfo(struct rtw_adapter *padapter,
 912                            struct wlan_network *pnetwork)
 913 {
 914         int i;
 915         struct sta_info *bmc_sta, *psta;
 916         struct recv_reorder_ctrl *preorder_ctrl;
 917         struct sta_priv *pstapriv = &padapter->stapriv;
 918
 919         psta = rtw_get_stainfo23a(pstapriv, pnetwork->network.MacAddress);
 920         if (!psta)
 921                 psta = rtw_alloc_stainfo23a(pstapriv,
 922                                             pnetwork->network.MacAddress,
 923                                             GFP_ATOMIC);
 924
 925         if (psta) { /* update ptarget_sta */
 926                 DBG_8723A("%s\n", __func__);
 927
 928                 psta->aid  = pnetwork->join_res;
 929                 psta->mac_id = 0;
 930
 931                 /* sta mode */
 932                 rtl8723a_SetHalODMVar(padapter, HAL_ODM_STA_INFO, psta, true);
 933
 934                 /* security related */
 935                 if (padapter->securitypriv.dot11AuthAlgrthm ==
 936                     dot11AuthAlgrthm_8021X) {
 937                         padapter->securitypriv.binstallGrpkey = 0;
 938                         padapter->securitypriv.busetkipkey = 0;
 939
 940                         psta->ieee8021x_blocked = true;
 941                         psta->dot118021XPrivacy =
 942                                 padapter->securitypriv.dot11PrivacyAlgrthm;
 943
 944                         memset(&psta->dot118021x_UncstKey, 0,
 945                                sizeof (union Keytype));
 946
 947                         memset(&psta->dot11tkiprxmickey, 0,
 948                                sizeof (union Keytype));
 949                         memset(&psta->dot11tkiptxmickey, 0,
 950                                sizeof (union Keytype));
 951
 952                         memset(&psta->dot11txpn, 0, sizeof (union pn48));
 953                         memset(&psta->dot11rxpn, 0, sizeof (union pn48));
 954                 }
 955
 956                 /*      Commented by Albert 2012/07/21 */
 957                 /*      When doing the WPS, the wps_ie_len won't equal to 0 */
 958                 /*      And the Wi-Fi driver shouldn't allow the data packet
 959                         to be transmitted. */
 960                 if (padapter->securitypriv.wps_ie_len != 0) {
 961                         psta->ieee8021x_blocked = true;
 962                         padapter->securitypriv.wps_ie_len = 0;
 963                 }
 964
 965                 /* for A-MPDU Rx reordering buffer control for bmc_sta &
 966                  * sta_info */
 967                 /* if A-MPDU Rx is enabled, resetting
 968                    rx_ordering_ctrl wstart_b(indicate_seq) to default
 969                    value = 0xffff */
 970                 /* todo: check if AP can send A-MPDU packets */
 971                 for (i = 0; i < 16 ; i++) {
 972                         /* preorder_ctrl = &precvpriv->recvreorder_ctrl[i]; */
 973                         preorder_ctrl = &psta->recvreorder_ctrl[i];
 974                         preorder_ctrl->enable = false;
 975                         preorder_ctrl->indicate_seq = 0xffff;
 976                         preorder_ctrl->wend_b = 0xffff;
 977                         /* max_ampdu_sz; ex. 32(kbytes) -> wsize_b = 32 */
 978                         preorder_ctrl->wsize_b = 64;
 979                 }
 980
 981                 bmc_sta = rtw_get_bcmc_stainfo23a(padapter);
 982                 if (bmc_sta) {
 983                         for (i = 0; i < 16 ; i++) {
 984                                 preorder_ctrl = &bmc_sta->recvreorder_ctrl[i];
 985                                 preorder_ctrl->enable = false;
 986                                 preorder_ctrl->indicate_seq = 0xffff;
 987                                 preorder_ctrl->wend_b = 0xffff;
 988                                 /* max_ampdu_sz; ex. 32(kbytes) ->
 989                                    wsize_b = 32 */
 990                                 preorder_ctrl->wsize_b = 64;
 991                         }
 992                 }
 993
 994                 /* misc. */
 995                 update_sta_info23a(padapter, psta);
 996
 997         }
 998
 999         return psta;
1000 }
1001
1002 /* pnetwork : returns from rtw23a_joinbss_event_cb */
1003 /* ptarget_wlan: found from scanned_queue */
1004 static void
1005 rtw_joinbss_update_network23a(struct rtw_adapter *padapter,
1006                               struct wlan_network *ptarget_wlan,
1007                               struct wlan_network  *pnetwork)
1008 {
1009         struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
1010         struct wlan_network *cur_network = &pmlmepriv->cur_network;
1011
1012         DBG_8723A("%s\n", __func__);
1013
1014         RT_TRACE(_module_rtl871x_mlme_c_, _drv_info_,
1015                  ("\nfw_state:%x, BSSID:"MAC_FMT"\n", get_fwstate(pmlmepriv),
1016                   MAC_ARG(pnetwork->network.MacAddress)));
1017
1018         /*  why not use ptarget_wlan?? */
1019         memcpy(&cur_network->network, &pnetwork->network,
1020                pnetwork->network.Length);
1021         /*  some IEs in pnetwork is wrong, so we should use ptarget_wlan IEs */
1022         cur_network->network.IELength = ptarget_wlan->network.IELength;
1023         memcpy(&cur_network->network.IEs[0], &ptarget_wlan->network.IEs[0],
1024                MAX_IE_SZ);
1025
1026         cur_network->network.capability = ptarget_wlan->network.capability;
1027         cur_network->network.beacon_interval =
1028                 ptarget_wlan->network.beacon_interval;
1029         cur_network->network.tsf = ptarget_wlan->network.tsf;
1030         cur_network->aid = pnetwork->join_res;
1031
1032         rtw_set_signal_stat_timer(&padapter->recvpriv);
1033         padapter->recvpriv.signal_strength =
1034                 ptarget_wlan->network.PhyInfo.SignalStrength;
1035         padapter->recvpriv.signal_qual =
1036                 ptarget_wlan->network.PhyInfo.SignalQuality;
1037         /*
1038          * the ptarget_wlan->network.Rssi is raw data, we use
1039          * ptarget_wlan->network.PhyInfo.SignalStrength instead (has scaled)
1040          */
1041         padapter->recvpriv.rssi = translate_percentage_to_dbm(
1042                 ptarget_wlan->network.PhyInfo.SignalStrength);
1043         DBG_8723A("%s signal_strength:%3u, rssi:%3d, signal_qual:%3u\n",
1044                   __func__, padapter->recvpriv.signal_strength,
1045                   padapter->recvpriv.rssi, padapter->recvpriv.signal_qual);
1046         rtw_set_signal_stat_timer(&padapter->recvpriv);
1047
1048         /* update fw_state will clr _FW_UNDER_LINKING here indirectly */
1049         switch (pnetwork->network.ifmode) {
1050         case NL80211_IFTYPE_P2P_CLIENT:
1051         case NL80211_IFTYPE_STATION:
1052                 if (pmlmepriv->fw_state & WIFI_UNDER_WPS)
1053                         pmlmepriv->fw_state = WIFI_STATION_STATE|WIFI_UNDER_WPS;
1054                 else
1055                         pmlmepriv->fw_state = WIFI_STATION_STATE;
1056                 break;
1057         case NL80211_IFTYPE_ADHOC:
1058                 pmlmepriv->fw_state = WIFI_ADHOC_STATE;
1059                 break;
1060         default:
1061                 pmlmepriv->fw_state = WIFI_NULL_STATE;
1062                 RT_TRACE(_module_rtl871x_mlme_c_, _drv_err_,
1063                          ("Invalid network_mode\n"));
1064                 break;
1065         }
1066
1067         rtw_update_protection23a(padapter, cur_network->network.IEs,
1068                                  cur_network->network.IELength);
1069
1070         rtw_update_ht_cap23a(padapter, cur_network->network.IEs,
1071                              cur_network->network.IELength);
1072 }
1073
1074 /*
1075  * Notes:
1076  * the function could be > passive_level (the same context as Rx tasklet)
1077  * pnetwork : returns from rtw23a_joinbss_event_cb
1078  * ptarget_wlan: found from scanned_queue
1079  * if join_res > 0, for (fw_state==WIFI_STATION_STATE),
1080  * we check if  "ptarget_sta" & "ptarget_wlan" exist.
1081  * if join_res > 0, for (fw_state==WIFI_ADHOC_STATE),
1082  * we only check if "ptarget_wlan" exist.
1083  * if join_res > 0, update "cur_network->network" from "pnetwork->network"
1084  * if (ptarget_wlan !=NULL).
1085  */
1086
1087 void rtw_joinbss_event_prehandle23a(struct rtw_adapter *adapter, u8 *pbuf)
1088 {
1089         struct sta_info *ptarget_sta, *pcur_sta;
1090         struct sta_priv *pstapriv = &adapter->stapriv;
1091         struct mlme_priv *pmlmepriv = &adapter->mlmepriv;
1092         struct wlan_network *pnetwork = (struct wlan_network *)pbuf;
1093         struct wlan_network *cur_network = &pmlmepriv->cur_network;
1094         struct wlan_network *pcur_wlan, *ptarget_wlan = NULL;
1095         bool the_same_macaddr;
1096
1097         RT_TRACE(_module_rtl871x_mlme_c_,_drv_info_,
1098                  ("joinbss event call back received with res=%d\n",
1099                   pnetwork->join_res));
1100
1101         if (pmlmepriv->assoc_ssid.ssid_len == 0) {
1102                 RT_TRACE(_module_rtl871x_mlme_c_,_drv_err_,
1103                          ("@@@@@   joinbss event call back  for Any SSid\n"));
1104         } else {
1105                 RT_TRACE(_module_rtl871x_mlme_c_,_drv_err_,
1106                          ("@@@@@   rtw23a_joinbss_event_cb for SSid:%s\n",
1107                           pmlmepriv->assoc_ssid.ssid));
1108         }
1109
1110         if (ether_addr_equal(pnetwork->network.MacAddress,
1111                              cur_network->network.MacAddress))
1112                 the_same_macaddr = true;
1113         else
1114                 the_same_macaddr = false;
1115
1116         pnetwork->network.Length = get_wlan_bssid_ex_sz(&pnetwork->network);
1117         if (pnetwork->network.Length > sizeof(struct wlan_bssid_ex)) {
1118                 RT_TRACE(_module_rtl871x_mlme_c_,_drv_err_,
1119                          ("\n\n ***joinbss_evt_callback return a wrong bss "
1120                           "***\n\n"));
1121                 return;
1122         }
1123
1124         spin_lock_bh(&pmlmepriv->lock);
1125
1126         RT_TRACE(_module_rtl871x_mlme_c_,_drv_info_,
1127                  ("\n rtw23a_joinbss_event_cb !! _enter_critical\n"));
1128
1129         if (pnetwork->join_res > 0) {
1130                 spin_lock_bh(&pmlmepriv->scanned_queue.lock);
1131                 if (check_fwstate(pmlmepriv,_FW_UNDER_LINKING)) {
1132                         /* s1. find ptarget_wlan */
1133                         if (check_fwstate(pmlmepriv, _FW_LINKED)) {
1134                                 if (the_same_macaddr == true) {
1135                                         ptarget_wlan = rtw_find_network23a(&pmlmepriv->scanned_queue, cur_network->network.MacAddress);
1136                                 } else {
1137                                         pcur_wlan = rtw_find_network23a(&pmlmepriv->scanned_queue, cur_network->network.MacAddress);
1138                                         if (pcur_wlan)
1139                                                 pcur_wlan->fixed = false;
1140
1141                                         pcur_sta = rtw_get_stainfo23a(pstapriv, cur_network->network.MacAddress);
1142                                         if (pcur_sta) {
1143                                                 spin_lock_bh(&pstapriv->sta_hash_lock);
1144                                                 rtw_free_stainfo23a(adapter,
1145                                                                     pcur_sta);
1146                                                 spin_unlock_bh(&pstapriv->sta_hash_lock);
1147                                         }
1148
1149                                         ptarget_wlan = rtw_find_network23a(&pmlmepriv->scanned_queue, pnetwork->network.MacAddress);
1150                                         if (check_fwstate(pmlmepriv,
1151                                                           WIFI_STATION_STATE)) {
1152                                                 if (ptarget_wlan)
1153                                                         ptarget_wlan->fixed =
1154                                                                 true;
1155                                         }
1156                                 }
1157
1158                         } else {
1159                                 ptarget_wlan = rtw_find_network23a(
1160                                         &pmlmepriv->scanned_queue,
1161                                         pnetwork->network.MacAddress);
1162                                 if (check_fwstate(pmlmepriv,
1163                                                   WIFI_STATION_STATE)) {
1164                                         if (ptarget_wlan)
1165                                                 ptarget_wlan->fixed = true;
1166                                 }
1167                         }
1168
1169                         /* s2. update cur_network */
1170                         if (ptarget_wlan)
1171                                 rtw_joinbss_update_network23a(adapter,
1172                                                               ptarget_wlan,
1173                                                               pnetwork);
1174                         else {
1175                                 RT_TRACE(_module_rtl871x_mlme_c_,_drv_err_,
1176                                          ("Can't find ptarget_wlan when "
1177                                           "joinbss_event callback\n"));
1178                                 spin_unlock_bh(&pmlmepriv->scanned_queue.lock);
1179                                 goto ignore_joinbss_callback;
1180                         }
1181
1182                         /* s3. find ptarget_sta & update ptarget_sta after
1183                            update cur_network only for station mode */
1184                         if (check_fwstate(pmlmepriv, WIFI_STATION_STATE)) {
1185                                 ptarget_sta = rtw_joinbss_update_stainfo(
1186                                         adapter, pnetwork);
1187                                 if (!ptarget_sta) {
1188                                         RT_TRACE(_module_rtl871x_mlme_c_,
1189                                                  _drv_err_,
1190                                                  ("Can't update stainfo when "
1191                                                   "joinbss_event callback\n"));
1192                                         spin_unlock_bh(&pmlmepriv->scanned_queue.lock);
1193                                         goto ignore_joinbss_callback;
1194                                 }
1195                         }
1196
1197                         /* s4. indicate connect */
1198                         if (check_fwstate(pmlmepriv, WIFI_STATION_STATE))
1199                                 rtw_indicate_connect23a(adapter);
1200                         else {
1201                                 /* adhoc mode will rtw_indicate_connect23a
1202                                    when rtw_stassoc_event_callback23a */
1203                                 RT_TRACE(_module_rtl871x_mlme_c_,_drv_info_,
1204                                          ("adhoc mode, fw_state:%x",
1205                                           get_fwstate(pmlmepriv)));
1206                         }
1207
1208                         /* s5. Cancle assoc_timer */
1209                         del_timer_sync(&pmlmepriv->assoc_timer);
1210
1211                         RT_TRACE(_module_rtl871x_mlme_c_,_drv_info_,
1212                                  ("Cancle assoc_timer\n"));
1213                 } else {
1214                         RT_TRACE(_module_rtl871x_mlme_c_, _drv_err_,
1215                                  ("rtw23a_joinbss_event_cb err: fw_state:%x",
1216                                  get_fwstate(pmlmepriv)));
1217                         spin_unlock_bh(&pmlmepriv->scanned_queue.lock);
1218                         goto ignore_joinbss_callback;
1219                 }
1220                 spin_unlock_bh(&pmlmepriv->scanned_queue.lock);
1221         } else if (pnetwork->join_res == -4) {
1222                 rtw_reset_securitypriv23a(adapter);
1223                 mod_timer(&pmlmepriv->assoc_timer,
1224                           jiffies + msecs_to_jiffies(1));
1225
1226                 /* rtw_free_assoc_resources23a(adapter, 1); */
1227
1228                 if (check_fwstate(pmlmepriv, _FW_UNDER_LINKING)) {
1229                         RT_TRACE(_module_rtl871x_mlme_c_, _drv_err_,
1230                                  ("fail! clear _FW_UNDER_LINKING ^^^fw_state="
1231                                   "%x\n", get_fwstate(pmlmepriv)));
1232                         _clr_fwstate_(pmlmepriv, _FW_UNDER_LINKING);
1233                 }
1234         } else {
1235                 /* if join_res < 0 (join fails), then try again */
1236                 mod_timer(&pmlmepriv->assoc_timer,
1237                           jiffies + msecs_to_jiffies(1));
1238                 _clr_fwstate_(pmlmepriv, _FW_UNDER_LINKING);
1239         }
1240
1241 ignore_joinbss_callback:
1242
1243         spin_unlock_bh(&pmlmepriv->lock);
1244 }
1245
1246 void rtw23a_joinbss_event_cb(struct rtw_adapter *adapter, const u8 *pbuf)
1247 {
1248         struct wlan_network *pnetwork = (struct wlan_network *)pbuf;
1249
1250         mlmeext_joinbss_event_callback23a(adapter, pnetwork->join_res);
1251
1252         rtw_os_xmit_schedule23a(adapter);
1253 }
1254
1255 void rtw_stassoc_event_callback23a(struct rtw_adapter *adapter, const u8 *pbuf)
1256 {
1257         struct sta_info *psta;
1258         struct mlme_priv *pmlmepriv = &adapter->mlmepriv;
1259         struct stassoc_event *pstassoc = (struct stassoc_event*)pbuf;
1260         struct wlan_network *cur_network = &pmlmepriv->cur_network;
1261         struct wlan_network *ptarget_wlan;
1262
1263         if (rtw_access_ctrl23a(adapter, pstassoc->macaddr) == false)
1264                 return;
1265
1266 #ifdef CONFIG_8723AU_AP_MODE
1267         if (check_fwstate(pmlmepriv, WIFI_AP_STATE)) {
1268                 psta = rtw_get_stainfo23a(&adapter->stapriv, pstassoc->macaddr);
1269                 if (psta) {
1270                         /* bss_cap_update_on_sta_join23a(adapter, psta); */
1271                         /* sta_info_update23a(adapter, psta); */
1272                         ap_sta_info_defer_update23a(adapter, psta);
1273                 }
1274                 return;
1275         }
1276 #endif
1277         /* for AD-HOC mode */
1278         psta = rtw_get_stainfo23a(&adapter->stapriv, pstassoc->macaddr);
1279         if (psta != NULL) {
1280                 /* the sta have been in sta_info_queue => do nothing */
1281                 RT_TRACE(_module_rtl871x_mlme_c_,_drv_err_,
1282                          ("Error: rtw_stassoc_event_callback23a: sta has "
1283                           "been in sta_hash_queue\n"));
1284                 /* between drv has received this event before and
1285                    fw have not yet to set key to CAM_ENTRY) */
1286                 return;
1287         }
1288
1289         psta = rtw_alloc_stainfo23a(&adapter->stapriv, pstassoc->macaddr,
1290                 GFP_KERNEL);
1291         if (!psta) {
1292                 RT_TRACE(_module_rtl871x_mlme_c_,_drv_err_,
1293                          ("Can't alloc sta_info when "
1294                           "rtw_stassoc_event_callback23a\n"));
1295                 return;
1296         }
1297
1298         /* to do : init sta_info variable */
1299         psta->qos_option = 0;
1300         psta->mac_id = (uint)pstassoc->cam_id;
1301         /* psta->aid = (uint)pstassoc->cam_id; */
1302         DBG_8723A("%s\n",__func__);
1303         /* for ad-hoc mode */
1304         rtl8723a_SetHalODMVar(adapter, HAL_ODM_STA_INFO, psta, true);
1305
1306         if (adapter->securitypriv.dot11AuthAlgrthm == dot11AuthAlgrthm_8021X)
1307                 psta->dot118021XPrivacy =
1308                         adapter->securitypriv.dot11PrivacyAlgrthm;
1309
1310         psta->ieee8021x_blocked = false;
1311
1312         spin_lock_bh(&pmlmepriv->lock);
1313
1314         if (check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE) ||
1315             check_fwstate(pmlmepriv, WIFI_ADHOC_STATE)) {
1316                 if (adapter->stapriv.asoc_sta_count == 2) {
1317                         spin_lock_bh(&pmlmepriv->scanned_queue.lock);
1318                         ptarget_wlan =
1319                                 rtw_find_network23a(&pmlmepriv->scanned_queue,
1320                                                     cur_network->network.MacAddress);
1321                         if (ptarget_wlan)
1322                                 ptarget_wlan->fixed = true;
1323                         spin_unlock_bh(&pmlmepriv->scanned_queue.lock);
1324                         /*  a sta + bc/mc_stainfo (not Ibss_stainfo) */
1325                         rtw_indicate_connect23a(adapter);
1326                 }
1327         }
1328
1329         spin_unlock_bh(&pmlmepriv->lock);
1330
1331         mlmeext_sta_add_event_callback23a(adapter, psta);
1332 }
1333
1334 void rtw_stadel_event_callback23a(struct rtw_adapter *adapter, const u8 *pbuf)
1335 {
1336         int mac_id;
1337         struct sta_info *psta;
1338         struct wlan_network* pwlan;
1339         struct wlan_bssid_ex *pdev_network;
1340         struct mlme_priv *pmlmepriv = &adapter->mlmepriv;
1341         struct stadel_event *pstadel = (struct stadel_event *)pbuf;
1342         struct sta_priv *pstapriv = &adapter->stapriv;
1343         struct wlan_network *tgt_network = &pmlmepriv->cur_network;
1344
1345         psta = rtw_get_stainfo23a(&adapter->stapriv, pstadel->macaddr);
1346         if (psta)
1347                 mac_id = psta->mac_id;
1348         else
1349                 mac_id = pstadel->mac_id;
1350
1351         DBG_8723A("%s(mac_id=%d)=" MAC_FMT "\n", __func__, mac_id,
1352                   MAC_ARG(pstadel->macaddr));
1353
1354         if (check_fwstate(pmlmepriv, WIFI_AP_STATE))
1355                 return;
1356
1357         mlmeext_sta_del_event_callback23a(adapter);
1358
1359         spin_lock_bh(&pmlmepriv->lock);
1360
1361         if (check_fwstate(pmlmepriv, WIFI_STATION_STATE)) {
1362                 if (adapter->mlmepriv.to_roaming > 0) {
1363                         /* this stadel_event is caused by roaming,
1364                            decrease to_roaming */
1365                         pmlmepriv->to_roaming--;
1366                 } else if (adapter->mlmepriv.to_roaming == 0)
1367                         rtw_set_roaming(adapter, adapter->registrypriv.max_roaming_times);
1368                 if (*((u16 *)pstadel->rsvd) != WLAN_REASON_EXPIRATION_CHK)
1369                         rtw_set_roaming(adapter, 0); /* don't roam */
1370
1371                 rtw_free_uc_swdec_pending_queue23a(adapter);
1372
1373                 rtw_free_assoc_resources23a(adapter, 1);
1374                 rtw_indicate_disconnect23a(adapter);
1375                 spin_lock_bh(&pmlmepriv->scanned_queue.lock);
1376                 /*  remove the network entry in scanned_queue */
1377                 pwlan = rtw_find_network23a(&pmlmepriv->scanned_queue,
1378                                             tgt_network->network.MacAddress);
1379                 if (pwlan) {
1380                         pwlan->fixed = false;
1381                         rtw_free_network_nolock(pmlmepriv, pwlan);
1382                 }
1383                 spin_unlock_bh(&pmlmepriv->scanned_queue.lock);
1384
1385                 _rtw_roaming(adapter, tgt_network);
1386         }
1387
1388         if (check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE) ||
1389             check_fwstate(pmlmepriv, WIFI_ADHOC_STATE)) {
1390
1391                 spin_lock_bh(&pstapriv->sta_hash_lock);
1392                 rtw_free_stainfo23a(adapter,  psta);
1393                 spin_unlock_bh(&pstapriv->sta_hash_lock);
1394
1395                 /* a sta + bc/mc_stainfo (not Ibss_stainfo) */
1396                 if (adapter->stapriv.asoc_sta_count == 1) {
1397                         spin_lock_bh(&pmlmepriv->scanned_queue.lock);
1398                         /* free old ibss network */
1399                         /* pwlan = rtw_find_network23a(
1400                            &pmlmepriv->scanned_queue, pstadel->macaddr); */
1401                         pwlan = rtw_find_network23a(&pmlmepriv->scanned_queue,
1402                                                     tgt_network->network.MacAddress);
1403                         if (pwlan) {
1404                                 pwlan->fixed = false;
1405                                 rtw_free_network_nolock(pmlmepriv, pwlan);
1406                         }
1407                         spin_unlock_bh(&pmlmepriv->scanned_queue.lock);
1408                         /* re-create ibss */
1409                         pdev_network = &adapter->registrypriv.dev_network;
1410
1411                         memcpy(pdev_network, &tgt_network->network,
1412                                get_wlan_bssid_ex_sz(&tgt_network->network));
1413
1414                         rtw_do_join_adhoc(adapter);
1415                 }
1416         }
1417
1418         spin_unlock_bh(&pmlmepriv->lock);
1419 }
1420
1421 /*
1422 * rtw23a_join_to_handler - Timeout/failure handler for CMD JoinBss
1423 * @adapter: pointer to _adapter structure
1424 */
1425 void rtw23a_join_to_handler (unsigned long data)
1426 {
1427         struct rtw_adapter *adapter = (struct rtw_adapter *)data;
1428         struct mlme_priv *pmlmepriv = &adapter->mlmepriv;
1429         int do_join_r;
1430
1431         DBG_8723A("%s, fw_state=%x\n", __func__, get_fwstate(pmlmepriv));
1432
1433         if (adapter->bDriverStopped || adapter->bSurpriseRemoved)
1434                 return;
1435
1436         spin_lock_bh(&pmlmepriv->lock);
1437
1438         if (adapter->mlmepriv.to_roaming > 0) {
1439                 /* join timeout caused by roaming */
1440                 while (1) {
1441                         pmlmepriv->to_roaming--;
1442                         if (adapter->mlmepriv.to_roaming != 0) {
1443                                 /* try another */
1444                                 DBG_8723A("%s try another roaming\n", __func__);
1445                                 do_join_r = rtw_do_join(adapter);
1446                                 if (do_join_r != _SUCCESS) {
1447                                         DBG_8723A("%s roaming do_join return "
1448                                                   "%d\n", __func__ , do_join_r);
1449                                         continue;
1450                                 }
1451                                 break;
1452                         } else {
1453                                 DBG_8723A("%s We've try roaming but fail\n",
1454                                           __func__);
1455                                 rtw_indicate_disconnect23a(adapter);
1456                                 break;
1457                         }
1458                 }
1459         } else {
1460                 rtw_indicate_disconnect23a(adapter);
1461                 free_scanqueue(pmlmepriv);/*  */
1462
1463                 /* indicate disconnect for the case that join_timeout and
1464                    check_fwstate != FW_LINKED */
1465                 rtw_cfg80211_indicate_disconnect(adapter);
1466         }
1467
1468         spin_unlock_bh(&pmlmepriv->lock);
1469
1470 }
1471
1472 /*
1473 * rtw_scan_timeout_handler23a - Timeout/Failure handler for CMD SiteSurvey
1474 * @data: pointer to _adapter structure
1475 */
1476 void rtw_scan_timeout_handler23a(unsigned long data)
1477 {
1478         struct rtw_adapter *adapter = (struct rtw_adapter *)data;
1479         struct mlme_priv *pmlmepriv = &adapter->mlmepriv;
1480
1481         DBG_8723A("%s(%s): fw_state =%x\n", __func__, adapter->pnetdev->name,
1482                   get_fwstate(pmlmepriv));
1483
1484         spin_lock_bh(&pmlmepriv->lock);
1485
1486         _clr_fwstate_(pmlmepriv, _FW_UNDER_SURVEY);
1487
1488         spin_unlock_bh(&pmlmepriv->lock);
1489
1490         rtw_cfg80211_indicate_scan_done(wdev_to_priv(adapter->rtw_wdev), true);
1491 }
1492
1493 void rtw_dynamic_check_timer_handler(unsigned long data)
1494 {
1495         struct rtw_adapter *adapter = (struct rtw_adapter *)data;
1496
1497         if (adapter->hw_init_completed == false)
1498                 goto out;
1499
1500         if (adapter->bDriverStopped == true ||
1501             adapter->bSurpriseRemoved == true)
1502                 goto out;
1503
1504         if (adapter->net_closed == true)
1505                 goto out;
1506
1507         rtw_dynamic_chk_wk_cmd23a(adapter);
1508
1509 out:
1510         mod_timer(&adapter->mlmepriv.dynamic_chk_timer,
1511                   jiffies + msecs_to_jiffies(2000));
1512 }
1513
1514 inline bool rtw_is_scan_deny(struct rtw_adapter *adapter)
1515 {
1516         struct mlme_priv *mlmepriv = &adapter->mlmepriv;
1517         return (atomic_read(&mlmepriv->set_scan_deny) != 0) ? true : false;
1518 }
1519
1520 void rtw_clear_scan_deny(struct rtw_adapter *adapter)
1521 {
1522         struct mlme_priv *mlmepriv = &adapter->mlmepriv;
1523         atomic_set(&mlmepriv->set_scan_deny, 0);
1524 }
1525
1526 void rtw_set_scan_deny_timer_hdl(unsigned long data)
1527 {
1528         struct rtw_adapter *adapter = (struct rtw_adapter *)data;
1529         rtw_clear_scan_deny(adapter);
1530 }
1531
1532 void rtw_set_scan_deny(struct rtw_adapter *adapter, u32 ms)
1533 {
1534         struct mlme_priv *mlmepriv = &adapter->mlmepriv;
1535
1536         atomic_set(&mlmepriv->set_scan_deny, 1);
1537         mod_timer(&mlmepriv->set_scan_deny_timer,
1538                   jiffies + msecs_to_jiffies(ms));
1539 }
1540
1541 #if defined(IEEE80211_SCAN_RESULT_EXPIRE)
1542 #define RTW_SCAN_RESULT_EXPIRE IEEE80211_SCAN_RESULT_EXPIRE/HZ*1000 -1000 /* 3000 -1000 */
1543 #else
1544 #define RTW_SCAN_RESULT_EXPIRE 2000
1545 #endif
1546
1547 /*
1548 * Select a new join candidate from the original @param candidate and
1549 *     @param competitor
1550 * @return true: candidate is updated
1551 * @return false: candidate is not updated
1552 */
1553 static int rtw_check_join_candidate(struct mlme_priv *pmlmepriv,
1554                                     struct wlan_network **candidate,
1555                                     struct wlan_network *competitor)
1556 {
1557         int updated = false;
1558         struct rtw_adapter *adapter;
1559
1560         adapter = container_of(pmlmepriv, struct rtw_adapter, mlmepriv);
1561
1562         /* check bssid, if needed */
1563         if (pmlmepriv->assoc_by_bssid == true) {
1564                 if (!ether_addr_equal(competitor->network.MacAddress,
1565                                       pmlmepriv->assoc_bssid))
1566                         goto exit;
1567         }
1568
1569         /* check ssid, if needed */
1570         if (pmlmepriv->assoc_ssid.ssid_len) {
1571                 if (competitor->network.Ssid.ssid_len !=
1572                     pmlmepriv->assoc_ssid.ssid_len ||
1573                     memcmp(competitor->network.Ssid.ssid,
1574                            pmlmepriv->assoc_ssid.ssid,
1575                            pmlmepriv->assoc_ssid.ssid_len))
1576                         goto exit;
1577         }
1578
1579         if (rtw_is_desired_network(adapter, competitor) == false)
1580                 goto exit;
1581
1582         if (adapter->mlmepriv.to_roaming > 0) {
1583                 unsigned int passed;
1584
1585                 passed = jiffies_to_msecs(jiffies - competitor->last_scanned);
1586                 if (passed >= RTW_SCAN_RESULT_EXPIRE ||
1587                     is_same_ess(&competitor->network,
1588                                 &pmlmepriv->cur_network.network) == false)
1589                         goto exit;
1590         }
1591
1592         if (!*candidate ||
1593             (*candidate)->network.Rssi<competitor->network.Rssi) {
1594                 *candidate = competitor;
1595                 updated = true;
1596         }
1597
1598         if (updated) {
1599                 DBG_8723A("[by_bssid:%u][assoc_ssid:%s][to_roaming:%u] "
1600                           "new candidate: %s("MAC_FMT") rssi:%d\n",
1601                           pmlmepriv->assoc_by_bssid,
1602                           pmlmepriv->assoc_ssid.ssid,
1603                           adapter->mlmepriv.to_roaming,
1604                           (*candidate)->network.Ssid.ssid,
1605                           MAC_ARG((*candidate)->network.MacAddress),
1606                           (int)(*candidate)->network.Rssi);
1607         }
1608
1609 exit:
1610         return updated;
1611 }
1612
1613 /*
1614 Calling context:
1615 The caller of the sub-routine will be in critical section...
1616
1617 The caller must hold the following spinlock
1618
1619 pmlmepriv->lock
1620
1621 */
1622
1623 static int rtw_do_join(struct rtw_adapter *padapter)
1624 {
1625         struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
1626         int ret;
1627
1628         pmlmepriv->cur_network.join_res = -2;
1629
1630         set_fwstate(pmlmepriv, _FW_UNDER_LINKING);
1631
1632         pmlmepriv->to_join = true;
1633
1634         ret = rtw_select_and_join_from_scanned_queue23a(pmlmepriv);
1635         if (ret == _SUCCESS) {
1636                 pmlmepriv->to_join = false;
1637         } else {
1638                 if (check_fwstate(pmlmepriv, WIFI_ADHOC_STATE)) {
1639                         /* switch to ADHOC_MASTER */
1640                         ret = rtw_do_join_adhoc(padapter);
1641                         if (ret != _SUCCESS)
1642                                 goto exit;
1643                 } else {
1644                         /*  can't associate ; reset under-linking */
1645                         _clr_fwstate_(pmlmepriv, _FW_UNDER_LINKING);
1646
1647                         ret = _FAIL;
1648                         pmlmepriv->to_join = false;
1649                 }
1650         }
1651
1652 exit:
1653         return ret;
1654 }
1655
1656 static struct wlan_network *
1657 rtw_select_candidate_from_queue(struct mlme_priv *pmlmepriv)
1658 {
1659         struct wlan_network *pnetwork, *candidate = NULL;
1660         struct rtw_queue *queue = &pmlmepriv->scanned_queue;
1661         struct list_head *phead, *plist, *ptmp;
1662
1663         spin_lock_bh(&pmlmepriv->scanned_queue.lock);
1664         phead = get_list_head(queue);
1665
1666         list_for_each_safe(plist, ptmp, phead) {
1667                 pnetwork = container_of(plist, struct wlan_network, list);
1668                 if (!pnetwork) {
1669                         RT_TRACE(_module_rtl871x_mlme_c_, _drv_err_,
1670                                  ("%s: return _FAIL:(pnetwork == NULL)\n",
1671                                   __func__));
1672                         goto exit;
1673                 }
1674
1675                 rtw_check_join_candidate(pmlmepriv, &candidate, pnetwork);
1676         }
1677
1678 exit:
1679         spin_unlock_bh(&pmlmepriv->scanned_queue.lock);
1680         return candidate;
1681 }
1682
1683
1684 int rtw_do_join_adhoc(struct rtw_adapter *adapter)
1685 {
1686         struct mlme_priv *pmlmepriv = &adapter->mlmepriv;
1687         struct wlan_bssid_ex *pdev_network;
1688         u8 *ibss;
1689         int ret;
1690
1691         pdev_network = &adapter->registrypriv.dev_network;
1692         ibss = adapter->registrypriv.dev_network.MacAddress;
1693
1694         _clr_fwstate_(pmlmepriv, _FW_UNDER_SURVEY);
1695
1696         RT_TRACE(_module_rtl871x_mlme_c_, _drv_err_,
1697                  ("switching to adhoc master\n"));
1698
1699         memcpy(&pdev_network->Ssid, &pmlmepriv->assoc_ssid,
1700                sizeof(struct cfg80211_ssid));
1701
1702         rtw_update_registrypriv_dev_network23a(adapter);
1703         rtw_generate_random_ibss23a(ibss);
1704
1705         pmlmepriv->fw_state = WIFI_ADHOC_MASTER_STATE;
1706
1707         ret = rtw_createbss_cmd23a(adapter);
1708         if (ret != _SUCCESS) {
1709                 RT_TRACE(_module_rtl871x_mlme_c_, _drv_err_,
1710                          ("Error =>rtw_createbss_cmd23a status FAIL\n"));
1711         } else  {
1712                 pmlmepriv->to_join = false;
1713         }
1714
1715         return ret;
1716 }
1717
1718 int rtw_do_join_network(struct rtw_adapter *adapter,
1719                         struct wlan_network *candidate)
1720 {
1721         int ret;
1722
1723         /*  check for situation of  _FW_LINKED */
1724         if (check_fwstate(&adapter->mlmepriv, _FW_LINKED)) {
1725                 DBG_8723A("%s: _FW_LINKED while ask_for_joinbss!\n", __func__);
1726
1727                 rtw_disassoc_cmd23a(adapter, 0, true);
1728                 rtw_indicate_disconnect23a(adapter);
1729                 rtw_free_assoc_resources23a(adapter, 0);
1730         }
1731         set_fwstate(&adapter->mlmepriv, _FW_UNDER_LINKING);
1732
1733         ret = rtw_joinbss_cmd23a(adapter, candidate);
1734
1735         if (ret == _SUCCESS)
1736                 mod_timer(&adapter->mlmepriv.assoc_timer,
1737                           jiffies + msecs_to_jiffies(MAX_JOIN_TIMEOUT));
1738
1739         return ret;
1740 }
1741
1742 int rtw_select_and_join_from_scanned_queue23a(struct mlme_priv *pmlmepriv)
1743 {
1744         struct rtw_adapter *adapter;
1745         struct wlan_network *candidate = NULL;
1746         int ret;
1747
1748         adapter = pmlmepriv->nic_hdl;
1749
1750         candidate = rtw_select_candidate_from_queue(pmlmepriv);
1751         if (!candidate) {
1752                 DBG_8723A("%s: return _FAIL(candidate == NULL)\n", __func__);
1753                 ret = _FAIL;
1754                 goto exit;
1755         } else {
1756                 DBG_8723A("%s: candidate: %s("MAC_FMT", ch:%u)\n", __func__,
1757                           candidate->network.Ssid.ssid,
1758                           MAC_ARG(candidate->network.MacAddress),
1759                           candidate->network.DSConfig);
1760         }
1761
1762         ret = rtw_do_join_network(adapter, candidate);
1763
1764 exit:
1765         return ret;
1766 }
1767
1768 int rtw_set_auth23a(struct rtw_adapter * adapter,
1769                     struct security_priv *psecuritypriv)
1770 {
1771         struct cmd_obj* pcmd;
1772         struct setauth_parm *psetauthparm;
1773         struct cmd_priv *pcmdpriv = &adapter->cmdpriv;
1774         int res = _SUCCESS;
1775
1776         pcmd = kzalloc(sizeof(struct cmd_obj), GFP_KERNEL);
1777         if (!pcmd) {
1778                 res = _FAIL;  /* try again */
1779                 goto exit;
1780         }
1781
1782         psetauthparm = kzalloc(sizeof(struct setauth_parm), GFP_KERNEL);
1783         if (!psetauthparm) {
1784                 kfree(pcmd);
1785                 res = _FAIL;
1786                 goto exit;
1787         }
1788
1789         psetauthparm->mode = (unsigned char)psecuritypriv->dot11AuthAlgrthm;
1790
1791         pcmd->cmdcode = _SetAuth_CMD_;
1792         pcmd->parmbuf = (unsigned char *)psetauthparm;
1793         pcmd->cmdsz =  (sizeof(struct setauth_parm));
1794         pcmd->rsp = NULL;
1795         pcmd->rspsz = 0;
1796
1797         RT_TRACE(_module_rtl871x_mlme_c_,_drv_err_,
1798                  ("after enqueue set_auth_cmd, auth_mode=%x\n",
1799                   psecuritypriv->dot11AuthAlgrthm));
1800
1801         res = rtw_enqueue_cmd23a(pcmdpriv, pcmd);
1802
1803 exit:
1804
1805         return res;
1806 }
1807
1808 int rtw_set_key23a(struct rtw_adapter *adapter,
1809                    struct security_priv *psecuritypriv, int keyid, u8 set_tx)
1810 {
1811         u8 keylen;
1812         struct cmd_obj *pcmd;
1813         struct setkey_parm *psetkeyparm;
1814         struct cmd_priv *pcmdpriv = &adapter->cmdpriv;
1815         struct mlme_priv *pmlmepriv = &adapter->mlmepriv;
1816         int res = _SUCCESS;
1817
1818         if (keyid >= 4) {
1819                 res = _FAIL;
1820                 goto exit;
1821         }
1822
1823         pcmd = kzalloc(sizeof(struct cmd_obj), GFP_KERNEL);
1824         if (!pcmd) {
1825                 res = _FAIL;  /* try again */
1826                 goto exit;
1827         }
1828         psetkeyparm = kzalloc(sizeof(struct setkey_parm), GFP_KERNEL);
1829         if (!psetkeyparm) {
1830                 kfree(pcmd);
1831                 res = _FAIL;
1832                 goto exit;
1833         }
1834
1835         if (psecuritypriv->dot11AuthAlgrthm == dot11AuthAlgrthm_8021X) {
1836                 psetkeyparm->algorithm = (unsigned char)
1837                         psecuritypriv->dot118021XGrpPrivacy;
1838                 RT_TRACE(_module_rtl871x_mlme_c_, _drv_err_,
1839                          ("\n rtw_set_key23a: psetkeyparm->algorithm = "
1840                           "(unsigned char)psecuritypriv->dot118021XGrpPrivacy "
1841                           "=%d\n", psetkeyparm->algorithm));
1842         } else {
1843                 psetkeyparm->algorithm = (u8)psecuritypriv->dot11PrivacyAlgrthm;
1844                 RT_TRACE(_module_rtl871x_mlme_c_, _drv_err_,
1845                          ("\n rtw_set_key23a: psetkeyparm->algorithm = (u8)"
1846                           "psecuritypriv->dot11PrivacyAlgrthm =%d\n",
1847                           psetkeyparm->algorithm));
1848         }
1849         psetkeyparm->keyid = keyid;/* 0~3 */
1850         psetkeyparm->set_tx = set_tx;
1851         if (is_wep_enc(psetkeyparm->algorithm))
1852                 pmlmepriv->key_mask |= BIT(psetkeyparm->keyid);
1853
1854         DBG_8723A("==> rtw_set_key23a algorithm(%x), keyid(%x), key_mask(%x)\n",
1855                   psetkeyparm->algorithm, psetkeyparm->keyid,
1856                   pmlmepriv->key_mask);
1857         RT_TRACE(_module_rtl871x_mlme_c_, _drv_err_,
1858                  ("\n rtw_set_key23a: psetkeyparm->algorithm =%d psetkeyparm->"
1859                   "keyid = (u8)keyid =%d\n", psetkeyparm->algorithm, keyid));
1860
1861         switch (psetkeyparm->algorithm) {
1862         case WLAN_CIPHER_SUITE_WEP40:
1863                 keylen = 5;
1864                 memcpy(&psetkeyparm->key[0],
1865                        &psecuritypriv->wep_key[keyid].key, keylen);
1866                 break;
1867         case WLAN_CIPHER_SUITE_WEP104:
1868                 keylen = 13;
1869                 memcpy(&psetkeyparm->key[0],
1870                        &psecuritypriv->wep_key[keyid].key, keylen);
1871                 break;
1872         case WLAN_CIPHER_SUITE_TKIP:
1873                 keylen = 16;
1874                 memcpy(&psetkeyparm->key,
1875                        &psecuritypriv->dot118021XGrpKey[keyid], keylen);
1876                 psetkeyparm->grpkey = 1;
1877                 break;
1878         case WLAN_CIPHER_SUITE_CCMP:
1879                 keylen = 16;
1880                 memcpy(&psetkeyparm->key,
1881                        &psecuritypriv->dot118021XGrpKey[keyid], keylen);
1882                 psetkeyparm->grpkey = 1;
1883                 break;
1884         default:
1885                 RT_TRACE(_module_rtl871x_mlme_c_, _drv_err_,
1886                          ("\n rtw_set_key23a:psecuritypriv->dot11PrivacyAlgrthm"
1887                           " = %x (must be 1 or 2 or 4 or 5)\n",
1888                           psecuritypriv->dot11PrivacyAlgrthm));
1889                 res = _FAIL;
1890                 kfree(pcmd);
1891                 kfree(psetkeyparm);
1892                 goto exit;
1893         }
1894
1895         pcmd->cmdcode = _SetKey_CMD_;
1896         pcmd->parmbuf = (u8 *)psetkeyparm;
1897         pcmd->cmdsz =  (sizeof(struct setkey_parm));
1898         pcmd->rsp = NULL;
1899         pcmd->rspsz = 0;
1900
1901         /* sema_init(&pcmd->cmd_sem, 0); */
1902
1903         res = rtw_enqueue_cmd23a(pcmdpriv, pcmd);
1904
1905 exit:
1906
1907         return res;
1908 }
1909
1910 /* adjust IEs for rtw_joinbss_cmd23a in WMM */
1911 int rtw_restruct_wmm_ie23a(struct rtw_adapter *adapter, u8 *in_ie,
1912                            u8 *out_ie, uint in_len, uint initial_out_len)
1913 {
1914         int ielength;
1915         const u8 *p;
1916
1917         ielength = initial_out_len;
1918
1919         p = cfg80211_find_vendor_ie(WLAN_OUI_MICROSOFT,
1920                                     WLAN_OUI_TYPE_MICROSOFT_WMM,
1921                                     in_ie, in_len);
1922
1923         if (p && p[1]) {
1924                 memcpy(out_ie + initial_out_len, p, 9);
1925
1926                 out_ie[initial_out_len + 1] = 7;
1927                 out_ie[initial_out_len + 6] = 0;
1928                 out_ie[initial_out_len + 8] = 0;
1929
1930                 ielength += 9;
1931         }
1932
1933         return ielength;
1934 }
1935
1936 /*  */
1937 /*  Ported from 8185: IsInPreAuthKeyList().
1938     (Renamed from SecIsInPreAuthKeyList(), 2006-10-13.) */
1939 /*  Added by Annie, 2006-05-07. */
1940 /*  */
1941 /*  Search by BSSID, */
1942 /*  Return Value: */
1943 /*              -1      :if there is no pre-auth key in the  table */
1944 /*              >= 0    :if there is pre-auth key, and   return the entry id */
1945 /*  */
1946 /*  */
1947
1948 static int SecIsInPMKIDList(struct rtw_adapter *Adapter, u8 *bssid)
1949 {
1950         struct security_priv *psecuritypriv = &Adapter->securitypriv;
1951         int i = 0;
1952
1953         do {
1954                 if (psecuritypriv->PMKIDList[i].bUsed &&
1955                     ether_addr_equal(psecuritypriv->PMKIDList[i].Bssid, bssid)) {
1956                         break;
1957                 } else {
1958                         i++;
1959                         /* continue; */
1960                 }
1961         } while (i < NUM_PMKID_CACHE);
1962
1963         if (i == NUM_PMKID_CACHE)
1964                 i = -1;/*  Could not find. */
1965         else {
1966                 /*  There is one Pre-Authentication Key for
1967                     the specific BSSID. */
1968         }
1969
1970         return i;
1971 }
1972
1973 /*  */
1974 /*  Check the RSN IE length */
1975 /*  If the RSN IE length <= 20, the RSN IE didn't include
1976     the PMKID information */
1977 /*  0-11th element in the array are the fixed IE */
1978 /*  12th element in the array is the IE */
1979 /*  13th element in the array is the IE length */
1980 /*  */
1981
1982 static int rtw_append_pmkid(struct rtw_adapter *Adapter, int iEntry,
1983                             u8 *ie, uint ie_len)
1984 {
1985         struct security_priv *psecuritypriv = &Adapter->securitypriv;
1986
1987         if (ie[1] <= 20) {
1988                 /*  The RSN IE didn't include the PMK ID,
1989                     append the PMK information */
1990                         ie[ie_len] = 1;
1991                         ie_len++;
1992                         ie[ie_len] = 0; /* PMKID count = 0x0100 */
1993                         ie_len++;
1994                         memcpy(&ie[ie_len],
1995                                &psecuritypriv->PMKIDList[iEntry].PMKID, 16);
1996
1997                         ie_len += 16;
1998                         ie[1] += 18;/* PMKID length = 2+16 */
1999         }
2000         return ie_len;
2001 }
2002
2003 int rtw_restruct_sec_ie23a(struct rtw_adapter *adapter, u8 *in_ie, u8 *out_ie,
2004                            uint in_len)
2005 {
2006         u8 authmode;
2007         uint ielength;
2008         int iEntry;
2009         struct mlme_priv *pmlmepriv = &adapter->mlmepriv;
2010         struct security_priv *psecuritypriv = &adapter->securitypriv;
2011         uint ndisauthmode = psecuritypriv->ndisauthtype;
2012         uint ndissecuritytype = psecuritypriv->ndisencryptstatus;
2013
2014         RT_TRACE(_module_rtl871x_mlme_c_, _drv_notice_,
2015                  ("+rtw_restruct_sec_ie23a: ndisauthmode=%d "
2016                   "ndissecuritytype=%d\n", ndisauthmode, ndissecuritytype));
2017
2018         ielength = 0;
2019         if (ndisauthmode == Ndis802_11AuthModeWPA ||
2020             ndisauthmode == Ndis802_11AuthModeWPAPSK)
2021                 authmode = WLAN_EID_VENDOR_SPECIFIC;
2022         if (ndisauthmode == Ndis802_11AuthModeWPA2 ||
2023             ndisauthmode == Ndis802_11AuthModeWPA2PSK)
2024                 authmode = WLAN_EID_RSN;
2025
2026         if (check_fwstate(pmlmepriv, WIFI_UNDER_WPS)) {
2027                 memcpy(out_ie + ielength, psecuritypriv->wps_ie,
2028                        psecuritypriv->wps_ie_len);
2029
2030                 ielength += psecuritypriv->wps_ie_len;
2031         } else if (authmode == WLAN_EID_VENDOR_SPECIFIC ||
2032                    authmode == WLAN_EID_RSN) {
2033                 /* copy RSN or SSN */
2034                 memcpy(&out_ie[ielength], &psecuritypriv->supplicant_ie[0],
2035                        psecuritypriv->supplicant_ie[1] + 2);
2036                 ielength += psecuritypriv->supplicant_ie[1] + 2;
2037         }
2038
2039         iEntry = SecIsInPMKIDList(adapter, pmlmepriv->assoc_bssid);
2040         if (iEntry < 0)
2041                 return ielength;
2042         else {
2043                 if (authmode == WLAN_EID_RSN)
2044                         ielength = rtw_append_pmkid(adapter, iEntry,
2045                                                     out_ie, ielength);
2046         }
2047
2048         return ielength;
2049 }
2050
2051 void rtw_init_registrypriv_dev_network23a(struct rtw_adapter* adapter)
2052 {
2053         struct registry_priv* pregistrypriv = &adapter->registrypriv;
2054         struct eeprom_priv* peepriv = &adapter->eeprompriv;
2055         struct wlan_bssid_ex    *pdev_network = &pregistrypriv->dev_network;
2056         u8 *myhwaddr = myid(peepriv);
2057
2058         ether_addr_copy(pdev_network->MacAddress, myhwaddr);
2059
2060         memcpy(&pdev_network->Ssid, &pregistrypriv->ssid,
2061                sizeof(struct cfg80211_ssid));
2062
2063         pdev_network->beacon_interval = 100;
2064 }
2065
2066 void rtw_update_registrypriv_dev_network23a(struct rtw_adapter* adapter)
2067 {
2068         int sz = 0;
2069         struct registry_priv* pregistrypriv = &adapter->registrypriv;
2070         struct wlan_bssid_ex *pdev_network = &pregistrypriv->dev_network;
2071         struct security_priv *psecuritypriv = &adapter->securitypriv;
2072         struct wlan_network *cur_network = &adapter->mlmepriv.cur_network;
2073         /* struct       xmit_priv       *pxmitpriv = &adapter->xmitpriv; */
2074
2075         pdev_network->Privacy =
2076                 (psecuritypriv->dot11PrivacyAlgrthm > 0 ? 1 : 0);
2077
2078         pdev_network->Rssi = 0;
2079
2080         pdev_network->DSConfig = pregistrypriv->channel;
2081         RT_TRACE(_module_rtl871x_mlme_c_, _drv_info_,
2082                  ("pregistrypriv->channel =%d, pdev_network->DSConfig = 0x%x\n",
2083                   pregistrypriv->channel, pdev_network->DSConfig));
2084
2085         if (cur_network->network.ifmode == NL80211_IFTYPE_ADHOC)
2086                 pdev_network->ATIMWindow = 0;
2087
2088         pdev_network->ifmode = cur_network->network.ifmode;
2089
2090         /*  1. Supported rates */
2091         /*  2. IE */
2092
2093         sz = rtw_generate_ie23a(pregistrypriv);
2094
2095         pdev_network->IELength = sz;
2096
2097         pdev_network->Length =
2098                 get_wlan_bssid_ex_sz(pdev_network);
2099
2100         /* notes: translate IELength & Length after assign the
2101            Length to cmdsz in createbss_cmd(); */
2102         /* pdev_network->IELength = cpu_to_le32(sz); */
2103 }
2104
2105 /* the function is at passive_level */
2106 void rtw_joinbss_reset23a(struct rtw_adapter *padapter)
2107 {
2108         u8 threshold;
2109         struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
2110         struct ht_priv *phtpriv = &pmlmepriv->htpriv;
2111
2112         /* todo: if you want to do something io/reg/hw setting
2113            before join_bss, please add code here */
2114
2115         pmlmepriv->num_FortyMHzIntolerant = 0;
2116
2117         pmlmepriv->num_sta_no_ht = 0;
2118
2119         phtpriv->ampdu_enable = false;/* reset to disabled */
2120
2121         /*  TH = 1 => means that invalidate usb rx aggregation */
2122         /*  TH = 0 => means that validate usb rx aggregation, use init value. */
2123         if (phtpriv->ht_option) {
2124                 if (padapter->registrypriv.wifi_spec == 1)
2125                         threshold = 1;
2126                 else
2127                         threshold = 0;
2128         } else
2129                 threshold = 1;
2130
2131         rtl8723a_set_rxdma_agg_pg_th(padapter, threshold);
2132 }
2133
2134 /* the function is >= passive_level */
2135 bool rtw_restructure_ht_ie23a(struct rtw_adapter *padapter, u8 *in_ie,
2136                               u8 *out_ie, uint in_len, uint *pout_len)
2137 {
2138         u32 out_len;
2139         int max_rx_ampdu_factor;
2140         unsigned char *pframe;
2141         const u8 *p;
2142         struct ieee80211_ht_cap ht_capie;
2143         u8 WMM_IE[7] = {0x00, 0x50, 0xf2, 0x02, 0x00, 0x01, 0x00};
2144         struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
2145         struct ht_priv *phtpriv = &pmlmepriv->htpriv;
2146
2147         phtpriv->ht_option = false;
2148
2149         p = cfg80211_find_ie(WLAN_EID_HT_CAPABILITY, in_ie, in_len);
2150
2151         if (p && p[1] > 0) {
2152                 u32 rx_packet_offset, max_recvbuf_sz;
2153                 if (pmlmepriv->qos_option == 0) {
2154                         out_len = *pout_len;
2155                         pframe = rtw_set_ie23a(out_ie + out_len,
2156                                                WLAN_EID_VENDOR_SPECIFIC,
2157                                                sizeof(WMM_IE), WMM_IE,
2158                                                pout_len);
2159
2160                         pmlmepriv->qos_option = 1;
2161                 }
2162
2163                 out_len = *pout_len;
2164
2165                 memset(&ht_capie, 0, sizeof(struct ieee80211_ht_cap));
2166
2167                 ht_capie.cap_info = IEEE80211_HT_CAP_SUP_WIDTH_20_40 |
2168                         IEEE80211_HT_CAP_SGI_20 | IEEE80211_HT_CAP_SGI_40 |
2169                         IEEE80211_HT_CAP_TX_STBC | IEEE80211_HT_CAP_DSSSCCK40;
2170
2171                 GetHalDefVar8192CUsb(padapter, HAL_DEF_RX_PACKET_OFFSET,
2172                                      &rx_packet_offset);
2173                 GetHalDefVar8192CUsb(padapter, HAL_DEF_MAX_RECVBUF_SZ,
2174                                      &max_recvbuf_sz);
2175
2176                 GetHalDefVar8192CUsb(padapter, HW_VAR_MAX_RX_AMPDU_FACTOR,
2177                                      &max_rx_ampdu_factor);
2178                 ht_capie.ampdu_params_info = max_rx_ampdu_factor & 0x03;
2179
2180                 if (padapter->securitypriv.dot11PrivacyAlgrthm ==
2181                     WLAN_CIPHER_SUITE_CCMP)
2182                         ht_capie.ampdu_params_info |=
2183                                 (IEEE80211_HT_AMPDU_PARM_DENSITY& (0x07 << 2));
2184                 else
2185                         ht_capie.ampdu_params_info |=
2186                                 (IEEE80211_HT_AMPDU_PARM_DENSITY & 0x00);
2187
2188                 pframe = rtw_set_ie23a(out_ie + out_len, WLAN_EID_HT_CAPABILITY,
2189                                     sizeof(struct ieee80211_ht_cap),
2190                                     (unsigned char*)&ht_capie, pout_len);
2191
2192                 phtpriv->ht_option = true;
2193
2194                 p = cfg80211_find_ie(WLAN_EID_HT_OPERATION, in_ie, in_len);
2195                 if (p && (p[1] == sizeof(struct ieee80211_ht_operation))) {
2196                         out_len = *pout_len;
2197                         pframe = rtw_set_ie23a(out_ie + out_len,
2198                                                WLAN_EID_HT_OPERATION,
2199                                                p[1], p + 2 , pout_len);
2200                 }
2201         }
2202
2203         return phtpriv->ht_option;
2204 }
2205
2206 /* the function is > passive_level (in critical_section) */
2207 void rtw_update_ht_cap23a(struct rtw_adapter *padapter, u8 *pie, uint ie_len)
2208 {
2209         u8 max_ampdu_sz;
2210         const u8 *p;
2211         struct ieee80211_ht_cap *pht_capie;
2212         struct ieee80211_ht_operation *pht_addtinfo;
2213         struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
2214         struct ht_priv *phtpriv = &pmlmepriv->htpriv;
2215         struct registry_priv *pregistrypriv = &padapter->registrypriv;
2216         struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
2217         struct mlme_ext_info *pmlmeinfo = &pmlmeext->mlmext_info;
2218
2219         if (!phtpriv->ht_option)
2220                 return;
2221
2222         if ((!pmlmeinfo->HT_info_enable) || (!pmlmeinfo->HT_caps_enable))
2223                 return;
2224
2225         DBG_8723A("+rtw_update_ht_cap23a()\n");
2226
2227         /* maybe needs check if ap supports rx ampdu. */
2228         if (!phtpriv->ampdu_enable && pregistrypriv->ampdu_enable == 1) {
2229                 if (pregistrypriv->wifi_spec == 1)
2230                         phtpriv->ampdu_enable = false;
2231                 else
2232                         phtpriv->ampdu_enable = true;
2233         } else if (pregistrypriv->ampdu_enable == 2)
2234                 phtpriv->ampdu_enable = true;
2235
2236         /* check Max Rx A-MPDU Size */
2237         p = cfg80211_find_ie(WLAN_EID_HT_CAPABILITY, pie, ie_len);
2238
2239         if (p && p[1] > 0) {
2240                 pht_capie = (struct ieee80211_ht_cap *)(p + 2);
2241                 max_ampdu_sz = pht_capie->ampdu_params_info &
2242                         IEEE80211_HT_AMPDU_PARM_FACTOR;
2243                 /*  max_ampdu_sz (kbytes); */
2244                 max_ampdu_sz = 1 << (max_ampdu_sz + 3);
2245
2246                 phtpriv->rx_ampdu_maxlen = max_ampdu_sz;
2247         }
2248
2249         p = cfg80211_find_ie(WLAN_EID_HT_OPERATION, pie, ie_len);
2250         if (p && p[1] > 0) {
2251                 pht_addtinfo = (struct ieee80211_ht_operation *)(p + 2);
2252                 /* todo: */
2253         }
2254
2255         /* update cur_bwmode & cur_ch_offset */
2256         if (pregistrypriv->cbw40_enable &&
2257             pmlmeinfo->ht_cap.cap_info &
2258             cpu_to_le16(IEEE80211_HT_CAP_SUP_WIDTH_20_40) &&
2259             pmlmeinfo->HT_info.ht_param & IEEE80211_HT_PARAM_CHAN_WIDTH_ANY) {
2260                 int i;
2261                 u8 rf_type;
2262
2263                 rf_type = rtl8723a_get_rf_type(padapter);
2264
2265                 /* update the MCS rates */
2266                 for (i = 0; i < IEEE80211_HT_MCS_MASK_LEN; i++) {
2267                         if (rf_type == RF_1T1R || rf_type == RF_1T2R)
2268                                 pmlmeinfo->ht_cap.mcs.rx_mask[i] &=
2269                                         MCS_rate_1R23A[i];
2270                         else
2271                                 pmlmeinfo->ht_cap.mcs.rx_mask[i] &=
2272                                         MCS_rate_2R23A[i];
2273                 }
2274                 /* switch to the 40M Hz mode according to the AP */
2275                 pmlmeext->cur_bwmode = HT_CHANNEL_WIDTH_40;
2276                 switch (pmlmeinfo->HT_info.ht_param &
2277                         IEEE80211_HT_PARAM_CHA_SEC_OFFSET) {
2278                 case IEEE80211_HT_PARAM_CHA_SEC_ABOVE:
2279                         pmlmeext->cur_ch_offset = HAL_PRIME_CHNL_OFFSET_LOWER;
2280                         break;
2281
2282                 case IEEE80211_HT_PARAM_CHA_SEC_BELOW:
2283                         pmlmeext->cur_ch_offset = HAL_PRIME_CHNL_OFFSET_UPPER;
2284                         break;
2285
2286                 default:
2287                         pmlmeext->cur_ch_offset =
2288                                 HAL_PRIME_CHNL_OFFSET_DONT_CARE;
2289                         break;
2290                 }
2291         }
2292
2293         /*  */
2294         /*  Config SM Power Save setting */
2295         /*  */
2296         pmlmeinfo->SM_PS =
2297                 (le16_to_cpu(pmlmeinfo->ht_cap.cap_info) &
2298                  IEEE80211_HT_CAP_SM_PS) >> IEEE80211_HT_CAP_SM_PS_SHIFT;
2299         if (pmlmeinfo->SM_PS == WLAN_HT_CAP_SM_PS_STATIC)
2300                 DBG_8723A("%s(): WLAN_HT_CAP_SM_PS_STATIC\n", __func__);
2301
2302         /*  */
2303         /*  Config current HT Protection mode. */
2304         /*  */
2305         pmlmeinfo->HT_protection =
2306                 le16_to_cpu(pmlmeinfo->HT_info.operation_mode) &
2307                 IEEE80211_HT_OP_MODE_PROTECTION;
2308 }
2309
2310 void rtw_issue_addbareq_cmd23a(struct rtw_adapter *padapter,
2311                                struct xmit_frame *pxmitframe)
2312 {
2313         u8 issued;
2314         int priority;
2315         struct sta_info *psta;
2316         struct ht_priv  *phtpriv;
2317         struct pkt_attrib *pattrib = &pxmitframe->attrib;
2318         s32 bmcst = is_multicast_ether_addr(pattrib->ra);
2319
2320         if (bmcst || padapter->mlmepriv.LinkDetectInfo.NumTxOkInPeriod < 100)
2321                 return;
2322
2323         priority = pattrib->priority;
2324
2325         if (pattrib->psta)
2326                 psta = pattrib->psta;
2327         else {
2328                 DBG_8723A("%s, call rtw_get_stainfo23a()\n", __func__);
2329                 psta = rtw_get_stainfo23a(&padapter->stapriv, pattrib->ra);
2330         }
2331
2332         if (!psta) {
2333                 DBG_8723A("%s, psta == NUL\n", __func__);
2334                 return;
2335         }
2336
2337         if (!(psta->state &_FW_LINKED)) {
2338                 DBG_8723A("%s, psta->state(0x%x) != _FW_LINKED\n",
2339                           __func__, psta->state);
2340                 return;
2341         }
2342
2343         phtpriv = &psta->htpriv;
2344
2345         if (phtpriv->ht_option && phtpriv->ampdu_enable) {
2346                 issued = (phtpriv->agg_enable_bitmap>>priority)&0x1;
2347                 issued |= (phtpriv->candidate_tid_bitmap>>priority)&0x1;
2348
2349                 if (issued == 0) {
2350                         DBG_8723A("rtw_issue_addbareq_cmd23a, p =%d\n",
2351                                   priority);
2352                         psta->htpriv.candidate_tid_bitmap |= BIT(priority);
2353                         rtw_addbareq_cmd23a(padapter, (u8) priority,
2354                                             pattrib->ra);
2355                 }
2356         }
2357 }
2358
2359 int rtw_linked_check(struct rtw_adapter *padapter)
2360 {
2361         if (check_fwstate(&padapter->mlmepriv, WIFI_AP_STATE) ||
2362             check_fwstate(&padapter->mlmepriv,
2363                           WIFI_ADHOC_STATE|WIFI_ADHOC_MASTER_STATE)) {
2364                 if (padapter->stapriv.asoc_sta_count > 2)
2365                         return true;
2366         } else {        /* Station mode */
2367                 if (check_fwstate(&padapter->mlmepriv, _FW_LINKED))
2368                         return true;
2369         }
2370         return false;
2371 }