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