drivers/net/wireless/rockchip_wlan/rtl8723bs/hal/rtl8723b/rtl8723b_cmd.c

   1 /******************************************************************************
   2  *
   3  * Copyright(c) 2007 - 2012 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  * You should have received a copy of the GNU General Public License along with
  15  * this program; if not, write to the Free Software Foundation, Inc.,
  16  * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
  17  *
  18  *
  19  ******************************************************************************/
  20 #define _RTL8723B_CMD_C_
  21
  22 #include <rtl8723b_hal.h>
  23 #include "hal_com_h2c.h"
  24
  25 #define MAX_H2C_BOX_NUMS        4
  26 #define MESSAGE_BOX_SIZE                4
  27
  28 #define RTL8723B_MAX_CMD_LEN    7
  29 #define RTL8723B_EX_MESSAGE_BOX_SIZE    4
  30
  31 static u8 _is_fw_read_cmd_down(_adapter* padapter, u8 msgbox_num)
  32 {
  33         u8      read_down = _FALSE;
  34         int     retry_cnts = 100;
  35
  36         u8 valid;
  37
  38         //DBG_8192C(" _is_fw_read_cmd_down ,reg_1cc(%x),msg_box(%d)...\n",rtw_read8(padapter,REG_HMETFR),msgbox_num);
  39
  40         do{
  41                 valid = rtw_read8(padapter,REG_HMETFR) & BIT(msgbox_num);
  42                 if(0 == valid ){
  43                         read_down = _TRUE;
  44                 }
  45 #ifdef CONFIG_WOWLAN
  46                 else
  47                         rtw_msleep_os(1);
  48 #endif
  49         }while( (!read_down) && (retry_cnts--));
  50
  51         return read_down;
  52
  53 }
  54
  55
  56 /*****************************************
  57 * H2C Msg format :
  58 *| 31 - 8               |7-5    | 4 - 0 |
  59 *| h2c_msg      |Class  |CMD_ID |
  60 *| 31-0                                         |
  61 *| Ext msg                                      |
  62 *
  63 ******************************************/
  64 s32 FillH2CCmd8723B(PADAPTER padapter, u8 ElementID, u32 CmdLen, u8 *pCmdBuffer)
  65 {
  66         u8 h2c_box_num;
  67         u32     msgbox_addr;
  68         u32 msgbox_ex_addr=0;
  69         PHAL_DATA_TYPE pHalData;
  70         u32     h2c_cmd = 0;
  71         u32     h2c_cmd_ex = 0;
  72         s32 ret = _FAIL;
  73         struct dvobj_priv *psdpriv = padapter->dvobj;
  74         struct debug_priv *pdbgpriv = &psdpriv->drv_dbg;
  75 _func_enter_;
  76
  77         padapter = GET_PRIMARY_ADAPTER(padapter);
  78         pHalData = GET_HAL_DATA(padapter);
  79 #ifdef DBG_CHECK_FW_PS_STATE
  80 #ifdef DBG_CHECK_FW_PS_STATE_H2C
  81         if(rtw_fw_ps_state(padapter) == _FAIL)
  82         {
  83                 DBG_871X("%s: h2c doesn't leave 32k ElementID=%02x \n", __FUNCTION__, ElementID);
  84                 pdbgpriv->dbg_h2c_leave32k_fail_cnt++;
  85         }
  86
  87         //DBG_871X("H2C ElementID=%02x , pHalData->LastHMEBoxNum=%02x\n", ElementID, pHalData->LastHMEBoxNum);
  88 #endif //DBG_CHECK_FW_PS_STATE_H2C
  89 #endif //DBG_CHECK_FW_PS_STATE
  90         _enter_critical_mutex(&(adapter_to_dvobj(padapter)->h2c_fwcmd_mutex), NULL);
  91
  92         if (!pCmdBuffer) {
  93                 goto exit;
  94         }
  95         if(CmdLen > RTL8723B_MAX_CMD_LEN) {
  96                 goto exit;
  97         }
  98         if (padapter->bSurpriseRemoved == _TRUE)
  99                 goto exit;
 100
 101         //pay attention to if  race condition happened in  H2C cmd setting.
 102         do{
 103                 h2c_box_num = pHalData->LastHMEBoxNum;
 104
 105                 if(!_is_fw_read_cmd_down(padapter, h2c_box_num)){
 106                         DBG_8192C(" fw read cmd failed...\n");
 107 #ifdef DBG_CHECK_FW_PS_STATE
 108                         DBG_871X("MAC_1C0=%08x, MAC_1C4=%08x, MAC_1C8=%08x, MAC_1CC=%08x\n", rtw_read32(padapter, 0x1c0), rtw_read32(padapter, 0x1c4)
 109                                 , rtw_read32(padapter, 0x1c8), rtw_read32(padapter, 0x1cc));
 110 #endif //DBG_CHECK_FW_PS_STATE
 111                         //DBG_8192C(" 0x1c0: 0x%8x\n", rtw_read32(padapter, 0x1c0));
 112                         //DBG_8192C(" 0x1c4: 0x%8x\n", rtw_read32(padapter, 0x1c4));
 113                         goto exit;
 114                 }
 115
 116                 if(CmdLen<=3)
 117                 {
 118                         _rtw_memcpy((u8*)(&h2c_cmd)+1, pCmdBuffer, CmdLen );
 119                 }
 120                 else{
 121                         _rtw_memcpy((u8*)(&h2c_cmd)+1, pCmdBuffer, 3);
 122                         _rtw_memcpy((u8*)(&h2c_cmd_ex), pCmdBuffer+3, CmdLen-3);
 123 //                      *(u8*)(&h2c_cmd) |= BIT(7);
 124                 }
 125
 126                 *(u8*)(&h2c_cmd) |= ElementID;
 127
 128                 if(CmdLen>3){
 129                         msgbox_ex_addr = REG_HMEBOX_EXT0_8723B + (h2c_box_num *RTL8723B_EX_MESSAGE_BOX_SIZE);
 130                         h2c_cmd_ex = le32_to_cpu( h2c_cmd_ex );
 131                         rtw_write32(padapter, msgbox_ex_addr, h2c_cmd_ex);
 132                 }
 133                 msgbox_addr =REG_HMEBOX_0 + (h2c_box_num *MESSAGE_BOX_SIZE);
 134                 h2c_cmd = le32_to_cpu( h2c_cmd );
 135                 rtw_write32(padapter,msgbox_addr, h2c_cmd);
 136
 137                 //DBG_8192C("MSG_BOX:%d, CmdLen(%d), CmdID(0x%x), reg:0x%x =>h2c_cmd:0x%.8x, reg:0x%x =>h2c_cmd_ex:0x%.8x\n"
 138                 //      ,pHalData->LastHMEBoxNum , CmdLen, ElementID, msgbox_addr, h2c_cmd, msgbox_ex_addr, h2c_cmd_ex);
 139
 140                 pHalData->LastHMEBoxNum = (h2c_box_num+1) % MAX_H2C_BOX_NUMS;
 141
 142         }while(0);
 143
 144         ret = _SUCCESS;
 145
 146 exit:
 147
 148         _exit_critical_mutex(&(adapter_to_dvobj(padapter)->h2c_fwcmd_mutex), NULL);
 149
 150 _func_exit_;
 151
 152         return ret;
 153 }
 154
 155 static void ConstructBeacon(_adapter *padapter, u8 *pframe, u32 *pLength)
 156 {
 157         struct rtw_ieee80211_hdr        *pwlanhdr;
 158         u16                                     *fctrl;
 159         u32                                     rate_len, pktlen;
 160         struct mlme_ext_priv    *pmlmeext = &(padapter->mlmeextpriv);
 161         struct mlme_ext_info    *pmlmeinfo = &(pmlmeext->mlmext_info);
 162         WLAN_BSSID_EX           *cur_network = &(pmlmeinfo->network);
 163         u8      bc_addr[] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
 164
 165
 166         //DBG_871X("%s\n", __FUNCTION__);
 167
 168         pwlanhdr = (struct rtw_ieee80211_hdr *)pframe;
 169
 170         fctrl = &(pwlanhdr->frame_ctl);
 171         *(fctrl) = 0;
 172
 173         _rtw_memcpy(pwlanhdr->addr1, bc_addr, ETH_ALEN);
 174         _rtw_memcpy(pwlanhdr->addr2, myid(&(padapter->eeprompriv)), ETH_ALEN);
 175         _rtw_memcpy(pwlanhdr->addr3, get_my_bssid(cur_network), ETH_ALEN);
 176
 177         SetSeqNum(pwlanhdr, 0/*pmlmeext->mgnt_seq*/);
 178         //pmlmeext->mgnt_seq++;
 179         SetFrameSubType(pframe, WIFI_BEACON);
 180
 181         pframe += sizeof(struct rtw_ieee80211_hdr_3addr);
 182         pktlen = sizeof (struct rtw_ieee80211_hdr_3addr);
 183
 184         //timestamp will be inserted by hardware
 185         pframe += 8;
 186         pktlen += 8;
 187
 188         // beacon interval: 2 bytes
 189         _rtw_memcpy(pframe, (unsigned char *)(rtw_get_beacon_interval_from_ie(cur_network->IEs)), 2);
 190
 191         pframe += 2;
 192         pktlen += 2;
 193
 194         // capability info: 2 bytes
 195         _rtw_memcpy(pframe, (unsigned char *)(rtw_get_capability_from_ie(cur_network->IEs)), 2);
 196
 197         pframe += 2;
 198         pktlen += 2;
 199
 200         if( (pmlmeinfo->state&0x03) == WIFI_FW_AP_STATE)
 201         {
 202                 //DBG_871X("ie len=%d\n", cur_network->IELength);
 203                 pktlen += cur_network->IELength - sizeof(NDIS_802_11_FIXED_IEs);
 204                 _rtw_memcpy(pframe, cur_network->IEs+sizeof(NDIS_802_11_FIXED_IEs), pktlen);
 205
 206                 goto _ConstructBeacon;
 207         }
 208
 209         //below for ad-hoc mode
 210
 211         // SSID
 212         pframe = rtw_set_ie(pframe, _SSID_IE_, cur_network->Ssid.SsidLength, cur_network->Ssid.Ssid, &pktlen);
 213
 214         // supported rates...
 215         rate_len = rtw_get_rateset_len(cur_network->SupportedRates);
 216         pframe = rtw_set_ie(pframe, _SUPPORTEDRATES_IE_, ((rate_len > 8)? 8: rate_len), cur_network->SupportedRates, &pktlen);
 217
 218         // DS parameter set
 219         pframe = rtw_set_ie(pframe, _DSSET_IE_, 1, (unsigned char *)&(cur_network->Configuration.DSConfig), &pktlen);
 220
 221         if( (pmlmeinfo->state&0x03) == WIFI_FW_ADHOC_STATE)
 222         {
 223                 u32 ATIMWindow;
 224                 // IBSS Parameter Set...
 225                 //ATIMWindow = cur->Configuration.ATIMWindow;
 226                 ATIMWindow = 0;
 227                 pframe = rtw_set_ie(pframe, _IBSS_PARA_IE_, 2, (unsigned char *)(&ATIMWindow), &pktlen);
 228         }
 229
 230
 231         //todo: ERP IE
 232
 233
 234         // EXTERNDED SUPPORTED RATE
 235         if (rate_len > 8)
 236         {
 237                 pframe = rtw_set_ie(pframe, _EXT_SUPPORTEDRATES_IE_, (rate_len - 8), (cur_network->SupportedRates + 8), &pktlen);
 238         }
 239
 240
 241         //todo:HT for adhoc
 242
 243 _ConstructBeacon:
 244
 245         if ((pktlen + TXDESC_SIZE) > 512)
 246         {
 247                 DBG_871X("beacon frame too large\n");
 248                 return;
 249         }
 250
 251         *pLength = pktlen;
 252
 253         //DBG_871X("%s bcn_sz=%d\n", __FUNCTION__, pktlen);
 254
 255 }
 256
 257 static void ConstructPSPoll(_adapter *padapter, u8 *pframe, u32 *pLength)
 258 {
 259         struct rtw_ieee80211_hdr        *pwlanhdr;
 260         u16                                     *fctrl;
 261         u32                                     pktlen;
 262         struct mlme_ext_priv    *pmlmeext = &(padapter->mlmeextpriv);
 263         struct mlme_ext_info    *pmlmeinfo = &(pmlmeext->mlmext_info);
 264
 265         //DBG_871X("%s\n", __FUNCTION__);
 266
 267         pwlanhdr = (struct rtw_ieee80211_hdr *)pframe;
 268
 269         // Frame control.
 270         fctrl = &(pwlanhdr->frame_ctl);
 271         *(fctrl) = 0;
 272         SetPwrMgt(fctrl);
 273         SetFrameSubType(pframe, WIFI_PSPOLL);
 274
 275         // AID.
 276         SetDuration(pframe, (pmlmeinfo->aid | 0xc000));
 277
 278         // BSSID.
 279         _rtw_memcpy(pwlanhdr->addr1, get_my_bssid(&(pmlmeinfo->network)), ETH_ALEN);
 280
 281         // TA.
 282         _rtw_memcpy(pwlanhdr->addr2, myid(&(padapter->eeprompriv)), ETH_ALEN);
 283
 284         *pLength = 16;
 285 }
 286
 287 static void ConstructNullFunctionData(
 288         PADAPTER padapter,
 289         u8              *pframe,
 290         u32             *pLength,
 291         u8              *StaAddr,
 292         u8              bQoS,
 293         u8              AC,
 294         u8              bEosp,
 295         u8              bForcePowerSave)
 296 {
 297         struct rtw_ieee80211_hdr        *pwlanhdr;
 298         u16                                             *fctrl;
 299         u32                                             pktlen;
 300         struct mlme_priv                *pmlmepriv = &padapter->mlmepriv;
 301         struct wlan_network             *cur_network = &pmlmepriv->cur_network;
 302         struct mlme_ext_priv    *pmlmeext = &(padapter->mlmeextpriv);
 303         struct mlme_ext_info    *pmlmeinfo = &(pmlmeext->mlmext_info);
 304
 305
 306         //DBG_871X("%s:%d\n", __FUNCTION__, bForcePowerSave);
 307
 308         pwlanhdr = (struct rtw_ieee80211_hdr*)pframe;
 309
 310         fctrl = &pwlanhdr->frame_ctl;
 311         *(fctrl) = 0;
 312         if (bForcePowerSave)
 313         {
 314                 SetPwrMgt(fctrl);
 315         }
 316
 317         switch(cur_network->network.InfrastructureMode)
 318         {
 319                 case Ndis802_11Infrastructure:
 320                         SetToDs(fctrl);
 321                         _rtw_memcpy(pwlanhdr->addr1, get_my_bssid(&(pmlmeinfo->network)), ETH_ALEN);
 322                         _rtw_memcpy(pwlanhdr->addr2, myid(&(padapter->eeprompriv)), ETH_ALEN);
 323                         _rtw_memcpy(pwlanhdr->addr3, StaAddr, ETH_ALEN);
 324                         break;
 325                 case Ndis802_11APMode:
 326                         SetFrDs(fctrl);
 327                         _rtw_memcpy(pwlanhdr->addr1, StaAddr, ETH_ALEN);
 328                         _rtw_memcpy(pwlanhdr->addr2, get_my_bssid(&(pmlmeinfo->network)), ETH_ALEN);
 329                         _rtw_memcpy(pwlanhdr->addr3, myid(&(padapter->eeprompriv)), ETH_ALEN);
 330                         break;
 331                 case Ndis802_11IBSS:
 332                 default:
 333                         _rtw_memcpy(pwlanhdr->addr1, StaAddr, ETH_ALEN);
 334                         _rtw_memcpy(pwlanhdr->addr2, myid(&(padapter->eeprompriv)), ETH_ALEN);
 335                         _rtw_memcpy(pwlanhdr->addr3, get_my_bssid(&(pmlmeinfo->network)), ETH_ALEN);
 336                         break;
 337         }
 338
 339         SetSeqNum(pwlanhdr, 0);
 340
 341         if (bQoS == _TRUE) {
 342                 struct rtw_ieee80211_hdr_3addr_qos *pwlanqoshdr;
 343
 344                 SetFrameSubType(pframe, WIFI_QOS_DATA_NULL);
 345
 346                 pwlanqoshdr = (struct rtw_ieee80211_hdr_3addr_qos*)pframe;
 347                 SetPriority(&pwlanqoshdr->qc, AC);
 348                 SetEOSP(&pwlanqoshdr->qc, bEosp);
 349
 350                 pktlen = sizeof(struct rtw_ieee80211_hdr_3addr_qos);
 351         } else {
 352                 SetFrameSubType(pframe, WIFI_DATA_NULL);
 353
 354                 pktlen = sizeof(struct rtw_ieee80211_hdr_3addr);
 355         }
 356
 357         *pLength = pktlen;
 358 }
 359
 360
 361 #ifdef CONFIG_WOWLAN
 362 //
 363 // Description:
 364 //      Construct the ARP response packet to support ARP offload.
 365 //
 366 static void ConstructARPResponse(
 367         PADAPTER padapter,
 368         u8                      *pframe,
 369         u32                     *pLength,
 370         u8                      *pIPAddress
 371         )
 372 {
 373         struct rtw_ieee80211_hdr        *pwlanhdr;
 374         u16                                             *fctrl;
 375         u32                                             pktlen;
 376         struct mlme_priv                *pmlmepriv = &padapter->mlmepriv;
 377         struct wlan_network             *cur_network = &pmlmepriv->cur_network;
 378         struct mlme_ext_priv    *pmlmeext = &(padapter->mlmeextpriv);
 379         struct mlme_ext_info    *pmlmeinfo = &(pmlmeext->mlmext_info);
 380         struct security_priv *psecuritypriv = &padapter->securitypriv;
 381         static u8                       ARPLLCHeader[8] = {0xAA, 0xAA, 0x03, 0x00, 0x00, 0x00, 0x08, 0x06};
 382         u8                              *pARPRspPkt = pframe;
 383         //for TKIP Cal MIC
 384         u8                              *payload = pframe;
 385         u8                      EncryptionHeadOverhead = 0;
 386         //DBG_871X("%s:%d\n", __FUNCTION__, bForcePowerSave);
 387
 388         pwlanhdr = (struct rtw_ieee80211_hdr*)pframe;
 389
 390         fctrl = &pwlanhdr->frame_ctl;
 391         *(fctrl) = 0;
 392
 393         //-------------------------------------------------------------------------
 394         // MAC Header.
 395         //-------------------------------------------------------------------------
 396         SetFrameType(fctrl, WIFI_DATA);
 397         //SetFrameSubType(fctrl, 0);
 398         SetToDs(fctrl);
 399         _rtw_memcpy(pwlanhdr->addr1, get_my_bssid(&(pmlmeinfo->network)), ETH_ALEN);
 400         _rtw_memcpy(pwlanhdr->addr2, myid(&(padapter->eeprompriv)), ETH_ALEN);
 401         _rtw_memcpy(pwlanhdr->addr3, get_my_bssid(&(pmlmeinfo->network)), ETH_ALEN);
 402
 403         SetSeqNum(pwlanhdr, 0);
 404         SetDuration(pwlanhdr, 0);
 405         //SET_80211_HDR_FRAME_CONTROL(pARPRspPkt, 0);
 406         //SET_80211_HDR_TYPE_AND_SUBTYPE(pARPRspPkt, Type_Data);
 407         //SET_80211_HDR_TO_DS(pARPRspPkt, 1);
 408         //SET_80211_HDR_ADDRESS1(pARPRspPkt, pMgntInfo->Bssid);
 409         //SET_80211_HDR_ADDRESS2(pARPRspPkt, Adapter->CurrentAddress);
 410         //SET_80211_HDR_ADDRESS3(pARPRspPkt, pMgntInfo->Bssid);
 411
 412         //SET_80211_HDR_DURATION(pARPRspPkt, 0);
 413         //SET_80211_HDR_FRAGMENT_SEQUENCE(pARPRspPkt, 0);
 414 #ifdef CONFIG_WAPI_SUPPORT
 415         *pLength = sMacHdrLng;
 416 #else
 417         *pLength = 24;
 418 #endif
 419
 420 //YJ,del,120503
 421 #if 0
 422         //-------------------------------------------------------------------------
 423         // Qos Header: leave space for it if necessary.
 424         //-------------------------------------------------------------------------
 425         if(pStaQos->CurrentQosMode > QOS_DISABLE)
 426         {
 427                 SET_80211_HDR_QOS_EN(pARPRspPkt, 1);
 428                 PlatformZeroMemory(&(Buffer[*pLength]), sQoSCtlLng);
 429                 *pLength += sQoSCtlLng;
 430         }
 431 #endif
 432         //-------------------------------------------------------------------------
 433         // Security Header: leave space for it if necessary.
 434         //-------------------------------------------------------------------------
 435
 436 #if 1
 437         switch (psecuritypriv->dot11PrivacyAlgrthm)
 438         {
 439                 case _WEP40_:
 440                 case _WEP104_:
 441                         EncryptionHeadOverhead = 4;
 442                         break;
 443                 case _TKIP_:
 444                         EncryptionHeadOverhead = 8;
 445                         break;
 446                 case _AES_:
 447                         EncryptionHeadOverhead = 8;
 448                         break;
 449 #ifdef CONFIG_WAPI_SUPPORT
 450                 case _SMS4_:
 451                         EncryptionHeadOverhead = 18;
 452                         break;
 453 #endif
 454                 default:
 455                         EncryptionHeadOverhead = 0;
 456         }
 457
 458         if(EncryptionHeadOverhead > 0)
 459         {
 460                 _rtw_memset(&(pframe[*pLength]), 0,EncryptionHeadOverhead);
 461                 *pLength += EncryptionHeadOverhead;
 462                 //SET_80211_HDR_WEP(pARPRspPkt, 1);  //Suggested by CCW.
 463                 SetPrivacy(fctrl);
 464         }
 465 #endif
 466         //-------------------------------------------------------------------------
 467         // Frame Body.
 468         //-------------------------------------------------------------------------
 469         pARPRspPkt =  (u8*)(pframe+ *pLength);
 470         payload = pARPRspPkt; //Get Payload pointer
 471         // LLC header
 472         _rtw_memcpy(pARPRspPkt, ARPLLCHeader, 8);
 473         *pLength += 8;
 474
 475         // ARP element
 476         pARPRspPkt += 8;
 477         SET_ARP_PKT_HW(pARPRspPkt, 0x0100);
 478         SET_ARP_PKT_PROTOCOL(pARPRspPkt, 0x0008);       // IP protocol
 479         SET_ARP_PKT_HW_ADDR_LEN(pARPRspPkt, 6);
 480         SET_ARP_PKT_PROTOCOL_ADDR_LEN(pARPRspPkt, 4);
 481         SET_ARP_PKT_OPERATION(pARPRspPkt, 0x0200); // ARP response
 482         SET_ARP_PKT_SENDER_MAC_ADDR(pARPRspPkt, myid(&(padapter->eeprompriv)));
 483         SET_ARP_PKT_SENDER_IP_ADDR(pARPRspPkt, pIPAddress);
 484 #ifdef CONFIG_ARP_KEEP_ALIVE
 485         if (rtw_gw_addr_query(padapter)==0) {
 486                 SET_ARP_PKT_TARGET_MAC_ADDR(pARPRspPkt, pmlmepriv->gw_mac_addr);
 487                 SET_ARP_PKT_TARGET_IP_ADDR(pARPRspPkt, pmlmepriv->gw_ip);
 488         }
 489         else
 490 #endif
 491         {
 492                 SET_ARP_PKT_TARGET_MAC_ADDR(pARPRspPkt, get_my_bssid(&(pmlmeinfo->network)));
 493                 SET_ARP_PKT_TARGET_IP_ADDR(pARPRspPkt, pIPAddress);
 494                 DBG_871X("%s Target Mac Addr:" MAC_FMT "\n", __FUNCTION__, MAC_ARG(get_my_bssid(&(pmlmeinfo->network))));
 495                 DBG_871X("%s Target IP Addr" IP_FMT "\n", __FUNCTION__, IP_ARG(pIPAddress));
 496         }
 497
 498         *pLength += 28;
 499
 500         if (psecuritypriv->dot11PrivacyAlgrthm == _TKIP_)
 501         {
 502                 u8      mic[8];
 503                 struct mic_data micdata;
 504                 struct sta_info *psta = NULL;
 505                 u8      priority[4]={0x0,0x0,0x0,0x0};
 506                 u8      null_key[16]={0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0};
 507
 508                 DBG_871X("%s(): Add MIC\n",__FUNCTION__);
 509
 510                 psta = rtw_get_stainfo(&padapter->stapriv, get_my_bssid(&(pmlmeinfo->network)));
 511                 if (psta != NULL) {
 512                         if(_rtw_memcmp(&psta->dot11tkiptxmickey.skey[0],null_key, 16)==_TRUE){
 513                                 DBG_871X("%s(): STA dot11tkiptxmickey==0\n",__FUNCTION__);
 514                         }
 515                         //start to calculate the mic code
 516                         rtw_secmicsetkey(&micdata, &psta->dot11tkiptxmickey.skey[0]);
 517                 }
 518
 519                 rtw_secmicappend(&micdata, pwlanhdr->addr3, 6);  //DA
 520
 521                 rtw_secmicappend(&micdata, pwlanhdr->addr2, 6); //SA
 522
 523                 priority[0]=0;
 524                 rtw_secmicappend(&micdata, &priority[0], 4);
 525
 526                 rtw_secmicappend(&micdata, payload, 36); //payload length = 8 + 28
 527
 528                 rtw_secgetmic(&micdata,&(mic[0]));
 529
 530                 pARPRspPkt += 28;
 531                 _rtw_memcpy(pARPRspPkt, &(mic[0]),8);
 532
 533                 *pLength += 8;
 534         }
 535 }
 536
 537 #ifdef CONFIG_PNO_SUPPORT
 538 static void ConstructPnoInfo(
 539         PADAPTER padapter,
 540         u8                      *pframe,
 541         u32                     *pLength
 542         )
 543 {
 544
 545         struct pwrctrl_priv *pwrctl = adapter_to_pwrctl(padapter);
 546
 547         u8      *pPnoInfoPkt = pframe;
 548         pPnoInfoPkt =  (u8*)(pframe+ *pLength);
 549         _rtw_memcpy(pPnoInfoPkt, &pwrctl->pnlo_info->ssid_num, 1);
 550
 551         *pLength+=1;
 552         pPnoInfoPkt += 1;
 553         _rtw_memcpy(pPnoInfoPkt, &pwrctl->pnlo_info->hidden_ssid_num, 1);
 554
 555         *pLength+=3;
 556         pPnoInfoPkt += 3;
 557         _rtw_memcpy(pPnoInfoPkt, &pwrctl->pnlo_info->fast_scan_period, 1);
 558
 559         *pLength+=4;
 560         pPnoInfoPkt += 4;
 561         _rtw_memcpy(pPnoInfoPkt, &pwrctl->pnlo_info->fast_scan_iterations, 4);
 562
 563         *pLength+=4;
 564         pPnoInfoPkt += 4;
 565         _rtw_memcpy(pPnoInfoPkt, &pwrctl->pnlo_info->slow_scan_period, 4);
 566
 567         *pLength+=4;
 568         pPnoInfoPkt += 4;
 569         _rtw_memcpy(pPnoInfoPkt, &pwrctl->pnlo_info->ssid_length,
 570                         MAX_PNO_LIST_COUNT);
 571
 572         *pLength+=MAX_PNO_LIST_COUNT;
 573         pPnoInfoPkt += MAX_PNO_LIST_COUNT;
 574         _rtw_memcpy(pPnoInfoPkt, &pwrctl->pnlo_info->ssid_cipher_info,
 575                         MAX_PNO_LIST_COUNT);
 576
 577         *pLength+=MAX_PNO_LIST_COUNT;
 578         pPnoInfoPkt += MAX_PNO_LIST_COUNT;
 579         _rtw_memcpy(pPnoInfoPkt, &pwrctl->pnlo_info->ssid_channel_info,
 580                         MAX_PNO_LIST_COUNT);
 581
 582         *pLength+=MAX_PNO_LIST_COUNT;
 583         pPnoInfoPkt += MAX_PNO_LIST_COUNT;
 584         _rtw_memcpy(pPnoInfoPkt, &pwrctl->pnlo_info->loc_probe_req,
 585                         MAX_HIDDEN_AP);
 586
 587         *pLength+=MAX_HIDDEN_AP;
 588         pPnoInfoPkt += MAX_HIDDEN_AP;
 589 }
 590
 591 static void ConstructSSIDList(
 592         PADAPTER padapter,
 593         u8                      *pframe,
 594         u32                     *pLength
 595         )
 596 {
 597         int i = 0;
 598         u8      *pSSIDListPkt = pframe;
 599         struct pwrctrl_priv *pwrctl = adapter_to_pwrctl(padapter);
 600
 601         pSSIDListPkt =  (u8*)(pframe+ *pLength);
 602
 603         for(i = 0; i < pwrctl->pnlo_info->ssid_num ; i++) {
 604                 _rtw_memcpy(pSSIDListPkt, &pwrctl->pno_ssid_list->node[i].SSID,
 605                         pwrctl->pnlo_info->ssid_length[i]);
 606
 607                 *pLength += WLAN_SSID_MAXLEN;
 608                 pSSIDListPkt += WLAN_SSID_MAXLEN;
 609         }
 610 }
 611
 612 static void ConstructScanInfo(
 613         PADAPTER padapter,
 614         u8                      *pframe,
 615         u32                     *pLength
 616         )
 617 {
 618         int i = 0;
 619         u8      *pScanInfoPkt = pframe;
 620         struct pwrctrl_priv *pwrctl = adapter_to_pwrctl(padapter);
 621
 622         pScanInfoPkt =  (u8*)(pframe+ *pLength);
 623
 624         _rtw_memcpy(pScanInfoPkt, &pwrctl->pscan_info->channel_num, 1);
 625
 626         *pLength+=1;
 627         pScanInfoPkt += 1;
 628         _rtw_memcpy(pScanInfoPkt, &pwrctl->pscan_info->orig_ch, 1);
 629
 630
 631         *pLength+=1;
 632         pScanInfoPkt += 1;
 633         _rtw_memcpy(pScanInfoPkt, &pwrctl->pscan_info->orig_bw, 1);
 634
 635
 636         *pLength+=1;
 637         pScanInfoPkt += 1;
 638         _rtw_memcpy(pScanInfoPkt, &pwrctl->pscan_info->orig_40_offset, 1);
 639
 640         *pLength+=1;
 641         pScanInfoPkt += 1;
 642         _rtw_memcpy(pScanInfoPkt, &pwrctl->pscan_info->orig_80_offset, 1);
 643
 644         *pLength+=1;
 645         pScanInfoPkt += 1;
 646         _rtw_memcpy(pScanInfoPkt, &pwrctl->pscan_info->periodScan, 1);
 647
 648         *pLength+=1;
 649         pScanInfoPkt += 1;
 650         _rtw_memcpy(pScanInfoPkt, &pwrctl->pscan_info->period_scan_time, 1);
 651
 652         *pLength+=1;
 653         pScanInfoPkt += 1;
 654         _rtw_memcpy(pScanInfoPkt, &pwrctl->pscan_info->enableRFE, 1);
 655
 656         *pLength+=1;
 657         pScanInfoPkt += 1;
 658         _rtw_memcpy(pScanInfoPkt, &pwrctl->pscan_info->rfe_type, 8);
 659
 660         *pLength+=8;
 661         pScanInfoPkt += 8;
 662
 663         for(i = 0 ; i < MAX_SCAN_LIST_COUNT ; i ++) {
 664                 _rtw_memcpy(pScanInfoPkt,
 665                         &pwrctl->pscan_info->ssid_channel_info[i], 4);
 666                 *pLength+=4;
 667                 pScanInfoPkt += 4;
 668         }
 669 }
 670 #endif
 671
 672 #ifdef CONFIG_GTK_OL
 673 static void ConstructGTKResponse(
 674         PADAPTER padapter,
 675         u8                      *pframe,
 676         u32                     *pLength
 677         )
 678 {
 679         struct rtw_ieee80211_hdr        *pwlanhdr;
 680         u16                                             *fctrl;
 681         u32                                             pktlen;
 682         struct mlme_priv                *pmlmepriv = &padapter->mlmepriv;
 683         struct wlan_network             *cur_network = &pmlmepriv->cur_network;
 684         struct mlme_ext_priv    *pmlmeext = &(padapter->mlmeextpriv);
 685         struct mlme_ext_info    *pmlmeinfo = &(pmlmeext->mlmext_info);
 686         struct security_priv *psecuritypriv = &padapter->securitypriv;
 687         static u8                       LLCHeader[8] = {0xAA, 0xAA, 0x03, 0x00, 0x00, 0x00, 0x88, 0x8E};
 688         static u8                       GTKbody_a[11] ={0x01, 0x03, 0x00, 0x5F, 0x02, 0x03, 0x12, 0x00, 0x10, 0x42, 0x0B};
 689         u8                              *pGTKRspPkt = pframe;
 690         u8                      EncryptionHeadOverhead = 0;
 691         //DBG_871X("%s:%d\n", __FUNCTION__, bForcePowerSave);
 692
 693         pwlanhdr = (struct rtw_ieee80211_hdr*)pframe;
 694
 695         fctrl = &pwlanhdr->frame_ctl;
 696         *(fctrl) = 0;
 697
 698         //-------------------------------------------------------------------------
 699         // MAC Header.
 700         //-------------------------------------------------------------------------
 701         SetFrameType(fctrl, WIFI_DATA);
 702         //SetFrameSubType(fctrl, 0);
 703         SetToDs(fctrl);
 704         _rtw_memcpy(pwlanhdr->addr1, get_my_bssid(&(pmlmeinfo->network)), ETH_ALEN);
 705         _rtw_memcpy(pwlanhdr->addr2, myid(&(padapter->eeprompriv)), ETH_ALEN);
 706         _rtw_memcpy(pwlanhdr->addr3, get_my_bssid(&(pmlmeinfo->network)), ETH_ALEN);
 707
 708         SetSeqNum(pwlanhdr, 0);
 709         SetDuration(pwlanhdr, 0);
 710
 711 #ifdef CONFIG_WAPI_SUPPORT
 712         *pLength = sMacHdrLng;
 713 #else
 714         *pLength = 24;
 715 #endif //CONFIG_WAPI_SUPPORT
 716
 717 //YJ,del,120503
 718 #if 0
 719         //-------------------------------------------------------------------------
 720         // Qos Header: leave space for it if necessary.
 721         //-------------------------------------------------------------------------
 722         if(pStaQos->CurrentQosMode > QOS_DISABLE)
 723         {
 724                 SET_80211_HDR_QOS_EN(pGTKRspPkt, 1);
 725                 PlatformZeroMemory(&(Buffer[*pLength]), sQoSCtlLng);
 726                 *pLength += sQoSCtlLng;
 727         }
 728 #endif //0
 729         //-------------------------------------------------------------------------
 730         // Security Header: leave space for it if necessary.
 731         //-------------------------------------------------------------------------
 732
 733 #if 1
 734         switch (psecuritypriv->dot11PrivacyAlgrthm)
 735         {
 736                 case _WEP40_:
 737                 case _WEP104_:
 738                         EncryptionHeadOverhead = 4;
 739                         break;
 740                 case _TKIP_:
 741                         EncryptionHeadOverhead = 8;
 742                         break;
 743                 case _AES_:
 744                         EncryptionHeadOverhead = 8;
 745                         break;
 746 #ifdef CONFIG_WAPI_SUPPORT
 747                 case _SMS4_:
 748                         EncryptionHeadOverhead = 18;
 749                         break;
 750 #endif //CONFIG_WAPI_SUPPORT
 751                 default:
 752                         EncryptionHeadOverhead = 0;
 753         }
 754
 755         if(EncryptionHeadOverhead > 0)
 756         {
 757                 _rtw_memset(&(pframe[*pLength]), 0,EncryptionHeadOverhead);
 758                 *pLength += EncryptionHeadOverhead;
 759                 //SET_80211_HDR_WEP(pGTKRspPkt, 1);  //Suggested by CCW.
 760                 //GTK's privacy bit is done by FW
 761                 //SetPrivacy(fctrl);
 762         }
 763 #endif //1
 764         //-------------------------------------------------------------------------
 765         // Frame Body.
 766         //-------------------------------------------------------------------------
 767         pGTKRspPkt =  (u8*)(pframe+ *pLength);
 768         // LLC header
 769         _rtw_memcpy(pGTKRspPkt, LLCHeader, 8);
 770         *pLength += 8;
 771
 772         // GTK element
 773         pGTKRspPkt += 8;
 774
 775         //GTK frame body after LLC, part 1
 776         _rtw_memcpy(pGTKRspPkt, GTKbody_a, 11);
 777         *pLength += 11;
 778         pGTKRspPkt += 11;
 779         //GTK frame body after LLC, part 2
 780         _rtw_memset(&(pframe[*pLength]), 0, 88);
 781         *pLength += 88;
 782         pGTKRspPkt += 88;
 783
 784 }
 785 #endif //CONFIG_GTK_OL
 786
 787 #ifdef CONFIG_PNO_SUPPORT
 788 static void ConstructProbeReq(_adapter *padapter, u8 *pframe, u32 *pLength,
 789                 pno_ssid_t *ssid)
 790 {
 791         struct rtw_ieee80211_hdr        *pwlanhdr;
 792         u16                             *fctrl;
 793         u32                             pktlen;
 794         unsigned char                   *mac;
 795         unsigned char                   bssrate[NumRates];
 796         struct xmit_priv                *pxmitpriv = &(padapter->xmitpriv);
 797         struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
 798         struct mlme_ext_priv    *pmlmeext = &(padapter->mlmeextpriv);
 799         struct mlme_ext_info    *pmlmeinfo = &(pmlmeext->mlmext_info);
 800         int     bssrate_len = 0;
 801         u8      bc_addr[] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
 802
 803         pwlanhdr = (struct rtw_ieee80211_hdr *)pframe;
 804         mac = myid(&(padapter->eeprompriv));
 805
 806         fctrl = &(pwlanhdr->frame_ctl);
 807         *(fctrl) = 0;
 808
 809         _rtw_memcpy(pwlanhdr->addr1, bc_addr, ETH_ALEN);
 810         _rtw_memcpy(pwlanhdr->addr3, bc_addr, ETH_ALEN);
 811
 812         _rtw_memcpy(pwlanhdr->addr2, mac, ETH_ALEN);
 813
 814         SetSeqNum(pwlanhdr, 0);
 815         SetFrameSubType(pframe, WIFI_PROBEREQ);
 816
 817         pktlen = sizeof(struct rtw_ieee80211_hdr_3addr);
 818         pframe += pktlen;
 819
 820         if (ssid == NULL) {
 821                 pframe = rtw_set_ie(pframe, _SSID_IE_, 0, NULL, &pktlen);
 822         } else {
 823                 pframe = rtw_set_ie(pframe, _SSID_IE_, ssid->SSID_len, ssid->SSID, &pktlen);
 824         }
 825
 826         get_rate_set(padapter, bssrate, &bssrate_len);
 827
 828         if (bssrate_len > 8)
 829         {
 830                 pframe = rtw_set_ie(pframe, _SUPPORTEDRATES_IE_ , 8, bssrate, &pktlen);
 831                 pframe = rtw_set_ie(pframe, _EXT_SUPPORTEDRATES_IE_ , (bssrate_len - 8), (bssrate + 8), &pktlen);
 832         }
 833         else
 834         {
 835                 pframe = rtw_set_ie(pframe, _SUPPORTEDRATES_IE_ , bssrate_len , bssrate, &pktlen);
 836         }
 837
 838         *pLength = pktlen;
 839 }
 840 #endif //CONFIG_PNO_SUPPORT
 841 #endif //CONFIG_WOWLAN
 842
 843 static void ConstructProbeRsp(_adapter *padapter, u8 *pframe, u32 *pLength, u8 *StaAddr, BOOLEAN bHideSSID)
 844 {
 845         struct rtw_ieee80211_hdr        *pwlanhdr;
 846         u16                                     *fctrl;
 847         u8                                      *mac, *bssid;
 848         u32                                     pktlen;
 849         struct mlme_ext_priv    *pmlmeext = &(padapter->mlmeextpriv);
 850         struct mlme_ext_info    *pmlmeinfo = &(pmlmeext->mlmext_info);
 851         WLAN_BSSID_EX           *cur_network = &(pmlmeinfo->network);
 852 #if defined (CONFIG_AP_MODE) && defined (CONFIG_NATIVEAP_MLME)
 853         u8 *pwps_ie;
 854         uint wps_ielen;
 855         struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
 856 #endif //#if defined (CONFIG_AP_MODE) && defined (CONFIG_NATIVEAP_MLME)
 857 #ifdef CONFIG_P2P
 858         struct wifidirect_info  *pwdinfo = &(padapter->wdinfo);
 859 #ifdef CONFIG_WFD
 860         u32                             wfdielen = 0;
 861 #endif //CONFIG_WFD
 862 #endif //CONFIG_P2P
 863
 864
 865         //DBG_871X("%s\n", __FUNCTION__);
 866
 867         pwlanhdr = (struct rtw_ieee80211_hdr *)pframe;
 868
 869         mac = myid(&(padapter->eeprompriv));
 870         bssid = cur_network->MacAddress;
 871
 872         fctrl = &(pwlanhdr->frame_ctl);
 873         *(fctrl) = 0;
 874         _rtw_memcpy(pwlanhdr->addr1, StaAddr, ETH_ALEN);
 875         _rtw_memcpy(pwlanhdr->addr2, mac, ETH_ALEN);
 876         _rtw_memcpy(pwlanhdr->addr3, bssid, ETH_ALEN);
 877
 878         DBG_871X("%s FW Mac Addr:" MAC_FMT "\n", __FUNCTION__, MAC_ARG(mac));
 879         DBG_871X("%s FW IP Addr" IP_FMT "\n", __FUNCTION__, IP_ARG(StaAddr));
 880
 881         SetSeqNum(pwlanhdr, 0);
 882         SetFrameSubType(fctrl, WIFI_PROBERSP);
 883
 884         pktlen = sizeof(struct rtw_ieee80211_hdr_3addr);
 885         pframe += pktlen;
 886
 887         if(cur_network->IELength>MAX_IE_SZ)
 888                 return;
 889
 890         pwps_ie = rtw_get_wps_ie(cur_network->IEs+_FIXED_IE_LENGTH_,
 891                         cur_network->IELength-_FIXED_IE_LENGTH_, NULL, &wps_ielen);
 892
 893         //inerset & update wps_probe_resp_ie
 894         if ((pmlmepriv->wps_probe_resp_ie!=NULL) && pwps_ie && (wps_ielen>0)) {
 895                 uint wps_offset, remainder_ielen;
 896                 u8 *premainder_ie;
 897
 898                 wps_offset = (uint)(pwps_ie - cur_network->IEs);
 899
 900                 premainder_ie = pwps_ie + wps_ielen;
 901
 902                 remainder_ielen = cur_network->IELength - wps_offset - wps_ielen;
 903
 904                 _rtw_memcpy(pframe, cur_network->IEs, wps_offset);
 905                 pframe += wps_offset;
 906                 pktlen += wps_offset;
 907
 908                 wps_ielen = (uint)pmlmepriv->wps_probe_resp_ie[1];//to get ie data len
 909                 if ((wps_offset+wps_ielen+2)<=MAX_IE_SZ) {
 910                         _rtw_memcpy(pframe, pmlmepriv->wps_probe_resp_ie, wps_ielen+2);
 911                         pframe += wps_ielen+2;
 912                         pktlen += wps_ielen+2;
 913                 }
 914
 915                 if ((wps_offset+wps_ielen+2+remainder_ielen)<=MAX_IE_SZ) {
 916                         _rtw_memcpy(pframe, premainder_ie, remainder_ielen);
 917                         pframe += remainder_ielen;
 918                         pktlen += remainder_ielen;
 919                 }
 920         } else {
 921                 _rtw_memcpy(pframe, cur_network->IEs, cur_network->IELength);
 922                 pframe += cur_network->IELength;
 923                 pktlen += cur_network->IELength;
 924         }
 925
 926         /* retrieve SSID IE from cur_network->Ssid */
 927         {
 928                 u8 *ssid_ie;
 929                 sint ssid_ielen;
 930                 sint ssid_ielen_diff;
 931                 u8 buf[MAX_IE_SZ];
 932                 u8 *ies = pframe + sizeof(struct rtw_ieee80211_hdr_3addr);
 933
 934                 ssid_ie = rtw_get_ie(ies+_FIXED_IE_LENGTH_, _SSID_IE_, &ssid_ielen,
 935                                         (pframe-ies)-_FIXED_IE_LENGTH_);
 936
 937                 ssid_ielen_diff = cur_network->Ssid.SsidLength - ssid_ielen;
 938
 939                 if (ssid_ie &&  cur_network->Ssid.SsidLength) {
 940                         uint remainder_ielen;
 941                         u8 *remainder_ie;
 942                         remainder_ie = ssid_ie+2;
 943                         remainder_ielen = (pframe-remainder_ie);
 944
 945                         if (remainder_ielen > MAX_IE_SZ) {
 946                                 DBG_871X_LEVEL(_drv_warning_, FUNC_ADPT_FMT" remainder_ielen > MAX_IE_SZ\n", FUNC_ADPT_ARG(padapter));
 947                                 remainder_ielen = MAX_IE_SZ;
 948                         }
 949
 950                         _rtw_memcpy(buf, remainder_ie, remainder_ielen);
 951                         _rtw_memcpy(remainder_ie+ssid_ielen_diff, buf, remainder_ielen);
 952                         *(ssid_ie+1) = cur_network->Ssid.SsidLength;
 953                         _rtw_memcpy(ssid_ie+2, cur_network->Ssid.Ssid, cur_network->Ssid.SsidLength);
 954                         pframe += ssid_ielen_diff;
 955                         pktlen += ssid_ielen_diff;
 956                 }
 957         }
 958
 959 #ifdef CONFIG_P2P
 960         if(rtw_p2p_chk_role(pwdinfo, P2P_ROLE_GO) /*&& is_valid_p2p_probereq*/)
 961         {
 962                 u32 len;
 963 #ifdef CONFIG_IOCTL_CFG80211
 964                 if(adapter_wdev_data(padapter)->p2p_enabled && pwdinfo->driver_interface == DRIVER_CFG80211 )
 965                 {
 966                         //if pwdinfo->role == P2P_ROLE_DEVICE will call issue_probersp_p2p()
 967                         len = pmlmepriv->p2p_go_probe_resp_ie_len;
 968                         if(pmlmepriv->p2p_go_probe_resp_ie && len>0)
 969                                 _rtw_memcpy(pframe, pmlmepriv->p2p_go_probe_resp_ie, len);
 970                 }
 971                 else
 972 #endif //CONFIG_IOCTL_CFG80211
 973                 {
 974                         len = build_probe_resp_p2p_ie(pwdinfo, pframe);
 975                 }
 976
 977                 pframe += len;
 978                 pktlen += len;
 979
 980 #ifdef CONFIG_WFD
 981 #ifdef CONFIG_IOCTL_CFG80211
 982                 if(_TRUE == pwdinfo->wfd_info->wfd_enable)
 983 #endif //CONFIG_IOCTL_CFG80211
 984                 {
 985                         len = build_probe_resp_wfd_ie(pwdinfo, pframe, 0);
 986                 }
 987 #ifdef CONFIG_IOCTL_CFG80211
 988                 else
 989                 {
 990                         len = 0;
 991                         if(pmlmepriv->wfd_probe_resp_ie && pmlmepriv->wfd_probe_resp_ie_len>0)
 992                         {
 993                                 len = pmlmepriv->wfd_probe_resp_ie_len;
 994                                 _rtw_memcpy(pframe, pmlmepriv->wfd_probe_resp_ie, len);
 995                         }
 996                 }
 997 #endif //CONFIG_IOCTL_CFG80211
 998                 pframe += len;
 999                 pktlen += len;
1000 #endif //CONFIG_WFD
1001
1002         }
1003 #endif //CONFIG_P2P
1004
1005         *pLength = pktlen;
1006
1007 }
1008
1009 // To check if reserved page content is destroyed by beacon beacuse beacon is too large.
1010 // 2010.06.23. Added by tynli.
1011 VOID
1012 CheckFwRsvdPageContent(
1013         IN      PADAPTER                Adapter
1014 )
1015 {
1016         HAL_DATA_TYPE*  pHalData = GET_HAL_DATA(Adapter);
1017         u32     MaxBcnPageNum;
1018
1019         if(pHalData->FwRsvdPageStartOffset != 0)
1020         {
1021                 /*MaxBcnPageNum = PageNum_128(pMgntInfo->MaxBeaconSize);
1022                 RT_ASSERT((MaxBcnPageNum <= pHalData->FwRsvdPageStartOffset),
1023                         ("CheckFwRsvdPageContent(): The reserved page content has been"\
1024                         "destroyed by beacon!!! MaxBcnPageNum(%d) FwRsvdPageStartOffset(%d)\n!",
1025                         MaxBcnPageNum, pHalData->FwRsvdPageStartOffset));*/
1026         }
1027 }
1028
1029 //
1030 // Description: Get the reserved page number in Tx packet buffer.
1031 // Retrun value: the page number.
1032 // 2012.08.09, by tynli.
1033 //
1034 u8 GetTxBufferRsvdPageNum8723B(_adapter *padapter, bool wowlan)
1035 {
1036         HAL_DATA_TYPE   *pHalData = GET_HAL_DATA(padapter);
1037         u8      RsvdPageNum=0;
1038         // default reseved 1 page for the IC type which is undefined.
1039         u8      TxPageBndy= LAST_ENTRY_OF_TX_PKT_BUFFER_8723B;
1040
1041         rtw_hal_get_def_var(padapter, HAL_DEF_TX_PAGE_BOUNDARY, (u8 *)&TxPageBndy);
1042
1043         RsvdPageNum = LAST_ENTRY_OF_TX_PKT_BUFFER_8723B -TxPageBndy + 1;
1044
1045         return RsvdPageNum;
1046 }
1047
1048 static void rtl8723b_set_FwRsvdPage_cmd(PADAPTER padapter, PRSVDPAGE_LOC rsvdpageloc)
1049 {
1050         u8 u1H2CRsvdPageParm[H2C_RSVDPAGE_LOC_LEN]={0};
1051
1052         DBG_871X("8723BRsvdPageLoc: ProbeRsp=%d PsPoll=%d Null=%d QoSNull=%d BTNull=%d\n",
1053                 rsvdpageloc->LocProbeRsp, rsvdpageloc->LocPsPoll,
1054                 rsvdpageloc->LocNullData, rsvdpageloc->LocQosNull,
1055                 rsvdpageloc->LocBTQosNull);
1056
1057         SET_8723B_H2CCMD_RSVDPAGE_LOC_PROBE_RSP(u1H2CRsvdPageParm, rsvdpageloc->LocProbeRsp);
1058         SET_8723B_H2CCMD_RSVDPAGE_LOC_PSPOLL(u1H2CRsvdPageParm, rsvdpageloc->LocPsPoll);
1059         SET_8723B_H2CCMD_RSVDPAGE_LOC_NULL_DATA(u1H2CRsvdPageParm, rsvdpageloc->LocNullData);
1060         SET_8723B_H2CCMD_RSVDPAGE_LOC_QOS_NULL_DATA(u1H2CRsvdPageParm, rsvdpageloc->LocQosNull);
1061         SET_8723B_H2CCMD_RSVDPAGE_LOC_BT_QOS_NULL_DATA(u1H2CRsvdPageParm, rsvdpageloc->LocBTQosNull);
1062
1063         RT_PRINT_DATA(_module_hal_init_c_, _drv_always_, "u1H2CRsvdPageParm:", u1H2CRsvdPageParm, H2C_RSVDPAGE_LOC_LEN);
1064         FillH2CCmd8723B(padapter, H2C_8723B_RSVD_PAGE, H2C_RSVDPAGE_LOC_LEN, u1H2CRsvdPageParm);
1065 }
1066
1067 static void rtl8723b_set_FwAoacRsvdPage_cmd(PADAPTER padapter, PRSVDPAGE_LOC rsvdpageloc)
1068 {
1069         struct pwrctrl_priv *pwrpriv = adapter_to_pwrctl(padapter);
1070         struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
1071         u8      res = 0, count = 0;
1072 #ifdef CONFIG_WOWLAN
1073         u8 u1H2CAoacRsvdPageParm[H2C_AOAC_RSVDPAGE_LOC_LEN]={0};
1074
1075         DBG_871X("8723BAOACRsvdPageLoc: RWC=%d ArpRsp=%d NbrAdv=%d GtkRsp=%d GtkInfo=%d ProbeReq=%d NetworkList=%d\n",
1076                         rsvdpageloc->LocRemoteCtrlInfo, rsvdpageloc->LocArpRsp,
1077                         rsvdpageloc->LocNbrAdv, rsvdpageloc->LocGTKRsp,
1078                         rsvdpageloc->LocGTKInfo, rsvdpageloc->LocProbeReq,
1079                         rsvdpageloc->LocNetList);
1080
1081         if (check_fwstate(pmlmepriv, _FW_LINKED)) {
1082                 SET_H2CCMD_AOAC_RSVDPAGE_LOC_REMOTE_WAKE_CTRL_INFO(u1H2CAoacRsvdPageParm, rsvdpageloc->LocRemoteCtrlInfo);
1083                 SET_H2CCMD_AOAC_RSVDPAGE_LOC_ARP_RSP(u1H2CAoacRsvdPageParm, rsvdpageloc->LocArpRsp);
1084                 //SET_H2CCMD_AOAC_RSVDPAGE_LOC_NEIGHBOR_ADV(u1H2CAoacRsvdPageParm, rsvdpageloc->LocNbrAdv);
1085                 SET_H2CCMD_AOAC_RSVDPAGE_LOC_GTK_RSP(u1H2CAoacRsvdPageParm, rsvdpageloc->LocGTKRsp);
1086                 SET_H2CCMD_AOAC_RSVDPAGE_LOC_GTK_INFO(u1H2CAoacRsvdPageParm, rsvdpageloc->LocGTKInfo);
1087 #ifdef CONFIG_GTK_OL
1088                 SET_H2CCMD_AOAC_RSVDPAGE_LOC_GTK_EXT_MEM(u1H2CAoacRsvdPageParm, rsvdpageloc->LocGTKEXTMEM);
1089 #endif // CONFIG_GTK_OL
1090                 RT_PRINT_DATA(_module_hal_init_c_, _drv_always_, "u1H2CAoacRsvdPageParm:", u1H2CAoacRsvdPageParm, H2C_AOAC_RSVDPAGE_LOC_LEN);
1091                 FillH2CCmd8723B(padapter, H2C_8723B_AOAC_RSVD_PAGE, H2C_AOAC_RSVDPAGE_LOC_LEN, u1H2CAoacRsvdPageParm);
1092         } else {
1093 #ifdef CONFIG_PNO_SUPPORT
1094                 if(!pwrpriv->pno_in_resume) {
1095                         DBG_871X("NLO_INFO=%d\n", rsvdpageloc->LocPNOInfo);
1096                         _rtw_memset(&u1H2CAoacRsvdPageParm, 0, sizeof(u1H2CAoacRsvdPageParm));
1097                         SET_H2CCMD_AOAC_RSVDPAGE_LOC_NLO_INFO(u1H2CAoacRsvdPageParm, rsvdpageloc->LocPNOInfo);
1098                         FillH2CCmd8723B(padapter, H2C_AOAC_RSVDPAGE3, H2C_AOAC_RSVDPAGE_LOC_LEN, u1H2CAoacRsvdPageParm);
1099                         rtw_msleep_os(10);
1100                 }
1101 #endif
1102         }
1103
1104 #endif // CONFIG_WOWLAN
1105 }
1106
1107 #ifdef CONFIG_AP_WOWLAN
1108 static void rtl8723b_set_ap_wow_rsvdpage_cmd(PADAPTER padapter,
1109                 PRSVDPAGE_LOC rsvdpageloc)
1110 {
1111         struct  pwrctrl_priv *pwrpriv = adapter_to_pwrctl(padapter);
1112         struct  mlme_priv *pmlmepriv = &padapter->mlmepriv;
1113         u8      res = 0, count = 0, header = 0;
1114         u8 rsvdparm[H2C_AOAC_RSVDPAGE_LOC_LEN]={0};
1115
1116         header = rtw_read8(padapter, REG_BCNQ_BDNY);
1117
1118         DBG_871X("%s: beacon: %d, probeRsp: %d, header:0x%02x\n", __func__,
1119                         rsvdpageloc->LocApOffloadBCN,
1120                         rsvdpageloc->LocProbeRsp,
1121                         header);
1122
1123         SET_H2CCMD_AP_WOWLAN_RSVDPAGE_LOC_BCN(rsvdparm,
1124                         rsvdpageloc->LocApOffloadBCN + header);
1125
1126         FillH2CCmd8723B(padapter, H2C_8723B_BCN_RSVDPAGE,
1127                         H2C_BCN_RSVDPAGE_LEN, rsvdparm);
1128
1129         rtw_msleep_os(10);
1130
1131         _rtw_memset(&rsvdparm, 0, sizeof(rsvdparm));
1132
1133         SET_H2CCMD_AP_WOWLAN_RSVDPAGE_LOC_ProbeRsp(
1134                         rsvdparm,
1135                         rsvdpageloc->LocProbeRsp + header);
1136
1137         FillH2CCmd8723B(padapter, H2C_8723B_PROBERSP_RSVDPAGE,
1138                         H2C_PROBERSP_RSVDPAGE_LEN, rsvdparm);
1139
1140         rtw_msleep_os(10);
1141 }
1142 #endif //CONFIG_AP_WOWLAN
1143
1144 void rtl8723b_set_FwMediaStatusRpt_cmd(PADAPTER padapter, u8 mstatus, u8 macid)
1145 {
1146         u8 u1H2CMediaStatusRptParm[H2C_MEDIA_STATUS_RPT_LEN]={0};
1147         u8 macid_end = 0;
1148
1149         DBG_871X("%s(): mstatus = %d macid=%d\n", __func__, mstatus, macid);
1150
1151         SET_8723B_H2CCMD_MSRRPT_PARM_OPMODE(u1H2CMediaStatusRptParm, mstatus);
1152         SET_8723B_H2CCMD_MSRRPT_PARM_MACID_IND(u1H2CMediaStatusRptParm, 0);
1153         SET_8723B_H2CCMD_MSRRPT_PARM_MACID(u1H2CMediaStatusRptParm, macid);
1154         SET_8723B_H2CCMD_MSRRPT_PARM_MACID_END(u1H2CMediaStatusRptParm, macid_end);
1155
1156         RT_PRINT_DATA(_module_hal_init_c_, _drv_always_, "u1H2CMediaStatusRptParm:", u1H2CMediaStatusRptParm, H2C_MEDIA_STATUS_RPT_LEN);
1157         FillH2CCmd8723B(padapter, H2C_8723B_MEDIA_STATUS_RPT, H2C_MEDIA_STATUS_RPT_LEN, u1H2CMediaStatusRptParm);
1158 }
1159
1160 static void rtl8723b_set_FwKeepAlive_cmd(PADAPTER padapter, u8 benable, u8 pkt_type)
1161 {
1162         u8 u1H2CKeepAliveParm[H2C_KEEP_ALIVE_CTRL_LEN]={0};
1163         u8 adopt = 1;
1164 #ifdef CONFIG_PLATFORM_INTEL_BYT
1165         u8 check_period = 10;
1166 #else
1167         u8 check_period = 5;
1168 #endif
1169
1170         DBG_871X("%s(): benable = %d\n", __func__, benable);
1171         SET_8723B_H2CCMD_KEEPALIVE_PARM_ENABLE(u1H2CKeepAliveParm, benable);
1172         SET_8723B_H2CCMD_KEEPALIVE_PARM_ADOPT(u1H2CKeepAliveParm, adopt);
1173         SET_8723B_H2CCMD_KEEPALIVE_PARM_PKT_TYPE(u1H2CKeepAliveParm, pkt_type);
1174         SET_8723B_H2CCMD_KEEPALIVE_PARM_CHECK_PERIOD(u1H2CKeepAliveParm, check_period);
1175
1176         RT_PRINT_DATA(_module_hal_init_c_, _drv_always_, "u1H2CKeepAliveParm:", u1H2CKeepAliveParm, H2C_KEEP_ALIVE_CTRL_LEN);
1177
1178         FillH2CCmd8723B(padapter, H2C_8723B_KEEP_ALIVE, H2C_KEEP_ALIVE_CTRL_LEN, u1H2CKeepAliveParm);
1179 }
1180
1181 static void rtl8723b_set_FwDisconDecision_cmd(PADAPTER padapter, u8 benable)
1182 {
1183         u8 u1H2CDisconDecisionParm[H2C_DISCON_DECISION_LEN]={0};
1184         u8 adopt = 1, check_period = 10, trypkt_num = 0;
1185
1186         DBG_871X("%s(): benable = %d\n", __func__, benable);
1187         SET_8723B_H2CCMD_DISCONDECISION_PARM_ENABLE(u1H2CDisconDecisionParm, benable);
1188         SET_8723B_H2CCMD_DISCONDECISION_PARM_ADOPT(u1H2CDisconDecisionParm, adopt);
1189         SET_8723B_H2CCMD_DISCONDECISION_PARM_CHECK_PERIOD(u1H2CDisconDecisionParm, check_period);
1190         SET_8723B_H2CCMD_DISCONDECISION_PARM_TRY_PKT_NUM(u1H2CDisconDecisionParm, trypkt_num);
1191
1192         RT_PRINT_DATA(_module_hal_init_c_, _drv_always_, "u1H2CDisconDecisionParm:", u1H2CDisconDecisionParm, H2C_DISCON_DECISION_LEN);
1193
1194         FillH2CCmd8723B(padapter, H2C_8723B_DISCON_DECISION, H2C_DISCON_DECISION_LEN, u1H2CDisconDecisionParm);
1195 }
1196
1197 void rtl8723b_set_FwMacIdConfig_cmd(_adapter* padapter, u8 mac_id, u8 raid, u8 bw, u8 sgi, u32 mask)
1198 {
1199         HAL_DATA_TYPE   *pHalData = GET_HAL_DATA(padapter);
1200         u8 u1H2CMacIdConfigParm[H2C_MACID_CFG_LEN]={0};
1201
1202         DBG_871X("%s(): mac_id=%d raid=0x%x bw=%d mask=0x%x\n", __func__, mac_id, raid, bw, mask);
1203
1204 _func_enter_;
1205
1206         SET_8723B_H2CCMD_MACID_CFG_MACID(u1H2CMacIdConfigParm, mac_id);
1207         SET_8723B_H2CCMD_MACID_CFG_RAID(u1H2CMacIdConfigParm, raid);
1208         SET_8723B_H2CCMD_MACID_CFG_SGI_EN(u1H2CMacIdConfigParm, (sgi)? 1:0);
1209         SET_8723B_H2CCMD_MACID_CFG_BW(u1H2CMacIdConfigParm, bw);
1210
1211         //DisableTXPowerTraining
1212         if(pHalData->bDisableTXPowerTraining){
1213                 SET_8723B_H2CCMD_MACID_CFG_DISPT(u1H2CMacIdConfigParm,1);
1214                 DBG_871X("%s,Disable PWT by driver\n",__FUNCTION__);
1215         }
1216         else{
1217                 PDM_ODM_T       pDM_OutSrc = &pHalData->odmpriv;
1218
1219                 if(pDM_OutSrc->bDisablePowerTraining){
1220                         SET_8723B_H2CCMD_MACID_CFG_DISPT(u1H2CMacIdConfigParm,1);
1221                         DBG_871X("%s,Disable PWT by DM\n",__FUNCTION__);
1222                 }
1223         }
1224
1225         SET_8723B_H2CCMD_MACID_CFG_RATE_MASK0(u1H2CMacIdConfigParm, (u8)(mask & 0x000000ff));
1226         SET_8723B_H2CCMD_MACID_CFG_RATE_MASK1(u1H2CMacIdConfigParm, (u8)((mask & 0x0000ff00) >>8));
1227         SET_8723B_H2CCMD_MACID_CFG_RATE_MASK2(u1H2CMacIdConfigParm, (u8)((mask & 0x00ff0000) >> 16));
1228         SET_8723B_H2CCMD_MACID_CFG_RATE_MASK3(u1H2CMacIdConfigParm, (u8)((mask & 0xff000000) >> 24));
1229
1230         RT_PRINT_DATA(_module_hal_init_c_, _drv_always_, "u1H2CMacIdConfigParm:", u1H2CMacIdConfigParm, H2C_MACID_CFG_LEN);
1231         FillH2CCmd8723B(padapter, H2C_8723B_MACID_CFG, H2C_MACID_CFG_LEN, u1H2CMacIdConfigParm);
1232
1233 _func_exit_;
1234 }
1235
1236 void rtl8723b_set_FwRssiSetting_cmd(_adapter*padapter, u8 *param)
1237 {
1238         u8 u1H2CRssiSettingParm[H2C_RSSI_SETTING_LEN]={0};
1239         u8 mac_id = *param;
1240         u8 rssi = *(param+2);
1241         u8 uldl_state = 0;
1242
1243 _func_enter_;
1244         //DBG_871X("%s(): param=%.2x-%.2x-%.2x\n", __func__, *param, *(param+1), *(param+2));
1245         //DBG_871X("%s(): mac_id=%d rssi=%d\n", __func__, mac_id, rssi);
1246
1247         SET_8723B_H2CCMD_RSSI_SETTING_MACID(u1H2CRssiSettingParm, mac_id);
1248         SET_8723B_H2CCMD_RSSI_SETTING_RSSI(u1H2CRssiSettingParm, rssi);
1249         SET_8723B_H2CCMD_RSSI_SETTING_ULDL_STATE(u1H2CRssiSettingParm, uldl_state);
1250
1251         RT_PRINT_DATA(_module_hal_init_c_, _drv_notice_, "u1H2CRssiSettingParm:", u1H2CRssiSettingParm, H2C_RSSI_SETTING_LEN);
1252         FillH2CCmd8723B(padapter, H2C_8723B_RSSI_SETTING, H2C_RSSI_SETTING_LEN, u1H2CRssiSettingParm);
1253
1254 _func_exit_;
1255 }
1256
1257 void rtl8723b_set_FwAPReqRPT_cmd(PADAPTER padapter, u32 need_ack)
1258 {
1259         u8 u1H2CApReqRptParm[H2C_AP_REQ_TXRPT_LEN]={0};
1260         u8 macid1 = 1, macid2 = 0;
1261
1262         DBG_871X("%s(): need_ack = %d\n", __func__, need_ack);
1263
1264         SET_8723B_H2CCMD_APREQRPT_PARM_MACID1(u1H2CApReqRptParm, macid1);
1265         SET_8723B_H2CCMD_APREQRPT_PARM_MACID2(u1H2CApReqRptParm, macid2);
1266
1267         RT_PRINT_DATA(_module_hal_init_c_, _drv_always_, "u1H2CApReqRptParm:", u1H2CApReqRptParm, H2C_AP_REQ_TXRPT_LEN);
1268         FillH2CCmd8723B(padapter, H2C_8723B_AP_REQ_TXRPT, H2C_AP_REQ_TXRPT_LEN, u1H2CApReqRptParm);
1269 }
1270
1271 void rtl8723b_set_FwPwrMode_cmd(PADAPTER padapter, u8 psmode)
1272 {
1273         int i;
1274         u8 smart_ps = 0;
1275         struct pwrctrl_priv *pwrpriv = adapter_to_pwrctl(padapter);
1276         struct mlme_ext_priv    *pmlmeext = &padapter->mlmeextpriv;
1277         u8 u1H2CPwrModeParm[H2C_PWRMODE_LEN]={0};
1278         u8 PowerState=0, awake_intvl = 1, byte5 = 0, rlbm = 0;
1279 #ifdef CONFIG_P2P
1280         struct wifidirect_info *wdinfo = &(padapter->wdinfo);
1281 #endif // CONFIG_P2P
1282
1283 _func_enter_;
1284
1285 #ifdef CONFIG_PLATFORM_INTEL_BYT
1286         if(psmode == PS_MODE_DTIM)
1287                 psmode = PS_MODE_MAX;
1288 #endif //CONFIG_PLATFORM_INTEL_BYT
1289
1290
1291         if(pwrpriv->dtim > 0)
1292                 DBG_871X("%s(): FW LPS mode = %d, SmartPS=%d, dtim=%d\n", __func__, psmode, pwrpriv->smart_ps, pwrpriv->dtim);
1293         else
1294                 DBG_871X("%s(): FW LPS mode = %d, SmartPS=%d\n", __func__, psmode, pwrpriv->smart_ps);
1295
1296         if(psmode == PS_MODE_MIN)
1297         {
1298                 rlbm = 0;
1299                 awake_intvl = 2;
1300                 smart_ps = pwrpriv->smart_ps;
1301         }
1302         else if(psmode == PS_MODE_MAX)
1303         {
1304                 rlbm = 1;
1305                 awake_intvl = 2;
1306                 smart_ps = pwrpriv->smart_ps;
1307         }
1308         else if(psmode == PS_MODE_DTIM) //For WOWLAN LPS, DTIM = (awake_intvl - 1)
1309         {
1310                 if(pwrpriv->dtim > 0 && pwrpriv->dtim < 16)
1311                         awake_intvl = pwrpriv->dtim+1;//DTIM = (awake_intvl - 1)
1312                 else
1313                         awake_intvl = 4;//DTIM=3
1314
1315
1316                 rlbm = 2;
1317                 smart_ps = pwrpriv->smart_ps;
1318         }
1319         else
1320         {
1321                 rlbm = 2;
1322                 awake_intvl = 4;
1323                 smart_ps = pwrpriv->smart_ps;
1324         }
1325
1326 #ifdef CONFIG_P2P
1327         if (!rtw_p2p_chk_state(wdinfo, P2P_STATE_NONE)) {
1328                 awake_intvl = 2;
1329                 rlbm = 1;
1330         }
1331 #endif // CONFIG_P2P
1332
1333         if(padapter->registrypriv.wifi_spec==1)
1334         {
1335                 awake_intvl = 2;
1336                 rlbm = 1;
1337         }
1338
1339         if (psmode > 0)
1340         {
1341 #ifdef CONFIG_BT_COEXIST
1342                 if (rtw_btcoex_IsBtControlLps(padapter) == _TRUE)
1343                 {
1344                         PowerState = rtw_btcoex_RpwmVal(padapter);
1345                         byte5 = rtw_btcoex_LpsVal(padapter);
1346
1347                         if ((rlbm == 2) && (byte5 & BIT(4)))
1348                         {
1349                                 // Keep awake interval to 1 to prevent from
1350                                 // decreasing coex performance
1351                                 awake_intvl = 2;
1352                                 rlbm = 2;
1353                         }
1354                 }
1355                 else
1356 #endif // CONFIG_BT_COEXIST
1357                 {
1358                         PowerState = 0x00;// AllON(0x0C), RFON(0x04), RFOFF(0x00)
1359                         byte5 = 0x40;
1360                 }
1361         }
1362         else
1363         {
1364                 PowerState = 0x0C;// AllON(0x0C), RFON(0x04), RFOFF(0x00)
1365                 byte5 = 0x40;
1366         }
1367
1368         SET_8723B_H2CCMD_PWRMODE_PARM_MODE(u1H2CPwrModeParm, (psmode>0)?1:0);
1369         SET_8723B_H2CCMD_PWRMODE_PARM_SMART_PS(u1H2CPwrModeParm, smart_ps);
1370         SET_8723B_H2CCMD_PWRMODE_PARM_RLBM(u1H2CPwrModeParm, rlbm);
1371         SET_8723B_H2CCMD_PWRMODE_PARM_BCN_PASS_TIME(u1H2CPwrModeParm, awake_intvl);
1372         SET_8723B_H2CCMD_PWRMODE_PARM_ALL_QUEUE_UAPSD(u1H2CPwrModeParm, padapter->registrypriv.uapsd_enable);
1373         SET_8723B_H2CCMD_PWRMODE_PARM_PWR_STATE(u1H2CPwrModeParm, PowerState);
1374         SET_8723B_H2CCMD_PWRMODE_PARM_BYTE5(u1H2CPwrModeParm, byte5);
1375 #ifdef CONFIG_LPS_LCLK
1376         if(psmode != PS_MODE_ACTIVE)
1377         {
1378                 if(pmlmeext ->adaptive_tsf_done == _FALSE && pmlmeext->bcn_cnt>0)
1379                 {
1380                         u8 ratio_20_delay, ratio_80_delay;
1381
1382                         //byte 6 for adaptive_early_32k
1383                         //[0:3] = DrvBcnEarly  (ms) , [4:7] = DrvBcnTimeOut  (ms)
1384                         // 20% for DrvBcnEarly, 80% for DrvBcnTimeOut
1385                         ratio_20_delay = 0;
1386                         ratio_80_delay = 0;
1387                         pmlmeext->DrvBcnEarly = 0xff;
1388                         pmlmeext->DrvBcnTimeOut = 0xff;
1389
1390                         //DBG_871X("%s(): bcn_cnt = %d\n", __func__, pmlmeext->bcn_cnt);
1391
1392                         for(i=0; i<9; i++)
1393                         {
1394                                 pmlmeext->bcn_delay_ratio[i] = (pmlmeext->bcn_delay_cnt[i] * 100) /pmlmeext->bcn_cnt;
1395
1396                                 //DBG_871X("%s(): bcn_delay_cnt[%d]=%d, bcn_delay_ratio[%d] = %d\n", __func__, i, pmlmeext->bcn_delay_cnt[i]
1397                                 //      ,i ,pmlmeext->bcn_delay_ratio[i]);
1398
1399                                 ratio_20_delay += pmlmeext->bcn_delay_ratio[i];
1400                                 ratio_80_delay += pmlmeext->bcn_delay_ratio[i];
1401
1402                                 if(ratio_20_delay > 20 && pmlmeext->DrvBcnEarly == 0xff)
1403                                 {
1404                                         pmlmeext->DrvBcnEarly = i;
1405                                         //DBG_871X("%s(): DrvBcnEarly = %d\n", __func__, pmlmeext->DrvBcnEarly);
1406                                 }
1407
1408                                 if(ratio_80_delay > 80 && pmlmeext->DrvBcnTimeOut == 0xff)
1409                                 {
1410                                         pmlmeext->DrvBcnTimeOut = i;
1411                                         //DBG_871X("%s(): DrvBcnTimeOut = %d\n", __func__, pmlmeext->DrvBcnTimeOut);
1412                                 }
1413
1414                                 //reset adaptive_early_32k cnt
1415                                 pmlmeext->bcn_delay_cnt[i] = 0;
1416                                 pmlmeext->bcn_delay_ratio[i] = 0;
1417
1418                         }
1419
1420                         pmlmeext->bcn_cnt = 0;
1421                         pmlmeext ->adaptive_tsf_done = _TRUE;
1422
1423                 }
1424                 else
1425                 {
1426                         //DBG_871X("%s(): DrvBcnEarly = %d\n", __func__, pmlmeext->DrvBcnEarly);
1427                         //DBG_871X("%s(): DrvBcnTimeOut = %d\n", __func__, pmlmeext->DrvBcnTimeOut);
1428                 }
1429
1430 /* offload to FW if fw version > v15.10
1431                 pmlmeext->DrvBcnEarly=0;
1432                 pmlmeext->DrvBcnTimeOut=7;
1433
1434                 if((pmlmeext->DrvBcnEarly!=0Xff) && (pmlmeext->DrvBcnTimeOut!=0xff))
1435                         u1H2CPwrModeParm[H2C_PWRMODE_LEN-1] = BIT(0) | ((pmlmeext->DrvBcnEarly<<1)&0x0E) |((pmlmeext->DrvBcnTimeOut<<4)&0xf0) ;
1436 */
1437
1438         }
1439 #endif
1440
1441 #ifdef CONFIG_BT_COEXIST
1442         rtw_btcoex_RecordPwrMode(padapter, u1H2CPwrModeParm, H2C_PWRMODE_LEN);
1443 #endif // CONFIG_BT_COEXIST
1444
1445         RT_PRINT_DATA(_module_hal_init_c_, _drv_always_, "u1H2CPwrModeParm:", u1H2CPwrModeParm, H2C_PWRMODE_LEN);
1446
1447         FillH2CCmd8723B(padapter, H2C_8723B_SET_PWR_MODE, H2C_PWRMODE_LEN, u1H2CPwrModeParm);
1448 _func_exit_;
1449 }
1450
1451 void rtl8723b_set_FwPsTuneParam_cmd(PADAPTER padapter)
1452 {
1453         struct pwrctrl_priv *pwrpriv = adapter_to_pwrctl(padapter);
1454         u8 u1H2CPsTuneParm[H2C_PSTUNEPARAM_LEN]={0};
1455         u8 bcn_to_limit = 10; //10 * 100 * awakeinterval (ms)
1456         u8 dtim_timeout = 5; //ms //wait broadcast data timer
1457         u8 ps_timeout = 20;  //ms //Keep awake when tx
1458         u8 dtim_period = 3;
1459
1460 _func_enter_;
1461         //DBG_871X("%s(): FW LPS mode = %d\n", __func__, psmode);
1462
1463         SET_8723B_H2CCMD_PSTUNE_PARM_BCN_TO_LIMIT(u1H2CPsTuneParm, bcn_to_limit);
1464         SET_8723B_H2CCMD_PSTUNE_PARM_DTIM_TIMEOUT(u1H2CPsTuneParm, dtim_timeout);
1465         SET_8723B_H2CCMD_PSTUNE_PARM_PS_TIMEOUT(u1H2CPsTuneParm, ps_timeout);
1466         SET_8723B_H2CCMD_PSTUNE_PARM_ADOPT(u1H2CPsTuneParm, 1);
1467         SET_8723B_H2CCMD_PSTUNE_PARM_DTIM_PERIOD(u1H2CPsTuneParm, dtim_period);
1468
1469         RT_PRINT_DATA(_module_hal_init_c_, _drv_always_, "u1H2CPsTuneParm:", u1H2CPsTuneParm, H2C_PSTUNEPARAM_LEN);
1470
1471         FillH2CCmd8723B(padapter, H2C_8723B_PS_TUNING_PARA, H2C_PSTUNEPARAM_LEN, u1H2CPsTuneParm);
1472 _func_exit_;
1473 }
1474
1475 void rtl8723b_set_FwBtMpOper_cmd(PADAPTER padapter, u8 idx, u8 ver, u8 reqnum, u8 *param)
1476 {
1477         u8 u1H2CBtMpOperParm[H2C_BTMP_OPER_LEN+1]={0};
1478
1479 _func_enter_;
1480
1481         DBG_8192C("%s: idx=%d ver=%d reqnum=%d param1=0x%02x param2=0x%02x\n", __FUNCTION__, idx, ver, reqnum, param[0], param[1]);
1482
1483         SET_8723B_H2CCMD_BT_MPOPER_VER(u1H2CBtMpOperParm, ver);
1484         SET_8723B_H2CCMD_BT_MPOPER_REQNUM(u1H2CBtMpOperParm, reqnum);
1485         SET_8723B_H2CCMD_BT_MPOPER_IDX(u1H2CBtMpOperParm, idx);
1486         SET_8723B_H2CCMD_BT_MPOPER_PARAM1(u1H2CBtMpOperParm, param[0]);
1487         SET_8723B_H2CCMD_BT_MPOPER_PARAM2(u1H2CBtMpOperParm, param[1]);
1488         SET_8723B_H2CCMD_BT_MPOPER_PARAM3(u1H2CBtMpOperParm, param[2]);
1489
1490         RT_PRINT_DATA(_module_hal_init_c_, _drv_always_, "u1H2CBtMpOperParm:", u1H2CBtMpOperParm, H2C_BTMP_OPER_LEN);
1491
1492         FillH2CCmd8723B(padapter, H2C_8723B_BT_MP_OPER, H2C_BTMP_OPER_LEN+1, u1H2CBtMpOperParm);
1493 _func_exit_;
1494 }
1495
1496 void rtl8723b_set_FwPwrModeInIPS_cmd(PADAPTER padapter, u8 cmd_param)
1497 {
1498         //u8 cmd_param; //BIT0:enable, BIT1:NoConnect32k
1499
1500         DBG_871X("%s()\n", __func__);
1501
1502         cmd_param = cmd_param;
1503
1504         FillH2CCmd8723B(padapter, H2C_8723B_FWLPS_IN_IPS_, 1, &cmd_param);
1505
1506 }
1507
1508 #ifdef CONFIG_WOWLAN
1509 static void rtl8723b_set_FwRemoteWakeCtrl_Cmd(PADAPTER padapter, u8 benable)
1510 {
1511         u8 u1H2CRemoteWakeCtrlParm[H2C_REMOTE_WAKE_CTRL_LEN]={0};
1512         struct security_priv* psecuritypriv=&(padapter->securitypriv);
1513         struct pwrctrl_priv *ppwrpriv = adapter_to_pwrctl(padapter);
1514         u8 res = 0, count = 0;
1515
1516         DBG_871X("%s(): Enable=%d\n", __func__, benable);
1517
1518         if (!ppwrpriv->wowlan_pno_enable) {
1519         SET_H2CCMD_REMOTE_WAKECTRL_ENABLE(u1H2CRemoteWakeCtrlParm, benable);
1520         SET_H2CCMD_REMOTE_WAKE_CTRL_ARP_OFFLOAD_EN(u1H2CRemoteWakeCtrlParm, 1);
1521 #ifdef CONFIG_GTK_OL
1522                 if (psecuritypriv->binstallKCK_KEK == _TRUE &&
1523                                 psecuritypriv->dot11PrivacyAlgrthm == _AES_) {
1524                 SET_H2CCMD_REMOTE_WAKE_CTRL_GTK_OFFLOAD_EN(u1H2CRemoteWakeCtrlParm, 1);
1525                 } else {
1526                 DBG_871X("no kck or security is not AES\n");
1527                 SET_H2CCMD_REMOTE_WAKE_CTRL_GTK_OFFLOAD_EN(u1H2CRemoteWakeCtrlParm, 0);
1528         }
1529 #endif //CONFIG_GTK_OL
1530
1531         SET_H2CCMD_REMOTE_WAKE_CTRL_FW_UNICAST_EN(u1H2CRemoteWakeCtrlParm, 1);
1532
1533                 if ((psecuritypriv->dot11PrivacyAlgrthm == _AES_) ||
1534                                 (psecuritypriv->dot11PrivacyAlgrthm == _NO_PRIVACY_))
1535                 {
1536                         SET_H2CCMD_REMOTE_WAKE_CTRL_ARP_ACTION(u1H2CRemoteWakeCtrlParm, 0);
1537                 } else {
1538                         SET_H2CCMD_REMOTE_WAKE_CTRL_ARP_ACTION(u1H2CRemoteWakeCtrlParm, 1);
1539                 }
1540         }
1541 #ifdef CONFIG_PNO_SUPPORT
1542         else {
1543                 SET_H2CCMD_REMOTE_WAKECTRL_ENABLE(u1H2CRemoteWakeCtrlParm, benable);
1544                 SET_H2CCMD_REMOTE_WAKE_CTRL_NLO_OFFLOAD_EN(u1H2CRemoteWakeCtrlParm, benable);
1545         }
1546 #endif
1547 exit:
1548         RT_PRINT_DATA(_module_hal_init_c_, _drv_always_, "u1H2CRemoteWakeCtrlParm:", u1H2CRemoteWakeCtrlParm, H2C_REMOTE_WAKE_CTRL_LEN);
1549         FillH2CCmd8723B(padapter, H2C_8723B_REMOTE_WAKE_CTRL,
1550                 H2C_REMOTE_WAKE_CTRL_LEN, u1H2CRemoteWakeCtrlParm);
1551 #ifdef CONFIG_PNO_SUPPORT
1552         if (ppwrpriv->wowlan_pno_enable && ppwrpriv->pno_in_resume == _FALSE) {
1553                 res = rtw_read8(padapter, REG_PNO_STATUS);
1554                 DBG_871X("cmd: 0x81 REG_PNO_STATUS: 0x%02x\n", res);
1555                 while(!(res&BIT(7)) && count < 25) {
1556                         DBG_871X("[%d] cmd: 0x81 REG_PNO_STATUS: 0x%02x\n", count, res);
1557                         res = rtw_read8(padapter, REG_PNO_STATUS);
1558                         count++;
1559                         rtw_msleep_os(2);
1560                 }
1561                 DBG_871X("cmd: 0x81 REG_PNO_STATUS: 0x%02x\n", res);
1562         }
1563 #endif //CONFIG_PNO_SUPPORT
1564 }
1565
1566 static void rtl8723b_set_FwAOACGlobalInfo_Cmd(PADAPTER padapter,  u8 group_alg, u8 pairwise_alg)
1567 {
1568         u8 u1H2CAOACGlobalInfoParm[H2C_AOAC_GLOBAL_INFO_LEN]={0};
1569
1570         DBG_871X("%s(): group_alg=%d pairwise_alg=%d\n", __func__, group_alg, pairwise_alg);
1571
1572         SET_H2CCMD_AOAC_GLOBAL_INFO_PAIRWISE_ENC_ALG(u1H2CAOACGlobalInfoParm, pairwise_alg);
1573         SET_H2CCMD_AOAC_GLOBAL_INFO_GROUP_ENC_ALG(u1H2CAOACGlobalInfoParm, group_alg);
1574
1575         RT_PRINT_DATA(_module_hal_init_c_, _drv_always_, "u1H2CAOACGlobalInfoParm:", u1H2CAOACGlobalInfoParm, H2C_AOAC_GLOBAL_INFO_LEN);
1576
1577         FillH2CCmd8723B(padapter, H2C_8723B_AOAC_GLOBAL_INFO, H2C_AOAC_GLOBAL_INFO_LEN, u1H2CAOACGlobalInfoParm);
1578 }
1579
1580 #ifdef CONFIG_PNO_SUPPORT
1581 static void rtl8723b_set_FwScanOffloadInfo_cmd(PADAPTER padapter, PRSVDPAGE_LOC rsvdpageloc, u8 enable)
1582 {
1583         u8 u1H2CScanOffloadInfoParm[H2C_SCAN_OFFLOAD_CTRL_LEN]={0};
1584         u8 res = 0, count = 0;
1585         struct pwrctrl_priv *pwrpriv = adapter_to_pwrctl(padapter);
1586
1587         DBG_871X("%s: loc_probe_packet:%d, loc_scan_info: %d loc_ssid_info:%d\n",
1588                 __func__, rsvdpageloc->LocProbePacket, rsvdpageloc->LocScanInfo, rsvdpageloc->LocSSIDInfo);
1589
1590         SET_H2CCMD_AOAC_NLO_FUN_EN(u1H2CScanOffloadInfoParm, enable);
1591         SET_H2CCMD_AOAC_RSVDPAGE_LOC_SCAN_INFO(u1H2CScanOffloadInfoParm, rsvdpageloc->LocScanInfo);
1592         SET_H2CCMD_AOAC_RSVDPAGE_LOC_PROBE_PACKET(u1H2CScanOffloadInfoParm, rsvdpageloc->LocProbePacket);
1593         SET_H2CCMD_AOAC_RSVDPAGE_LOC_SSID_INFO(u1H2CScanOffloadInfoParm, rsvdpageloc->LocSSIDInfo);
1594
1595         RT_PRINT_DATA(_module_hal_init_c_, _drv_always_, "u1H2CScanOffloadInfoParm:", u1H2CScanOffloadInfoParm, H2C_SCAN_OFFLOAD_CTRL_LEN);
1596         FillH2CCmd8723B(padapter, H2C_8723B_D0_SCAN_OFFLOAD_INFO, H2C_SCAN_OFFLOAD_CTRL_LEN, u1H2CScanOffloadInfoParm);
1597
1598         rtw_msleep_os(20);
1599 }
1600 #endif //CONFIG_PNO_SUPPORT
1601
1602 static void rtl8723b_set_FwWoWlanRelated_cmd(_adapter* padapter, u8 enable)
1603 {
1604         struct security_priv *psecpriv = &padapter->securitypriv;
1605         struct pwrctrl_priv *ppwrpriv = adapter_to_pwrctl(padapter);
1606         struct mlme_priv        *pmlmepriv = &padapter->mlmepriv;
1607         struct sta_info *psta = NULL;
1608         u8      pkt_type = 0;
1609
1610         DBG_871X_LEVEL(_drv_always_, "+%s()+: enable=%d\n", __func__, enable);
1611 _func_enter_;
1612         if(enable)
1613         {
1614                 rtl8723b_set_FwAOACGlobalInfo_Cmd(padapter, psecpriv->dot118021XGrpPrivacy, psecpriv->dot11PrivacyAlgrthm);
1615
1616                 rtl8723b_set_FwJoinBssRpt_cmd(padapter, RT_MEDIA_CONNECT);      //RT_MEDIA_CONNECT will confuse in the future
1617
1618                 if(!(ppwrpriv->wowlan_pno_enable))
1619                 {
1620                         psta = rtw_get_stainfo(&padapter->stapriv, get_bssid(pmlmepriv));
1621                         if (psta != NULL)
1622                                 rtl8723b_set_FwMediaStatusRpt_cmd(padapter, RT_MEDIA_CONNECT, psta->mac_id);
1623                 }
1624                 else
1625                         DBG_871X("%s(): Disconnected, no FwMediaStatusRpt CONNECT\n",__FUNCTION__);
1626
1627                 rtw_msleep_os(2);
1628
1629                 if(!(ppwrpriv->wowlan_pno_enable)) {
1630                 rtl8723b_set_FwDisconDecision_cmd(padapter, enable);
1631                 rtw_msleep_os(2);
1632
1633                         if ((psecpriv->dot11PrivacyAlgrthm != _WEP40_) || (psecpriv->dot11PrivacyAlgrthm != _WEP104_))
1634                                 pkt_type = 1;
1635                         rtl8723b_set_FwKeepAlive_cmd(padapter, enable, pkt_type);
1636                 rtw_msleep_os(2);
1637                 }
1638
1639                 rtw_hal_set_wowlan_ctrl_cmd(padapter, enable);
1640                 rtw_msleep_os(2);
1641
1642                 rtl8723b_set_FwRemoteWakeCtrl_Cmd(padapter, enable);
1643         }
1644         else
1645         {
1646 #if 0
1647                 {
1648                         u32 PageSize = 0;
1649                         rtw_hal_get_def_var(adapter, HAL_DEF_TX_PAGE_SIZE, (u8 *)&PageSize);
1650                         dump_TX_FIFO(padapter, 4, PageSize);
1651                 }
1652 #endif
1653                 rtl8723b_set_FwRemoteWakeCtrl_Cmd(padapter, enable);
1654                 rtw_msleep_os(2);
1655                 rtw_hal_set_wowlan_ctrl_cmd(padapter, enable);
1656         }
1657
1658 _func_exit_;
1659         DBG_871X_LEVEL(_drv_always_, "-%s()-\n", __func__);
1660         return ;
1661 }
1662
1663 void rtl8723b_set_wowlan_cmd(_adapter* padapter, u8 enable)
1664 {
1665         rtl8723b_set_FwWoWlanRelated_cmd(padapter, enable);
1666 }
1667 #endif //CONFIG_WOWLAN
1668
1669 #ifdef CONFIG_AP_WOWLAN
1670 static void rtl8723b_set_FwAPWoWlanCtrl_Cmd(PADAPTER padapter, u8 bFuncEn)
1671 {
1672         u8 u1H2CAPWoWlanCtrlParm[H2C_WOWLAN_LEN]={0};
1673         u8 discont_wake = 1, gpionum = 0, gpio_dur = 0;
1674         u8 gpio_high_active = 1; //0: low active, 1: high active
1675         u8 gpio_pulse = bFuncEn;
1676 #ifdef CONFIG_GPIO_WAKEUP
1677         gpionum = WAKEUP_GPIO_IDX;
1678 #endif
1679
1680         DBG_871X("%s(): bFuncEn=%d\n", __func__, bFuncEn);
1681
1682         if (bFuncEn)
1683                 gpio_dur = 16;
1684         else
1685                 gpio_dur = 0;
1686
1687         SET_H2CCMD_AP_WOW_GPIO_CTRL_INDEX(u1H2CAPWoWlanCtrlParm,
1688                         gpionum);
1689         SET_H2CCMD_AP_WOW_GPIO_CTRL_PLUS(u1H2CAPWoWlanCtrlParm,
1690                         gpio_pulse);
1691         SET_H2CCMD_AP_WOW_GPIO_CTRL_HIGH_ACTIVE(u1H2CAPWoWlanCtrlParm,
1692                         gpio_high_active);
1693         SET_H2CCMD_AP_WOW_GPIO_CTRL_EN(u1H2CAPWoWlanCtrlParm,
1694                         bFuncEn);
1695         SET_H2CCMD_AP_WOW_GPIO_CTRL_DURATION(u1H2CAPWoWlanCtrlParm,
1696                         gpio_dur);
1697
1698         FillH2CCmd8723B(padapter, H2C_8723B_AP_WOW_GPIO_CTRL,
1699                         H2C_AP_WOW_GPIO_CTRL_LEN, u1H2CAPWoWlanCtrlParm);
1700 }
1701
1702 static void rtl8723b_set_Fw_AP_Offload_Cmd(PADAPTER padapter, u8 bFuncEn)
1703 {
1704         u8 u1H2CAPOffloadCtrlParm[H2C_WOWLAN_LEN]={0};
1705
1706         DBG_871X("%s(): bFuncEn=%d\n", __func__, bFuncEn);
1707
1708         SET_H2CCMD_AP_WOWLAN_EN(u1H2CAPOffloadCtrlParm, bFuncEn);
1709
1710         FillH2CCmd8723B(padapter, H2C_8723B_AP_OFFLOAD,
1711                         H2C_AP_OFFLOAD_LEN, u1H2CAPOffloadCtrlParm);
1712 }
1713
1714 static void rtl8723b_set_AP_FwWoWlan_cmd(_adapter* padapter, u8 enable)
1715 {
1716         struct security_priv *psecpriv = &padapter->securitypriv;
1717         struct pwrctrl_priv *ppwrpriv = adapter_to_pwrctl(padapter);
1718         struct mlme_priv        *pmlmepriv = &padapter->mlmepriv;
1719         struct sta_info *psta = NULL;
1720         u8      pkt_type = 0;
1721         u8      res = 0;
1722
1723         DBG_871X_LEVEL(_drv_always_, "+%s()+: enable=%d\n", __func__, enable);
1724 _func_enter_;
1725         if (enable) {
1726 #ifdef CONFIG_CONCURRENT_MODE
1727                 if (rtw_buddy_adapter_up(padapter) == _TRUE &&
1728                         check_buddy_fwstate(padapter, WIFI_AP_STATE) == _TRUE) {
1729                                 rtl8723b_set_FwJoinBssRpt_cmd(padapter->pbuddy_adapter, RT_MEDIA_CONNECT);
1730                                 issue_beacon(padapter->pbuddy_adapter, 0);
1731                 } else {
1732                 rtl8723b_set_FwJoinBssRpt_cmd(padapter, RT_MEDIA_CONNECT);
1733                 issue_beacon(padapter, 0);
1734         }
1735 #else
1736                 rtl8723b_set_FwJoinBssRpt_cmd(padapter, RT_MEDIA_CONNECT);
1737                 issue_beacon(padapter, 0);
1738 #endif
1739         }
1740 #if 0
1741         else
1742
1743                 dump_TX_FIFO(padapter);
1744 #endif
1745         rtl8723b_set_FwAPWoWlanCtrl_Cmd(padapter, enable);
1746         rtw_msleep_os(10);
1747         rtl8723b_set_Fw_AP_Offload_Cmd(padapter, enable);
1748         rtw_msleep_os(10);
1749 _func_exit_;
1750         DBG_871X_LEVEL(_drv_always_, "-%s()-\n", __func__);
1751         return ;
1752 }
1753
1754 void rtl8723b_set_ap_wowlan_cmd(_adapter* padapter, u8 enable)
1755 {
1756         rtl8723b_set_AP_FwWoWlan_cmd(padapter, enable);
1757 }
1758 #endif //CONFIG_AP_WOWLAN
1759
1760 static s32 rtl8723b_set_FwLowPwrLps_cmd(PADAPTER padapter, u8 enable)
1761 {
1762         //TODO
1763         return _FALSE;
1764 }
1765
1766 //
1767 // Description: Fill the reserved packets that FW will use to RSVD page.
1768 //                      Now we just send 4 types packet to rsvd page.
1769 //                      (1)Beacon, (2)Ps-poll, (3)Null data, (4)ProbeRsp.
1770 //      Input:
1771 //          bDLFinished - FALSE: At the first time we will send all the packets as a large packet to Hw,
1772 //                                              so we need to set the packet length to total lengh.
1773 //                            TRUE: At the second time, we should send the first packet (default:beacon)
1774 //                                              to Hw again and set the lengh in descriptor to the real beacon lengh.
1775 // 2009.10.15 by tynli.
1776 static void rtl8723b_set_FwRsvdPagePkt(PADAPTER padapter, BOOLEAN bDLFinished)
1777 {
1778         PHAL_DATA_TYPE pHalData;
1779         struct xmit_frame       *pcmdframe;
1780         struct pkt_attrib       *pattrib;
1781         struct xmit_priv        *pxmitpriv;
1782         struct mlme_ext_priv    *pmlmeext;
1783         struct mlme_ext_info    *pmlmeinfo;
1784         struct pwrctrl_priv *pwrctl;
1785         struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
1786         u32     BeaconLength=0, ProbeRspLength=0, PSPollLength=0;
1787         u32     NullDataLength=0, QosNullLength=0, BTQosNullLength=0;
1788         u32     ProbeReqLength=0;
1789         u8      *ReservedPagePacket;
1790         u8      TxDescLen = TXDESC_SIZE, TxDescOffset = TXDESC_OFFSET;
1791         u8      TotalPageNum=0, CurtPktPageNum=0, RsvdPageNum=0;
1792         u16     BufIndex, PageSize = 128;
1793         u32     TotalPacketLen, MaxRsvdPageBufSize=0;
1794         RSVDPAGE_LOC    RsvdPageLoc;
1795 #ifdef CONFIG_WOWLAN
1796         u32     ARPLegnth = 0, GTKLegnth = 0, PNOLength = 0, ScanInfoLength = 0;
1797         u32     SSIDLegnth = 0;
1798         struct security_priv *psecuritypriv = &padapter->securitypriv; //added by xx
1799         u8 currentip[4];
1800         u8 cur_dot11txpn[8];
1801 #ifdef CONFIG_GTK_OL
1802         struct sta_priv *pstapriv = &padapter->stapriv;
1803         struct sta_info * psta;
1804         u8 kek[RTW_KEK_LEN];
1805         u8 kck[RTW_KCK_LEN];
1806 #endif
1807 #ifdef  CONFIG_PNO_SUPPORT
1808         int index;
1809         u8 ssid_num;
1810 #endif //CONFIG_PNO_SUPPORT
1811 #endif
1812 #ifdef DBG_CONFIG_ERROR_DETECT
1813         struct sreset_priv *psrtpriv;
1814 #endif // DBG_CONFIG_ERROR_DETECT
1815
1816         //DBG_871X("%s---->\n", __FUNCTION__);
1817
1818         pHalData = GET_HAL_DATA(padapter);
1819 #ifdef DBG_CONFIG_ERROR_DETECT
1820         psrtpriv = &pHalData->srestpriv;
1821 #endif
1822         pxmitpriv = &padapter->xmitpriv;
1823         pmlmeext = &padapter->mlmeextpriv;
1824         pmlmeinfo = &pmlmeext->mlmext_info;
1825         pwrctl = adapter_to_pwrctl(padapter);
1826
1827         RsvdPageNum = BCNQ_PAGE_NUM_8723B + WOWLAN_PAGE_NUM_8723B;
1828         MaxRsvdPageBufSize = RsvdPageNum*PageSize;
1829
1830         pcmdframe = rtw_alloc_cmdxmitframe(pxmitpriv);
1831         if (pcmdframe == NULL) {
1832                 DBG_871X("%s: alloc ReservedPagePacket fail!\n", __FUNCTION__);
1833                 return;
1834         }
1835
1836         ReservedPagePacket = pcmdframe->buf_addr;
1837         _rtw_memset(&RsvdPageLoc, 0, sizeof(RSVDPAGE_LOC));
1838
1839         //3 (1) beacon
1840         BufIndex = TxDescOffset;
1841         ConstructBeacon(padapter, &ReservedPagePacket[BufIndex], &BeaconLength);
1842
1843         // When we count the first page size, we need to reserve description size for the RSVD
1844         // packet, it will be filled in front of the packet in TXPKTBUF.
1845         CurtPktPageNum = (u8)PageNum_128(TxDescLen + BeaconLength);
1846         //If we don't add 1 more page, the WOWLAN function has a problem. Baron thinks it's a bug of firmware
1847         if (CurtPktPageNum == 1)
1848         {
1849                 CurtPktPageNum += 1;
1850         }
1851         TotalPageNum += CurtPktPageNum;
1852
1853         BufIndex += (CurtPktPageNum*PageSize);
1854
1855         //3 (2) ps-poll
1856         RsvdPageLoc.LocPsPoll = TotalPageNum;
1857         ConstructPSPoll(padapter, &ReservedPagePacket[BufIndex], &PSPollLength);
1858         rtl8723b_fill_fake_txdesc(padapter, &ReservedPagePacket[BufIndex-TxDescLen], PSPollLength, _TRUE, _FALSE, _FALSE);
1859
1860         //DBG_871X("%s(): HW_VAR_SET_TX_CMD: PS-POLL %p %d\n",
1861         //      __FUNCTION__, &ReservedPagePacket[BufIndex-TxDescLen], (PSPollLength+TxDescLen));
1862
1863         CurtPktPageNum = (u8)PageNum_128(TxDescLen + PSPollLength);
1864
1865         TotalPageNum += CurtPktPageNum;
1866
1867         BufIndex += (CurtPktPageNum*PageSize);
1868
1869         //3 (3) null data
1870         RsvdPageLoc.LocNullData = TotalPageNum;
1871         ConstructNullFunctionData(
1872                 padapter,
1873                 &ReservedPagePacket[BufIndex],
1874                 &NullDataLength,
1875                 get_my_bssid(&pmlmeinfo->network),
1876                 _FALSE, 0, 0, _FALSE);
1877         rtl8723b_fill_fake_txdesc(padapter, &ReservedPagePacket[BufIndex-TxDescLen], NullDataLength, _FALSE, _FALSE, _FALSE);
1878
1879         //DBG_871X("%s(): HW_VAR_SET_TX_CMD: NULL DATA %p %d\n",
1880         //      __FUNCTION__, &ReservedPagePacket[BufIndex-TxDescLen], (NullDataLength+TxDescLen));
1881
1882         CurtPktPageNum = (u8)PageNum_128(TxDescLen + NullDataLength);
1883
1884         TotalPageNum += CurtPktPageNum;
1885
1886         BufIndex += (CurtPktPageNum*PageSize);
1887
1888 #if 0
1889         //3 (4) probe response
1890         RsvdPageLoc.LocProbeRsp = TotalPageNum;
1891         ConstructProbeRsp(
1892                 padapter,
1893                 &ReservedPagePacket[BufIndex],
1894                 &ProbeRspLength,
1895                 get_my_bssid(&pmlmeinfo->network),
1896                 _FALSE);
1897         rtl8723b_fill_fake_txdesc(padapter, &ReservedPagePacket[BufIndex-TxDescLen], ProbeRspLength, _FALSE, _FALSE, _FALSE);
1898
1899         //DBG_871X("%s(): HW_VAR_SET_TX_CMD: PROBE RSP %p %d\n",
1900         //      __FUNCTION__, &ReservedPagePacket[BufIndex-TxDescLen], (ProbeRspLength+TxDescLen));
1901
1902         CurtPktPageNum = (u8)PageNum_128(TxDescLen + ProbeRspLength);
1903
1904         TotalPageNum += CurtPktPageNum;
1905
1906         BufIndex += (CurtPktPageNum*PageSize);
1907 #endif
1908
1909         //3 (5) Qos null data
1910         RsvdPageLoc.LocQosNull = TotalPageNum;
1911         ConstructNullFunctionData(
1912                 padapter,
1913                 &ReservedPagePacket[BufIndex],
1914                 &QosNullLength,
1915                 get_my_bssid(&pmlmeinfo->network),
1916                 _TRUE, 0, 0, _FALSE);
1917         rtl8723b_fill_fake_txdesc(padapter, &ReservedPagePacket[BufIndex-TxDescLen], QosNullLength, _FALSE, _FALSE, _FALSE);
1918
1919         //DBG_871X("%s(): HW_VAR_SET_TX_CMD: QOS NULL DATA %p %d\n",
1920         //      __FUNCTION__, &ReservedPagePacket[BufIndex-TxDescLen], (QosNullLength+TxDescLen));
1921
1922         CurtPktPageNum = (u8)PageNum_128(TxDescLen + QosNullLength);
1923
1924         TotalPageNum += CurtPktPageNum;
1925
1926         BufIndex += (CurtPktPageNum*PageSize);
1927
1928         //3 (6) BT Qos null data
1929         RsvdPageLoc.LocBTQosNull = TotalPageNum;
1930         ConstructNullFunctionData(
1931                 padapter,
1932                 &ReservedPagePacket[BufIndex],
1933                 &BTQosNullLength,
1934                 get_my_bssid(&pmlmeinfo->network),
1935                 _TRUE, 0, 0, _FALSE);
1936         rtl8723b_fill_fake_txdesc(padapter, &ReservedPagePacket[BufIndex-TxDescLen], BTQosNullLength, _FALSE, _TRUE, _FALSE);
1937
1938         //DBG_871X("%s(): HW_VAR_SET_TX_CMD: BT QOS NULL DATA %p %d\n",
1939         //      __FUNCTION__, &ReservedPagePacket[BufIndex-TxDescLen], (BTQosNullLength+TxDescLen));
1940
1941         CurtPktPageNum = (u8)PageNum_128(TxDescLen + BTQosNullLength);
1942
1943         TotalPageNum += CurtPktPageNum;
1944
1945         BufIndex += (CurtPktPageNum*PageSize);
1946
1947 #ifdef CONFIG_WOWLAN
1948         if (check_fwstate(pmlmepriv, _FW_LINKED)) {
1949         //if (pwrctl->wowlan_mode == _TRUE) {
1950                 //BufIndex += (CurtPktPageNum*PageSize);
1951
1952         //3(7) ARP RSP
1953         rtw_get_current_ip_address(padapter, currentip);
1954         RsvdPageLoc.LocArpRsp= TotalPageNum;
1955 #ifdef DBG_CONFIG_ERROR_DETECT
1956         if(psrtpriv->silent_reset_inprogress == _FALSE)
1957 #endif //DBG_CONFIG_ERROR_DETECT
1958         {
1959         ConstructARPResponse(
1960                 padapter,
1961                 &ReservedPagePacket[BufIndex],
1962                 &ARPLegnth,
1963                 currentip
1964                 );
1965         rtl8723b_fill_fake_txdesc(padapter, &ReservedPagePacket[BufIndex-TxDescLen], ARPLegnth, _FALSE, _FALSE, _TRUE);
1966
1967         //DBG_871X("%s(): HW_VAR_SET_TX_CMD: ARP RSP %p %d\n",
1968         //      __FUNCTION__, &ReservedPagePacket[BufIndex-TxDescLen], (ARPLegnth+TxDescLen));
1969
1970         CurtPktPageNum = (u8)PageNum_128(TxDescLen + ARPLegnth);
1971         }
1972 #ifdef DBG_CONFIG_ERROR_DETECT
1973         else
1974                 CurtPktPageNum = (u8)PageNum_128(128);
1975 #endif //DBG_CONFIG_ERROR_DETECT
1976         TotalPageNum += CurtPktPageNum;
1977
1978         BufIndex += (CurtPktPageNum*PageSize);
1979
1980         //3(8) SEC IV
1981         rtw_get_sec_iv(padapter, cur_dot11txpn, get_my_bssid(&pmlmeinfo->network));
1982         RsvdPageLoc.LocRemoteCtrlInfo = TotalPageNum;
1983         _rtw_memcpy(ReservedPagePacket+BufIndex-TxDescLen, cur_dot11txpn, _AES_IV_LEN_);
1984
1985         //DBG_871X("%s(): HW_VAR_SET_TX_CMD: SEC IV %p %d\n",
1986         //      __FUNCTION__, &ReservedPagePacket[BufIndex-TxDescLen], _AES_IV_LEN_);
1987
1988         CurtPktPageNum = (u8)PageNum_128(_AES_IV_LEN_);
1989
1990         TotalPageNum += CurtPktPageNum;
1991
1992 #ifdef CONFIG_GTK_OL
1993         BufIndex += (CurtPktPageNum*PageSize);
1994
1995         //if the ap staion info. exists, get the kek, kck from staion info.
1996         psta = rtw_get_stainfo(pstapriv, get_bssid(pmlmepriv));
1997         if (psta == NULL)
1998         {
1999                 _rtw_memset(kek, 0, RTW_KEK_LEN);
2000                 _rtw_memset(kck, 0, RTW_KCK_LEN);
2001                 DBG_8192C("%s, KEK, KCK download rsvd page all zero \n", __func__);
2002         }
2003         else
2004         {
2005                 _rtw_memcpy(kek, psta->kek, RTW_KEK_LEN);
2006                 _rtw_memcpy(kck, psta->kck, RTW_KCK_LEN);
2007         }
2008
2009         //3(9) KEK, KCK
2010         RsvdPageLoc.LocGTKInfo = TotalPageNum;
2011         _rtw_memcpy(ReservedPagePacket+BufIndex-TxDescLen, kck, RTW_KCK_LEN);
2012         _rtw_memcpy(ReservedPagePacket+BufIndex-TxDescLen+RTW_KCK_LEN, kek, RTW_KEK_LEN);
2013
2014 #if 0
2015         {
2016                 int i;
2017                 printk("\ntoFW KCK: ");
2018                 for(i=0;i<16; i++)
2019                         printk(" %02x ", kck[i]);
2020                 printk("\ntoFW KEK: ");
2021                 for(i=0;i<16; i++)
2022                         printk(" %02x ", kek[i]);
2023                 printk("\n");
2024         }
2025 #endif
2026
2027         //DBG_871X("%s(): HW_VAR_SET_TX_CMD: KEK KCK %p %d\n",
2028         //      __FUNCTION__, &ReservedPagePacket[BufIndex-TxDescLen], (TxDescLen + RTW_KCK_LEN + RTW_KEK_LEN));
2029
2030         CurtPktPageNum = (u8)PageNum_128(TxDescLen + RTW_KCK_LEN + RTW_KEK_LEN);
2031
2032         TotalPageNum += CurtPktPageNum;
2033
2034         BufIndex += (CurtPktPageNum*PageSize);
2035
2036         //3(10) GTK Response
2037         RsvdPageLoc.LocGTKRsp= TotalPageNum;
2038         ConstructGTKResponse(
2039                 padapter,
2040                 &ReservedPagePacket[BufIndex],
2041                 &GTKLegnth
2042                 );
2043
2044         rtl8723b_fill_fake_txdesc(padapter, &ReservedPagePacket[BufIndex-TxDescLen], GTKLegnth, _FALSE, _FALSE, _TRUE);
2045 #if 0
2046         {
2047                 int gj;
2048                 printk("123GTK pkt=> \n");
2049                 for(gj=0; gj < GTKLegnth+TxDescLen; gj++) {
2050                         printk(" %02x ", ReservedPagePacket[BufIndex-TxDescLen+gj]);
2051                         if ((gj + 1)%16==0)
2052                                 printk("\n");
2053                 }
2054                 printk(" <=end\n");
2055         }
2056 #endif
2057
2058         //DBG_871X("%s(): HW_VAR_SET_TX_CMD: GTK RSP %p %d\n",
2059         //      __FUNCTION__, &ReservedPagePacket[BufIndex-TxDescLen], (TxDescLen + GTKLegnth));
2060
2061         CurtPktPageNum = (u8)PageNum_128(TxDescLen + GTKLegnth);
2062
2063         TotalPageNum += CurtPktPageNum;
2064
2065         BufIndex += (CurtPktPageNum*PageSize);
2066
2067         //below page is empty for GTK extension memory
2068         //3(11) GTK EXT MEM
2069         RsvdPageLoc.LocGTKEXTMEM= TotalPageNum;
2070
2071         CurtPktPageNum = 2;
2072
2073         TotalPageNum += CurtPktPageNum;
2074
2075         TotalPacketLen = BufIndex-TxDescLen + 256; //extension memory for FW
2076 #else
2077         TotalPacketLen = BufIndex-TxDescLen + sizeof (union pn48); //IV len
2078 #endif //CONFIG_GTK_OL
2079         } else
2080 #endif //CONFIG_WOWLAN
2081         {
2082 #ifdef CONFIG_PNO_SUPPORT
2083                 if (pwrctl->pno_in_resume == _FALSE && pwrctl->pno_inited == _TRUE) {
2084
2085                         //Broadcast Probe Request
2086                         RsvdPageLoc.LocProbePacket = TotalPageNum;
2087
2088                         ConstructProbeReq(
2089                                 padapter,
2090                                 &ReservedPagePacket[BufIndex],
2091                                 &ProbeReqLength,
2092                                 NULL);
2093
2094                         rtl8723b_fill_fake_txdesc(padapter,
2095                                 &ReservedPagePacket[BufIndex-TxDescLen],
2096                                 ProbeReqLength, _FALSE, _FALSE, _FALSE);
2097
2098 #ifdef CONFIG_PNO_SET_DEBUG
2099                         {
2100                                 int gj;
2101                                 printk("probe req pkt=> \n");
2102                                 for(gj=0; gj < ProbeReqLength + TxDescLen; gj++) {
2103                                         printk(" %02x ",ReservedPagePacket[BufIndex- TxDescLen + gj]);
2104                                         if ((gj + 1)%8==0)
2105                                                 printk("\n");
2106                                 }
2107                                 printk(" <=end\n");
2108                         }
2109 #endif
2110                         CurtPktPageNum =
2111                                 (u8)PageNum_128(TxDescLen + ProbeReqLength);
2112
2113                         TotalPageNum += CurtPktPageNum;
2114
2115                         BufIndex += (CurtPktPageNum*PageSize);
2116
2117                         //Hidden SSID Probe Request
2118                         ssid_num = pwrctl->pnlo_info->hidden_ssid_num;
2119
2120                         for (index = 0 ; index < ssid_num ; index++) {
2121                                 pwrctl->pnlo_info->loc_probe_req[index] = TotalPageNum;
2122
2123                                 ConstructProbeReq(
2124                                         padapter,
2125                                         &ReservedPagePacket[BufIndex],
2126                                         &ProbeReqLength,
2127                                         &pwrctl->pno_ssid_list->node[index]);
2128
2129                                 rtl8723b_fill_fake_txdesc(padapter,
2130                                         &ReservedPagePacket[BufIndex-TxDescLen],
2131                                         ProbeReqLength, _FALSE, _FALSE, _FALSE);
2132
2133 #ifdef CONFIG_PNO_SET_DEBUG
2134                                 {
2135                                         int gj;
2136                                         printk("probe req pkt=> \n");
2137                                         for(gj=0; gj < ProbeReqLength + TxDescLen; gj++) {
2138                                                 printk(" %02x ", ReservedPagePacket[BufIndex- TxDescLen + gj]);
2139                                                 if ((gj + 1)%8==0)
2140                                                         printk("\n");
2141                                         }
2142                                         printk(" <=end\n");
2143                                 }
2144 #endif
2145                                 CurtPktPageNum =
2146                                         (u8)PageNum_128(TxDescLen + ProbeReqLength);
2147
2148                                 TotalPageNum += CurtPktPageNum;
2149
2150                                 BufIndex += (CurtPktPageNum*PageSize);
2151                         }
2152
2153                         //PNO INFO Page
2154                         RsvdPageLoc.LocPNOInfo = TotalPageNum;
2155                         ConstructPnoInfo(padapter, &ReservedPagePacket[BufIndex -TxDescLen], &PNOLength);
2156 #ifdef CONFIG_PNO_SET_DEBUG
2157         {
2158                         int gj;
2159                         printk("PNO pkt=> \n");
2160                         for(gj=0; gj < PNOLength; gj++) {
2161                                 printk(" %02x ", ReservedPagePacket[BufIndex-TxDescLen +gj]);
2162                                 if ((gj + 1)%8==0)
2163                                         printk("\n");
2164                         }
2165                         printk(" <=end\n");
2166         }
2167 #endif
2168
2169                         CurtPktPageNum = (u8)PageNum_128(PNOLength);
2170                         TotalPageNum += CurtPktPageNum;
2171                         BufIndex += (CurtPktPageNum*PageSize);
2172
2173                         //SSID List Page
2174                         RsvdPageLoc.LocSSIDInfo = TotalPageNum;
2175                         ConstructSSIDList(padapter, &ReservedPagePacket[BufIndex-TxDescLen], &SSIDLegnth);
2176 #ifdef CONFIG_PNO_SET_DEBUG
2177         {
2178                         int gj;
2179                         printk("SSID list pkt=> \n");
2180                         for(gj=0; gj < SSIDLegnth; gj++) {
2181                                 printk(" %02x ", ReservedPagePacket[BufIndex-TxDescLen+gj]);
2182                                 if ((gj + 1)%8==0)
2183                                         printk("\n");
2184                         }
2185                         printk(" <=end\n");
2186         }
2187 #endif
2188                         CurtPktPageNum = (u8)PageNum_128(SSIDLegnth);
2189                         TotalPageNum += CurtPktPageNum;
2190                         BufIndex += (CurtPktPageNum*PageSize);
2191
2192                         //Scan Info Page
2193                         RsvdPageLoc.LocScanInfo = TotalPageNum;
2194                         ConstructScanInfo(padapter, &ReservedPagePacket[BufIndex-TxDescLen], &ScanInfoLength);
2195 #ifdef CONFIG_PNO_SET_DEBUG
2196         {
2197                         int gj;
2198                         printk("Scan info pkt=> \n");
2199                         for(gj=0; gj < ScanInfoLength; gj++) {
2200                                 printk(" %02x ", ReservedPagePacket[BufIndex-TxDescLen+gj]);
2201                                 if ((gj + 1)%8==0)
2202                                         printk("\n");
2203                         }
2204                         printk(" <=end\n");
2205         }
2206 #endif
2207                         CurtPktPageNum = (u8)PageNum_128(ScanInfoLength);
2208                         TotalPageNum += CurtPktPageNum;
2209                         BufIndex += (CurtPktPageNum*PageSize);
2210
2211                         TotalPacketLen = BufIndex + ScanInfoLength;
2212                 } else {
2213                 TotalPacketLen = BufIndex + BTQosNullLength;
2214         }
2215 #else //CONFIG_PNO_SUPPORT
2216                 TotalPacketLen = BufIndex + BTQosNullLength;
2217 #endif
2218         }
2219
2220         if(TotalPacketLen > MaxRsvdPageBufSize)
2221         {
2222                 DBG_871X("%s(): ERROR: The rsvd page size is not enough!!TotalPacketLen %d, MaxRsvdPageBufSize %d\n",__FUNCTION__,
2223                         TotalPacketLen,MaxRsvdPageBufSize);
2224                 goto error;
2225         }
2226         else
2227         {
2228                 // update attribute
2229                 pattrib = &pcmdframe->attrib;
2230                 update_mgntframe_attrib(padapter, pattrib);
2231                 pattrib->qsel = QSLT_BEACON;
2232                 pattrib->pktlen = pattrib->last_txcmdsz = TotalPacketLen - TxDescOffset;
2233 #ifdef CONFIG_PCI_HCI
2234                 dump_mgntframe(padapter, pcmdframe);
2235 #else
2236                 dump_mgntframe_and_wait(padapter, pcmdframe, 100);
2237 #endif
2238         }
2239
2240         DBG_871X("%s: Set RSVD page location to Fw ,TotalPacketLen(%d), TotalPageNum(%d)\n", __FUNCTION__,TotalPacketLen,TotalPageNum);
2241         if(check_fwstate(pmlmepriv, _FW_LINKED)) {
2242         rtl8723b_set_FwRsvdPage_cmd(padapter, &RsvdPageLoc);
2243                 rtl8723b_set_FwAoacRsvdPage_cmd(padapter, &RsvdPageLoc);
2244         } else {
2245                 rtl8723b_set_FwAoacRsvdPage_cmd(padapter, &RsvdPageLoc);
2246 #ifdef CONFIG_PNO_SUPPORT
2247                 if(pwrctl->pno_in_resume)
2248                         rtl8723b_set_FwScanOffloadInfo_cmd(padapter,
2249                                         &RsvdPageLoc, 0);
2250                 else
2251                         rtl8723b_set_FwScanOffloadInfo_cmd(padapter,
2252                                         &RsvdPageLoc, 1);
2253 #endif
2254         }
2255         return;
2256
2257 error:
2258
2259         rtw_free_xmitframe(pxmitpriv, pcmdframe);
2260 }
2261
2262 #ifdef CONFIG_AP_WOWLAN
2263 //
2264 //Description: Fill the reserved packets that FW will use to RSVD page.
2265 //Now we just send 2 types packet to rsvd page. (1)Beacon, (2)ProbeRsp.
2266 //
2267 //Input: bDLFinished
2268 //
2269 //FALSE: At the first time we will send all the packets as a large packet to Hw,
2270 //       so we need to set the packet length to total lengh.
2271 //
2272 //TRUE: At the second time, we should send the first packet (default:beacon)
2273 //      to Hw again and set the lengh in descriptor to the real beacon lengh.
2274 // 2009.10.15 by tynli.
2275 static void rtl8723b_set_AP_FwRsvdPagePkt(PADAPTER padapter,
2276                 BOOLEAN bDLFinished)
2277 {
2278         PHAL_DATA_TYPE pHalData;
2279         struct xmit_frame       *pcmdframe;
2280         struct pkt_attrib       *pattrib;
2281         struct xmit_priv        *pxmitpriv;
2282         struct mlme_ext_priv    *pmlmeext;
2283         struct mlme_ext_info    *pmlmeinfo;
2284         struct pwrctrl_priv *pwrctl;
2285         struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
2286         u32     BeaconLength=0, ProbeRspLength=0;
2287         u8      *ReservedPagePacket;
2288         u8      TxDescLen = TXDESC_SIZE, TxDescOffset = TXDESC_OFFSET;
2289         u8      TotalPageNum=0, CurtPktPageNum=0, RsvdPageNum=0;
2290         u8      currentip[4];
2291         u16     BufIndex, PageSize = 128;
2292         u32     TotalPacketLen = 0, MaxRsvdPageBufSize=0;
2293         RSVDPAGE_LOC    RsvdPageLoc;
2294 #ifdef DBG_CONFIG_ERROR_DETECT
2295         struct sreset_priv *psrtpriv;
2296 #endif // DBG_CONFIG_ERROR_DETECT
2297
2298         //DBG_871X("%s---->\n", __FUNCTION__);
2299         DBG_8192C("+" FUNC_ADPT_FMT ": iface_type=%d\n",
2300                 FUNC_ADPT_ARG(padapter), get_iface_type(padapter));
2301
2302         pHalData = GET_HAL_DATA(padapter);
2303 #ifdef DBG_CONFIG_ERROR_DETECT
2304         psrtpriv = &pHalData->srestpriv;
2305 #endif
2306         pxmitpriv = &padapter->xmitpriv;
2307         pmlmeext = &padapter->mlmeextpriv;
2308         pmlmeinfo = &pmlmeext->mlmext_info;
2309         pwrctl = adapter_to_pwrctl(padapter);
2310
2311         RsvdPageNum = BCNQ_PAGE_NUM_8723B + AP_WOWLAN_PAGE_NUM_8723B;
2312         MaxRsvdPageBufSize = RsvdPageNum*PageSize;
2313
2314         pcmdframe = rtw_alloc_cmdxmitframe(pxmitpriv);
2315         if (pcmdframe == NULL) {
2316                 DBG_871X("%s: alloc ReservedPagePacket fail!\n", __FUNCTION__);
2317                 return;
2318         }
2319
2320         ReservedPagePacket = pcmdframe->buf_addr;
2321         _rtw_memset(&RsvdPageLoc, 0, sizeof(RSVDPAGE_LOC));
2322
2323         //3 (1) beacon
2324         BufIndex = TxDescOffset;
2325         ConstructBeacon(padapter, &ReservedPagePacket[BufIndex], &BeaconLength);
2326
2327         // When we count the first page size, we need to reserve description size for the RSVD
2328         // packet, it will be filled in front of the packet in TXPKTBUF.
2329         CurtPktPageNum = (u8)PageNum_128(TxDescLen + BeaconLength);
2330         //If we don't add 1 more page, the WOWLAN function has a problem. Baron thinks it's a bug of firmware
2331         if (CurtPktPageNum == 1)
2332         {
2333                 CurtPktPageNum += 1;
2334         }
2335         TotalPageNum += CurtPktPageNum;
2336
2337         BufIndex += (CurtPktPageNum*PageSize);
2338
2339         //2 (4) probe response
2340         RsvdPageLoc.LocProbeRsp = TotalPageNum;
2341
2342         rtw_get_current_ip_address(padapter, currentip);
2343
2344         ConstructProbeRsp(
2345                 padapter,
2346                 &ReservedPagePacket[BufIndex],
2347                 &ProbeRspLength,
2348                 currentip,
2349                 _FALSE);
2350         rtl8723b_fill_fake_txdesc(padapter,
2351                         &ReservedPagePacket[BufIndex-TxDescLen],
2352                         ProbeRspLength,
2353                         _FALSE, _FALSE, _FALSE);
2354
2355         DBG_871X("%s(): HW_VAR_SET_TX_CMD: PROBE RSP %p %d\n",
2356                 __func__, &ReservedPagePacket[BufIndex-TxDescLen],
2357                 (ProbeRspLength+TxDescLen));
2358
2359         CurtPktPageNum = (u8)PageNum_128(TxDescLen + ProbeRspLength);
2360
2361         TotalPageNum += CurtPktPageNum;
2362
2363         BufIndex += (CurtPktPageNum*PageSize);
2364
2365         TotalPacketLen = BufIndex + ProbeRspLength;
2366
2367         if (TotalPacketLen > MaxRsvdPageBufSize) {
2368                 DBG_871X("%s(): ERROR: The rsvd page size is not enough \
2369                                 !!TotalPacketLen %d, MaxRsvdPageBufSize %d\n",
2370                                 __func__, TotalPacketLen,MaxRsvdPageBufSize);
2371                 goto error;
2372         } else {
2373                 // update attribute
2374                 pattrib = &pcmdframe->attrib;
2375                 update_mgntframe_attrib(padapter, pattrib);
2376                 pattrib->qsel = QSLT_BEACON;
2377                 pattrib->pktlen = TotalPacketLen - TxDescOffset;
2378                 pattrib->last_txcmdsz = TotalPacketLen - TxDescOffset;
2379 #ifdef CONFIG_PCI_HCI
2380                 dump_mgntframe(padapter, pcmdframe);
2381 #else
2382                 dump_mgntframe_and_wait(padapter, pcmdframe, 100);
2383 #endif
2384         }
2385
2386         DBG_871X("%s: Set RSVD page location to Fw ,TotalPacketLen(%d), TotalPageNum(%d)\n", __FUNCTION__,TotalPacketLen,TotalPageNum);
2387         rtl8723b_set_ap_wow_rsvdpage_cmd(padapter, &RsvdPageLoc);
2388
2389         return;
2390 error:
2391         rtw_free_xmitframe(pxmitpriv, pcmdframe);
2392 }
2393 #endif //CONFIG_AP_WOWLAN
2394
2395 void rtl8723b_download_rsvd_page(PADAPTER padapter, u8 mstatus)
2396 {
2397         HAL_DATA_TYPE   *pHalData = GET_HAL_DATA(padapter);
2398         struct mlme_ext_priv    *pmlmeext = &(padapter->mlmeextpriv);
2399         struct mlme_ext_info    *pmlmeinfo = &(pmlmeext->mlmext_info);
2400         struct pwrctrl_priv *pwrpriv = adapter_to_pwrctl(padapter);
2401         BOOLEAN         bcn_valid = _FALSE;
2402         u8      DLBcnCount=0;
2403         u32 poll = 0;
2404         u8 val8;
2405
2406 _func_enter_;
2407
2408         DBG_8192C("+" FUNC_ADPT_FMT ": iface_type=%d mstatus(%x)\n",
2409                 FUNC_ADPT_ARG(padapter), get_iface_type(padapter), mstatus);
2410
2411         if(mstatus == RT_MEDIA_CONNECT)
2412         {
2413                 BOOLEAN bRecover = _FALSE;
2414                 u8 v8;
2415
2416                 // We should set AID, correct TSF, HW seq enable before set JoinBssReport to Fw in 88/92C.
2417                 // Suggested by filen. Added by tynli.
2418                 rtw_write16(padapter, REG_BCN_PSR_RPT, (0xC000|pmlmeinfo->aid));
2419
2420                 // set REG_CR bit 8
2421                 v8 = rtw_read8(padapter, REG_CR+1);
2422                 v8 |= BIT(0); // ENSWBCN
2423                 rtw_write8(padapter,  REG_CR+1, v8);
2424
2425                 // Disable Hw protection for a time which revserd for Hw sending beacon.
2426                 // Fix download reserved page packet fail that access collision with the protection time.
2427                 // 2010.05.11. Added by tynli.
2428                 val8 = rtw_read8(padapter, REG_BCN_CTRL);
2429                 val8 &= ~EN_BCN_FUNCTION;
2430                 val8 |= DIS_TSF_UDT;
2431                 rtw_write8(padapter, REG_BCN_CTRL, val8);
2432
2433                 // Set FWHW_TXQ_CTRL 0x422[6]=0 to tell Hw the packet is not a real beacon frame.
2434                 if (pHalData->RegFwHwTxQCtrl & BIT(6))
2435                         bRecover = _TRUE;
2436
2437                 // To tell Hw the packet is not a real beacon frame.
2438                 rtw_write8(padapter, REG_FWHW_TXQ_CTRL+2, pHalData->RegFwHwTxQCtrl & ~BIT(6));
2439                 pHalData->RegFwHwTxQCtrl &= ~BIT(6);
2440
2441                 // Clear beacon valid check bit.
2442                 rtw_hal_set_hwreg(padapter, HW_VAR_BCN_VALID, NULL);
2443                 rtw_hal_set_hwreg(padapter, HW_VAR_DL_BCN_SEL, NULL);
2444
2445                 DLBcnCount = 0;
2446                 poll = 0;
2447                 do
2448                 {
2449 #ifdef CONFIG_AP_WOWLAN
2450                         if (pwrpriv->wowlan_ap_mode)
2451                                 rtl8723b_set_AP_FwRsvdPagePkt(padapter, 0);
2452                         else
2453                                 rtl8723b_set_FwRsvdPagePkt(padapter, 0);
2454 #else
2455                         // download rsvd page.
2456                         rtl8723b_set_FwRsvdPagePkt(padapter, 0);
2457 #endif
2458                         DLBcnCount++;
2459                         do
2460                         {
2461                                 rtw_yield_os();
2462                                 //rtw_mdelay_os(10);
2463                                 // check rsvd page download OK.
2464                                 rtw_hal_get_hwreg(padapter, HW_VAR_BCN_VALID, (u8*)(&bcn_valid));
2465                                 poll++;
2466                         } while(!bcn_valid && (poll%10)!=0 && !padapter->bSurpriseRemoved && !padapter->bDriverStopped);
2467
2468                 }while(!bcn_valid && DLBcnCount<=100 && !padapter->bSurpriseRemoved && !padapter->bDriverStopped);
2469
2470                 if(padapter->bSurpriseRemoved || padapter->bDriverStopped)
2471                 {
2472                 }
2473                 else if(!bcn_valid)
2474                         DBG_871X(ADPT_FMT": 1 DL RSVD page failed! DLBcnCount:%u, poll:%u\n",
2475                                 ADPT_ARG(padapter) ,DLBcnCount, poll);
2476                 else {
2477                         struct pwrctrl_priv *pwrctl = adapter_to_pwrctl(padapter);
2478                         pwrctl->fw_psmode_iface_id = padapter->iface_id;
2479                         DBG_871X(ADPT_FMT": 1 DL RSVD page success! DLBcnCount:%u, poll:%u\n",
2480                                 ADPT_ARG(padapter), DLBcnCount, poll);
2481                 }
2482
2483                 // 2010.05.11. Added by tynli.
2484                 val8 = rtw_read8(padapter, REG_BCN_CTRL);
2485                 val8 |= EN_BCN_FUNCTION;
2486                 val8 &= ~DIS_TSF_UDT;
2487                 rtw_write8(padapter, REG_BCN_CTRL, val8);
2488
2489                 // To make sure that if there exists an adapter which would like to send beacon.
2490                 // If exists, the origianl value of 0x422[6] will be 1, we should check this to
2491                 // prevent from setting 0x422[6] to 0 after download reserved page, or it will cause
2492                 // the beacon cannot be sent by HW.
2493                 // 2010.06.23. Added by tynli.
2494                 if(bRecover)
2495                 {
2496                         rtw_write8(padapter, REG_FWHW_TXQ_CTRL+2, pHalData->RegFwHwTxQCtrl | BIT(6));
2497                         pHalData->RegFwHwTxQCtrl |= BIT(6);
2498                 }
2499
2500                 // Clear CR[8] or beacon packet will not be send to TxBuf anymore.
2501 #ifndef CONFIG_PCI_HCI
2502                 v8 = rtw_read8(padapter, REG_CR+1);
2503                 v8 &= ~BIT(0); // ~ENSWBCN
2504                 rtw_write8(padapter, REG_CR+1, v8);
2505 #endif
2506         }
2507
2508 _func_exit_;
2509 }
2510
2511 void rtl8723b_set_rssi_cmd(_adapter*padapter, u8 *param)
2512 {
2513         rtl8723b_set_FwRssiSetting_cmd(padapter, param);
2514 }
2515
2516 void rtl8723b_set_FwJoinBssRpt_cmd(PADAPTER padapter, u8 mstatus)
2517 {
2518         struct sta_info *psta = NULL;
2519         struct pwrctrl_priv *ppwrpriv = adapter_to_pwrctl(padapter);
2520         struct mlme_priv        *pmlmepriv = &padapter->mlmepriv;
2521
2522         if(mstatus == 1)
2523                 rtl8723b_download_rsvd_page(padapter, RT_MEDIA_CONNECT);
2524 }
2525
2526 //arg[0] = macid
2527 //arg[1] = raid
2528 //arg[2] = shortGIrate
2529 //arg[3] = init_rate
2530 void rtl8723b_Add_RateATid(PADAPTER pAdapter, u32 bitmap, u8* arg, u8 rssi_level)
2531 {
2532         HAL_DATA_TYPE   *pHalData = GET_HAL_DATA(pAdapter);
2533         struct mlme_ext_priv    *pmlmeext = &pAdapter->mlmeextpriv;
2534         struct mlme_ext_info    *pmlmeinfo = &(pmlmeext->mlmext_info);
2535         struct sta_info *psta;
2536         u8 mac_id = arg[0];
2537         u8 raid = arg[1];
2538         u8 shortGI = arg[2];
2539         u8 bw;
2540         u32 mask = bitmap&0x0FFFFFFF;
2541
2542         psta = pmlmeinfo->FW_sta_info[mac_id].psta;
2543         if(psta == NULL)
2544         {
2545                 return;
2546         }
2547
2548         bw = psta->bw_mode;
2549
2550         if(rssi_level != DM_RATR_STA_INIT)
2551                 mask = ODM_Get_Rate_Bitmap(&pHalData->odmpriv, mac_id, mask, rssi_level);
2552
2553         DBG_871X("%s(): mac_id=%d raid=0x%x bw=%d mask=0x%x\n", __func__, mac_id, raid, bw, mask);
2554         rtl8723b_set_FwMacIdConfig_cmd(pAdapter, mac_id, raid, bw, shortGI, mask);
2555 }
2556
2557 #if 0
2558 void rtl8723b_fw_try_ap_cmd(PADAPTER padapter, u32 need_ack)
2559 {
2560         rtl8723b_set_FwAPReqRPT_cmd(padapter, need_ack);
2561 }
2562 #endif
2563
2564 #ifdef CONFIG_BT_COEXIST
2565 static void ConstructBtNullFunctionData(
2566         PADAPTER padapter,
2567         u8 *pframe,
2568         u32 *pLength,
2569         u8 *StaAddr,
2570         u8 bQoS,
2571         u8 AC,
2572         u8 bEosp,
2573         u8 bForcePowerSave)
2574 {
2575         struct rtw_ieee80211_hdr *pwlanhdr;
2576         u16 *fctrl;
2577         u32 pktlen;
2578         struct mlme_ext_priv *pmlmeext;
2579         struct mlme_ext_info *pmlmeinfo;
2580         u8 bssid[ETH_ALEN];
2581
2582
2583         DBG_871X("+" FUNC_ADPT_FMT ": qos=%d eosp=%d ps=%d\n",
2584                 FUNC_ADPT_ARG(padapter), bQoS, bEosp, bForcePowerSave);
2585
2586         pwlanhdr = (struct rtw_ieee80211_hdr*)pframe;
2587         pmlmeext = &padapter->mlmeextpriv;
2588         pmlmeinfo = &pmlmeext->mlmext_info;
2589
2590         if (NULL == StaAddr)
2591         {
2592                 _rtw_memcpy(bssid, myid(&padapter->eeprompriv), ETH_ALEN);
2593                 StaAddr = bssid;
2594         }
2595
2596         fctrl = &pwlanhdr->frame_ctl;
2597         *fctrl = 0;
2598         if (bForcePowerSave)
2599                 SetPwrMgt(fctrl);
2600
2601         SetFrDs(fctrl);
2602         _rtw_memcpy(pwlanhdr->addr1, StaAddr, ETH_ALEN);
2603         _rtw_memcpy(pwlanhdr->addr2, myid(&padapter->eeprompriv), ETH_ALEN);
2604         _rtw_memcpy(pwlanhdr->addr3, myid(&padapter->eeprompriv), ETH_ALEN);
2605
2606         SetDuration(pwlanhdr, 0);
2607         SetSeqNum(pwlanhdr, 0);
2608
2609         if (bQoS == _TRUE)
2610         {
2611                 struct rtw_ieee80211_hdr_3addr_qos *pwlanqoshdr;
2612
2613                 SetFrameSubType(pframe, WIFI_QOS_DATA_NULL);
2614
2615                 pwlanqoshdr = (struct rtw_ieee80211_hdr_3addr_qos*)pframe;
2616                 SetPriority(&pwlanqoshdr->qc, AC);
2617                 SetEOSP(&pwlanqoshdr->qc, bEosp);
2618
2619                 pktlen = sizeof(struct rtw_ieee80211_hdr_3addr_qos);
2620         }
2621         else
2622         {
2623                 SetFrameSubType(pframe, WIFI_DATA_NULL);
2624
2625                 pktlen = sizeof(struct rtw_ieee80211_hdr_3addr);
2626         }
2627
2628         *pLength = pktlen;
2629 }
2630
2631 static void SetFwRsvdPagePkt_BTCoex(PADAPTER padapter)
2632 {
2633         PHAL_DATA_TYPE pHalData;
2634         struct xmit_frame *pcmdframe;
2635         struct pkt_attrib *pattrib;
2636         struct xmit_priv *pxmitpriv;
2637         struct mlme_ext_priv *pmlmeext;
2638         struct mlme_ext_info *pmlmeinfo;
2639         u32     BeaconLength = 0;
2640         u32     BTQosNullLength = 0;
2641         u8 *ReservedPagePacket;
2642         u8 TxDescLen, TxDescOffset;
2643         u8 TotalPageNum=0, CurtPktPageNum=0, RsvdPageNum=0;
2644         u16     BufIndex, PageSize;
2645         u32     TotalPacketLen, MaxRsvdPageBufSize=0;
2646         RSVDPAGE_LOC RsvdPageLoc;
2647
2648
2649 //      DBG_8192C("+" FUNC_ADPT_FMT "\n", FUNC_ADPT_ARG(padapter));
2650
2651         pHalData = GET_HAL_DATA(padapter);
2652         pxmitpriv = &padapter->xmitpriv;
2653         pmlmeext = &padapter->mlmeextpriv;
2654         pmlmeinfo = &pmlmeext->mlmext_info;
2655         TxDescLen = TXDESC_SIZE;
2656         TxDescOffset = TXDESC_OFFSET;
2657         PageSize = PAGE_SIZE_TX_8723B;
2658
2659         RsvdPageNum = BCNQ_PAGE_NUM_8723B;
2660         MaxRsvdPageBufSize = RsvdPageNum*PageSize;
2661
2662         pcmdframe = rtw_alloc_cmdxmitframe(pxmitpriv);
2663         if (pcmdframe == NULL) {
2664                 DBG_8192C("%s: alloc ReservedPagePacket fail!\n", __FUNCTION__);
2665                 return;
2666         }
2667
2668         ReservedPagePacket = pcmdframe->buf_addr;
2669         _rtw_memset(&RsvdPageLoc, 0, sizeof(RSVDPAGE_LOC));
2670
2671         //3 (1) beacon
2672         BufIndex = TxDescOffset;
2673         ConstructBeacon(padapter, &ReservedPagePacket[BufIndex], &BeaconLength);
2674
2675         // When we count the first page size, we need to reserve description size for the RSVD
2676         // packet, it will be filled in front of the packet in TXPKTBUF.
2677         CurtPktPageNum = (u8)PageNum_128(TxDescLen + BeaconLength);
2678         //If we don't add 1 more page, the WOWLAN function has a problem. Baron thinks it's a bug of firmware
2679         if (CurtPktPageNum == 1)
2680         {
2681                 CurtPktPageNum += 1;
2682         }
2683         TotalPageNum += CurtPktPageNum;
2684
2685         BufIndex += (CurtPktPageNum*PageSize);
2686
2687         // Jump to lastest page
2688         if (BufIndex < (MaxRsvdPageBufSize - PageSize))
2689         {
2690                 BufIndex = TxDescOffset + (MaxRsvdPageBufSize - PageSize);
2691                 TotalPageNum = BCNQ_PAGE_NUM_8723B - 1;
2692         }
2693
2694         //3 (6) BT Qos null data
2695         RsvdPageLoc.LocBTQosNull = TotalPageNum;
2696         ConstructBtNullFunctionData(
2697                 padapter,
2698                 &ReservedPagePacket[BufIndex],
2699                 &BTQosNullLength,
2700                 NULL,
2701                 _TRUE, 0, 0, _FALSE);
2702         rtl8723b_fill_fake_txdesc(padapter, &ReservedPagePacket[BufIndex-TxDescLen], BTQosNullLength, _FALSE, _TRUE, _FALSE);
2703
2704         CurtPktPageNum = (u8)PageNum_128(TxDescLen + BTQosNullLength);
2705
2706         TotalPageNum += CurtPktPageNum;
2707
2708         TotalPacketLen = BufIndex + BTQosNullLength;
2709         if (TotalPacketLen > MaxRsvdPageBufSize)
2710         {
2711                 DBG_8192C(FUNC_ADPT_FMT ": ERROR: The rsvd page size is not enough!!TotalPacketLen %d, MaxRsvdPageBufSize %d\n",
2712                         FUNC_ADPT_ARG(padapter), TotalPacketLen, MaxRsvdPageBufSize);
2713                 goto error;
2714         }
2715
2716         // update attribute
2717         pattrib = &pcmdframe->attrib;
2718         update_mgntframe_attrib(padapter, pattrib);
2719         pattrib->qsel = QSLT_BEACON;
2720         pattrib->pktlen = pattrib->last_txcmdsz = TotalPacketLen - TxDescOffset;
2721 #ifdef CONFIG_PCI_HCI
2722         dump_mgntframe(padapter, pcmdframe);
2723 #else
2724         dump_mgntframe_and_wait(padapter, pcmdframe, 100);
2725 #endif
2726
2727 //      DBG_8192C(FUNC_ADPT_FMT ": Set RSVD page location to Fw, TotalPacketLen(%d), TotalPageNum(%d)\n",
2728 //              FUNC_ADPT_ARG(padapter), TotalPacketLen, TotalPageNum);
2729         rtl8723b_set_FwRsvdPage_cmd(padapter, &RsvdPageLoc);
2730         rtl8723b_set_FwAoacRsvdPage_cmd(padapter, &RsvdPageLoc);
2731
2732         return;
2733
2734 error:
2735         rtw_free_xmitframe(pxmitpriv, pcmdframe);
2736 }
2737
2738 void rtl8723b_download_BTCoex_AP_mode_rsvd_page(PADAPTER padapter)
2739 {
2740         PHAL_DATA_TYPE pHalData;
2741         struct mlme_ext_priv *pmlmeext;
2742         struct mlme_ext_info *pmlmeinfo;
2743         u8 bRecover = _FALSE;
2744         u8 bcn_valid = _FALSE;
2745         u8 DLBcnCount = 0;
2746         u32 poll = 0;
2747         u8 val8;
2748
2749
2750         DBG_8192C("+" FUNC_ADPT_FMT ": iface_type=%d fw_state=0x%08X\n",
2751                 FUNC_ADPT_ARG(padapter), get_iface_type(padapter), get_fwstate(&padapter->mlmepriv));
2752
2753 #ifdef CONFIG_DEBUG
2754         if (check_fwstate(&padapter->mlmepriv, WIFI_AP_STATE) == _FALSE)
2755         {
2756                 DBG_8192C(FUNC_ADPT_FMT ": [WARNING] not in AP mode!!\n",
2757                         FUNC_ADPT_ARG(padapter));
2758         }
2759 #endif // CONFIG_DEBUG
2760
2761         pHalData = GET_HAL_DATA(padapter);
2762         pmlmeext = &padapter->mlmeextpriv;
2763         pmlmeinfo = &pmlmeext->mlmext_info;
2764
2765         // We should set AID, correct TSF, HW seq enable before set JoinBssReport to Fw in 88/92C.
2766         // Suggested by filen. Added by tynli.
2767         rtw_write16(padapter, REG_BCN_PSR_RPT, (0xC000|pmlmeinfo->aid));
2768
2769         // set REG_CR bit 8
2770         val8 = rtw_read8(padapter, REG_CR+1);
2771         val8 |= BIT(0); // ENSWBCN
2772         rtw_write8(padapter,  REG_CR+1, val8);
2773
2774         // Disable Hw protection for a time which revserd for Hw sending beacon.
2775         // Fix download reserved page packet fail that access collision with the protection time.
2776         // 2010.05.11. Added by tynli.
2777         val8 = rtw_read8(padapter, REG_BCN_CTRL);
2778         val8 &= ~EN_BCN_FUNCTION;
2779         val8 |= DIS_TSF_UDT;
2780         rtw_write8(padapter, REG_BCN_CTRL, val8);
2781
2782         // Set FWHW_TXQ_CTRL 0x422[6]=0 to tell Hw the packet is not a real beacon frame.
2783         if (pHalData->RegFwHwTxQCtrl & BIT(6))
2784                 bRecover = _TRUE;
2785
2786         // To tell Hw the packet is not a real beacon frame.
2787         pHalData->RegFwHwTxQCtrl &= ~BIT(6);
2788         rtw_write8(padapter, REG_FWHW_TXQ_CTRL+2, pHalData->RegFwHwTxQCtrl);
2789
2790         // Clear beacon valid check bit.
2791         rtw_hal_set_hwreg(padapter, HW_VAR_BCN_VALID, NULL);
2792         rtw_hal_set_hwreg(padapter, HW_VAR_DL_BCN_SEL, NULL);
2793
2794         DLBcnCount = 0;
2795         poll = 0;
2796         do {
2797                 SetFwRsvdPagePkt_BTCoex(padapter);
2798                 DLBcnCount++;
2799                 do {
2800                         rtw_yield_os();
2801 //                      rtw_mdelay_os(10);
2802                         // check rsvd page download OK.
2803                         rtw_hal_get_hwreg(padapter, HW_VAR_BCN_VALID, &bcn_valid);
2804                         poll++;
2805                 } while (!bcn_valid && (poll%10)!=0 && !padapter->bSurpriseRemoved && !padapter->bDriverStopped);
2806         } while (!bcn_valid && (DLBcnCount<=100) && !padapter->bSurpriseRemoved && !padapter->bDriverStopped);
2807
2808         if (_TRUE == bcn_valid)
2809         {
2810                 struct pwrctrl_priv *pwrctl = adapter_to_pwrctl(padapter);
2811                 pwrctl->fw_psmode_iface_id = padapter->iface_id;
2812                 DBG_8192C(ADPT_FMT": DL RSVD page success! DLBcnCount:%d, poll:%d\n",
2813                         ADPT_ARG(padapter), DLBcnCount, poll);
2814         }
2815         else
2816         {
2817                 DBG_8192C(ADPT_FMT": DL RSVD page fail! DLBcnCount:%d, poll:%d\n",
2818                         ADPT_ARG(padapter), DLBcnCount, poll);
2819                 DBG_8192C(ADPT_FMT": DL RSVD page fail! bSurpriseRemoved=%d\n",
2820                         ADPT_ARG(padapter), padapter->bSurpriseRemoved);
2821                 DBG_8192C(ADPT_FMT": DL RSVD page fail! bDriverStopped=%d\n",
2822                         ADPT_ARG(padapter), padapter->bDriverStopped);
2823         }
2824
2825         // 2010.05.11. Added by tynli.
2826         val8 = rtw_read8(padapter, REG_BCN_CTRL);
2827         val8 |= EN_BCN_FUNCTION;
2828         val8 &= ~DIS_TSF_UDT;
2829         rtw_write8(padapter, REG_BCN_CTRL, val8);
2830
2831         // To make sure that if there exists an adapter which would like to send beacon.
2832         // If exists, the origianl value of 0x422[6] will be 1, we should check this to
2833         // prevent from setting 0x422[6] to 0 after download reserved page, or it will cause
2834         // the beacon cannot be sent by HW.
2835         // 2010.06.23. Added by tynli.
2836         if (bRecover)
2837         {
2838                 pHalData->RegFwHwTxQCtrl |= BIT(6);
2839                 rtw_write8(padapter, REG_FWHW_TXQ_CTRL+2, pHalData->RegFwHwTxQCtrl);
2840         }
2841
2842         // Clear CR[8] or beacon packet will not be send to TxBuf anymore.
2843 #ifndef CONFIG_PCI_HCI
2844         val8 = rtw_read8(padapter, REG_CR+1);
2845         val8 &= ~BIT(0); // ~ENSWBCN
2846         rtw_write8(padapter, REG_CR+1, val8);
2847 #endif
2848 }
2849 #endif // CONFIG_BT_COEXIST
2850
2851 #ifdef CONFIG_P2P
2852 void rtl8723b_set_p2p_ps_offload_cmd(_adapter* padapter, u8 p2p_ps_state)
2853 {
2854         HAL_DATA_TYPE   *pHalData = GET_HAL_DATA(padapter);
2855         struct pwrctrl_priv             *pwrpriv = adapter_to_pwrctl(padapter);
2856         struct wifidirect_info  *pwdinfo = &( padapter->wdinfo );
2857         struct P2P_PS_Offload_t *p2p_ps_offload = (struct P2P_PS_Offload_t      *)(&pHalData->p2p_ps_offload);
2858         u8      i;
2859
2860 _func_enter_;
2861
2862 #if 1
2863         switch(p2p_ps_state)
2864         {
2865                 case P2P_PS_DISABLE:
2866                         DBG_8192C("P2P_PS_DISABLE \n");
2867                         _rtw_memset(p2p_ps_offload, 0 ,1);
2868                         break;
2869                 case P2P_PS_ENABLE:
2870                         DBG_8192C("P2P_PS_ENABLE \n");
2871                         // update CTWindow value.
2872                         if( pwdinfo->ctwindow > 0 )
2873                         {
2874                                 p2p_ps_offload->CTWindow_En = 1;
2875                                 rtw_write8(padapter, REG_P2P_CTWIN, pwdinfo->ctwindow);
2876                         }
2877
2878                         // hw only support 2 set of NoA
2879                         for( i=0 ; i<pwdinfo->noa_num ; i++)
2880                         {
2881                                 // To control the register setting for which NOA
2882                                 rtw_write8(padapter, REG_NOA_DESC_SEL, (i << 4));
2883                                 if(i == 0)
2884                                         p2p_ps_offload->NoA0_En = 1;
2885                                 else
2886                                         p2p_ps_offload->NoA1_En = 1;
2887
2888                                 // config P2P NoA Descriptor Register
2889                                 //DBG_8192C("%s(): noa_duration = %x\n",__FUNCTION__,pwdinfo->noa_duration[i]);
2890                                 rtw_write32(padapter, REG_NOA_DESC_DURATION, pwdinfo->noa_duration[i]);
2891
2892                                 //DBG_8192C("%s(): noa_interval = %x\n",__FUNCTION__,pwdinfo->noa_interval[i]);
2893                                 rtw_write32(padapter, REG_NOA_DESC_INTERVAL, pwdinfo->noa_interval[i]);
2894
2895                                 //DBG_8192C("%s(): start_time = %x\n",__FUNCTION__,pwdinfo->noa_start_time[i]);
2896                                 rtw_write32(padapter, REG_NOA_DESC_START, pwdinfo->noa_start_time[i]);
2897
2898                                 //DBG_8192C("%s(): noa_count = %x\n",__FUNCTION__,pwdinfo->noa_count[i]);
2899                                 rtw_write8(padapter, REG_NOA_DESC_COUNT, pwdinfo->noa_count[i]);
2900                         }
2901
2902                         if( (pwdinfo->opp_ps == 1) || (pwdinfo->noa_num > 0) )
2903                         {
2904                                 // rst p2p circuit
2905                                 rtw_write8(padapter, REG_DUAL_TSF_RST, BIT(4));
2906
2907                                 p2p_ps_offload->Offload_En = 1;
2908
2909                                 if(pwdinfo->role == P2P_ROLE_GO)
2910                                 {
2911                                         p2p_ps_offload->role= 1;
2912                                         p2p_ps_offload->AllStaSleep = 0;
2913                                 }
2914                                 else
2915                                 {
2916                                         p2p_ps_offload->role= 0;
2917                                 }
2918
2919                                 p2p_ps_offload->discovery = 0;
2920                         }
2921                         break;
2922                 case P2P_PS_SCAN:
2923                         DBG_8192C("P2P_PS_SCAN \n");
2924                         p2p_ps_offload->discovery = 1;
2925                         break;
2926                 case P2P_PS_SCAN_DONE:
2927                         DBG_8192C("P2P_PS_SCAN_DONE \n");
2928                         p2p_ps_offload->discovery = 0;
2929                         pwdinfo->p2p_ps_state = P2P_PS_ENABLE;
2930                         break;
2931                 default:
2932                         break;
2933         }
2934
2935         FillH2CCmd8723B(padapter, H2C_8723B_P2P_PS_OFFLOAD, 1, (u8 *)p2p_ps_offload);
2936 #endif
2937
2938 _func_exit_;
2939
2940 }
2941 #endif //CONFIG_P2P
2942
2943
2944 #ifdef CONFIG_TSF_RESET_OFFLOAD
2945 /*
2946         ask FW to Reset sync register at Beacon early interrupt
2947 */
2948 u8 rtl8723b_reset_tsf(_adapter *padapter, u8 reset_port )
2949 {
2950         u8      buf[2];
2951         u8      res=_SUCCESS;
2952
2953 _func_enter_;
2954         if (IFACE_PORT0==reset_port) {
2955                 buf[0] = 0x1; buf[1] = 0;
2956
2957         } else{
2958                 buf[0] = 0x0; buf[1] = 0x1;
2959         }
2960         FillH2CCmd8723B(padapter, H2C_8723B_RESET_TSF, 2, buf);
2961 _func_exit_;
2962
2963         return res;
2964 }
2965 #endif  // CONFIG_TSF_RESET_OFFLOAD
2966