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                 else
  46                         rtw_msleep_os(1);
  47         }while( (!read_down) && (retry_cnts--));
  48
  49         return read_down;
  50
  51 }
  52
  53
  54 /*****************************************
  55 * H2C Msg format :
  56 *| 31 - 8               |7-5    | 4 - 0 |
  57 *| h2c_msg      |Class  |CMD_ID |
  58 *| 31-0                                         |
  59 *| Ext msg                                      |
  60 *
  61 ******************************************/
  62 s32 FillH2CCmd8723B(PADAPTER padapter, u8 ElementID, u32 CmdLen, u8 *pCmdBuffer)
  63 {
  64         u8 h2c_box_num;
  65         u32     msgbox_addr;
  66         u32 msgbox_ex_addr=0;
  67         PHAL_DATA_TYPE pHalData;
  68         u32     h2c_cmd = 0;
  69         u32     h2c_cmd_ex = 0;
  70         s32 ret = _FAIL;
  71         struct dvobj_priv *psdpriv = padapter->dvobj;
  72         struct debug_priv *pdbgpriv = &psdpriv->drv_dbg;
  73 _func_enter_;
  74
  75         padapter = GET_PRIMARY_ADAPTER(padapter);
  76         pHalData = GET_HAL_DATA(padapter);
  77 #ifdef DBG_CHECK_FW_PS_STATE
  78 #ifdef DBG_CHECK_FW_PS_STATE_H2C
  79         if(rtw_fw_ps_state(padapter) == _FAIL)
  80         {
  81                 DBG_871X("%s: h2c doesn't leave 32k ElementID=%02x \n", __FUNCTION__, ElementID);
  82                 pdbgpriv->dbg_h2c_leave32k_fail_cnt++;
  83         }
  84
  85         //DBG_871X("H2C ElementID=%02x , pHalData->LastHMEBoxNum=%02x\n", ElementID, pHalData->LastHMEBoxNum);
  86 #endif //DBG_CHECK_FW_PS_STATE_H2C
  87 #endif //DBG_CHECK_FW_PS_STATE
  88         _enter_critical_mutex(&(adapter_to_dvobj(padapter)->h2c_fwcmd_mutex), NULL);
  89
  90         if (!pCmdBuffer) {
  91                 goto exit;
  92         }
  93         if(CmdLen > RTL8723B_MAX_CMD_LEN) {
  94                 goto exit;
  95         }
  96         if (rtw_is_surprise_removed(padapter))
  97                 goto exit;
  98
  99         //pay attention to if  race condition happened in  H2C cmd setting.
 100         do{
 101                 h2c_box_num = pHalData->LastHMEBoxNum;
 102
 103                 if(!_is_fw_read_cmd_down(padapter, h2c_box_num)){
 104                         DBG_8192C(" fw read cmd failed...\n");
 105 #ifdef DBG_CHECK_FW_PS_STATE
 106                         DBG_871X("MAC_1C0=%08x, MAC_1C4=%08x, MAC_1C8=%08x, MAC_1CC=%08x\n", rtw_read32(padapter, 0x1c0), rtw_read32(padapter, 0x1c4)
 107                                 , rtw_read32(padapter, 0x1c8), rtw_read32(padapter, 0x1cc));
 108 #endif //DBG_CHECK_FW_PS_STATE
 109                         //DBG_8192C(" 0x1c0: 0x%8x\n", rtw_read32(padapter, 0x1c0));
 110                         //DBG_8192C(" 0x1c4: 0x%8x\n", rtw_read32(padapter, 0x1c4));
 111                         goto exit;
 112                 }
 113
 114                 if(CmdLen<=3)
 115                 {
 116                         _rtw_memcpy((u8*)(&h2c_cmd)+1, pCmdBuffer, CmdLen );
 117                 }
 118                 else{
 119                         _rtw_memcpy((u8*)(&h2c_cmd)+1, pCmdBuffer, 3);
 120                         _rtw_memcpy((u8*)(&h2c_cmd_ex), pCmdBuffer+3, CmdLen-3);
 121 //                      *(u8*)(&h2c_cmd) |= BIT(7);
 122                 }
 123
 124                 *(u8*)(&h2c_cmd) |= ElementID;
 125
 126                 if(CmdLen>3){
 127                         msgbox_ex_addr = REG_HMEBOX_EXT0_8723B + (h2c_box_num *RTL8723B_EX_MESSAGE_BOX_SIZE);
 128                         h2c_cmd_ex = le32_to_cpu( h2c_cmd_ex );
 129                         rtw_write32(padapter, msgbox_ex_addr, h2c_cmd_ex);
 130                 }
 131                 msgbox_addr =REG_HMEBOX_0 + (h2c_box_num *MESSAGE_BOX_SIZE);
 132                 h2c_cmd = le32_to_cpu( h2c_cmd );
 133                 rtw_write32(padapter,msgbox_addr, h2c_cmd);
 134
 135                 //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"
 136                 //      ,pHalData->LastHMEBoxNum , CmdLen, ElementID, msgbox_addr, h2c_cmd, msgbox_ex_addr, h2c_cmd_ex);
 137
 138                 pHalData->LastHMEBoxNum = (h2c_box_num+1) % MAX_H2C_BOX_NUMS;
 139
 140         }while(0);
 141
 142         ret = _SUCCESS;
 143
 144 exit:
 145
 146         _exit_critical_mutex(&(adapter_to_dvobj(padapter)->h2c_fwcmd_mutex), NULL);
 147
 148 _func_exit_;
 149
 150         return ret;
 151 }
 152
 153 static void ConstructBeacon(_adapter *padapter, u8 *pframe, u32 *pLength)
 154 {
 155         struct rtw_ieee80211_hdr        *pwlanhdr;
 156         u16                                     *fctrl;
 157         u32                                     rate_len, pktlen;
 158         struct mlme_ext_priv    *pmlmeext = &(padapter->mlmeextpriv);
 159         struct mlme_ext_info    *pmlmeinfo = &(pmlmeext->mlmext_info);
 160         WLAN_BSSID_EX           *cur_network = &(pmlmeinfo->network);
 161         u8      bc_addr[] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
 162
 163
 164         //DBG_871X("%s\n", __FUNCTION__);
 165
 166         pwlanhdr = (struct rtw_ieee80211_hdr *)pframe;
 167
 168         fctrl = &(pwlanhdr->frame_ctl);
 169         *(fctrl) = 0;
 170
 171         _rtw_memcpy(pwlanhdr->addr1, bc_addr, ETH_ALEN);
 172         _rtw_memcpy(pwlanhdr->addr2, adapter_mac_addr(padapter), ETH_ALEN);
 173         _rtw_memcpy(pwlanhdr->addr3, get_my_bssid(cur_network), ETH_ALEN);
 174
 175         SetSeqNum(pwlanhdr, 0/*pmlmeext->mgnt_seq*/);
 176         //pmlmeext->mgnt_seq++;
 177         SetFrameSubType(pframe, WIFI_BEACON);
 178
 179         pframe += sizeof(struct rtw_ieee80211_hdr_3addr);
 180         pktlen = sizeof (struct rtw_ieee80211_hdr_3addr);
 181
 182         //timestamp will be inserted by hardware
 183         pframe += 8;
 184         pktlen += 8;
 185
 186         // beacon interval: 2 bytes
 187         _rtw_memcpy(pframe, (unsigned char *)(rtw_get_beacon_interval_from_ie(cur_network->IEs)), 2);
 188
 189         pframe += 2;
 190         pktlen += 2;
 191
 192         // capability info: 2 bytes
 193         _rtw_memcpy(pframe, (unsigned char *)(rtw_get_capability_from_ie(cur_network->IEs)), 2);
 194
 195         pframe += 2;
 196         pktlen += 2;
 197
 198         if( (pmlmeinfo->state&0x03) == WIFI_FW_AP_STATE)
 199         {
 200                 //DBG_871X("ie len=%d\n", cur_network->IELength);
 201                 pktlen += cur_network->IELength - sizeof(NDIS_802_11_FIXED_IEs);
 202                 _rtw_memcpy(pframe, cur_network->IEs+sizeof(NDIS_802_11_FIXED_IEs), pktlen);
 203
 204                 goto _ConstructBeacon;
 205         }
 206
 207         //below for ad-hoc mode
 208
 209         // SSID
 210         pframe = rtw_set_ie(pframe, _SSID_IE_, cur_network->Ssid.SsidLength, cur_network->Ssid.Ssid, &pktlen);
 211
 212         // supported rates...
 213         rate_len = rtw_get_rateset_len(cur_network->SupportedRates);
 214         pframe = rtw_set_ie(pframe, _SUPPORTEDRATES_IE_, ((rate_len > 8)? 8: rate_len), cur_network->SupportedRates, &pktlen);
 215
 216         // DS parameter set
 217         pframe = rtw_set_ie(pframe, _DSSET_IE_, 1, (unsigned char *)&(cur_network->Configuration.DSConfig), &pktlen);
 218
 219         if( (pmlmeinfo->state&0x03) == WIFI_FW_ADHOC_STATE)
 220         {
 221                 u32 ATIMWindow;
 222                 // IBSS Parameter Set...
 223                 //ATIMWindow = cur->Configuration.ATIMWindow;
 224                 ATIMWindow = 0;
 225                 pframe = rtw_set_ie(pframe, _IBSS_PARA_IE_, 2, (unsigned char *)(&ATIMWindow), &pktlen);
 226         }
 227
 228
 229         //todo: ERP IE
 230
 231
 232         // EXTERNDED SUPPORTED RATE
 233         if (rate_len > 8)
 234         {
 235                 pframe = rtw_set_ie(pframe, _EXT_SUPPORTEDRATES_IE_, (rate_len - 8), (cur_network->SupportedRates + 8), &pktlen);
 236         }
 237
 238
 239         //todo:HT for adhoc
 240
 241 _ConstructBeacon:
 242
 243         if ((pktlen + TXDESC_SIZE) > 512)
 244         {
 245                 DBG_871X("beacon frame too large\n");
 246                 return;
 247         }
 248
 249         *pLength = pktlen;
 250
 251         //DBG_871X("%s bcn_sz=%d\n", __FUNCTION__, pktlen);
 252
 253 }
 254
 255 static void ConstructPSPoll(_adapter *padapter, u8 *pframe, u32 *pLength)
 256 {
 257         struct rtw_ieee80211_hdr        *pwlanhdr;
 258         u16                                     *fctrl;
 259         u32                                     pktlen;
 260         struct mlme_ext_priv    *pmlmeext = &(padapter->mlmeextpriv);
 261         struct mlme_ext_info    *pmlmeinfo = &(pmlmeext->mlmext_info);
 262
 263         //DBG_871X("%s\n", __FUNCTION__);
 264
 265         pwlanhdr = (struct rtw_ieee80211_hdr *)pframe;
 266
 267         // Frame control.
 268         fctrl = &(pwlanhdr->frame_ctl);
 269         *(fctrl) = 0;
 270         SetPwrMgt(fctrl);
 271         SetFrameSubType(pframe, WIFI_PSPOLL);
 272
 273         // AID.
 274         SetDuration(pframe, (pmlmeinfo->aid | 0xc000));
 275
 276         // BSSID.
 277         _rtw_memcpy(pwlanhdr->addr1, get_my_bssid(&(pmlmeinfo->network)), ETH_ALEN);
 278
 279         // TA.
 280         _rtw_memcpy(pwlanhdr->addr2, adapter_mac_addr(padapter), ETH_ALEN);
 281
 282         *pLength = 16;
 283 }
 284
 285 static void ConstructNullFunctionData(
 286         PADAPTER padapter,
 287         u8              *pframe,
 288         u32             *pLength,
 289         u8              *StaAddr,
 290         u8              bQoS,
 291         u8              AC,
 292         u8              bEosp,
 293         u8              bForcePowerSave)
 294 {
 295         struct rtw_ieee80211_hdr        *pwlanhdr;
 296         u16                                             *fctrl;
 297         u32                                             pktlen;
 298         struct mlme_priv                *pmlmepriv = &padapter->mlmepriv;
 299         struct wlan_network             *cur_network = &pmlmepriv->cur_network;
 300         struct mlme_ext_priv    *pmlmeext = &(padapter->mlmeextpriv);
 301         struct mlme_ext_info    *pmlmeinfo = &(pmlmeext->mlmext_info);
 302
 303
 304         //DBG_871X("%s:%d\n", __FUNCTION__, bForcePowerSave);
 305
 306         pwlanhdr = (struct rtw_ieee80211_hdr*)pframe;
 307
 308         fctrl = &pwlanhdr->frame_ctl;
 309         *(fctrl) = 0;
 310         if (bForcePowerSave)
 311         {
 312                 SetPwrMgt(fctrl);
 313         }
 314
 315         switch(cur_network->network.InfrastructureMode)
 316         {
 317                 case Ndis802_11Infrastructure:
 318                         SetToDs(fctrl);
 319                         _rtw_memcpy(pwlanhdr->addr1, get_my_bssid(&(pmlmeinfo->network)), ETH_ALEN);
 320                         _rtw_memcpy(pwlanhdr->addr2, adapter_mac_addr(padapter), ETH_ALEN);
 321                         _rtw_memcpy(pwlanhdr->addr3, StaAddr, ETH_ALEN);
 322                         break;
 323                 case Ndis802_11APMode:
 324                         SetFrDs(fctrl);
 325                         _rtw_memcpy(pwlanhdr->addr1, StaAddr, ETH_ALEN);
 326                         _rtw_memcpy(pwlanhdr->addr2, get_my_bssid(&(pmlmeinfo->network)), ETH_ALEN);
 327                         _rtw_memcpy(pwlanhdr->addr3, adapter_mac_addr(padapter), ETH_ALEN);
 328                         break;
 329                 case Ndis802_11IBSS:
 330                 default:
 331                         _rtw_memcpy(pwlanhdr->addr1, StaAddr, ETH_ALEN);
 332                         _rtw_memcpy(pwlanhdr->addr2, adapter_mac_addr(padapter), ETH_ALEN);
 333                         _rtw_memcpy(pwlanhdr->addr3, get_my_bssid(&(pmlmeinfo->network)), ETH_ALEN);
 334                         break;
 335         }
 336
 337         SetSeqNum(pwlanhdr, 0);
 338
 339         if (bQoS == _TRUE) {
 340                 struct rtw_ieee80211_hdr_3addr_qos *pwlanqoshdr;
 341
 342                 SetFrameSubType(pframe, WIFI_QOS_DATA_NULL);
 343
 344                 pwlanqoshdr = (struct rtw_ieee80211_hdr_3addr_qos*)pframe;
 345                 SetPriority(&pwlanqoshdr->qc, AC);
 346                 SetEOSP(&pwlanqoshdr->qc, bEosp);
 347
 348                 pktlen = sizeof(struct rtw_ieee80211_hdr_3addr_qos);
 349         } else {
 350                 SetFrameSubType(pframe, WIFI_DATA_NULL);
 351
 352                 pktlen = sizeof(struct rtw_ieee80211_hdr_3addr);
 353         }
 354
 355         *pLength = pktlen;
 356 }
 357
 358 // To check if reserved page content is destroyed by beacon beacuse beacon is too large.
 359 // 2010.06.23. Added by tynli.
 360 VOID
 361 CheckFwRsvdPageContent(
 362         IN      PADAPTER                Adapter
 363 )
 364 {
 365         HAL_DATA_TYPE*  pHalData = GET_HAL_DATA(Adapter);
 366         u32     MaxBcnPageNum;
 367
 368         if(pHalData->FwRsvdPageStartOffset != 0)
 369         {
 370                 /*MaxBcnPageNum = PageNum_128(pMgntInfo->MaxBeaconSize);
 371                 RT_ASSERT((MaxBcnPageNum <= pHalData->FwRsvdPageStartOffset),
 372                         ("CheckFwRsvdPageContent(): The reserved page content has been"\
 373                         "destroyed by beacon!!! MaxBcnPageNum(%d) FwRsvdPageStartOffset(%d)\n!",
 374                         MaxBcnPageNum, pHalData->FwRsvdPageStartOffset));*/
 375         }
 376 }
 377
 378 //
 379 // Description: Get the reserved page number in Tx packet buffer.
 380 // Retrun value: the page number.
 381 // 2012.08.09, by tynli.
 382 //
 383 u8 GetTxBufferRsvdPageNum8723B(_adapter *padapter, bool wowlan)
 384 {
 385         HAL_DATA_TYPE   *pHalData = GET_HAL_DATA(padapter);
 386         u8      RsvdPageNum=0;
 387         // default reseved 1 page for the IC type which is undefined.
 388         u8      TxPageBndy= LAST_ENTRY_OF_TX_PKT_BUFFER_8723B;
 389
 390         rtw_hal_get_def_var(padapter, HAL_DEF_TX_PAGE_BOUNDARY, (u8 *)&TxPageBndy);
 391
 392         RsvdPageNum = LAST_ENTRY_OF_TX_PKT_BUFFER_8723B -TxPageBndy + 1;
 393
 394         return RsvdPageNum;
 395 }
 396
 397 static void rtl8723b_set_FwRsvdPage_cmd(PADAPTER padapter, PRSVDPAGE_LOC rsvdpageloc)
 398 {
 399         u8 u1H2CRsvdPageParm[H2C_RSVDPAGE_LOC_LEN]={0};
 400
 401         DBG_871X("8723BRsvdPageLoc: ProbeRsp=%d PsPoll=%d Null=%d QoSNull=%d BTNull=%d\n",
 402                 rsvdpageloc->LocProbeRsp, rsvdpageloc->LocPsPoll,
 403                 rsvdpageloc->LocNullData, rsvdpageloc->LocQosNull,
 404                 rsvdpageloc->LocBTQosNull);
 405
 406         SET_8723B_H2CCMD_RSVDPAGE_LOC_PROBE_RSP(u1H2CRsvdPageParm, rsvdpageloc->LocProbeRsp);
 407         SET_8723B_H2CCMD_RSVDPAGE_LOC_PSPOLL(u1H2CRsvdPageParm, rsvdpageloc->LocPsPoll);
 408         SET_8723B_H2CCMD_RSVDPAGE_LOC_NULL_DATA(u1H2CRsvdPageParm, rsvdpageloc->LocNullData);
 409         SET_8723B_H2CCMD_RSVDPAGE_LOC_QOS_NULL_DATA(u1H2CRsvdPageParm, rsvdpageloc->LocQosNull);
 410         SET_8723B_H2CCMD_RSVDPAGE_LOC_BT_QOS_NULL_DATA(u1H2CRsvdPageParm, rsvdpageloc->LocBTQosNull);
 411
 412         RT_PRINT_DATA(_module_hal_init_c_, _drv_always_, "u1H2CRsvdPageParm:", u1H2CRsvdPageParm, H2C_RSVDPAGE_LOC_LEN);
 413         FillH2CCmd8723B(padapter, H2C_8723B_RSVD_PAGE, H2C_RSVDPAGE_LOC_LEN, u1H2CRsvdPageParm);
 414 }
 415
 416 static void rtl8723b_set_FwAoacRsvdPage_cmd(PADAPTER padapter, PRSVDPAGE_LOC rsvdpageloc)
 417 {
 418         struct pwrctrl_priv *pwrpriv = adapter_to_pwrctl(padapter);
 419         struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
 420         u8      res = 0, count = 0;
 421 #ifdef CONFIG_WOWLAN
 422         u8 u1H2CAoacRsvdPageParm[H2C_AOAC_RSVDPAGE_LOC_LEN]={0};
 423
 424         DBG_871X("8723BAOACRsvdPageLoc: RWC=%d ArpRsp=%d NbrAdv=%d GtkRsp=%d GtkInfo=%d ProbeReq=%d NetworkList=%d\n",
 425                         rsvdpageloc->LocRemoteCtrlInfo, rsvdpageloc->LocArpRsp,
 426                         rsvdpageloc->LocNbrAdv, rsvdpageloc->LocGTKRsp,
 427                         rsvdpageloc->LocGTKInfo, rsvdpageloc->LocProbeReq,
 428                         rsvdpageloc->LocNetList);
 429
 430         if (check_fwstate(pmlmepriv, _FW_LINKED)) {
 431                 SET_H2CCMD_AOAC_RSVDPAGE_LOC_REMOTE_WAKE_CTRL_INFO(u1H2CAoacRsvdPageParm, rsvdpageloc->LocRemoteCtrlInfo);
 432                 SET_H2CCMD_AOAC_RSVDPAGE_LOC_ARP_RSP(u1H2CAoacRsvdPageParm, rsvdpageloc->LocArpRsp);
 433                 //SET_H2CCMD_AOAC_RSVDPAGE_LOC_NEIGHBOR_ADV(u1H2CAoacRsvdPageParm, rsvdpageloc->LocNbrAdv);
 434                 SET_H2CCMD_AOAC_RSVDPAGE_LOC_GTK_RSP(u1H2CAoacRsvdPageParm, rsvdpageloc->LocGTKRsp);
 435                 SET_H2CCMD_AOAC_RSVDPAGE_LOC_GTK_INFO(u1H2CAoacRsvdPageParm, rsvdpageloc->LocGTKInfo);
 436 #ifdef CONFIG_GTK_OL
 437                 SET_H2CCMD_AOAC_RSVDPAGE_LOC_GTK_EXT_MEM(u1H2CAoacRsvdPageParm, rsvdpageloc->LocGTKEXTMEM);
 438 #endif // CONFIG_GTK_OL
 439                 RT_PRINT_DATA(_module_hal_init_c_, _drv_always_, "u1H2CAoacRsvdPageParm:", u1H2CAoacRsvdPageParm, H2C_AOAC_RSVDPAGE_LOC_LEN);
 440                 FillH2CCmd8723B(padapter, H2C_8723B_AOAC_RSVD_PAGE, H2C_AOAC_RSVDPAGE_LOC_LEN, u1H2CAoacRsvdPageParm);
 441         } else {
 442 #ifdef CONFIG_PNO_SUPPORT
 443                 if(!pwrpriv->pno_in_resume) {
 444                         DBG_871X("NLO_INFO=%d\n", rsvdpageloc->LocPNOInfo);
 445                         _rtw_memset(&u1H2CAoacRsvdPageParm, 0, sizeof(u1H2CAoacRsvdPageParm));
 446                         SET_H2CCMD_AOAC_RSVDPAGE_LOC_NLO_INFO(u1H2CAoacRsvdPageParm, rsvdpageloc->LocPNOInfo);
 447                         FillH2CCmd8723B(padapter, H2C_AOAC_RSVDPAGE3, H2C_AOAC_RSVDPAGE_LOC_LEN, u1H2CAoacRsvdPageParm);
 448                         rtw_msleep_os(10);
 449                 }
 450 #endif
 451         }
 452
 453 #endif // CONFIG_WOWLAN
 454 }
 455
 456 static void rtl8723b_set_FwKeepAlive_cmd(PADAPTER padapter, u8 benable, u8 pkt_type)
 457 {
 458         u8 u1H2CKeepAliveParm[H2C_KEEP_ALIVE_CTRL_LEN]={0};
 459         u8 adopt = 1;
 460 #ifdef CONFIG_PLATFORM_INTEL_BYT
 461         u8 check_period = 10;
 462 #else
 463         u8 check_period = 5;
 464 #endif
 465
 466         DBG_871X("%s(): benable = %d\n", __func__, benable);
 467         SET_8723B_H2CCMD_KEEPALIVE_PARM_ENABLE(u1H2CKeepAliveParm, benable);
 468         SET_8723B_H2CCMD_KEEPALIVE_PARM_ADOPT(u1H2CKeepAliveParm, adopt);
 469         SET_8723B_H2CCMD_KEEPALIVE_PARM_PKT_TYPE(u1H2CKeepAliveParm, pkt_type);
 470         SET_8723B_H2CCMD_KEEPALIVE_PARM_CHECK_PERIOD(u1H2CKeepAliveParm, check_period);
 471
 472         RT_PRINT_DATA(_module_hal_init_c_, _drv_always_, "u1H2CKeepAliveParm:", u1H2CKeepAliveParm, H2C_KEEP_ALIVE_CTRL_LEN);
 473
 474         FillH2CCmd8723B(padapter, H2C_8723B_KEEP_ALIVE, H2C_KEEP_ALIVE_CTRL_LEN, u1H2CKeepAliveParm);
 475 }
 476
 477 static void rtl8723b_set_FwDisconDecision_cmd(PADAPTER padapter, u8 benable)
 478 {
 479         u8 u1H2CDisconDecisionParm[H2C_DISCON_DECISION_LEN]={0};
 480         u8 adopt = 1, check_period = 10, trypkt_num = 0;
 481
 482         DBG_871X("%s(): benable = %d\n", __func__, benable);
 483         SET_8723B_H2CCMD_DISCONDECISION_PARM_ENABLE(u1H2CDisconDecisionParm, benable);
 484         SET_8723B_H2CCMD_DISCONDECISION_PARM_ADOPT(u1H2CDisconDecisionParm, adopt);
 485         SET_8723B_H2CCMD_DISCONDECISION_PARM_CHECK_PERIOD(u1H2CDisconDecisionParm, check_period);
 486         SET_8723B_H2CCMD_DISCONDECISION_PARM_TRY_PKT_NUM(u1H2CDisconDecisionParm, trypkt_num);
 487
 488         RT_PRINT_DATA(_module_hal_init_c_, _drv_always_, "u1H2CDisconDecisionParm:", u1H2CDisconDecisionParm, H2C_DISCON_DECISION_LEN);
 489
 490         FillH2CCmd8723B(padapter, H2C_8723B_DISCON_DECISION, H2C_DISCON_DECISION_LEN, u1H2CDisconDecisionParm);
 491 }
 492
 493 void rtl8723b_set_FwMacIdConfig_cmd(_adapter* padapter, u8 mac_id, u8 raid, u8 bw, u8 sgi, u32 mask)
 494 {
 495         HAL_DATA_TYPE   *pHalData = GET_HAL_DATA(padapter);
 496         u8 u1H2CMacIdConfigParm[H2C_MACID_CFG_LEN]={0};
 497
 498         DBG_871X("%s(): mac_id=%d raid=0x%x bw=%d mask=0x%x\n", __func__, mac_id, raid, bw, mask);
 499
 500 _func_enter_;
 501
 502         SET_8723B_H2CCMD_MACID_CFG_MACID(u1H2CMacIdConfigParm, mac_id);
 503         SET_8723B_H2CCMD_MACID_CFG_RAID(u1H2CMacIdConfigParm, raid);
 504         SET_8723B_H2CCMD_MACID_CFG_SGI_EN(u1H2CMacIdConfigParm, (sgi)? 1:0);
 505         SET_8723B_H2CCMD_MACID_CFG_BW(u1H2CMacIdConfigParm, bw);
 506
 507         //DisableTXPowerTraining
 508         if(pHalData->bDisableTXPowerTraining){
 509                 SET_8723B_H2CCMD_MACID_CFG_DISPT(u1H2CMacIdConfigParm,1);
 510                 DBG_871X("%s,Disable PWT by driver\n",__FUNCTION__);
 511         }
 512         else{
 513                 PDM_ODM_T       pDM_OutSrc = &pHalData->odmpriv;
 514
 515                 if(pDM_OutSrc->bDisablePowerTraining){
 516                         SET_8723B_H2CCMD_MACID_CFG_DISPT(u1H2CMacIdConfigParm,1);
 517                         DBG_871X("%s,Disable PWT by DM\n",__FUNCTION__);
 518                 }
 519         }
 520
 521         SET_8723B_H2CCMD_MACID_CFG_RATE_MASK0(u1H2CMacIdConfigParm, (u8)(mask & 0x000000ff));
 522         SET_8723B_H2CCMD_MACID_CFG_RATE_MASK1(u1H2CMacIdConfigParm, (u8)((mask & 0x0000ff00) >>8));
 523         SET_8723B_H2CCMD_MACID_CFG_RATE_MASK2(u1H2CMacIdConfigParm, (u8)((mask & 0x00ff0000) >> 16));
 524         SET_8723B_H2CCMD_MACID_CFG_RATE_MASK3(u1H2CMacIdConfigParm, (u8)((mask & 0xff000000) >> 24));
 525
 526         RT_PRINT_DATA(_module_hal_init_c_, _drv_always_, "u1H2CMacIdConfigParm:", u1H2CMacIdConfigParm, H2C_MACID_CFG_LEN);
 527         FillH2CCmd8723B(padapter, H2C_8723B_MACID_CFG, H2C_MACID_CFG_LEN, u1H2CMacIdConfigParm);
 528
 529 _func_exit_;
 530 }
 531
 532 void rtl8723b_set_FwRssiSetting_cmd(_adapter*padapter, u8 *param)
 533 {
 534         u8 u1H2CRssiSettingParm[H2C_RSSI_SETTING_LEN]={0};
 535         u8 mac_id = *param;
 536         u8 rssi = *(param+2);
 537         u8 uldl_state = 0;
 538
 539 _func_enter_;
 540         //DBG_871X("%s(): param=%.2x-%.2x-%.2x\n", __func__, *param, *(param+1), *(param+2));
 541         //DBG_871X("%s(): mac_id=%d rssi=%d\n", __func__, mac_id, rssi);
 542
 543         SET_8723B_H2CCMD_RSSI_SETTING_MACID(u1H2CRssiSettingParm, mac_id);
 544         SET_8723B_H2CCMD_RSSI_SETTING_RSSI(u1H2CRssiSettingParm, rssi);
 545         SET_8723B_H2CCMD_RSSI_SETTING_ULDL_STATE(u1H2CRssiSettingParm, uldl_state);
 546
 547         RT_PRINT_DATA(_module_hal_init_c_, _drv_notice_, "u1H2CRssiSettingParm:", u1H2CRssiSettingParm, H2C_RSSI_SETTING_LEN);
 548         FillH2CCmd8723B(padapter, H2C_8723B_RSSI_SETTING, H2C_RSSI_SETTING_LEN, u1H2CRssiSettingParm);
 549
 550 _func_exit_;
 551 }
 552
 553 void rtl8723b_set_FwAPReqRPT_cmd(PADAPTER padapter, u32 need_ack)
 554 {
 555         u8 u1H2CApReqRptParm[H2C_AP_REQ_TXRPT_LEN]={0};
 556         u8 macid1 = 1, macid2 = 0;
 557
 558         DBG_871X("%s(): need_ack = %d\n", __func__, need_ack);
 559
 560         SET_8723B_H2CCMD_APREQRPT_PARM_MACID1(u1H2CApReqRptParm, macid1);
 561         SET_8723B_H2CCMD_APREQRPT_PARM_MACID2(u1H2CApReqRptParm, macid2);
 562
 563         RT_PRINT_DATA(_module_hal_init_c_, _drv_always_, "u1H2CApReqRptParm:", u1H2CApReqRptParm, H2C_AP_REQ_TXRPT_LEN);
 564         FillH2CCmd8723B(padapter, H2C_8723B_AP_REQ_TXRPT, H2C_AP_REQ_TXRPT_LEN, u1H2CApReqRptParm);
 565 }
 566
 567 void rtl8723b_set_FwPwrMode_cmd(PADAPTER padapter, u8 psmode)
 568 {
 569         int i;
 570         u8 smart_ps = 0;
 571         struct pwrctrl_priv *pwrpriv = adapter_to_pwrctl(padapter);
 572         struct mlme_ext_priv    *pmlmeext = &padapter->mlmeextpriv;
 573         u8 u1H2CPwrModeParm[H2C_PWRMODE_LEN]={0};
 574         u8 PowerState=0, awake_intvl = 1, byte5 = 0, rlbm = 0;
 575 #ifdef CONFIG_P2P
 576         struct wifidirect_info *wdinfo = &(padapter->wdinfo);
 577 #endif // CONFIG_P2P
 578
 579 _func_enter_;
 580
 581         if(pwrpriv->dtim > 0)
 582                 DBG_871X("%s(): FW LPS mode = %d, SmartPS=%d, dtim=%d\n", __func__, psmode, pwrpriv->smart_ps, pwrpriv->dtim);
 583         else
 584                 DBG_871X("%s(): FW LPS mode = %d, SmartPS=%d\n", __func__, psmode, pwrpriv->smart_ps);
 585
 586         if(psmode == PS_MODE_MIN)
 587         {
 588                 rlbm = 0;
 589                 awake_intvl = 2;
 590                 smart_ps = pwrpriv->smart_ps;
 591         }
 592         else if(psmode == PS_MODE_MAX)
 593         {
 594                 rlbm = 1;
 595                 awake_intvl = 2;
 596                 smart_ps = pwrpriv->smart_ps;
 597         }
 598         else if(psmode == PS_MODE_DTIM) //For WOWLAN LPS, DTIM = (awake_intvl - 1)
 599         {
 600                 if(pwrpriv->dtim > 0 && pwrpriv->dtim < 16)
 601                         awake_intvl = pwrpriv->dtim+1;//DTIM = (awake_intvl - 1)
 602                 else
 603                         awake_intvl = 4;//DTIM=3
 604
 605
 606                 rlbm = 2;
 607                 smart_ps = pwrpriv->smart_ps;
 608         }
 609         else
 610         {
 611                 rlbm = 2;
 612                 awake_intvl = 4;
 613                 smart_ps = pwrpriv->smart_ps;
 614         }
 615
 616 #ifdef CONFIG_P2P
 617         if (!rtw_p2p_chk_state(wdinfo, P2P_STATE_NONE)) {
 618                 awake_intvl = 2;
 619                 rlbm = 1;
 620         }
 621 #endif // CONFIG_P2P
 622
 623         if(padapter->registrypriv.wifi_spec==1)
 624         {
 625                 awake_intvl = 2;
 626                 rlbm = 1;
 627         }
 628
 629         if (psmode > 0)
 630         {
 631 #ifdef CONFIG_BT_COEXIST
 632                 if (rtw_btcoex_IsBtControlLps(padapter) == _TRUE)
 633                 {
 634                         PowerState = rtw_btcoex_RpwmVal(padapter);
 635                         byte5 = rtw_btcoex_LpsVal(padapter);
 636
 637                         if ((rlbm == 2) && (byte5 & BIT(4)))
 638                         {
 639                                 // Keep awake interval to 1 to prevent from
 640                                 // decreasing coex performance
 641                                 awake_intvl = 2;
 642                                 rlbm = 2;
 643                         }
 644                 }
 645                 else
 646 #endif // CONFIG_BT_COEXIST
 647                 {
 648                         PowerState = 0x00;// AllON(0x0C), RFON(0x04), RFOFF(0x00)
 649                         byte5 = 0x40;
 650                 }
 651         }
 652         else
 653         {
 654                 PowerState = 0x0C;// AllON(0x0C), RFON(0x04), RFOFF(0x00)
 655                 byte5 = 0x40;
 656         }
 657
 658         SET_8723B_H2CCMD_PWRMODE_PARM_MODE(u1H2CPwrModeParm, (psmode>0)?1:0);
 659         SET_8723B_H2CCMD_PWRMODE_PARM_SMART_PS(u1H2CPwrModeParm, smart_ps);
 660         SET_8723B_H2CCMD_PWRMODE_PARM_RLBM(u1H2CPwrModeParm, rlbm);
 661         SET_8723B_H2CCMD_PWRMODE_PARM_BCN_PASS_TIME(u1H2CPwrModeParm, awake_intvl);
 662         SET_8723B_H2CCMD_PWRMODE_PARM_ALL_QUEUE_UAPSD(u1H2CPwrModeParm, padapter->registrypriv.uapsd_enable);
 663         SET_8723B_H2CCMD_PWRMODE_PARM_PWR_STATE(u1H2CPwrModeParm, PowerState);
 664         SET_8723B_H2CCMD_PWRMODE_PARM_BYTE5(u1H2CPwrModeParm, byte5);
 665 #ifdef CONFIG_LPS_LCLK
 666         if(psmode != PS_MODE_ACTIVE)
 667         {
 668                 if(pmlmeext ->adaptive_tsf_done == _FALSE && pmlmeext->bcn_cnt>0)
 669                 {
 670                         u8 ratio_20_delay, ratio_80_delay;
 671
 672                         //byte 6 for adaptive_early_32k
 673                         //[0:3] = DrvBcnEarly  (ms) , [4:7] = DrvBcnTimeOut  (ms)
 674                         // 20% for DrvBcnEarly, 80% for DrvBcnTimeOut
 675                         ratio_20_delay = 0;
 676                         ratio_80_delay = 0;
 677                         pmlmeext->DrvBcnEarly = 0xff;
 678                         pmlmeext->DrvBcnTimeOut = 0xff;
 679
 680                         //DBG_871X("%s(): bcn_cnt = %d\n", __func__, pmlmeext->bcn_cnt);
 681
 682                         for(i=0; i<9; i++)
 683                         {
 684                                 pmlmeext->bcn_delay_ratio[i] = (pmlmeext->bcn_delay_cnt[i] * 100) /pmlmeext->bcn_cnt;
 685
 686                                 //DBG_871X("%s(): bcn_delay_cnt[%d]=%d, bcn_delay_ratio[%d] = %d\n", __func__, i, pmlmeext->bcn_delay_cnt[i]
 687                                 //      ,i ,pmlmeext->bcn_delay_ratio[i]);
 688
 689                                 ratio_20_delay += pmlmeext->bcn_delay_ratio[i];
 690                                 ratio_80_delay += pmlmeext->bcn_delay_ratio[i];
 691
 692                                 if(ratio_20_delay > 20 && pmlmeext->DrvBcnEarly == 0xff)
 693                                 {
 694                                         pmlmeext->DrvBcnEarly = i;
 695                                         //DBG_871X("%s(): DrvBcnEarly = %d\n", __func__, pmlmeext->DrvBcnEarly);
 696                                 }
 697
 698                                 if(ratio_80_delay > 80 && pmlmeext->DrvBcnTimeOut == 0xff)
 699                                 {
 700                                         pmlmeext->DrvBcnTimeOut = i;
 701                                         //DBG_871X("%s(): DrvBcnTimeOut = %d\n", __func__, pmlmeext->DrvBcnTimeOut);
 702                                 }
 703
 704                                 //reset adaptive_early_32k cnt
 705                                 pmlmeext->bcn_delay_cnt[i] = 0;
 706                                 pmlmeext->bcn_delay_ratio[i] = 0;
 707
 708                         }
 709
 710                         pmlmeext->bcn_cnt = 0;
 711                         pmlmeext ->adaptive_tsf_done = _TRUE;
 712
 713                 }
 714                 else
 715                 {
 716                         //DBG_871X("%s(): DrvBcnEarly = %d\n", __func__, pmlmeext->DrvBcnEarly);
 717                         //DBG_871X("%s(): DrvBcnTimeOut = %d\n", __func__, pmlmeext->DrvBcnTimeOut);
 718                 }
 719
 720 /* offload to FW if fw version > v15.10
 721                 pmlmeext->DrvBcnEarly=0;
 722                 pmlmeext->DrvBcnTimeOut=7;
 723
 724                 if((pmlmeext->DrvBcnEarly!=0Xff) && (pmlmeext->DrvBcnTimeOut!=0xff))
 725                         u1H2CPwrModeParm[H2C_PWRMODE_LEN-1] = BIT(0) | ((pmlmeext->DrvBcnEarly<<1)&0x0E) |((pmlmeext->DrvBcnTimeOut<<4)&0xf0) ;
 726 */
 727
 728         }
 729 #endif
 730
 731 #ifdef CONFIG_BT_COEXIST
 732         rtw_btcoex_RecordPwrMode(padapter, u1H2CPwrModeParm, H2C_PWRMODE_LEN);
 733 #endif // CONFIG_BT_COEXIST
 734
 735         RT_PRINT_DATA(_module_hal_init_c_, _drv_always_, "u1H2CPwrModeParm:", u1H2CPwrModeParm, H2C_PWRMODE_LEN);
 736
 737         FillH2CCmd8723B(padapter, H2C_8723B_SET_PWR_MODE, H2C_PWRMODE_LEN, u1H2CPwrModeParm);
 738 _func_exit_;
 739 }
 740
 741 #ifdef CONFIG_TDLS
 742 #ifdef CONFIG_TDLS_CH_SW
 743 void rtl8723b_set_BcnEarly_C2H_Rpt_cmd(PADAPTER padapter, u8 enable)
 744 {
 745         u8      u1H2CSetPwrMode[H2C_PWRMODE_LEN] = {0};
 746
 747         SET_8723B_H2CCMD_PWRMODE_PARM_MODE(u1H2CSetPwrMode, 1);
 748         SET_8723B_H2CCMD_PWRMODE_PARM_RLBM(u1H2CSetPwrMode, 1);
 749         SET_8723B_H2CCMD_PWRMODE_PARM_SMART_PS(u1H2CSetPwrMode, 0);
 750         SET_8723B_H2CCMD_PWRMODE_PARM_BCN_PASS_TIME(u1H2CSetPwrMode, 0);
 751         SET_8723B_H2CCMD_PWRMODE_PARM_ALL_QUEUE_UAPSD(u1H2CSetPwrMode, 0);
 752         SET_8723B_H2CCMD_PWRMODE_PARM_BCN_EARLY_C2H_RPT(u1H2CSetPwrMode, enable);
 753         SET_8723B_H2CCMD_PWRMODE_PARM_PWR_STATE(u1H2CSetPwrMode, 0x0C);
 754         SET_8723B_H2CCMD_PWRMODE_PARM_BYTE5(u1H2CSetPwrMode, 0);
 755         FillH2CCmd8723B(padapter, H2C_8723B_SET_PWR_MODE, sizeof(u1H2CSetPwrMode), u1H2CSetPwrMode);
 756 }
 757 #endif
 758 #endif
 759
 760 void rtl8723b_set_FwPsTuneParam_cmd(PADAPTER padapter)
 761 {
 762         struct pwrctrl_priv *pwrpriv = adapter_to_pwrctl(padapter);
 763         u8 u1H2CPsTuneParm[H2C_PSTUNEPARAM_LEN]={0};
 764         u8 bcn_to_limit = 10; //10 * 100 * awakeinterval (ms)
 765         u8 dtim_timeout = 5; //ms //wait broadcast data timer
 766         u8 ps_timeout = 20;  //ms //Keep awake when tx
 767         u8 dtim_period = 3;
 768
 769 _func_enter_;
 770         //DBG_871X("%s(): FW LPS mode = %d\n", __func__, psmode);
 771
 772         SET_8723B_H2CCMD_PSTUNE_PARM_BCN_TO_LIMIT(u1H2CPsTuneParm, bcn_to_limit);
 773         SET_8723B_H2CCMD_PSTUNE_PARM_DTIM_TIMEOUT(u1H2CPsTuneParm, dtim_timeout);
 774         SET_8723B_H2CCMD_PSTUNE_PARM_PS_TIMEOUT(u1H2CPsTuneParm, ps_timeout);
 775         SET_8723B_H2CCMD_PSTUNE_PARM_ADOPT(u1H2CPsTuneParm, 1);
 776         SET_8723B_H2CCMD_PSTUNE_PARM_DTIM_PERIOD(u1H2CPsTuneParm, dtim_period);
 777
 778         RT_PRINT_DATA(_module_hal_init_c_, _drv_always_, "u1H2CPsTuneParm:", u1H2CPsTuneParm, H2C_PSTUNEPARAM_LEN);
 779
 780         FillH2CCmd8723B(padapter, H2C_8723B_PS_TUNING_PARA, H2C_PSTUNEPARAM_LEN, u1H2CPsTuneParm);
 781 _func_exit_;
 782 }
 783
 784 void rtl8723b_set_FwBtMpOper_cmd(PADAPTER padapter, u8 idx, u8 ver, u8 reqnum, u8 *param)
 785 {
 786         u8 u1H2CBtMpOperParm[H2C_BTMP_OPER_LEN] = {0};
 787
 788 _func_enter_;
 789
 790         DBG_8192C("%s: idx=%d ver=%d reqnum=%d param1=0x%02x param2=0x%02x\n", __FUNCTION__, idx, ver, reqnum, param[0], param[1]);
 791
 792         SET_8723B_H2CCMD_BT_MPOPER_VER(u1H2CBtMpOperParm, ver);
 793         SET_8723B_H2CCMD_BT_MPOPER_REQNUM(u1H2CBtMpOperParm, reqnum);
 794         SET_8723B_H2CCMD_BT_MPOPER_IDX(u1H2CBtMpOperParm, idx);
 795         SET_8723B_H2CCMD_BT_MPOPER_PARAM1(u1H2CBtMpOperParm, param[0]);
 796         SET_8723B_H2CCMD_BT_MPOPER_PARAM2(u1H2CBtMpOperParm, param[1]);
 797         SET_8723B_H2CCMD_BT_MPOPER_PARAM3(u1H2CBtMpOperParm, param[2]);
 798
 799         RT_PRINT_DATA(_module_hal_init_c_, _drv_always_, "u1H2CBtMpOperParm:", u1H2CBtMpOperParm, H2C_BTMP_OPER_LEN);
 800
 801         FillH2CCmd8723B(padapter, H2C_8723B_BT_MP_OPER, H2C_BTMP_OPER_LEN, u1H2CBtMpOperParm);
 802 _func_exit_;
 803 }
 804
 805 void rtl8723b_set_FwPwrModeInIPS_cmd(PADAPTER padapter, u8 cmd_param)
 806 {
 807         //u8 cmd_param; //BIT0:enable, BIT1:NoConnect32k
 808
 809         DBG_871X("%s()\n", __func__);
 810
 811         FillH2CCmd8723B(padapter, H2C_8723B_FWLPS_IN_IPS_, 1, &cmd_param);
 812
 813 }
 814
 815
 816 static s32 rtl8723b_set_FwLowPwrLps_cmd(PADAPTER padapter, u8 enable)
 817 {
 818         //TODO
 819         return _FALSE;
 820 }
 821
 822 void rtl8723b_download_rsvd_page(PADAPTER padapter, u8 mstatus)
 823 {
 824         HAL_DATA_TYPE   *pHalData = GET_HAL_DATA(padapter);
 825         struct mlme_ext_priv    *pmlmeext = &(padapter->mlmeextpriv);
 826         struct mlme_ext_info    *pmlmeinfo = &(pmlmeext->mlmext_info);
 827         struct pwrctrl_priv *pwrpriv = adapter_to_pwrctl(padapter);
 828         BOOLEAN         bcn_valid = _FALSE;
 829         u8      DLBcnCount=0;
 830         u32 poll = 0;
 831         u8 val8;
 832
 833 _func_enter_;
 834
 835         DBG_8192C("+" FUNC_ADPT_FMT ": iface_type=%d mstatus(%x)\n",
 836                 FUNC_ADPT_ARG(padapter), get_iface_type(padapter), mstatus);
 837
 838         if(mstatus == RT_MEDIA_CONNECT)
 839         {
 840                 BOOLEAN bRecover = _FALSE;
 841                 u8 v8;
 842
 843                 // We should set AID, correct TSF, HW seq enable before set JoinBssReport to Fw in 88/92C.
 844                 // Suggested by filen. Added by tynli.
 845                 rtw_write16(padapter, REG_BCN_PSR_RPT, (0xC000|pmlmeinfo->aid));
 846
 847                 // set REG_CR bit 8
 848                 v8 = rtw_read8(padapter, REG_CR+1);
 849                 v8 |= BIT(0); // ENSWBCN
 850                 rtw_write8(padapter,  REG_CR+1, v8);
 851
 852                 // Disable Hw protection for a time which revserd for Hw sending beacon.
 853                 // Fix download reserved page packet fail that access collision with the protection time.
 854                 // 2010.05.11. Added by tynli.
 855                 val8 = rtw_read8(padapter, REG_BCN_CTRL);
 856                 val8 &= ~EN_BCN_FUNCTION;
 857                 val8 |= DIS_TSF_UDT;
 858                 rtw_write8(padapter, REG_BCN_CTRL, val8);
 859
 860                 // Set FWHW_TXQ_CTRL 0x422[6]=0 to tell Hw the packet is not a real beacon frame.
 861                 if (pHalData->RegFwHwTxQCtrl & BIT(6))
 862                         bRecover = _TRUE;
 863
 864                 // To tell Hw the packet is not a real beacon frame.
 865                 rtw_write8(padapter, REG_FWHW_TXQ_CTRL+2, pHalData->RegFwHwTxQCtrl & ~BIT(6));
 866                 pHalData->RegFwHwTxQCtrl &= ~BIT(6);
 867
 868                 // Clear beacon valid check bit.
 869                 rtw_hal_set_hwreg(padapter, HW_VAR_BCN_VALID, NULL);
 870                 rtw_hal_set_hwreg(padapter, HW_VAR_DL_BCN_SEL, NULL);
 871
 872                 DLBcnCount = 0;
 873                 poll = 0;
 874                 do
 875                 {
 876                         // download rsvd page.
 877                         rtw_hal_set_fw_rsvd_page(padapter, 0);
 878                         DLBcnCount++;
 879                         do
 880                         {
 881                                 rtw_yield_os();
 882                                 //rtw_mdelay_os(10);
 883                                 // check rsvd page download OK.
 884                                 rtw_hal_get_hwreg(padapter, HW_VAR_BCN_VALID, (u8*)(&bcn_valid));
 885                                 poll++;
 886                         } while (!bcn_valid && (poll%10) != 0 && !RTW_CANNOT_RUN(padapter));
 887
 888                 } while (!bcn_valid && DLBcnCount <= 100 && !RTW_CANNOT_RUN(padapter));
 889
 890                 if (RTW_CANNOT_RUN(padapter))
 891                         ;
 892                 else if(!bcn_valid)
 893                         DBG_871X(ADPT_FMT": 1 DL RSVD page failed! DLBcnCount:%u, poll:%u\n",
 894                                 ADPT_ARG(padapter) ,DLBcnCount, poll);
 895                 else {
 896                         struct pwrctrl_priv *pwrctl = adapter_to_pwrctl(padapter);
 897                         pwrctl->fw_psmode_iface_id = padapter->iface_id;
 898                         DBG_871X(ADPT_FMT": 1 DL RSVD page success! DLBcnCount:%u, poll:%u\n",
 899                                 ADPT_ARG(padapter), DLBcnCount, poll);
 900                 }
 901
 902                 // 2010.05.11. Added by tynli.
 903                 val8 = rtw_read8(padapter, REG_BCN_CTRL);
 904                 val8 |= EN_BCN_FUNCTION;
 905                 val8 &= ~DIS_TSF_UDT;
 906                 rtw_write8(padapter, REG_BCN_CTRL, val8);
 907
 908                 // To make sure that if there exists an adapter which would like to send beacon.
 909                 // If exists, the origianl value of 0x422[6] will be 1, we should check this to
 910                 // prevent from setting 0x422[6] to 0 after download reserved page, or it will cause
 911                 // the beacon cannot be sent by HW.
 912                 // 2010.06.23. Added by tynli.
 913                 if(bRecover)
 914                 {
 915                         rtw_write8(padapter, REG_FWHW_TXQ_CTRL+2, pHalData->RegFwHwTxQCtrl | BIT(6));
 916                         pHalData->RegFwHwTxQCtrl |= BIT(6);
 917                 }
 918
 919                 // Clear CR[8] or beacon packet will not be send to TxBuf anymore.
 920 #ifndef CONFIG_PCI_HCI
 921                 v8 = rtw_read8(padapter, REG_CR+1);
 922                 v8 &= ~BIT(0); // ~ENSWBCN
 923                 rtw_write8(padapter, REG_CR+1, v8);
 924 #endif
 925         }
 926
 927 _func_exit_;
 928 }
 929
 930 void rtl8723b_set_rssi_cmd(_adapter*padapter, u8 *param)
 931 {
 932         rtl8723b_set_FwRssiSetting_cmd(padapter, param);
 933 }
 934
 935 void rtl8723b_set_FwJoinBssRpt_cmd(PADAPTER padapter, u8 mstatus)
 936 {
 937         struct sta_info *psta = NULL;
 938         struct pwrctrl_priv *ppwrpriv = adapter_to_pwrctl(padapter);
 939         struct mlme_priv        *pmlmepriv = &padapter->mlmepriv;
 940
 941         if(mstatus == 1)
 942                 rtl8723b_download_rsvd_page(padapter, RT_MEDIA_CONNECT);
 943 }
 944
 945 //arg[0] = macid
 946 //arg[1] = raid
 947 //arg[2] = shortGIrate
 948 //arg[3] = init_rate
 949 void rtl8723b_Add_RateATid(PADAPTER pAdapter, u64 rate_bitmap, u8 *arg, u8 rssi_level)
 950 {
 951         HAL_DATA_TYPE   *pHalData = GET_HAL_DATA(pAdapter);
 952         struct macid_ctl_t *macid_ctl = &pAdapter->dvobj->macid_ctl;
 953         struct sta_info *psta = NULL;
 954         u8 mac_id = arg[0];
 955         u8 raid = arg[1];
 956         u8 shortGI = arg[2];
 957         u8 bw;
 958         u32 bitmap = (u32) rate_bitmap;
 959         u32 mask = bitmap&0x0FFFFFFF;
 960
 961         if (mac_id < macid_ctl->num)
 962                 psta = macid_ctl->sta[mac_id];
 963         if (psta == NULL) {
 964                 DBG_871X_LEVEL(_drv_always_, FUNC_ADPT_FMT" macid:%u, sta is NULL\n"
 965                         , FUNC_ADPT_ARG(pAdapter), mac_id);
 966                 return;
 967         }
 968
 969         bw = psta->bw_mode;
 970
 971         if(rssi_level != DM_RATR_STA_INIT)
 972                 mask = ODM_Get_Rate_Bitmap(&pHalData->odmpriv, mac_id, mask, rssi_level);
 973
 974         DBG_871X("%s(): mac_id=%d raid=0x%x bw=%d mask=0x%x\n", __func__, mac_id, raid, bw, mask);
 975         rtl8723b_set_FwMacIdConfig_cmd(pAdapter, mac_id, raid, bw, shortGI, mask);
 976 }
 977
 978 #if 0
 979 void rtl8723b_fw_try_ap_cmd(PADAPTER padapter, u32 need_ack)
 980 {
 981         rtl8723b_set_FwAPReqRPT_cmd(padapter, need_ack);
 982 }
 983 #endif
 984
 985 #ifdef CONFIG_BT_COEXIST
 986 static void ConstructBtNullFunctionData(
 987         PADAPTER padapter,
 988         u8 *pframe,
 989         u32 *pLength,
 990         u8 *StaAddr,
 991         u8 bQoS,
 992         u8 AC,
 993         u8 bEosp,
 994         u8 bForcePowerSave)
 995 {
 996         struct rtw_ieee80211_hdr *pwlanhdr;
 997         u16 *fctrl;
 998         u32 pktlen;
 999         struct mlme_ext_priv *pmlmeext;
1000         struct mlme_ext_info *pmlmeinfo;
1001         u8 bssid[ETH_ALEN];
1002
1003
1004         DBG_871X("+" FUNC_ADPT_FMT ": qos=%d eosp=%d ps=%d\n",
1005                 FUNC_ADPT_ARG(padapter), bQoS, bEosp, bForcePowerSave);
1006
1007         pwlanhdr = (struct rtw_ieee80211_hdr*)pframe;
1008         pmlmeext = &padapter->mlmeextpriv;
1009         pmlmeinfo = &pmlmeext->mlmext_info;
1010
1011         if (NULL == StaAddr)
1012         {
1013                 _rtw_memcpy(bssid, adapter_mac_addr(padapter), ETH_ALEN);
1014                 StaAddr = bssid;
1015         }
1016
1017         fctrl = &pwlanhdr->frame_ctl;
1018         *fctrl = 0;
1019         if (bForcePowerSave)
1020                 SetPwrMgt(fctrl);
1021
1022         SetFrDs(fctrl);
1023         _rtw_memcpy(pwlanhdr->addr1, StaAddr, ETH_ALEN);
1024         _rtw_memcpy(pwlanhdr->addr2, adapter_mac_addr(padapter), ETH_ALEN);
1025         _rtw_memcpy(pwlanhdr->addr3, adapter_mac_addr(padapter), ETH_ALEN);
1026
1027         SetDuration(pwlanhdr, 0);
1028         SetSeqNum(pwlanhdr, 0);
1029
1030         if (bQoS == _TRUE)
1031         {
1032                 struct rtw_ieee80211_hdr_3addr_qos *pwlanqoshdr;
1033
1034                 SetFrameSubType(pframe, WIFI_QOS_DATA_NULL);
1035
1036                 pwlanqoshdr = (struct rtw_ieee80211_hdr_3addr_qos*)pframe;
1037                 SetPriority(&pwlanqoshdr->qc, AC);
1038                 SetEOSP(&pwlanqoshdr->qc, bEosp);
1039
1040                 pktlen = sizeof(struct rtw_ieee80211_hdr_3addr_qos);
1041         }
1042         else
1043         {
1044                 SetFrameSubType(pframe, WIFI_DATA_NULL);
1045
1046                 pktlen = sizeof(struct rtw_ieee80211_hdr_3addr);
1047         }
1048
1049         *pLength = pktlen;
1050 }
1051
1052 static void SetFwRsvdPagePkt_BTCoex(PADAPTER padapter)
1053 {
1054         PHAL_DATA_TYPE pHalData;
1055         struct xmit_frame *pcmdframe;
1056         struct pkt_attrib *pattrib;
1057         struct xmit_priv *pxmitpriv;
1058         struct mlme_ext_priv *pmlmeext;
1059         struct mlme_ext_info *pmlmeinfo;
1060         u32     BeaconLength = 0;
1061         u32     BTQosNullLength = 0;
1062         u8 *ReservedPagePacket;
1063         u8 TxDescLen, TxDescOffset;
1064         u8 TotalPageNum=0, CurtPktPageNum=0, RsvdPageNum=0;
1065         u16     BufIndex, PageSize;
1066         u32     TotalPacketLen, MaxRsvdPageBufSize=0;
1067         RSVDPAGE_LOC RsvdPageLoc;
1068
1069
1070 //      DBG_8192C("+" FUNC_ADPT_FMT "\n", FUNC_ADPT_ARG(padapter));
1071
1072         pHalData = GET_HAL_DATA(padapter);
1073         pxmitpriv = &padapter->xmitpriv;
1074         pmlmeext = &padapter->mlmeextpriv;
1075         pmlmeinfo = &pmlmeext->mlmext_info;
1076         TxDescLen = TXDESC_SIZE;
1077         TxDescOffset = TXDESC_OFFSET;
1078         PageSize = PAGE_SIZE_TX_8723B;
1079
1080         RsvdPageNum = BCNQ_PAGE_NUM_8723B;
1081         MaxRsvdPageBufSize = RsvdPageNum*PageSize;
1082
1083         pcmdframe = rtw_alloc_cmdxmitframe(pxmitpriv);
1084         if (pcmdframe == NULL) {
1085                 DBG_8192C("%s: alloc ReservedPagePacket fail!\n", __FUNCTION__);
1086                 return;
1087         }
1088
1089         ReservedPagePacket = pcmdframe->buf_addr;
1090         _rtw_memset(&RsvdPageLoc, 0, sizeof(RSVDPAGE_LOC));
1091
1092         //3 (1) beacon
1093         BufIndex = TxDescOffset;
1094         ConstructBeacon(padapter, &ReservedPagePacket[BufIndex], &BeaconLength);
1095
1096         // When we count the first page size, we need to reserve description size for the RSVD
1097         // packet, it will be filled in front of the packet in TXPKTBUF.
1098         CurtPktPageNum = (u8)PageNum_128(TxDescLen + BeaconLength);
1099         //If we don't add 1 more page, the WOWLAN function has a problem. Baron thinks it's a bug of firmware
1100         if (CurtPktPageNum == 1)
1101         {
1102                 CurtPktPageNum += 1;
1103         }
1104         TotalPageNum += CurtPktPageNum;
1105
1106         BufIndex += (CurtPktPageNum*PageSize);
1107
1108         // Jump to lastest page
1109         if (BufIndex < (MaxRsvdPageBufSize - PageSize))
1110         {
1111                 BufIndex = TxDescOffset + (MaxRsvdPageBufSize - PageSize);
1112                 TotalPageNum = BCNQ_PAGE_NUM_8723B - 1;
1113         }
1114
1115         //3 (6) BT Qos null data
1116         RsvdPageLoc.LocBTQosNull = TotalPageNum;
1117         ConstructBtNullFunctionData(
1118                 padapter,
1119                 &ReservedPagePacket[BufIndex],
1120                 &BTQosNullLength,
1121                 NULL,
1122                 _TRUE, 0, 0, _FALSE);
1123         rtl8723b_fill_fake_txdesc(padapter, &ReservedPagePacket[BufIndex-TxDescLen], BTQosNullLength, _FALSE, _TRUE, _FALSE);
1124
1125         CurtPktPageNum = (u8)PageNum_128(TxDescLen + BTQosNullLength);
1126
1127         TotalPageNum += CurtPktPageNum;
1128
1129         TotalPacketLen = BufIndex + BTQosNullLength;
1130         if (TotalPacketLen > MaxRsvdPageBufSize)
1131         {
1132                 DBG_8192C(FUNC_ADPT_FMT ": ERROR: The rsvd page size is not enough!!TotalPacketLen %d, MaxRsvdPageBufSize %d\n",
1133                         FUNC_ADPT_ARG(padapter), TotalPacketLen, MaxRsvdPageBufSize);
1134                 goto error;
1135         }
1136
1137         // update attribute
1138         pattrib = &pcmdframe->attrib;
1139         update_mgntframe_attrib(padapter, pattrib);
1140         pattrib->qsel = QSLT_BEACON;
1141         pattrib->pktlen = pattrib->last_txcmdsz = TotalPacketLen - TxDescOffset;
1142 #ifdef CONFIG_PCI_HCI
1143         dump_mgntframe(padapter, pcmdframe);
1144 #else
1145         dump_mgntframe_and_wait(padapter, pcmdframe, 100);
1146 #endif
1147
1148 //      DBG_8192C(FUNC_ADPT_FMT ": Set RSVD page location to Fw, TotalPacketLen(%d), TotalPageNum(%d)\n",
1149 //              FUNC_ADPT_ARG(padapter), TotalPacketLen, TotalPageNum);
1150         rtl8723b_set_FwRsvdPage_cmd(padapter, &RsvdPageLoc);
1151         rtl8723b_set_FwAoacRsvdPage_cmd(padapter, &RsvdPageLoc);
1152
1153         return;
1154
1155 error:
1156         rtw_free_xmitframe(pxmitpriv, pcmdframe);
1157 }
1158
1159 void rtl8723b_download_BTCoex_AP_mode_rsvd_page(PADAPTER padapter)
1160 {
1161         PHAL_DATA_TYPE pHalData;
1162         struct mlme_ext_priv *pmlmeext;
1163         struct mlme_ext_info *pmlmeinfo;
1164         u8 bRecover = _FALSE;
1165         u8 bcn_valid = _FALSE;
1166         u8 DLBcnCount = 0;
1167         u32 poll = 0;
1168         u8 val8;
1169
1170
1171         DBG_8192C("+" FUNC_ADPT_FMT ": iface_type=%d fw_state=0x%08X\n",
1172                 FUNC_ADPT_ARG(padapter), get_iface_type(padapter), get_fwstate(&padapter->mlmepriv));
1173
1174 #ifdef CONFIG_DEBUG
1175         if (check_fwstate(&padapter->mlmepriv, WIFI_AP_STATE) == _FALSE)
1176         {
1177                 DBG_8192C(FUNC_ADPT_FMT ": [WARNING] not in AP mode!!\n",
1178                         FUNC_ADPT_ARG(padapter));
1179         }
1180 #endif // CONFIG_DEBUG
1181
1182         pHalData = GET_HAL_DATA(padapter);
1183         pmlmeext = &padapter->mlmeextpriv;
1184         pmlmeinfo = &pmlmeext->mlmext_info;
1185
1186         // We should set AID, correct TSF, HW seq enable before set JoinBssReport to Fw in 88/92C.
1187         // Suggested by filen. Added by tynli.
1188         rtw_write16(padapter, REG_BCN_PSR_RPT, (0xC000|pmlmeinfo->aid));
1189
1190         // set REG_CR bit 8
1191         val8 = rtw_read8(padapter, REG_CR+1);
1192         val8 |= BIT(0); // ENSWBCN
1193         rtw_write8(padapter,  REG_CR+1, val8);
1194
1195         // Disable Hw protection for a time which revserd for Hw sending beacon.
1196         // Fix download reserved page packet fail that access collision with the protection time.
1197         // 2010.05.11. Added by tynli.
1198         val8 = rtw_read8(padapter, REG_BCN_CTRL);
1199         val8 &= ~EN_BCN_FUNCTION;
1200         val8 |= DIS_TSF_UDT;
1201         rtw_write8(padapter, REG_BCN_CTRL, val8);
1202
1203         // Set FWHW_TXQ_CTRL 0x422[6]=0 to tell Hw the packet is not a real beacon frame.
1204         if (pHalData->RegFwHwTxQCtrl & BIT(6))
1205                 bRecover = _TRUE;
1206
1207         // To tell Hw the packet is not a real beacon frame.
1208         pHalData->RegFwHwTxQCtrl &= ~BIT(6);
1209         rtw_write8(padapter, REG_FWHW_TXQ_CTRL+2, pHalData->RegFwHwTxQCtrl);
1210
1211         // Clear beacon valid check bit.
1212         rtw_hal_set_hwreg(padapter, HW_VAR_BCN_VALID, NULL);
1213         rtw_hal_set_hwreg(padapter, HW_VAR_DL_BCN_SEL, NULL);
1214
1215         DLBcnCount = 0;
1216         poll = 0;
1217         do {
1218                 SetFwRsvdPagePkt_BTCoex(padapter);
1219                 DLBcnCount++;
1220                 do {
1221                         rtw_yield_os();
1222 //                      rtw_mdelay_os(10);
1223                         // check rsvd page download OK.
1224                         rtw_hal_get_hwreg(padapter, HW_VAR_BCN_VALID, &bcn_valid);
1225                         poll++;
1226                 } while (!bcn_valid && (poll%10) != 0 && !RTW_CANNOT_RUN(padapter));
1227         } while (!bcn_valid && (DLBcnCount <= 100) && !RTW_CANNOT_RUN(padapter));
1228
1229         if (_TRUE == bcn_valid)
1230         {
1231                 struct pwrctrl_priv *pwrctl = adapter_to_pwrctl(padapter);
1232                 pwrctl->fw_psmode_iface_id = padapter->iface_id;
1233                 DBG_8192C(ADPT_FMT": DL RSVD page success! DLBcnCount:%d, poll:%d\n",
1234                         ADPT_ARG(padapter), DLBcnCount, poll);
1235         }
1236         else
1237         {
1238                 DBG_8192C(ADPT_FMT": DL RSVD page fail! DLBcnCount:%d, poll:%d\n",
1239                         ADPT_ARG(padapter), DLBcnCount, poll);
1240                 DBG_8192C(ADPT_FMT": DL RSVD page fail! bSurpriseRemoved=%s\n",
1241                         ADPT_ARG(padapter), rtw_is_surprise_removed(padapter)?"True":"False");
1242                 DBG_8192C(ADPT_FMT": DL RSVD page fail! bDriverStopped=%s\n",
1243                         ADPT_ARG(padapter), rtw_is_drv_stopped(padapter)?"True":"False");
1244         }
1245
1246         // 2010.05.11. Added by tynli.
1247         val8 = rtw_read8(padapter, REG_BCN_CTRL);
1248         val8 |= EN_BCN_FUNCTION;
1249         val8 &= ~DIS_TSF_UDT;
1250         rtw_write8(padapter, REG_BCN_CTRL, val8);
1251
1252         // To make sure that if there exists an adapter which would like to send beacon.
1253         // If exists, the origianl value of 0x422[6] will be 1, we should check this to
1254         // prevent from setting 0x422[6] to 0 after download reserved page, or it will cause
1255         // the beacon cannot be sent by HW.
1256         // 2010.06.23. Added by tynli.
1257         if (bRecover)
1258         {
1259                 pHalData->RegFwHwTxQCtrl |= BIT(6);
1260                 rtw_write8(padapter, REG_FWHW_TXQ_CTRL+2, pHalData->RegFwHwTxQCtrl);
1261         }
1262
1263         // Clear CR[8] or beacon packet will not be send to TxBuf anymore.
1264 #ifndef CONFIG_PCI_HCI
1265         val8 = rtw_read8(padapter, REG_CR+1);
1266         val8 &= ~BIT(0); // ~ENSWBCN
1267         rtw_write8(padapter, REG_CR+1, val8);
1268 #endif
1269 }
1270 #endif // CONFIG_BT_COEXIST
1271
1272 #ifdef CONFIG_P2P
1273 void rtl8723b_set_p2p_ps_offload_cmd(_adapter* padapter, u8 p2p_ps_state)
1274 {
1275         HAL_DATA_TYPE   *pHalData = GET_HAL_DATA(padapter);
1276         struct pwrctrl_priv             *pwrpriv = adapter_to_pwrctl(padapter);
1277         struct wifidirect_info  *pwdinfo = &( padapter->wdinfo );
1278         struct P2P_PS_Offload_t *p2p_ps_offload = (struct P2P_PS_Offload_t      *)(&pHalData->p2p_ps_offload);
1279         u8      i;
1280
1281 _func_enter_;
1282
1283 #if 1
1284         switch(p2p_ps_state)
1285         {
1286                 case P2P_PS_DISABLE:
1287                         DBG_8192C("P2P_PS_DISABLE \n");
1288                         _rtw_memset(p2p_ps_offload, 0 ,1);
1289                         break;
1290                 case P2P_PS_ENABLE:
1291                         DBG_8192C("P2P_PS_ENABLE \n");
1292                         // update CTWindow value.
1293                         if( pwdinfo->ctwindow > 0 )
1294                         {
1295                                 p2p_ps_offload->CTWindow_En = 1;
1296                                 rtw_write8(padapter, REG_P2P_CTWIN, pwdinfo->ctwindow);
1297                         }
1298
1299                         // hw only support 2 set of NoA
1300                         for( i=0 ; i<pwdinfo->noa_num ; i++)
1301                         {
1302                                 // To control the register setting for which NOA
1303                                 rtw_write8(padapter, REG_NOA_DESC_SEL, (i << 4));
1304                                 if(i == 0)
1305                                         p2p_ps_offload->NoA0_En = 1;
1306                                 else
1307                                         p2p_ps_offload->NoA1_En = 1;
1308
1309                                 // config P2P NoA Descriptor Register
1310                                 //DBG_8192C("%s(): noa_duration = %x\n",__FUNCTION__,pwdinfo->noa_duration[i]);
1311                                 rtw_write32(padapter, REG_NOA_DESC_DURATION, pwdinfo->noa_duration[i]);
1312
1313                                 //DBG_8192C("%s(): noa_interval = %x\n",__FUNCTION__,pwdinfo->noa_interval[i]);
1314                                 rtw_write32(padapter, REG_NOA_DESC_INTERVAL, pwdinfo->noa_interval[i]);
1315
1316                                 //DBG_8192C("%s(): start_time = %x\n",__FUNCTION__,pwdinfo->noa_start_time[i]);
1317                                 rtw_write32(padapter, REG_NOA_DESC_START, pwdinfo->noa_start_time[i]);
1318
1319                                 //DBG_8192C("%s(): noa_count = %x\n",__FUNCTION__,pwdinfo->noa_count[i]);
1320                                 rtw_write8(padapter, REG_NOA_DESC_COUNT, pwdinfo->noa_count[i]);
1321                         }
1322
1323                         if( (pwdinfo->opp_ps == 1) || (pwdinfo->noa_num > 0) )
1324                         {
1325                                 // rst p2p circuit
1326                                 rtw_write8(padapter, REG_DUAL_TSF_RST, BIT(4));
1327
1328                                 p2p_ps_offload->Offload_En = 1;
1329
1330                                 if(pwdinfo->role == P2P_ROLE_GO)
1331                                 {
1332                                         p2p_ps_offload->role= 1;
1333                                         p2p_ps_offload->AllStaSleep = 0;
1334                                 }
1335                                 else
1336                                 {
1337                                         p2p_ps_offload->role= 0;
1338                                 }
1339
1340                                 p2p_ps_offload->discovery = 0;
1341                         }
1342                         break;
1343                 case P2P_PS_SCAN:
1344                         DBG_8192C("P2P_PS_SCAN \n");
1345                         p2p_ps_offload->discovery = 1;
1346                         break;
1347                 case P2P_PS_SCAN_DONE:
1348                         DBG_8192C("P2P_PS_SCAN_DONE \n");
1349                         p2p_ps_offload->discovery = 0;
1350                         pwdinfo->p2p_ps_state = P2P_PS_ENABLE;
1351                         break;
1352                 default:
1353                         break;
1354         }
1355
1356         FillH2CCmd8723B(padapter, H2C_8723B_P2P_PS_OFFLOAD, 1, (u8 *)p2p_ps_offload);
1357 #endif
1358
1359 _func_exit_;
1360
1361 }
1362 #endif //CONFIG_P2P
1363
1364
1365 #ifdef CONFIG_TSF_RESET_OFFLOAD
1366 /*
1367         ask FW to Reset sync register at Beacon early interrupt
1368 */
1369 u8 rtl8723b_reset_tsf(_adapter *padapter, u8 reset_port )
1370 {
1371         u8      buf[2];
1372         u8      res=_SUCCESS;
1373
1374 _func_enter_;
1375         if (IFACE_PORT0==reset_port) {
1376                 buf[0] = 0x1; buf[1] = 0;
1377
1378         } else{
1379                 buf[0] = 0x0; buf[1] = 0x1;
1380         }
1381         FillH2CCmd8723B(padapter, H2C_8723B_RESET_TSF, 2, buf);
1382 _func_exit_;
1383
1384         return res;
1385 }
1386 #endif  // CONFIG_TSF_RESET_OFFLOAD
1387