drivers/staging/rtl8723bs/hal/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  ******************************************************************************/
  15 #define _RTL8723B_CMD_C_
  16
  17 #include <drv_types.h>
  18 #include <rtw_debug.h>
  19 #include <rtl8723b_hal.h>
  20 #include "hal_com_h2c.h"
  21
  22 #define MAX_H2C_BOX_NUMS        4
  23 #define MESSAGE_BOX_SIZE                4
  24
  25 #define RTL8723B_MAX_CMD_LEN    7
  26 #define RTL8723B_EX_MESSAGE_BOX_SIZE    4
  27
  28 static u8 _is_fw_read_cmd_down(struct adapter *padapter, u8 msgbox_num)
  29 {
  30         u8 read_down = false;
  31         int     retry_cnts = 100;
  32
  33         u8 valid;
  34
  35         /* DBG_8192C(" _is_fw_read_cmd_down , reg_1cc(%x), msg_box(%d)...\n", rtw_read8(padapter, REG_HMETFR), msgbox_num); */
  36
  37         do{
  38                 valid = rtw_read8(padapter, REG_HMETFR) & BIT(msgbox_num);
  39                 if (0 == valid) {
  40                         read_down = true;
  41                 }
  42 #ifdef CONFIG_WOWLAN
  43                 else
  44                         msleep(1);
  45 #endif
  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 FillH2CCmd8723B(struct adapter *padapter, u8 ElementID, u32 CmdLen, u8 *pCmdBuffer)
  62 {
  63         u8 h2c_box_num;
  64         u32 msgbox_addr;
  65         u32 msgbox_ex_addr = 0;
  66         struct hal_com_data *pHalData;
  67         u32 h2c_cmd = 0;
  68         u32 h2c_cmd_ex = 0;
  69         s32 ret = _FAIL;
  70
  71         padapter = GET_PRIMARY_ADAPTER(padapter);
  72         pHalData = GET_HAL_DATA(padapter);
  73         if (mutex_lock_interruptible(&(adapter_to_dvobj(padapter)->h2c_fwcmd_mutex)))
  74                 return ret;
  75
  76         if (!pCmdBuffer) {
  77                 goto exit;
  78         }
  79         if (CmdLen > RTL8723B_MAX_CMD_LEN) {
  80                 goto exit;
  81         }
  82         if (padapter->bSurpriseRemoved == true)
  83                 goto exit;
  84
  85         /* pay attention to if  race condition happened in  H2C cmd setting. */
  86         do{
  87                 h2c_box_num = pHalData->LastHMEBoxNum;
  88
  89                 if (!_is_fw_read_cmd_down(padapter, h2c_box_num)) {
  90                         DBG_8192C(" fw read cmd failed...\n");
  91                         /* DBG_8192C(" 0x1c0: 0x%8x\n", rtw_read32(padapter, 0x1c0)); */
  92                         /* DBG_8192C(" 0x1c4: 0x%8x\n", rtw_read32(padapter, 0x1c4)); */
  93                         goto exit;
  94                 }
  95
  96                 if (CmdLen<=3)
  97                 {
  98                         memcpy((u8 *)(&h2c_cmd)+1, pCmdBuffer, CmdLen);
  99                 }
 100                 else {
 101                         memcpy((u8 *)(&h2c_cmd)+1, pCmdBuffer, 3);
 102                         memcpy((u8 *)(&h2c_cmd_ex), pCmdBuffer+3, CmdLen-3);
 103 /*                      *(u8 *)(&h2c_cmd) |= BIT(7); */
 104                 }
 105
 106                 *(u8 *)(&h2c_cmd) |= ElementID;
 107
 108                 if (CmdLen>3) {
 109                         msgbox_ex_addr = REG_HMEBOX_EXT0_8723B + (h2c_box_num *RTL8723B_EX_MESSAGE_BOX_SIZE);
 110                         rtw_write32(padapter, msgbox_ex_addr, h2c_cmd_ex);
 111                 }
 112                 msgbox_addr =REG_HMEBOX_0 + (h2c_box_num *MESSAGE_BOX_SIZE);
 113                 rtw_write32(padapter, msgbox_addr, h2c_cmd);
 114
 115                 /* 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" */
 116                 /*      , pHalData->LastHMEBoxNum , CmdLen, ElementID, msgbox_addr, h2c_cmd, msgbox_ex_addr, h2c_cmd_ex); */
 117
 118                 pHalData->LastHMEBoxNum = (h2c_box_num+1) % MAX_H2C_BOX_NUMS;
 119
 120         }while (0);
 121
 122         ret = _SUCCESS;
 123
 124 exit:
 125
 126         mutex_unlock(&(adapter_to_dvobj(padapter)->h2c_fwcmd_mutex));
 127         return ret;
 128 }
 129
 130 static void ConstructBeacon(struct adapter *padapter, u8 *pframe, u32 *pLength)
 131 {
 132         struct ieee80211_hdr    *pwlanhdr;
 133         __le16 *fctrl;
 134         u32                             rate_len, pktlen;
 135         struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
 136         struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
 137         struct wlan_bssid_ex            *cur_network = &(pmlmeinfo->network);
 138         u8 bc_addr[] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
 139
 140
 141         /* DBG_871X("%s\n", __func__); */
 142
 143         pwlanhdr = (struct ieee80211_hdr *)pframe;
 144
 145         fctrl = &(pwlanhdr->frame_control);
 146         *(fctrl) = 0;
 147
 148         memcpy(pwlanhdr->addr1, bc_addr, ETH_ALEN);
 149         memcpy(pwlanhdr->addr2, myid(&(padapter->eeprompriv)), ETH_ALEN);
 150         memcpy(pwlanhdr->addr3, get_my_bssid(cur_network), ETH_ALEN);
 151
 152         SetSeqNum(pwlanhdr, 0/*pmlmeext->mgnt_seq*/);
 153         /* pmlmeext->mgnt_seq++; */
 154         SetFrameSubType(pframe, WIFI_BEACON);
 155
 156         pframe += sizeof(struct ieee80211_hdr_3addr);
 157         pktlen = sizeof (struct ieee80211_hdr_3addr);
 158
 159         /* timestamp will be inserted by hardware */
 160         pframe += 8;
 161         pktlen += 8;
 162
 163         /*  beacon interval: 2 bytes */
 164         memcpy(pframe, (unsigned char *)(rtw_get_beacon_interval_from_ie(cur_network->IEs)), 2);
 165
 166         pframe += 2;
 167         pktlen += 2;
 168
 169         /*  capability info: 2 bytes */
 170         memcpy(pframe, (unsigned char *)(rtw_get_capability_from_ie(cur_network->IEs)), 2);
 171
 172         pframe += 2;
 173         pktlen += 2;
 174
 175         if ((pmlmeinfo->state&0x03) == WIFI_FW_AP_STATE)
 176         {
 177                 /* DBG_871X("ie len =%d\n", cur_network->IELength); */
 178                 pktlen += cur_network->IELength - sizeof(struct ndis_802_11_fix_ie);
 179                 memcpy(pframe, cur_network->IEs+sizeof(struct ndis_802_11_fix_ie), pktlen);
 180
 181                 goto _ConstructBeacon;
 182         }
 183
 184         /* below for ad-hoc mode */
 185
 186         /*  SSID */
 187         pframe = rtw_set_ie(pframe, _SSID_IE_, cur_network->Ssid.SsidLength, cur_network->Ssid.Ssid, &pktlen);
 188
 189         /*  supported rates... */
 190         rate_len = rtw_get_rateset_len(cur_network->SupportedRates);
 191         pframe = rtw_set_ie(pframe, _SUPPORTEDRATES_IE_, ((rate_len > 8)? 8: rate_len), cur_network->SupportedRates, &pktlen);
 192
 193         /*  DS parameter set */
 194         pframe = rtw_set_ie(pframe, _DSSET_IE_, 1, (unsigned char *)&(cur_network->Configuration.DSConfig), &pktlen);
 195
 196         if ((pmlmeinfo->state&0x03) == WIFI_FW_ADHOC_STATE)
 197         {
 198                 u32 ATIMWindow;
 199                 /*  IBSS Parameter Set... */
 200                 /* ATIMWindow = cur->Configuration.ATIMWindow; */
 201                 ATIMWindow = 0;
 202                 pframe = rtw_set_ie(pframe, _IBSS_PARA_IE_, 2, (unsigned char *)(&ATIMWindow), &pktlen);
 203         }
 204
 205
 206         /* todo: ERP IE */
 207
 208
 209         /*  EXTERNDED SUPPORTED RATE */
 210         if (rate_len > 8)
 211         {
 212                 pframe = rtw_set_ie(pframe, _EXT_SUPPORTEDRATES_IE_, (rate_len - 8), (cur_network->SupportedRates + 8), &pktlen);
 213         }
 214
 215
 216         /* todo:HT for adhoc */
 217
 218 _ConstructBeacon:
 219
 220         if ((pktlen + TXDESC_SIZE) > 512)
 221         {
 222                 DBG_871X("beacon frame too large\n");
 223                 return;
 224         }
 225
 226         *pLength = pktlen;
 227
 228         /* DBG_871X("%s bcn_sz =%d\n", __func__, pktlen); */
 229
 230 }
 231
 232 static void ConstructPSPoll(struct adapter *padapter, u8 *pframe, u32 *pLength)
 233 {
 234         struct ieee80211_hdr    *pwlanhdr;
 235         __le16 *fctrl;
 236         struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
 237         struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
 238
 239         /* DBG_871X("%s\n", __func__); */
 240
 241         pwlanhdr = (struct ieee80211_hdr *)pframe;
 242
 243         /*  Frame control. */
 244         fctrl = &(pwlanhdr->frame_control);
 245         *(fctrl) = 0;
 246         SetPwrMgt(fctrl);
 247         SetFrameSubType(pframe, WIFI_PSPOLL);
 248
 249         /*  AID. */
 250         SetDuration(pframe, (pmlmeinfo->aid | 0xc000));
 251
 252         /*  BSSID. */
 253         memcpy(pwlanhdr->addr1, get_my_bssid(&(pmlmeinfo->network)), ETH_ALEN);
 254
 255         /*  TA. */
 256         memcpy(pwlanhdr->addr2, myid(&(padapter->eeprompriv)), ETH_ALEN);
 257
 258         *pLength = 16;
 259 }
 260
 261 static void ConstructNullFunctionData(
 262         struct adapter *padapter,
 263         u8 *pframe,
 264         u32     *pLength,
 265         u8 *StaAddr,
 266         u8 bQoS,
 267         u8 AC,
 268         u8 bEosp,
 269         u8 bForcePowerSave)
 270 {
 271         struct ieee80211_hdr    *pwlanhdr;
 272         __le16 *fctrl;
 273         u32                                     pktlen;
 274         struct mlme_priv        *pmlmepriv = &padapter->mlmepriv;
 275         struct wlan_network             *cur_network = &pmlmepriv->cur_network;
 276         struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
 277         struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
 278
 279
 280         /* DBG_871X("%s:%d\n", __func__, bForcePowerSave); */
 281
 282         pwlanhdr = (struct ieee80211_hdr*)pframe;
 283
 284         fctrl = &pwlanhdr->frame_control;
 285         *(fctrl) = 0;
 286         if (bForcePowerSave)
 287         {
 288                 SetPwrMgt(fctrl);
 289         }
 290
 291         switch (cur_network->network.InfrastructureMode)
 292         {
 293                 case Ndis802_11Infrastructure:
 294                         SetToDs(fctrl);
 295                         memcpy(pwlanhdr->addr1, get_my_bssid(&(pmlmeinfo->network)), ETH_ALEN);
 296                         memcpy(pwlanhdr->addr2, myid(&(padapter->eeprompriv)), ETH_ALEN);
 297                         memcpy(pwlanhdr->addr3, StaAddr, ETH_ALEN);
 298                         break;
 299                 case Ndis802_11APMode:
 300                         SetFrDs(fctrl);
 301                         memcpy(pwlanhdr->addr1, StaAddr, ETH_ALEN);
 302                         memcpy(pwlanhdr->addr2, get_my_bssid(&(pmlmeinfo->network)), ETH_ALEN);
 303                         memcpy(pwlanhdr->addr3, myid(&(padapter->eeprompriv)), ETH_ALEN);
 304                         break;
 305                 case Ndis802_11IBSS:
 306                 default:
 307                         memcpy(pwlanhdr->addr1, StaAddr, ETH_ALEN);
 308                         memcpy(pwlanhdr->addr2, myid(&(padapter->eeprompriv)), ETH_ALEN);
 309                         memcpy(pwlanhdr->addr3, get_my_bssid(&(pmlmeinfo->network)), ETH_ALEN);
 310                         break;
 311         }
 312
 313         SetSeqNum(pwlanhdr, 0);
 314
 315         if (bQoS == true) {
 316                 struct ieee80211_qos_hdr *pwlanqoshdr;
 317
 318                 SetFrameSubType(pframe, WIFI_QOS_DATA_NULL);
 319
 320                 pwlanqoshdr = (struct ieee80211_qos_hdr*)pframe;
 321                 SetPriority(&pwlanqoshdr->qos_ctrl, AC);
 322                 SetEOSP(&pwlanqoshdr->qos_ctrl, bEosp);
 323
 324                 pktlen = sizeof(struct ieee80211_qos_hdr);
 325         } else {
 326                 SetFrameSubType(pframe, WIFI_DATA_NULL);
 327
 328                 pktlen = sizeof(struct ieee80211_hdr_3addr);
 329         }
 330
 331         *pLength = pktlen;
 332 }
 333
 334
 335 #ifdef CONFIG_WOWLAN
 336 /*  */
 337 /*  Description: */
 338 /*      Construct the ARP response packet to support ARP offload. */
 339 /*  */
 340 static void ConstructARPResponse(
 341         struct adapter *padapter,
 342         u8      *pframe,
 343         u32             *pLength,
 344         u8      *pIPAddress
 345         )
 346 {
 347         struct ieee80211_hdr    *pwlanhdr;
 348         __le16 *fctrl;
 349         struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
 350         struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
 351         struct security_priv *psecuritypriv = &padapter->securitypriv;
 352         static u8       ARPLLCHeader[8] = {0xAA, 0xAA, 0x03, 0x00, 0x00, 0x00, 0x08, 0x06};
 353         u8              *pARPRspPkt = pframe;
 354         /* for TKIP Cal MIC */
 355         u8              *payload = pframe;
 356         u8      EncryptionHeadOverhead = 0;
 357         /* DBG_871X("%s:%d\n", __func__, bForcePowerSave); */
 358
 359         pwlanhdr = (struct ieee80211_hdr*)pframe;
 360
 361         fctrl = &pwlanhdr->frame_control;
 362         *(fctrl) = 0;
 363
 364         /*  */
 365         /*  MAC Header. */
 366         /*  */
 367         SetFrameType(fctrl, WIFI_DATA);
 368         /* SetFrameSubType(fctrl, 0); */
 369         SetToDs(fctrl);
 370         memcpy(pwlanhdr->addr1, get_my_bssid(&(pmlmeinfo->network)), ETH_ALEN);
 371         memcpy(pwlanhdr->addr2, myid(&(padapter->eeprompriv)), ETH_ALEN);
 372         memcpy(pwlanhdr->addr3, get_my_bssid(&(pmlmeinfo->network)), ETH_ALEN);
 373
 374         SetSeqNum(pwlanhdr, 0);
 375         SetDuration(pwlanhdr, 0);
 376         /* SET_80211_HDR_FRAME_CONTROL(pARPRspPkt, 0); */
 377         /* SET_80211_HDR_TYPE_AND_SUBTYPE(pARPRspPkt, Type_Data); */
 378         /* SET_80211_HDR_TO_DS(pARPRspPkt, 1); */
 379         /* SET_80211_HDR_ADDRESS1(pARPRspPkt, pMgntInfo->Bssid); */
 380         /* SET_80211_HDR_ADDRESS2(pARPRspPkt, Adapter->CurrentAddress); */
 381         /* SET_80211_HDR_ADDRESS3(pARPRspPkt, pMgntInfo->Bssid); */
 382
 383         /* SET_80211_HDR_DURATION(pARPRspPkt, 0); */
 384         /* SET_80211_HDR_FRAGMENT_SEQUENCE(pARPRspPkt, 0); */
 385         *pLength = 24;
 386
 387         /*  */
 388         /*  Security Header: leave space for it if necessary. */
 389         /*  */
 390
 391         switch (psecuritypriv->dot11PrivacyAlgrthm)
 392         {
 393                 case _WEP40_:
 394                 case _WEP104_:
 395                         EncryptionHeadOverhead = 4;
 396                         break;
 397                 case _TKIP_:
 398                         EncryptionHeadOverhead = 8;
 399                         break;
 400                 case _AES_:
 401                         EncryptionHeadOverhead = 8;
 402                         break;
 403                 default:
 404                         EncryptionHeadOverhead = 0;
 405         }
 406
 407         if (EncryptionHeadOverhead > 0)
 408         {
 409                 memset(&(pframe[*pLength]), 0, EncryptionHeadOverhead);
 410                 *pLength += EncryptionHeadOverhead;
 411                 SetPrivacy(fctrl);
 412         }
 413
 414         /*  */
 415         /*  Frame Body. */
 416         /*  */
 417         pARPRspPkt =  (u8 *)(pframe+ *pLength);
 418         payload = pARPRspPkt; /* Get Payload pointer */
 419         /*  LLC header */
 420         memcpy(pARPRspPkt, ARPLLCHeader, 8);
 421         *pLength += 8;
 422
 423         /*  ARP element */
 424         pARPRspPkt += 8;
 425         SET_ARP_PKT_HW(pARPRspPkt, 0x0100);
 426         SET_ARP_PKT_PROTOCOL(pARPRspPkt, 0x0008);       /*  IP protocol */
 427         SET_ARP_PKT_HW_ADDR_LEN(pARPRspPkt, 6);
 428         SET_ARP_PKT_PROTOCOL_ADDR_LEN(pARPRspPkt, 4);
 429         SET_ARP_PKT_OPERATION(pARPRspPkt, 0x0200); /*  ARP response */
 430         SET_ARP_PKT_SENDER_MAC_ADDR(pARPRspPkt, myid(&(padapter->eeprompriv)));
 431         SET_ARP_PKT_SENDER_IP_ADDR(pARPRspPkt, pIPAddress);
 432         {
 433                 SET_ARP_PKT_TARGET_MAC_ADDR(pARPRspPkt, get_my_bssid(&(pmlmeinfo->network)));
 434                 SET_ARP_PKT_TARGET_IP_ADDR(pARPRspPkt, pIPAddress);
 435                 DBG_871X("%s Target Mac Addr:" MAC_FMT "\n", __func__, MAC_ARG(get_my_bssid(&(pmlmeinfo->network))));
 436                 DBG_871X("%s Target IP Addr" IP_FMT "\n", __func__, IP_ARG(pIPAddress));
 437         }
 438
 439         *pLength += 28;
 440
 441         if (psecuritypriv->dot11PrivacyAlgrthm == _TKIP_)
 442         {
 443                 u8 mic[8];
 444                 struct mic_data micdata;
 445                 struct sta_info *psta = NULL;
 446                 u8 priority[4]={0x0, 0x0, 0x0, 0x0};
 447                 u8 null_key[16]={0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0};
 448
 449                 DBG_871X("%s(): Add MIC\n", __func__);
 450
 451                 psta = rtw_get_stainfo(&padapter->stapriv, get_my_bssid(&(pmlmeinfo->network)));
 452                 if (psta != NULL) {
 453                         if (!memcmp(&psta->dot11tkiptxmickey.skey[0], null_key, 16)) {
 454                                 DBG_871X("%s(): STA dot11tkiptxmickey == 0\n", __func__);
 455                         }
 456                         /* start to calculate the mic code */
 457                         rtw_secmicsetkey(&micdata, &psta->dot11tkiptxmickey.skey[0]);
 458                 }
 459
 460                 rtw_secmicappend(&micdata, pwlanhdr->addr3, 6);  /* DA */
 461
 462                 rtw_secmicappend(&micdata, pwlanhdr->addr2, 6); /* SA */
 463
 464                 priority[0]= 0;
 465                 rtw_secmicappend(&micdata, &priority[0], 4);
 466
 467                 rtw_secmicappend(&micdata, payload, 36); /* payload length = 8 + 28 */
 468
 469                 rtw_secgetmic(&micdata,&(mic[0]));
 470
 471                 pARPRspPkt += 28;
 472                 memcpy(pARPRspPkt, &(mic[0]), 8);
 473
 474                 *pLength += 8;
 475         }
 476 }
 477
 478 #ifdef CONFIG_PNO_SUPPORT
 479 static void ConstructPnoInfo(
 480         struct adapter *padapter,
 481         u8      *pframe,
 482         u32             *pLength
 483         )
 484 {
 485
 486         struct pwrctrl_priv *pwrctl = adapter_to_pwrctl(padapter);
 487
 488         u8 *pPnoInfoPkt = pframe;
 489         pPnoInfoPkt =  (u8 *)(pframe+ *pLength);
 490         memcpy(pPnoInfoPkt, &pwrctl->pnlo_info->ssid_num, 4);
 491
 492         *pLength+=4;
 493         pPnoInfoPkt += 4;
 494         memcpy(pPnoInfoPkt, &pwrctl->pnlo_info->fast_scan_period, 4);
 495
 496         *pLength+=4;
 497         pPnoInfoPkt += 4;
 498         memcpy(pPnoInfoPkt, &pwrctl->pnlo_info->fast_scan_iterations, 4);
 499
 500         *pLength+=4;
 501         pPnoInfoPkt += 4;
 502         memcpy(pPnoInfoPkt, &pwrctl->pnlo_info->slow_scan_period, 4);
 503
 504         *pLength+=4;
 505         pPnoInfoPkt += 4;
 506         memcpy(pPnoInfoPkt, &pwrctl->pnlo_info->ssid_length,
 507                         MAX_PNO_LIST_COUNT);
 508
 509         *pLength+=MAX_PNO_LIST_COUNT;
 510         pPnoInfoPkt += MAX_PNO_LIST_COUNT;
 511         memcpy(pPnoInfoPkt, &pwrctl->pnlo_info->ssid_cipher_info,
 512                         MAX_PNO_LIST_COUNT);
 513
 514         *pLength+=MAX_PNO_LIST_COUNT;
 515         pPnoInfoPkt += MAX_PNO_LIST_COUNT;
 516         memcpy(pPnoInfoPkt, &pwrctl->pnlo_info->ssid_channel_info,
 517                         MAX_PNO_LIST_COUNT);
 518
 519         *pLength+=MAX_PNO_LIST_COUNT;
 520         pPnoInfoPkt += MAX_PNO_LIST_COUNT;
 521 }
 522
 523 static void ConstructSSIDList(
 524         struct adapter *padapter,
 525         u8      *pframe,
 526         u32             *pLength
 527         )
 528 {
 529         int i = 0;
 530         u8 *pSSIDListPkt = pframe;
 531         struct pwrctrl_priv *pwrctl = adapter_to_pwrctl(padapter);
 532
 533         pSSIDListPkt =  (u8 *)(pframe+ *pLength);
 534
 535         for (i = 0; i < pwrctl->pnlo_info->ssid_num ; i++) {
 536                 memcpy(pSSIDListPkt, &pwrctl->pno_ssid_list->node[i].SSID,
 537                         pwrctl->pnlo_info->ssid_length[i]);
 538
 539                 *pLength += WLAN_SSID_MAXLEN;
 540                 pSSIDListPkt += WLAN_SSID_MAXLEN;
 541         }
 542 }
 543
 544 static void ConstructScanInfo(
 545         struct adapter *padapter,
 546         u8      *pframe,
 547         u32             *pLength
 548         )
 549 {
 550         int i = 0;
 551         u8 *pScanInfoPkt = pframe;
 552         struct pwrctrl_priv *pwrctl = adapter_to_pwrctl(padapter);
 553
 554         pScanInfoPkt =  (u8 *)(pframe+ *pLength);
 555
 556         memcpy(pScanInfoPkt, &pwrctl->pscan_info->channel_num, 1);
 557
 558         *pLength+= 1;
 559         pScanInfoPkt += 1;
 560         memcpy(pScanInfoPkt, &pwrctl->pscan_info->orig_ch, 1);
 561
 562
 563         *pLength+= 1;
 564         pScanInfoPkt += 1;
 565         memcpy(pScanInfoPkt, &pwrctl->pscan_info->orig_bw, 1);
 566
 567
 568         *pLength+= 1;
 569         pScanInfoPkt += 1;
 570         memcpy(pScanInfoPkt, &pwrctl->pscan_info->orig_40_offset, 1);
 571
 572         *pLength+= 1;
 573         pScanInfoPkt += 1;
 574         memcpy(pScanInfoPkt, &pwrctl->pscan_info->orig_80_offset, 1);
 575
 576         *pLength+= 1;
 577         pScanInfoPkt += 1;
 578         memcpy(pScanInfoPkt, &pwrctl->pscan_info->periodScan, 1);
 579
 580         *pLength+= 1;
 581         pScanInfoPkt += 1;
 582         memcpy(pScanInfoPkt, &pwrctl->pscan_info->period_scan_time, 1);
 583
 584         *pLength+= 1;
 585         pScanInfoPkt += 1;
 586         memcpy(pScanInfoPkt, &pwrctl->pscan_info->enableRFE, 1);
 587
 588         *pLength+= 1;
 589         pScanInfoPkt += 1;
 590         memcpy(pScanInfoPkt, &pwrctl->pscan_info->rfe_type, 8);
 591
 592         *pLength+=8;
 593         pScanInfoPkt += 8;
 594
 595         for (i = 0 ; i < MAX_SCAN_LIST_COUNT ; i ++) {
 596                 memcpy(pScanInfoPkt,
 597                         &pwrctl->pscan_info->ssid_channel_info[i], 4);
 598                 *pLength+=4;
 599                 pScanInfoPkt += 4;
 600         }
 601 }
 602 #endif
 603
 604 #ifdef CONFIG_GTK_OL
 605 static void ConstructGTKResponse(
 606         struct adapter *padapter,
 607         u8      *pframe,
 608         u32             *pLength
 609         )
 610 {
 611         struct ieee80211_hdr    *pwlanhdr;
 612         u16                                     *fctrl;
 613         struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
 614         struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
 615         struct security_priv *psecuritypriv = &padapter->securitypriv;
 616         static u8       LLCHeader[8] = {0xAA, 0xAA, 0x03, 0x00, 0x00, 0x00, 0x88, 0x8E};
 617         static u8       GTKbody_a[11] ={0x01, 0x03, 0x00, 0x5F, 0x02, 0x03, 0x12, 0x00, 0x10, 0x42, 0x0B};
 618         u8              *pGTKRspPkt = pframe;
 619         u8      EncryptionHeadOverhead = 0;
 620         /* DBG_871X("%s:%d\n", __func__, bForcePowerSave); */
 621
 622         pwlanhdr = (struct ieee80211_hdr*)pframe;
 623
 624         fctrl = &pwlanhdr->frame_control;
 625         *(fctrl) = 0;
 626
 627         /*  */
 628         /*  MAC Header. */
 629         /*  */
 630         SetFrameType(fctrl, WIFI_DATA);
 631         /* SetFrameSubType(fctrl, 0); */
 632         SetToDs(fctrl);
 633         memcpy(pwlanhdr->addr1, get_my_bssid(&(pmlmeinfo->network)), ETH_ALEN);
 634         memcpy(pwlanhdr->addr2, myid(&(padapter->eeprompriv)), ETH_ALEN);
 635         memcpy(pwlanhdr->addr3, get_my_bssid(&(pmlmeinfo->network)), ETH_ALEN);
 636
 637         SetSeqNum(pwlanhdr, 0);
 638         SetDuration(pwlanhdr, 0);
 639
 640         *pLength = 24;
 641
 642         /*  */
 643         /*  Security Header: leave space for it if necessary. */
 644         /*  */
 645
 646         switch (psecuritypriv->dot11PrivacyAlgrthm)
 647         {
 648                 case _WEP40_:
 649                 case _WEP104_:
 650                         EncryptionHeadOverhead = 4;
 651                         break;
 652                 case _TKIP_:
 653                         EncryptionHeadOverhead = 8;
 654                         break;
 655                 case _AES_:
 656                         EncryptionHeadOverhead = 8;
 657                         break;
 658                 default:
 659                         EncryptionHeadOverhead = 0;
 660         }
 661
 662         if (EncryptionHeadOverhead > 0)
 663         {
 664                 memset(&(pframe[*pLength]), 0, EncryptionHeadOverhead);
 665                 *pLength += EncryptionHeadOverhead;
 666                 /* GTK's privacy bit is done by FW */
 667                 /* SetPrivacy(fctrl); */
 668         }
 669
 670         /*  */
 671         /*  Frame Body. */
 672         /*  */
 673         pGTKRspPkt =  (u8 *)(pframe+ *pLength);
 674         /*  LLC header */
 675         memcpy(pGTKRspPkt, LLCHeader, 8);
 676         *pLength += 8;
 677
 678         /*  GTK element */
 679         pGTKRspPkt += 8;
 680
 681         /* GTK frame body after LLC, part 1 */
 682         memcpy(pGTKRspPkt, GTKbody_a, 11);
 683         *pLength += 11;
 684         pGTKRspPkt += 11;
 685         /* GTK frame body after LLC, part 2 */
 686         memset(&(pframe[*pLength]), 0, 88);
 687         *pLength += 88;
 688         pGTKRspPkt += 88;
 689
 690 }
 691 #endif /* CONFIG_GTK_OL */
 692
 693 #ifdef CONFIG_PNO_SUPPORT
 694 static void ConstructProbeReq(struct adapter *padapter, u8 *pframe, u32 *pLength)
 695 {
 696         struct ieee80211_hdr    *pwlanhdr;
 697         u16                     *fctrl;
 698         u32                     pktlen;
 699         unsigned char           *mac;
 700         unsigned char           bssrate[NumRates];
 701         struct xmit_priv        *pxmitpriv = &(padapter->xmitpriv);
 702         struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
 703         struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
 704         struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
 705         int     bssrate_len = 0;
 706         u8 bc_addr[] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
 707
 708         pwlanhdr = (struct ieee80211_hdr *)pframe;
 709         mac = myid(&(padapter->eeprompriv));
 710
 711         fctrl = &(pwlanhdr->frame_control);
 712         *(fctrl) = 0;
 713
 714         /* broadcast probe request frame */
 715         memcpy(pwlanhdr->addr1, bc_addr, ETH_ALEN);
 716         memcpy(pwlanhdr->addr3, bc_addr, ETH_ALEN);
 717
 718         memcpy(pwlanhdr->addr2, mac, ETH_ALEN);
 719
 720         SetSeqNum(pwlanhdr, 0);
 721         SetFrameSubType(pframe, WIFI_PROBEREQ);
 722
 723         pktlen = sizeof(struct ieee80211_hdr_3addr);
 724         pframe += pktlen;
 725
 726         pframe = rtw_set_ie(pframe, _SSID_IE_, 0, NULL, &pktlen);
 727
 728         get_rate_set(padapter, bssrate, &bssrate_len);
 729
 730         if (bssrate_len > 8)
 731         {
 732                 pframe = rtw_set_ie(pframe, _SUPPORTEDRATES_IE_ , 8, bssrate, &pktlen);
 733                 pframe = rtw_set_ie(pframe, _EXT_SUPPORTEDRATES_IE_ , (bssrate_len - 8), (bssrate + 8), &pktlen);
 734         }
 735         else
 736         {
 737                 pframe = rtw_set_ie(pframe, _SUPPORTEDRATES_IE_ , bssrate_len , bssrate, &pktlen);
 738         }
 739
 740         *pLength = pktlen;
 741 }
 742 #endif /* CONFIG_PNO_SUPPORT */
 743 #endif /* CONFIG_WOWLAN */
 744
 745 #ifdef CONFIG_AP_WOWLAN
 746 static void ConstructProbeRsp(struct adapter *padapter, u8 *pframe, u32 *pLength, u8 *StaAddr, bool bHideSSID)
 747 {
 748         struct ieee80211_hdr    *pwlanhdr;
 749         u16                             *fctrl;
 750         u8                      *mac, *bssid;
 751         u32                             pktlen;
 752         struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
 753         struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
 754         struct wlan_bssid_ex            *cur_network = &(pmlmeinfo->network);
 755         u8 *pwps_ie;
 756         uint wps_ielen;
 757         struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
 758
 759         /* DBG_871X("%s\n", __func__); */
 760
 761         pwlanhdr = (struct ieee80211_hdr *)pframe;
 762
 763         mac = myid(&(padapter->eeprompriv));
 764         bssid = cur_network->MacAddress;
 765
 766         fctrl = &(pwlanhdr->frame_control);
 767         *(fctrl) = 0;
 768         memcpy(pwlanhdr->addr1, StaAddr, ETH_ALEN);
 769         memcpy(pwlanhdr->addr2, mac, ETH_ALEN);
 770         memcpy(pwlanhdr->addr3, bssid, ETH_ALEN);
 771
 772         DBG_871X("%s FW Mac Addr:" MAC_FMT "\n", __func__, MAC_ARG(mac));
 773         DBG_871X("%s FW IP Addr" IP_FMT "\n", __func__, IP_ARG(StaAddr));
 774
 775         SetSeqNum(pwlanhdr, 0);
 776         SetFrameSubType(fctrl, WIFI_PROBERSP);
 777
 778         pktlen = sizeof(struct ieee80211_hdr_3addr);
 779         pframe += pktlen;
 780
 781         if (cur_network->IELength>MAX_IE_SZ)
 782                 return;
 783
 784         pwps_ie = rtw_get_wps_ie(cur_network->IEs+_FIXED_IE_LENGTH_,
 785                         cur_network->IELength-_FIXED_IE_LENGTH_, NULL, &wps_ielen);
 786
 787         /* inerset & update wps_probe_resp_ie */
 788         if ((pmlmepriv->wps_probe_resp_ie!= NULL) && pwps_ie && (wps_ielen>0)) {
 789                 uint wps_offset, remainder_ielen;
 790                 u8 *premainder_ie;
 791
 792                 wps_offset = (uint)(pwps_ie - cur_network->IEs);
 793
 794                 premainder_ie = pwps_ie + wps_ielen;
 795
 796                 remainder_ielen = cur_network->IELength - wps_offset - wps_ielen;
 797
 798                 memcpy(pframe, cur_network->IEs, wps_offset);
 799                 pframe += wps_offset;
 800                 pktlen += wps_offset;
 801
 802                 wps_ielen = (uint)pmlmepriv->wps_probe_resp_ie[1];/* to get ie data len */
 803                 if ((wps_offset+wps_ielen+2)<=MAX_IE_SZ) {
 804                         memcpy(pframe, pmlmepriv->wps_probe_resp_ie, wps_ielen+2);
 805                         pframe += wps_ielen+2;
 806                         pktlen += wps_ielen+2;
 807                 }
 808
 809                 if ((wps_offset+wps_ielen+2+remainder_ielen)<=MAX_IE_SZ) {
 810                         memcpy(pframe, premainder_ie, remainder_ielen);
 811                         pframe += remainder_ielen;
 812                         pktlen += remainder_ielen;
 813                 }
 814         } else {
 815                 memcpy(pframe, cur_network->IEs, cur_network->IELength);
 816                 pframe += cur_network->IELength;
 817                 pktlen += cur_network->IELength;
 818         }
 819
 820         /* retrieve SSID IE from cur_network->Ssid */
 821         {
 822                 u8 *ssid_ie;
 823                 sint ssid_ielen;
 824                 sint ssid_ielen_diff;
 825                 u8 buf[MAX_IE_SZ];
 826                 u8 *ies = pframe + sizeof(struct ieee80211_hdr_3addr);
 827
 828                 ssid_ie = rtw_get_ie(ies+_FIXED_IE_LENGTH_, _SSID_IE_, &ssid_ielen,
 829                                         (pframe-ies)-_FIXED_IE_LENGTH_);
 830
 831                 ssid_ielen_diff = cur_network->Ssid.SsidLength - ssid_ielen;
 832
 833                 if (ssid_ie &&  cur_network->Ssid.SsidLength) {
 834                         uint remainder_ielen;
 835                         u8 *remainder_ie;
 836                         remainder_ie = ssid_ie+2;
 837                         remainder_ielen = (pframe-remainder_ie);
 838
 839                         if (remainder_ielen > MAX_IE_SZ) {
 840                                 DBG_871X_LEVEL(_drv_warning_, FUNC_ADPT_FMT" remainder_ielen > MAX_IE_SZ\n", FUNC_ADPT_ARG(padapter));
 841                                 remainder_ielen = MAX_IE_SZ;
 842                         }
 843
 844                         memcpy(buf, remainder_ie, remainder_ielen);
 845                         memcpy(remainder_ie+ssid_ielen_diff, buf, remainder_ielen);
 846                         *(ssid_ie+1) = cur_network->Ssid.SsidLength;
 847                         memcpy(ssid_ie+2, cur_network->Ssid.Ssid, cur_network->Ssid.SsidLength);
 848                         pframe += ssid_ielen_diff;
 849                         pktlen += ssid_ielen_diff;
 850                 }
 851         }
 852
 853         *pLength = pktlen;
 854
 855 }
 856 #endif /*  CONFIG_AP_WOWLAN */
 857
 858 /*  To check if reserved page content is destroyed by beacon beacuse beacon is too large. */
 859 /*  2010.06.23. Added by tynli. */
 860 void
 861 CheckFwRsvdPageContent(
 862         struct adapter *        Adapter
 863 )
 864 {
 865 }
 866
 867 static void rtl8723b_set_FwRsvdPage_cmd(struct adapter *padapter, PRSVDPAGE_LOC rsvdpageloc)
 868 {
 869         u8 u1H2CRsvdPageParm[H2C_RSVDPAGE_LOC_LEN]={0};
 870
 871         DBG_871X("8723BRsvdPageLoc: ProbeRsp =%d PsPoll =%d Null =%d QoSNull =%d BTNull =%d\n",
 872                 rsvdpageloc->LocProbeRsp, rsvdpageloc->LocPsPoll,
 873                 rsvdpageloc->LocNullData, rsvdpageloc->LocQosNull,
 874                 rsvdpageloc->LocBTQosNull);
 875
 876         SET_8723B_H2CCMD_RSVDPAGE_LOC_PROBE_RSP(u1H2CRsvdPageParm, rsvdpageloc->LocProbeRsp);
 877         SET_8723B_H2CCMD_RSVDPAGE_LOC_PSPOLL(u1H2CRsvdPageParm, rsvdpageloc->LocPsPoll);
 878         SET_8723B_H2CCMD_RSVDPAGE_LOC_NULL_DATA(u1H2CRsvdPageParm, rsvdpageloc->LocNullData);
 879         SET_8723B_H2CCMD_RSVDPAGE_LOC_QOS_NULL_DATA(u1H2CRsvdPageParm, rsvdpageloc->LocQosNull);
 880         SET_8723B_H2CCMD_RSVDPAGE_LOC_BT_QOS_NULL_DATA(u1H2CRsvdPageParm, rsvdpageloc->LocBTQosNull);
 881
 882         RT_PRINT_DATA(_module_hal_init_c_, _drv_always_, "u1H2CRsvdPageParm:", u1H2CRsvdPageParm, H2C_RSVDPAGE_LOC_LEN);
 883         FillH2CCmd8723B(padapter, H2C_8723B_RSVD_PAGE, H2C_RSVDPAGE_LOC_LEN, u1H2CRsvdPageParm);
 884 }
 885
 886 static void rtl8723b_set_FwAoacRsvdPage_cmd(struct adapter *padapter, PRSVDPAGE_LOC rsvdpageloc)
 887 {
 888 #ifdef CONFIG_WOWLAN
 889         struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
 890         u8 u1H2CAoacRsvdPageParm[H2C_AOAC_RSVDPAGE_LOC_LEN]={0};
 891
 892         DBG_871X("8723BAOACRsvdPageLoc: RWC =%d ArpRsp =%d NbrAdv =%d GtkRsp =%d GtkInfo =%d ProbeReq =%d NetworkList =%d\n",
 893                         rsvdpageloc->LocRemoteCtrlInfo, rsvdpageloc->LocArpRsp,
 894                         rsvdpageloc->LocNbrAdv, rsvdpageloc->LocGTKRsp,
 895                         rsvdpageloc->LocGTKInfo, rsvdpageloc->LocProbeReq,
 896                         rsvdpageloc->LocNetList);
 897
 898         if (check_fwstate(pmlmepriv, _FW_LINKED)) {
 899                 SET_H2CCMD_AOAC_RSVDPAGE_LOC_REMOTE_WAKE_CTRL_INFO(u1H2CAoacRsvdPageParm, rsvdpageloc->LocRemoteCtrlInfo);
 900                 SET_H2CCMD_AOAC_RSVDPAGE_LOC_ARP_RSP(u1H2CAoacRsvdPageParm, rsvdpageloc->LocArpRsp);
 901                 /* SET_H2CCMD_AOAC_RSVDPAGE_LOC_NEIGHBOR_ADV(u1H2CAoacRsvdPageParm, rsvdpageloc->LocNbrAdv); */
 902                 SET_H2CCMD_AOAC_RSVDPAGE_LOC_GTK_RSP(u1H2CAoacRsvdPageParm, rsvdpageloc->LocGTKRsp);
 903                 SET_H2CCMD_AOAC_RSVDPAGE_LOC_GTK_INFO(u1H2CAoacRsvdPageParm, rsvdpageloc->LocGTKInfo);
 904 #ifdef CONFIG_GTK_OL
 905                 SET_H2CCMD_AOAC_RSVDPAGE_LOC_GTK_EXT_MEM(u1H2CAoacRsvdPageParm, rsvdpageloc->LocGTKEXTMEM);
 906 #endif /*  CONFIG_GTK_OL */
 907                 RT_PRINT_DATA(_module_hal_init_c_, _drv_always_, "u1H2CAoacRsvdPageParm:", u1H2CAoacRsvdPageParm, H2C_AOAC_RSVDPAGE_LOC_LEN);
 908                 FillH2CCmd8723B(padapter, H2C_8723B_AOAC_RSVD_PAGE, H2C_AOAC_RSVDPAGE_LOC_LEN, u1H2CAoacRsvdPageParm);
 909         } else {
 910 #ifdef CONFIG_PNO_SUPPORT
 911                 if (!pwrpriv->pno_in_resume) {
 912                         DBG_871X("NLO_INFO =%d\n", rsvdpageloc->LocPNOInfo);
 913                         memset(&u1H2CAoacRsvdPageParm, 0, sizeof(u1H2CAoacRsvdPageParm));
 914                         SET_H2CCMD_AOAC_RSVDPAGE_LOC_NLO_INFO(u1H2CAoacRsvdPageParm, rsvdpageloc->LocPNOInfo);
 915                         FillH2CCmd8723B(padapter, H2C_AOAC_RSVDPAGE3, H2C_AOAC_RSVDPAGE_LOC_LEN, u1H2CAoacRsvdPageParm);
 916                         msleep(10);
 917                 }
 918 #endif
 919         }
 920
 921 #endif /*  CONFIG_WOWLAN */
 922 }
 923
 924 #ifdef CONFIG_AP_WOWLAN
 925 static void rtl8723b_set_ap_wow_rsvdpage_cmd(struct adapter *padapter,
 926                 PRSVDPAGE_LOC rsvdpageloc)
 927 {
 928         u8 header;
 929         u8 rsvdparm[H2C_AOAC_RSVDPAGE_LOC_LEN]={0};
 930
 931         header = rtw_read8(padapter, REG_BCNQ_BDNY);
 932
 933         DBG_871X("%s: beacon: %d, probeRsp: %d, header:0x%02x\n", __func__,
 934                         rsvdpageloc->LocApOffloadBCN,
 935                         rsvdpageloc->LocProbeRsp,
 936                         header);
 937
 938         SET_H2CCMD_AP_WOWLAN_RSVDPAGE_LOC_BCN(rsvdparm,
 939                         rsvdpageloc->LocApOffloadBCN + header);
 940
 941         FillH2CCmd8723B(padapter, H2C_8723B_BCN_RSVDPAGE,
 942                         H2C_BCN_RSVDPAGE_LEN, rsvdparm);
 943
 944         msleep(10);
 945
 946         memset(&rsvdparm, 0, sizeof(rsvdparm));
 947
 948         SET_H2CCMD_AP_WOWLAN_RSVDPAGE_LOC_ProbeRsp(
 949                         rsvdparm,
 950                         rsvdpageloc->LocProbeRsp + header);
 951
 952         FillH2CCmd8723B(padapter, H2C_8723B_PROBERSP_RSVDPAGE,
 953                         H2C_PROBERSP_RSVDPAGE_LEN, rsvdparm);
 954
 955         msleep(10);
 956 }
 957 #endif /* CONFIG_AP_WOWLAN */
 958
 959 void rtl8723b_set_FwMediaStatusRpt_cmd(struct adapter *padapter, u8 mstatus, u8 macid)
 960 {
 961         u8 u1H2CMediaStatusRptParm[H2C_MEDIA_STATUS_RPT_LEN]={0};
 962         u8 macid_end = 0;
 963
 964         DBG_871X("%s(): mstatus = %d macid =%d\n", __func__, mstatus, macid);
 965
 966         SET_8723B_H2CCMD_MSRRPT_PARM_OPMODE(u1H2CMediaStatusRptParm, mstatus);
 967         SET_8723B_H2CCMD_MSRRPT_PARM_MACID_IND(u1H2CMediaStatusRptParm, 0);
 968         SET_8723B_H2CCMD_MSRRPT_PARM_MACID(u1H2CMediaStatusRptParm, macid);
 969         SET_8723B_H2CCMD_MSRRPT_PARM_MACID_END(u1H2CMediaStatusRptParm, macid_end);
 970
 971         RT_PRINT_DATA(_module_hal_init_c_, _drv_always_, "u1H2CMediaStatusRptParm:", u1H2CMediaStatusRptParm, H2C_MEDIA_STATUS_RPT_LEN);
 972         FillH2CCmd8723B(padapter, H2C_8723B_MEDIA_STATUS_RPT, H2C_MEDIA_STATUS_RPT_LEN, u1H2CMediaStatusRptParm);
 973 }
 974
 975 #ifdef CONFIG_WOWLAN
 976 static void rtl8723b_set_FwKeepAlive_cmd(struct adapter *padapter, u8 benable, u8 pkt_type)
 977 {
 978         u8 u1H2CKeepAliveParm[H2C_KEEP_ALIVE_CTRL_LEN]={0};
 979         u8 adopt = 1, check_period = 5;
 980
 981         DBG_871X("%s(): benable = %d\n", __func__, benable);
 982         SET_8723B_H2CCMD_KEEPALIVE_PARM_ENABLE(u1H2CKeepAliveParm, benable);
 983         SET_8723B_H2CCMD_KEEPALIVE_PARM_ADOPT(u1H2CKeepAliveParm, adopt);
 984         SET_8723B_H2CCMD_KEEPALIVE_PARM_PKT_TYPE(u1H2CKeepAliveParm, pkt_type);
 985         SET_8723B_H2CCMD_KEEPALIVE_PARM_CHECK_PERIOD(u1H2CKeepAliveParm, check_period);
 986
 987         RT_PRINT_DATA(_module_hal_init_c_, _drv_always_, "u1H2CKeepAliveParm:", u1H2CKeepAliveParm, H2C_KEEP_ALIVE_CTRL_LEN);
 988
 989         FillH2CCmd8723B(padapter, H2C_8723B_KEEP_ALIVE, H2C_KEEP_ALIVE_CTRL_LEN, u1H2CKeepAliveParm);
 990 }
 991
 992 static void rtl8723b_set_FwDisconDecision_cmd(struct adapter *padapter, u8 benable)
 993 {
 994         u8 u1H2CDisconDecisionParm[H2C_DISCON_DECISION_LEN]={0};
 995         u8 adopt = 1, check_period = 10, trypkt_num = 0;
 996
 997         DBG_871X("%s(): benable = %d\n", __func__, benable);
 998         SET_8723B_H2CCMD_DISCONDECISION_PARM_ENABLE(u1H2CDisconDecisionParm, benable);
 999         SET_8723B_H2CCMD_DISCONDECISION_PARM_ADOPT(u1H2CDisconDecisionParm, adopt);
1000         SET_8723B_H2CCMD_DISCONDECISION_PARM_CHECK_PERIOD(u1H2CDisconDecisionParm, check_period);
1001         SET_8723B_H2CCMD_DISCONDECISION_PARM_TRY_PKT_NUM(u1H2CDisconDecisionParm, trypkt_num);
1002
1003         RT_PRINT_DATA(_module_hal_init_c_, _drv_always_, "u1H2CDisconDecisionParm:", u1H2CDisconDecisionParm, H2C_DISCON_DECISION_LEN);
1004
1005         FillH2CCmd8723B(padapter, H2C_8723B_DISCON_DECISION, H2C_DISCON_DECISION_LEN, u1H2CDisconDecisionParm);
1006 }
1007 #endif /*  CONFIG_WOWLAN */
1008
1009 void rtl8723b_set_FwMacIdConfig_cmd(struct adapter *padapter, u8 mac_id, u8 raid, u8 bw, u8 sgi, u32 mask)
1010 {
1011         u8 u1H2CMacIdConfigParm[H2C_MACID_CFG_LEN]={0};
1012
1013         DBG_871X("%s(): mac_id =%d raid = 0x%x bw =%d mask = 0x%x\n", __func__, mac_id, raid, bw, mask);
1014
1015         SET_8723B_H2CCMD_MACID_CFG_MACID(u1H2CMacIdConfigParm, mac_id);
1016         SET_8723B_H2CCMD_MACID_CFG_RAID(u1H2CMacIdConfigParm, raid);
1017         SET_8723B_H2CCMD_MACID_CFG_SGI_EN(u1H2CMacIdConfigParm, (sgi)? 1:0);
1018         SET_8723B_H2CCMD_MACID_CFG_BW(u1H2CMacIdConfigParm, bw);
1019         SET_8723B_H2CCMD_MACID_CFG_RATE_MASK0(u1H2CMacIdConfigParm, (u8)(mask & 0x000000ff));
1020         SET_8723B_H2CCMD_MACID_CFG_RATE_MASK1(u1H2CMacIdConfigParm, (u8)((mask & 0x0000ff00) >>8));
1021         SET_8723B_H2CCMD_MACID_CFG_RATE_MASK2(u1H2CMacIdConfigParm, (u8)((mask & 0x00ff0000) >> 16));
1022         SET_8723B_H2CCMD_MACID_CFG_RATE_MASK3(u1H2CMacIdConfigParm, (u8)((mask & 0xff000000) >> 24));
1023
1024         RT_PRINT_DATA(_module_hal_init_c_, _drv_always_, "u1H2CMacIdConfigParm:", u1H2CMacIdConfigParm, H2C_MACID_CFG_LEN);
1025         FillH2CCmd8723B(padapter, H2C_8723B_MACID_CFG, H2C_MACID_CFG_LEN, u1H2CMacIdConfigParm);
1026 }
1027
1028 static void rtl8723b_set_FwRssiSetting_cmd(struct adapter *padapter, u8 *param)
1029 {
1030         u8 u1H2CRssiSettingParm[H2C_RSSI_SETTING_LEN]={0};
1031         u8 mac_id = *param;
1032         u8 rssi = *(param+2);
1033         u8 uldl_state = 0;
1034
1035         /* DBG_871X("%s(): param =%.2x-%.2x-%.2x\n", __func__, *param, *(param+1), *(param+2)); */
1036         /* DBG_871X("%s(): mac_id =%d rssi =%d\n", __func__, mac_id, rssi); */
1037
1038         SET_8723B_H2CCMD_RSSI_SETTING_MACID(u1H2CRssiSettingParm, mac_id);
1039         SET_8723B_H2CCMD_RSSI_SETTING_RSSI(u1H2CRssiSettingParm, rssi);
1040         SET_8723B_H2CCMD_RSSI_SETTING_ULDL_STATE(u1H2CRssiSettingParm, uldl_state);
1041
1042         RT_PRINT_DATA(_module_hal_init_c_, _drv_notice_, "u1H2CRssiSettingParm:", u1H2CRssiSettingParm, H2C_RSSI_SETTING_LEN);
1043         FillH2CCmd8723B(padapter, H2C_8723B_RSSI_SETTING, H2C_RSSI_SETTING_LEN, u1H2CRssiSettingParm);
1044 }
1045
1046 void rtl8723b_set_FwPwrMode_cmd(struct adapter *padapter, u8 psmode)
1047 {
1048         int i;
1049         struct pwrctrl_priv *pwrpriv = adapter_to_pwrctl(padapter);
1050         struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
1051         u8 u1H2CPwrModeParm[H2C_PWRMODE_LEN]={0};
1052         u8 PowerState = 0, awake_intvl = 1, byte5 = 0, rlbm = 0;
1053
1054         if (pwrpriv->dtim > 0)
1055                 DBG_871X("%s(): FW LPS mode = %d, SmartPS =%d, dtim =%d\n", __func__, psmode, pwrpriv->smart_ps, pwrpriv->dtim);
1056         else
1057                 DBG_871X("%s(): FW LPS mode = %d, SmartPS =%d\n", __func__, psmode, pwrpriv->smart_ps);
1058
1059 #ifdef CONFIG_WOWLAN
1060         if (psmode == PS_MODE_DTIM)  /* For WOWLAN LPS, DTIM = (awake_intvl - 1) */
1061         {
1062                 awake_intvl = 3;/* DTIM =2 */
1063                 rlbm = 2;
1064         }
1065         else
1066 #endif /* CONFIG_WOWLAN */
1067         {
1068                 if (pwrpriv->dtim > 0 && pwrpriv->dtim < 16)
1069                         awake_intvl = pwrpriv->dtim+1;/* DTIM = (awake_intvl - 1) */
1070                 else
1071                         awake_intvl = 3;/* DTIM =2 */
1072
1073                 rlbm = 2;
1074         }
1075
1076
1077         if (padapter->registrypriv.wifi_spec == 1)
1078         {
1079                 awake_intvl = 2;
1080                 rlbm = 2;
1081         }
1082
1083         if (psmode > 0)
1084         {
1085                 if (rtw_btcoex_IsBtControlLps(padapter) == true)
1086                 {
1087                         PowerState = rtw_btcoex_RpwmVal(padapter);
1088                         byte5 = rtw_btcoex_LpsVal(padapter);
1089
1090                         if ((rlbm == 2) && (byte5 & BIT(4)))
1091                         {
1092                                 /*  Keep awake interval to 1 to prevent from */
1093                                 /*  decreasing coex performance */
1094                                 awake_intvl = 2;
1095                                 rlbm = 2;
1096                         }
1097                 }
1098                 else
1099                 {
1100                         PowerState = 0x00;/*  AllON(0x0C), RFON(0x04), RFOFF(0x00) */
1101                         byte5 = 0x40;
1102                 }
1103         }
1104         else
1105         {
1106                 PowerState = 0x0C;/*  AllON(0x0C), RFON(0x04), RFOFF(0x00) */
1107                 byte5 = 0x40;
1108         }
1109
1110         SET_8723B_H2CCMD_PWRMODE_PARM_MODE(u1H2CPwrModeParm, (psmode>0)?1:0);
1111         SET_8723B_H2CCMD_PWRMODE_PARM_SMART_PS(u1H2CPwrModeParm, pwrpriv->smart_ps);
1112         SET_8723B_H2CCMD_PWRMODE_PARM_RLBM(u1H2CPwrModeParm, rlbm);
1113         SET_8723B_H2CCMD_PWRMODE_PARM_BCN_PASS_TIME(u1H2CPwrModeParm, awake_intvl);
1114         SET_8723B_H2CCMD_PWRMODE_PARM_ALL_QUEUE_UAPSD(u1H2CPwrModeParm, padapter->registrypriv.uapsd_enable);
1115         SET_8723B_H2CCMD_PWRMODE_PARM_PWR_STATE(u1H2CPwrModeParm, PowerState);
1116         SET_8723B_H2CCMD_PWRMODE_PARM_BYTE5(u1H2CPwrModeParm, byte5);
1117         if (psmode != PS_MODE_ACTIVE)
1118         {
1119                 if (pmlmeext ->adaptive_tsf_done == false && pmlmeext->bcn_cnt>0)
1120                 {
1121                         u8 ratio_20_delay, ratio_80_delay;
1122
1123                         /* byte 6 for adaptive_early_32k */
1124                         /* 0:3] = DrvBcnEarly  (ms) , [4:7] = DrvBcnTimeOut  (ms) */
1125                         /*  20% for DrvBcnEarly, 80% for DrvBcnTimeOut */
1126                         ratio_20_delay = 0;
1127                         ratio_80_delay = 0;
1128                         pmlmeext->DrvBcnEarly = 0xff;
1129                         pmlmeext->DrvBcnTimeOut = 0xff;
1130
1131                         DBG_871X("%s(): bcn_cnt = %d\n", __func__, pmlmeext->bcn_cnt);
1132
1133                         for (i = 0; i<9; i++)
1134                         {
1135                                 pmlmeext->bcn_delay_ratio[i] = (pmlmeext->bcn_delay_cnt[i] * 100) /pmlmeext->bcn_cnt;
1136
1137                                 DBG_871X("%s(): bcn_delay_cnt[%d]=%d, bcn_delay_ratio[%d] = %d\n", __func__, i, pmlmeext->bcn_delay_cnt[i]
1138                                         , i , pmlmeext->bcn_delay_ratio[i]);
1139
1140                                 ratio_20_delay += pmlmeext->bcn_delay_ratio[i];
1141                                 ratio_80_delay += pmlmeext->bcn_delay_ratio[i];
1142
1143                                 if (ratio_20_delay > 20 && pmlmeext->DrvBcnEarly == 0xff)
1144                                 {
1145                                         pmlmeext->DrvBcnEarly = i;
1146                                         DBG_871X("%s(): DrvBcnEarly = %d\n", __func__, pmlmeext->DrvBcnEarly);
1147                                 }
1148
1149                                 if (ratio_80_delay > 80 && pmlmeext->DrvBcnTimeOut == 0xff)
1150                                 {
1151                                         pmlmeext->DrvBcnTimeOut = i;
1152                                         DBG_871X("%s(): DrvBcnTimeOut = %d\n", __func__, pmlmeext->DrvBcnTimeOut);
1153                                 }
1154
1155                                 /* reset adaptive_early_32k cnt */
1156                                 pmlmeext->bcn_delay_cnt[i] = 0;
1157                                 pmlmeext->bcn_delay_ratio[i] = 0;
1158
1159                         }
1160
1161                         pmlmeext->bcn_cnt = 0;
1162                         pmlmeext ->adaptive_tsf_done = true;
1163
1164                 }
1165                 else
1166                 {
1167                         DBG_871X("%s(): DrvBcnEarly = %d\n", __func__, pmlmeext->DrvBcnEarly);
1168                         DBG_871X("%s(): DrvBcnTimeOut = %d\n", __func__, pmlmeext->DrvBcnTimeOut);
1169                 }
1170
1171 /* offload to FW if fw version > v15.10
1172                 pmlmeext->DrvBcnEarly = 0;
1173                 pmlmeext->DrvBcnTimeOut =7;
1174
1175                 if ((pmlmeext->DrvBcnEarly!= 0Xff) && (pmlmeext->DrvBcnTimeOut!= 0xff))
1176                         u1H2CPwrModeParm[H2C_PWRMODE_LEN-1] = BIT(0) | ((pmlmeext->DrvBcnEarly<<1)&0x0E) |((pmlmeext->DrvBcnTimeOut<<4)&0xf0) ;
1177 */
1178
1179         }
1180
1181         rtw_btcoex_RecordPwrMode(padapter, u1H2CPwrModeParm, H2C_PWRMODE_LEN);
1182
1183         RT_PRINT_DATA(_module_hal_init_c_, _drv_always_, "u1H2CPwrModeParm:", u1H2CPwrModeParm, H2C_PWRMODE_LEN);
1184
1185         FillH2CCmd8723B(padapter, H2C_8723B_SET_PWR_MODE, H2C_PWRMODE_LEN, u1H2CPwrModeParm);
1186 }
1187
1188 void rtl8723b_set_FwPsTuneParam_cmd(struct adapter *padapter)
1189 {
1190         u8 u1H2CPsTuneParm[H2C_PSTUNEPARAM_LEN]={0};
1191         u8 bcn_to_limit = 10; /* 10 * 100 * awakeinterval (ms) */
1192         u8 dtim_timeout = 5; /* ms wait broadcast data timer */
1193         u8 ps_timeout = 20;  /* ms Keep awake when tx */
1194         u8 dtim_period = 3;
1195
1196         /* DBG_871X("%s(): FW LPS mode = %d\n", __func__, psmode); */
1197
1198         SET_8723B_H2CCMD_PSTUNE_PARM_BCN_TO_LIMIT(u1H2CPsTuneParm, bcn_to_limit);
1199         SET_8723B_H2CCMD_PSTUNE_PARM_DTIM_TIMEOUT(u1H2CPsTuneParm, dtim_timeout);
1200         SET_8723B_H2CCMD_PSTUNE_PARM_PS_TIMEOUT(u1H2CPsTuneParm, ps_timeout);
1201         SET_8723B_H2CCMD_PSTUNE_PARM_ADOPT(u1H2CPsTuneParm, 1);
1202         SET_8723B_H2CCMD_PSTUNE_PARM_DTIM_PERIOD(u1H2CPsTuneParm, dtim_period);
1203
1204         RT_PRINT_DATA(_module_hal_init_c_, _drv_always_, "u1H2CPsTuneParm:", u1H2CPsTuneParm, H2C_PSTUNEPARAM_LEN);
1205
1206         FillH2CCmd8723B(padapter, H2C_8723B_PS_TUNING_PARA, H2C_PSTUNEPARAM_LEN, u1H2CPsTuneParm);
1207 }
1208
1209 void rtl8723b_set_FwPwrModeInIPS_cmd(struct adapter *padapter, u8 cmd_param)
1210 {
1211         /* BIT0:enable, BIT1:NoConnect32k */
1212
1213         DBG_871X("%s()\n", __func__);
1214
1215         FillH2CCmd8723B(padapter, H2C_8723B_FWLPS_IN_IPS_, 1, &cmd_param);
1216 }
1217
1218 #ifdef CONFIG_WOWLAN
1219 static void rtl8723b_set_FwWoWlanCtrl_Cmd(struct adapter *padapter, u8 bFuncEn)
1220 {
1221         struct security_priv *psecpriv = &padapter->securitypriv;
1222         u8 u1H2CWoWlanCtrlParm[H2C_WOWLAN_LEN]={0};
1223         u8 discont_wake = 1, gpionum = 0, gpio_dur = 0, hw_unicast = 0;
1224         u8 sdio_wakeup_enable = 1;
1225         u8 gpio_high_active = 0; /* 0: low active, 1: high active */
1226         u8 magic_pkt = 0;
1227
1228 #ifdef CONFIG_GPIO_WAKEUP
1229         gpionum = WAKEUP_GPIO_IDX;
1230         sdio_wakeup_enable = 0;
1231 #endif
1232
1233 #ifdef CONFIG_PNO_SUPPORT
1234         if (!ppwrpriv->wowlan_pno_enable) {
1235                 magic_pkt = 1;
1236         }
1237 #endif
1238
1239         if (psecpriv->dot11PrivacyAlgrthm == _WEP40_ || psecpriv->dot11PrivacyAlgrthm == _WEP104_)
1240                 hw_unicast = 1;
1241
1242         DBG_871X("%s(): bFuncEn =%d\n", __func__, bFuncEn);
1243
1244         SET_H2CCMD_WOWLAN_FUNC_ENABLE(u1H2CWoWlanCtrlParm, bFuncEn);
1245         SET_H2CCMD_WOWLAN_PATTERN_MATCH_ENABLE(u1H2CWoWlanCtrlParm, 0);
1246         SET_H2CCMD_WOWLAN_MAGIC_PKT_ENABLE(u1H2CWoWlanCtrlParm, magic_pkt);
1247         SET_H2CCMD_WOWLAN_UNICAST_PKT_ENABLE(u1H2CWoWlanCtrlParm, hw_unicast);
1248         SET_H2CCMD_WOWLAN_ALL_PKT_DROP(u1H2CWoWlanCtrlParm, 0);
1249         SET_H2CCMD_WOWLAN_GPIO_ACTIVE(u1H2CWoWlanCtrlParm, gpio_high_active);
1250         SET_H2CCMD_WOWLAN_DISCONNECT_WAKE_UP(u1H2CWoWlanCtrlParm, discont_wake);
1251         SET_H2CCMD_WOWLAN_GPIONUM(u1H2CWoWlanCtrlParm, gpionum);
1252         SET_H2CCMD_WOWLAN_DATAPIN_WAKE_UP(u1H2CWoWlanCtrlParm, sdio_wakeup_enable);
1253         SET_H2CCMD_WOWLAN_GPIO_DURATION(u1H2CWoWlanCtrlParm, gpio_dur);
1254         /* SET_H2CCMD_WOWLAN_GPIO_PULSE_EN(u1H2CWoWlanCtrlParm, 1); */
1255         SET_H2CCMD_WOWLAN_GPIO_PULSE_COUNT(u1H2CWoWlanCtrlParm, 0x09);
1256
1257         RT_PRINT_DATA(_module_hal_init_c_, _drv_always_, "u1H2CWoWlanCtrlParm:", u1H2CWoWlanCtrlParm, H2C_WOWLAN_LEN);
1258
1259         FillH2CCmd8723B(padapter, H2C_8723B_WOWLAN, H2C_WOWLAN_LEN, u1H2CWoWlanCtrlParm);
1260 }
1261
1262 static void rtl8723b_set_FwRemoteWakeCtrl_Cmd(struct adapter *padapter, u8 benable)
1263 {
1264         u8 u1H2CRemoteWakeCtrlParm[H2C_REMOTE_WAKE_CTRL_LEN]={0};
1265         struct security_priv* psecuritypriv =&(padapter->securitypriv);
1266         struct pwrctrl_priv *ppwrpriv = adapter_to_pwrctl(padapter);
1267
1268         DBG_871X("%s(): Enable =%d\n", __func__, benable);
1269
1270         if (!ppwrpriv->wowlan_pno_enable) {
1271                 SET_H2CCMD_REMOTE_WAKECTRL_ENABLE(u1H2CRemoteWakeCtrlParm, benable);
1272                 SET_H2CCMD_REMOTE_WAKE_CTRL_ARP_OFFLOAD_EN(u1H2CRemoteWakeCtrlParm, 1);
1273 #ifdef CONFIG_GTK_OL
1274                 if (psecuritypriv->binstallKCK_KEK &&
1275                     psecuritypriv->dot11PrivacyAlgrthm == _AES_) {
1276                         SET_H2CCMD_REMOTE_WAKE_CTRL_GTK_OFFLOAD_EN(u1H2CRemoteWakeCtrlParm, 1);
1277                 } else {
1278                         DBG_871X("no kck or security is not AES\n");
1279                         SET_H2CCMD_REMOTE_WAKE_CTRL_GTK_OFFLOAD_EN(u1H2CRemoteWakeCtrlParm, 0);
1280                 }
1281 #endif /* CONFIG_GTK_OL */
1282
1283                 SET_H2CCMD_REMOTE_WAKE_CTRL_FW_UNICAST_EN(u1H2CRemoteWakeCtrlParm, 1);
1284
1285                 if ((psecuritypriv->dot11PrivacyAlgrthm == _AES_) ||
1286                     (psecuritypriv->dot11PrivacyAlgrthm == _NO_PRIVACY_))
1287                         SET_H2CCMD_REMOTE_WAKE_CTRL_ARP_ACTION(u1H2CRemoteWakeCtrlParm, 0);
1288                 else
1289                         SET_H2CCMD_REMOTE_WAKE_CTRL_ARP_ACTION(u1H2CRemoteWakeCtrlParm, 1);
1290         }
1291 #ifdef CONFIG_PNO_SUPPORT
1292         else {
1293                 SET_H2CCMD_REMOTE_WAKECTRL_ENABLE(u1H2CRemoteWakeCtrlParm, benable);
1294                 SET_H2CCMD_REMOTE_WAKE_CTRL_NLO_OFFLOAD_EN(u1H2CRemoteWakeCtrlParm, benable);
1295         }
1296 #endif
1297         RT_PRINT_DATA(_module_hal_init_c_, _drv_always_, "u1H2CRemoteWakeCtrlParm:", u1H2CRemoteWakeCtrlParm, H2C_REMOTE_WAKE_CTRL_LEN);
1298         FillH2CCmd8723B(padapter, H2C_8723B_REMOTE_WAKE_CTRL,
1299                 H2C_REMOTE_WAKE_CTRL_LEN, u1H2CRemoteWakeCtrlParm);
1300 #ifdef CONFIG_PNO_SUPPORT
1301         if (ppwrpriv->wowlan_pno_enable && ppwrpriv->pno_in_resume == false) {
1302                 res = rtw_read8(padapter, REG_PNO_STATUS);
1303                 DBG_871X("cmd: 0x81 REG_PNO_STATUS: 0x%02x\n", res);
1304                 while (!(res&BIT(7)) && count < 25) {
1305                         DBG_871X("[%d] cmd: 0x81 REG_PNO_STATUS: 0x%02x\n", count, res);
1306                         res = rtw_read8(padapter, REG_PNO_STATUS);
1307                         count++;
1308                         msleep(2);
1309                 }
1310                 DBG_871X("cmd: 0x81 REG_PNO_STATUS: 0x%02x\n", res);
1311         }
1312 #endif /* CONFIG_PNO_SUPPORT */
1313 }
1314
1315 static void rtl8723b_set_FwAOACGlobalInfo_Cmd(struct adapter *padapter,  u8 group_alg, u8 pairwise_alg)
1316 {
1317         u8 u1H2CAOACGlobalInfoParm[H2C_AOAC_GLOBAL_INFO_LEN]={0};
1318
1319         DBG_871X("%s(): group_alg =%d pairwise_alg =%d\n", __func__, group_alg, pairwise_alg);
1320
1321         SET_H2CCMD_AOAC_GLOBAL_INFO_PAIRWISE_ENC_ALG(u1H2CAOACGlobalInfoParm, pairwise_alg);
1322         SET_H2CCMD_AOAC_GLOBAL_INFO_GROUP_ENC_ALG(u1H2CAOACGlobalInfoParm, group_alg);
1323
1324         RT_PRINT_DATA(_module_hal_init_c_, _drv_always_, "u1H2CAOACGlobalInfoParm:", u1H2CAOACGlobalInfoParm, H2C_AOAC_GLOBAL_INFO_LEN);
1325
1326         FillH2CCmd8723B(padapter, H2C_8723B_AOAC_GLOBAL_INFO, H2C_AOAC_GLOBAL_INFO_LEN, u1H2CAOACGlobalInfoParm);
1327 }
1328
1329 #ifdef CONFIG_PNO_SUPPORT
1330 static void rtl8723b_set_FwScanOffloadInfo_cmd(struct adapter *padapter, PRSVDPAGE_LOC rsvdpageloc, u8 enable)
1331 {
1332         u8 u1H2CScanOffloadInfoParm[H2C_SCAN_OFFLOAD_CTRL_LEN]={0};
1333         u8 res = 0, count = 0;
1334         struct pwrctrl_priv *pwrpriv = adapter_to_pwrctl(padapter);
1335
1336         DBG_871X("%s: loc_probe_packet:%d, loc_scan_info: %d loc_ssid_info:%d\n",
1337                 __func__, rsvdpageloc->LocProbePacket, rsvdpageloc->LocScanInfo, rsvdpageloc->LocSSIDInfo);
1338
1339         SET_H2CCMD_AOAC_NLO_FUN_EN(u1H2CScanOffloadInfoParm, enable);
1340         SET_H2CCMD_AOAC_RSVDPAGE_LOC_SCAN_INFO(u1H2CScanOffloadInfoParm, rsvdpageloc->LocScanInfo);
1341         SET_H2CCMD_AOAC_RSVDPAGE_LOC_PROBE_PACKET(u1H2CScanOffloadInfoParm, rsvdpageloc->LocProbePacket);
1342         SET_H2CCMD_AOAC_RSVDPAGE_LOC_SSID_INFO(u1H2CScanOffloadInfoParm, rsvdpageloc->LocSSIDInfo);
1343
1344         RT_PRINT_DATA(_module_hal_init_c_, _drv_always_, "u1H2CScanOffloadInfoParm:", u1H2CScanOffloadInfoParm, H2C_SCAN_OFFLOAD_CTRL_LEN);
1345         FillH2CCmd8723B(padapter, H2C_8723B_D0_SCAN_OFFLOAD_INFO, H2C_SCAN_OFFLOAD_CTRL_LEN, u1H2CScanOffloadInfoParm);
1346
1347         msleep(20);
1348 }
1349 #endif /* CONFIG_PNO_SUPPORT */
1350
1351 static void rtl8723b_set_FwWoWlanRelated_cmd(struct adapter *padapter, u8 enable)
1352 {
1353         struct security_priv *psecpriv = &padapter->securitypriv;
1354         struct pwrctrl_priv *ppwrpriv = adapter_to_pwrctl(padapter);
1355         struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
1356         struct sta_info *psta = NULL;
1357         u8 pkt_type = 0;
1358
1359         DBG_871X_LEVEL(_drv_always_, "+%s()+: enable =%d\n", __func__, enable);
1360         if (enable) {
1361                 rtl8723b_set_FwAOACGlobalInfo_Cmd(padapter, psecpriv->dot118021XGrpPrivacy, psecpriv->dot11PrivacyAlgrthm);
1362
1363                 rtl8723b_set_FwJoinBssRpt_cmd(padapter, RT_MEDIA_CONNECT);      /* RT_MEDIA_CONNECT will confuse in the future */
1364
1365                 if (!(ppwrpriv->wowlan_pno_enable))
1366                 {
1367                         psta = rtw_get_stainfo(&padapter->stapriv, get_bssid(pmlmepriv));
1368                         if (psta != NULL)
1369                                 rtl8723b_set_FwMediaStatusRpt_cmd(padapter, RT_MEDIA_CONNECT, psta->mac_id);
1370                 }
1371                 else
1372                         DBG_871X("%s(): Disconnected, no FwMediaStatusRpt CONNECT\n", __func__);
1373
1374                 msleep(2);
1375
1376                 if (!(ppwrpriv->wowlan_pno_enable)) {
1377                 rtl8723b_set_FwDisconDecision_cmd(padapter, enable);
1378                 msleep(2);
1379
1380                         if ((psecpriv->dot11PrivacyAlgrthm != _WEP40_) || (psecpriv->dot11PrivacyAlgrthm != _WEP104_))
1381                                 pkt_type = 1;
1382                         rtl8723b_set_FwKeepAlive_cmd(padapter, enable, pkt_type);
1383                 msleep(2);
1384                 }
1385
1386                 rtl8723b_set_FwWoWlanCtrl_Cmd(padapter, enable);
1387                 msleep(2);
1388
1389                 rtl8723b_set_FwRemoteWakeCtrl_Cmd(padapter, enable);
1390         }
1391         else
1392         {
1393                 rtl8723b_set_FwRemoteWakeCtrl_Cmd(padapter, enable);
1394                 msleep(2);
1395                 rtl8723b_set_FwWoWlanCtrl_Cmd(padapter, enable);
1396         }
1397
1398         DBG_871X_LEVEL(_drv_always_, "-%s()-\n", __func__);
1399         return ;
1400 }
1401
1402 void rtl8723b_set_wowlan_cmd(struct adapter *padapter, u8 enable)
1403 {
1404         rtl8723b_set_FwWoWlanRelated_cmd(padapter, enable);
1405 }
1406 #endif /* CONFIG_WOWLAN */
1407
1408 #ifdef CONFIG_AP_WOWLAN
1409 static void rtl8723b_set_FwAPWoWlanCtrl_Cmd(struct adapter *padapter, u8 bFuncEn)
1410 {
1411         u8 u1H2CAPWoWlanCtrlParm[H2C_WOWLAN_LEN]={0};
1412         u8 gpionum = 0, gpio_dur = 0;
1413         u8 gpio_high_active = 1; /* 0: low active, 1: high active */
1414         u8 gpio_pulse = bFuncEn;
1415 #ifdef CONFIG_GPIO_WAKEUP
1416         gpionum = WAKEUP_GPIO_IDX;
1417 #endif
1418
1419         DBG_871X("%s(): bFuncEn =%d\n", __func__, bFuncEn);
1420
1421         if (bFuncEn)
1422                 gpio_dur = 16;
1423         else
1424                 gpio_dur = 0;
1425
1426         SET_H2CCMD_AP_WOW_GPIO_CTRL_INDEX(u1H2CAPWoWlanCtrlParm,
1427                         gpionum);
1428         SET_H2CCMD_AP_WOW_GPIO_CTRL_PLUS(u1H2CAPWoWlanCtrlParm,
1429                         gpio_pulse);
1430         SET_H2CCMD_AP_WOW_GPIO_CTRL_HIGH_ACTIVE(u1H2CAPWoWlanCtrlParm,
1431                         gpio_high_active);
1432         SET_H2CCMD_AP_WOW_GPIO_CTRL_EN(u1H2CAPWoWlanCtrlParm,
1433                         bFuncEn);
1434         SET_H2CCMD_AP_WOW_GPIO_CTRL_DURATION(u1H2CAPWoWlanCtrlParm,
1435                         gpio_dur);
1436
1437         FillH2CCmd8723B(padapter, H2C_8723B_AP_WOW_GPIO_CTRL,
1438                         H2C_AP_WOW_GPIO_CTRL_LEN, u1H2CAPWoWlanCtrlParm);
1439 }
1440
1441 static void rtl8723b_set_Fw_AP_Offload_Cmd(struct adapter *padapter, u8 bFuncEn)
1442 {
1443         u8 u1H2CAPOffloadCtrlParm[H2C_WOWLAN_LEN]={0};
1444
1445         DBG_871X("%s(): bFuncEn =%d\n", __func__, bFuncEn);
1446
1447         SET_H2CCMD_AP_WOWLAN_EN(u1H2CAPOffloadCtrlParm, bFuncEn);
1448
1449         FillH2CCmd8723B(padapter, H2C_8723B_AP_OFFLOAD,
1450                         H2C_AP_OFFLOAD_LEN, u1H2CAPOffloadCtrlParm);
1451 }
1452
1453 static void rtl8723b_set_AP_FwWoWlan_cmd(struct adapter *padapter, u8 enable)
1454 {
1455         DBG_871X_LEVEL(_drv_always_, "+%s()+: enable =%d\n", __func__, enable);
1456         if (enable) {
1457                 rtl8723b_set_FwJoinBssRpt_cmd(padapter, RT_MEDIA_CONNECT);
1458                 issue_beacon(padapter, 0);
1459         }
1460
1461         rtl8723b_set_FwAPWoWlanCtrl_Cmd(padapter, enable);
1462         msleep(10);
1463         rtl8723b_set_Fw_AP_Offload_Cmd(padapter, enable);
1464         msleep(10);
1465         DBG_871X_LEVEL(_drv_always_, "-%s()-\n", __func__);
1466         return ;
1467 }
1468
1469 void rtl8723b_set_ap_wowlan_cmd(struct adapter *padapter, u8 enable)
1470 {
1471         rtl8723b_set_AP_FwWoWlan_cmd(padapter, enable);
1472 }
1473 #endif /* CONFIG_AP_WOWLAN */
1474
1475 /*  */
1476 /*  Description: Fill the reserved packets that FW will use to RSVD page. */
1477 /*                      Now we just send 4 types packet to rsvd page. */
1478 /*                      (1)Beacon, (2)Ps-poll, (3)Null data, (4)ProbeRsp. */
1479 /*      Input: */
1480 /*          bDLFinished - false: At the first time we will send all the packets as a large packet to Hw, */
1481 /*                                              so we need to set the packet length to total lengh. */
1482 /*                            true: At the second time, we should send the first packet (default:beacon) */
1483 /*                                              to Hw again and set the lengh in descriptor to the real beacon lengh. */
1484 /*  2009.10.15 by tynli. */
1485 static void rtl8723b_set_FwRsvdPagePkt(struct adapter *padapter, bool bDLFinished)
1486 {
1487         struct hal_com_data *pHalData;
1488         struct xmit_frame       *pcmdframe;
1489         struct pkt_attrib       *pattrib;
1490         struct xmit_priv *pxmitpriv;
1491         struct mlme_ext_priv *pmlmeext;
1492         struct mlme_ext_info *pmlmeinfo;
1493         struct pwrctrl_priv *pwrctl;
1494         struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
1495         u32 BeaconLength = 0, PSPollLength = 0;
1496         u32 NullDataLength = 0, QosNullLength = 0, BTQosNullLength = 0;
1497         u8 *ReservedPagePacket;
1498         u8 TxDescLen = TXDESC_SIZE, TxDescOffset = TXDESC_OFFSET;
1499         u8 TotalPageNum = 0, CurtPktPageNum = 0, RsvdPageNum = 0;
1500         u16 BufIndex, PageSize = 128;
1501         u32 TotalPacketLen, MaxRsvdPageBufSize = 0;
1502         RSVDPAGE_LOC    RsvdPageLoc;
1503 #ifdef CONFIG_WOWLAN
1504         u32 ARPLegnth = 0, GTKLegnth = 0;
1505         u8 currentip[4];
1506         u8 cur_dot11txpn[8];
1507 #ifdef CONFIG_GTK_OL
1508         struct sta_priv *pstapriv = &padapter->stapriv;
1509         struct sta_info * psta;
1510         u8 kek[RTW_KEK_LEN];
1511         u8 kck[RTW_KCK_LEN];
1512 #endif
1513 #endif
1514
1515         /* DBG_871X("%s---->\n", __func__); */
1516
1517         pHalData = GET_HAL_DATA(padapter);
1518         pxmitpriv = &padapter->xmitpriv;
1519         pmlmeext = &padapter->mlmeextpriv;
1520         pmlmeinfo = &pmlmeext->mlmext_info;
1521         pwrctl = adapter_to_pwrctl(padapter);
1522
1523         RsvdPageNum = BCNQ_PAGE_NUM_8723B + WOWLAN_PAGE_NUM_8723B;
1524         MaxRsvdPageBufSize = RsvdPageNum*PageSize;
1525
1526         pcmdframe = rtw_alloc_cmdxmitframe(pxmitpriv);
1527         if (pcmdframe == NULL) {
1528                 DBG_871X("%s: alloc ReservedPagePacket fail!\n", __func__);
1529                 return;
1530         }
1531
1532         ReservedPagePacket = pcmdframe->buf_addr;
1533         memset(&RsvdPageLoc, 0, sizeof(RSVDPAGE_LOC));
1534
1535         /* 3 (1) beacon */
1536         BufIndex = TxDescOffset;
1537         ConstructBeacon(padapter, &ReservedPagePacket[BufIndex], &BeaconLength);
1538
1539         /*  When we count the first page size, we need to reserve description size for the RSVD */
1540         /*  packet, it will be filled in front of the packet in TXPKTBUF. */
1541         CurtPktPageNum = (u8)PageNum_128(TxDescLen + BeaconLength);
1542         /* If we don't add 1 more page, the WOWLAN function has a problem. Baron thinks it's a bug of firmware */
1543         if (CurtPktPageNum == 1)
1544         {
1545                 CurtPktPageNum += 1;
1546         }
1547         TotalPageNum += CurtPktPageNum;
1548
1549         BufIndex += (CurtPktPageNum*PageSize);
1550
1551         /* 3 (2) ps-poll */
1552         RsvdPageLoc.LocPsPoll = TotalPageNum;
1553         ConstructPSPoll(padapter, &ReservedPagePacket[BufIndex], &PSPollLength);
1554         rtl8723b_fill_fake_txdesc(padapter, &ReservedPagePacket[BufIndex-TxDescLen], PSPollLength, true, false, false);
1555
1556         /* DBG_871X("%s(): HW_VAR_SET_TX_CMD: PS-POLL %p %d\n", */
1557         /*      __func__, &ReservedPagePacket[BufIndex-TxDescLen], (PSPollLength+TxDescLen)); */
1558
1559         CurtPktPageNum = (u8)PageNum_128(TxDescLen + PSPollLength);
1560
1561         TotalPageNum += CurtPktPageNum;
1562
1563         BufIndex += (CurtPktPageNum*PageSize);
1564
1565         /* 3 (3) null data */
1566         RsvdPageLoc.LocNullData = TotalPageNum;
1567         ConstructNullFunctionData(
1568                 padapter,
1569                 &ReservedPagePacket[BufIndex],
1570                 &NullDataLength,
1571                 get_my_bssid(&pmlmeinfo->network),
1572                 false, 0, 0, false);
1573         rtl8723b_fill_fake_txdesc(padapter, &ReservedPagePacket[BufIndex-TxDescLen], NullDataLength, false, false, false);
1574
1575         /* DBG_871X("%s(): HW_VAR_SET_TX_CMD: NULL DATA %p %d\n", */
1576         /*      __func__, &ReservedPagePacket[BufIndex-TxDescLen], (NullDataLength+TxDescLen)); */
1577
1578         CurtPktPageNum = (u8)PageNum_128(TxDescLen + NullDataLength);
1579
1580         TotalPageNum += CurtPktPageNum;
1581
1582         BufIndex += (CurtPktPageNum*PageSize);
1583
1584         /* 3 (5) Qos null data */
1585         RsvdPageLoc.LocQosNull = TotalPageNum;
1586         ConstructNullFunctionData(
1587                 padapter,
1588                 &ReservedPagePacket[BufIndex],
1589                 &QosNullLength,
1590                 get_my_bssid(&pmlmeinfo->network),
1591                 true, 0, 0, false);
1592         rtl8723b_fill_fake_txdesc(padapter, &ReservedPagePacket[BufIndex-TxDescLen], QosNullLength, false, false, false);
1593
1594         /* DBG_871X("%s(): HW_VAR_SET_TX_CMD: QOS NULL DATA %p %d\n", */
1595         /*      __func__, &ReservedPagePacket[BufIndex-TxDescLen], (QosNullLength+TxDescLen)); */
1596
1597         CurtPktPageNum = (u8)PageNum_128(TxDescLen + QosNullLength);
1598
1599         TotalPageNum += CurtPktPageNum;
1600
1601         BufIndex += (CurtPktPageNum*PageSize);
1602
1603         /* 3 (6) BT Qos null data */
1604         RsvdPageLoc.LocBTQosNull = TotalPageNum;
1605         ConstructNullFunctionData(
1606                 padapter,
1607                 &ReservedPagePacket[BufIndex],
1608                 &BTQosNullLength,
1609                 get_my_bssid(&pmlmeinfo->network),
1610                 true, 0, 0, false);
1611         rtl8723b_fill_fake_txdesc(padapter, &ReservedPagePacket[BufIndex-TxDescLen], BTQosNullLength, false, true, false);
1612
1613         /* DBG_871X("%s(): HW_VAR_SET_TX_CMD: BT QOS NULL DATA %p %d\n", */
1614         /*      __func__, &ReservedPagePacket[BufIndex-TxDescLen], (BTQosNullLength+TxDescLen)); */
1615
1616         CurtPktPageNum = (u8)PageNum_128(TxDescLen + BTQosNullLength);
1617
1618         TotalPageNum += CurtPktPageNum;
1619
1620         BufIndex += (CurtPktPageNum*PageSize);
1621
1622 #ifdef CONFIG_WOWLAN
1623         if (check_fwstate(pmlmepriv, _FW_LINKED)) {
1624         /* if (pwrctl->wowlan_mode == true) { */
1625                 /* BufIndex += (CurtPktPageNum*PageSize); */
1626
1627         /* 3(7) ARP RSP */
1628         rtw_get_current_ip_address(padapter, currentip);
1629         RsvdPageLoc.LocArpRsp = TotalPageNum;
1630         {
1631         ConstructARPResponse(
1632                 padapter,
1633                 &ReservedPagePacket[BufIndex],
1634                 &ARPLegnth,
1635                 currentip
1636                 );
1637         rtl8723b_fill_fake_txdesc(padapter, &ReservedPagePacket[BufIndex-TxDescLen], ARPLegnth, false, false, true);
1638
1639         /* DBG_871X("%s(): HW_VAR_SET_TX_CMD: ARP RSP %p %d\n", */
1640         /*      __func__, &ReservedPagePacket[BufIndex-TxDescLen], (ARPLegnth+TxDescLen)); */
1641
1642         CurtPktPageNum = (u8)PageNum_128(TxDescLen + ARPLegnth);
1643         }
1644         TotalPageNum += CurtPktPageNum;
1645
1646         BufIndex += (CurtPktPageNum*PageSize);
1647
1648         /* 3(8) SEC IV */
1649         rtw_get_sec_iv(padapter, cur_dot11txpn, get_my_bssid(&pmlmeinfo->network));
1650         RsvdPageLoc.LocRemoteCtrlInfo = TotalPageNum;
1651         memcpy(ReservedPagePacket+BufIndex-TxDescLen, cur_dot11txpn, _AES_IV_LEN_);
1652
1653         /* DBG_871X("%s(): HW_VAR_SET_TX_CMD: SEC IV %p %d\n", */
1654         /*      __func__, &ReservedPagePacket[BufIndex-TxDescLen], _AES_IV_LEN_); */
1655
1656         CurtPktPageNum = (u8)PageNum_128(_AES_IV_LEN_);
1657
1658         TotalPageNum += CurtPktPageNum;
1659
1660 #ifdef CONFIG_GTK_OL
1661         BufIndex += (CurtPktPageNum*PageSize);
1662
1663         /* if the ap staion info. exists, get the kek, kck from staion info. */
1664         psta = rtw_get_stainfo(pstapriv, get_bssid(pmlmepriv));
1665         if (psta == NULL)
1666         {
1667                 memset(kek, 0, RTW_KEK_LEN);
1668                 memset(kck, 0, RTW_KCK_LEN);
1669                 DBG_8192C("%s, KEK, KCK download rsvd page all zero\n", __func__);
1670         }
1671         else
1672         {
1673                 memcpy(kek, psta->kek, RTW_KEK_LEN);
1674                 memcpy(kck, psta->kck, RTW_KCK_LEN);
1675         }
1676
1677         /* 3(9) KEK, KCK */
1678         RsvdPageLoc.LocGTKInfo = TotalPageNum;
1679         memcpy(ReservedPagePacket+BufIndex-TxDescLen, kck, RTW_KCK_LEN);
1680         memcpy(ReservedPagePacket+BufIndex-TxDescLen+RTW_KCK_LEN, kek, RTW_KEK_LEN);
1681
1682         /* DBG_871X("%s(): HW_VAR_SET_TX_CMD: KEK KCK %p %d\n", */
1683         /*      __func__, &ReservedPagePacket[BufIndex-TxDescLen], (TxDescLen + RTW_KCK_LEN + RTW_KEK_LEN)); */
1684
1685         CurtPktPageNum = (u8)PageNum_128(TxDescLen + RTW_KCK_LEN + RTW_KEK_LEN);
1686
1687         TotalPageNum += CurtPktPageNum;
1688
1689         BufIndex += (CurtPktPageNum*PageSize);
1690
1691         /* 3(10) GTK Response */
1692         RsvdPageLoc.LocGTKRsp = TotalPageNum;
1693         ConstructGTKResponse(
1694                 padapter,
1695                 &ReservedPagePacket[BufIndex],
1696                 &GTKLegnth
1697                 );
1698
1699         rtl8723b_fill_fake_txdesc(padapter, &ReservedPagePacket[BufIndex-TxDescLen], GTKLegnth, false, false, true);
1700         /* DBG_871X("%s(): HW_VAR_SET_TX_CMD: GTK RSP %p %d\n", */
1701         /*      __func__, &ReservedPagePacket[BufIndex-TxDescLen], (TxDescLen + GTKLegnth)); */
1702
1703         CurtPktPageNum = (u8)PageNum_128(TxDescLen + GTKLegnth);
1704
1705         TotalPageNum += CurtPktPageNum;
1706
1707         BufIndex += (CurtPktPageNum*PageSize);
1708
1709         /* below page is empty for GTK extension memory */
1710         /* 3(11) GTK EXT MEM */
1711         RsvdPageLoc.LocGTKEXTMEM = TotalPageNum;
1712
1713         CurtPktPageNum = 2;
1714
1715         TotalPageNum += CurtPktPageNum;
1716
1717         TotalPacketLen = BufIndex-TxDescLen + 256; /* extension memory for FW */
1718 #else
1719         TotalPacketLen = BufIndex-TxDescLen + sizeof (union pn48); /* IV len */
1720 #endif /* CONFIG_GTK_OL */
1721         } else
1722 #endif /* CONFIG_WOWLAN */
1723         {
1724 #ifdef CONFIG_PNO_SUPPORT
1725                 if (pwrctl->pno_in_resume == false && pwrctl->pno_inited == true) {
1726                         /* Probe Request */
1727                         RsvdPageLoc.LocProbePacket = TotalPageNum;
1728                         ConstructProbeReq(
1729                                 padapter,
1730                                 &ReservedPagePacket[BufIndex],
1731                                 &ProbeReqLength);
1732
1733                         rtl8723b_fill_fake_txdesc(padapter,
1734                                 &ReservedPagePacket[BufIndex-TxDescLen],
1735                                 ProbeReqLength, false, false, false);
1736 #ifdef CONFIG_PNO_SET_DEBUG
1737         {
1738                         int gj;
1739                         printk("probe req pkt =>\n");
1740                         for (gj = 0; gj < ProbeReqLength + TxDescLen; gj++) {
1741                                 printk(" %02x ", ReservedPagePacket[BufIndex- TxDescLen + gj]);
1742                                 if ((gj + 1)%8 == 0)
1743                                         printk("\n");
1744                         }
1745                         printk(" <=end\n");
1746         }
1747 #endif
1748                         CurtPktPageNum =
1749                                 (u8)PageNum_128(TxDescLen + ProbeReqLength);
1750
1751                         TotalPageNum += CurtPktPageNum;
1752
1753                         BufIndex += (CurtPktPageNum*PageSize);
1754
1755                         /* PNO INFO Page */
1756                         RsvdPageLoc.LocPNOInfo = TotalPageNum;
1757                         ConstructPnoInfo(padapter, &ReservedPagePacket[BufIndex -TxDescLen], &PNOLength);
1758 #ifdef CONFIG_PNO_SET_DEBUG
1759         {
1760                         int gj;
1761                         printk("PNO pkt =>\n");
1762                         for (gj = 0; gj < PNOLength; gj++) {
1763                                 printk(" %02x ", ReservedPagePacket[BufIndex-TxDescLen +gj]);
1764                                 if ((gj + 1)%8 == 0)
1765                                         printk("\n");
1766                         }
1767                         printk(" <=end\n");
1768         }
1769 #endif
1770
1771                         CurtPktPageNum = (u8)PageNum_128(PNOLength);
1772                         TotalPageNum += CurtPktPageNum;
1773                         BufIndex += (CurtPktPageNum*PageSize);
1774
1775                         /* SSID List Page */
1776                         RsvdPageLoc.LocSSIDInfo = TotalPageNum;
1777                         ConstructSSIDList(padapter, &ReservedPagePacket[BufIndex-TxDescLen], &SSIDLegnth);
1778 #ifdef CONFIG_PNO_SET_DEBUG
1779         {
1780                         int gj;
1781                         printk("SSID list pkt =>\n");
1782                         for (gj = 0; gj < SSIDLegnth; gj++) {
1783                                 printk(" %02x ", ReservedPagePacket[BufIndex-TxDescLen+gj]);
1784                                 if ((gj + 1)%8 == 0)
1785                                         printk("\n");
1786                         }
1787                         printk(" <=end\n");
1788         }
1789 #endif
1790                         CurtPktPageNum = (u8)PageNum_128(SSIDLegnth);
1791                         TotalPageNum += CurtPktPageNum;
1792                         BufIndex += (CurtPktPageNum*PageSize);
1793
1794                         /* Scan Info Page */
1795                         RsvdPageLoc.LocScanInfo = TotalPageNum;
1796                         ConstructScanInfo(padapter, &ReservedPagePacket[BufIndex-TxDescLen], &ScanInfoLength);
1797 #ifdef CONFIG_PNO_SET_DEBUG
1798         {
1799                         int gj;
1800                         printk("Scan info pkt =>\n");
1801                         for (gj = 0; gj < ScanInfoLength; gj++) {
1802                                 printk(" %02x ", ReservedPagePacket[BufIndex-TxDescLen+gj]);
1803                                 if ((gj + 1)%8 == 0)
1804                                         printk("\n");
1805                         }
1806                         printk(" <=end\n");
1807         }
1808 #endif
1809                         CurtPktPageNum = (u8)PageNum_128(ScanInfoLength);
1810                         TotalPageNum += CurtPktPageNum;
1811                         BufIndex += (CurtPktPageNum*PageSize);
1812
1813                         TotalPacketLen = BufIndex + ScanInfoLength;
1814                 } else {
1815                 TotalPacketLen = BufIndex + BTQosNullLength;
1816         }
1817 #else /* CONFIG_PNO_SUPPORT */
1818                 TotalPacketLen = BufIndex + BTQosNullLength;
1819 #endif
1820         }
1821
1822         if (TotalPacketLen > MaxRsvdPageBufSize)
1823         {
1824                 DBG_871X("%s(): ERROR: The rsvd page size is not enough!!TotalPacketLen %d, MaxRsvdPageBufSize %d\n", __func__,
1825                         TotalPacketLen, MaxRsvdPageBufSize);
1826                 goto error;
1827         }
1828         else
1829         {
1830                 /*  update attribute */
1831                 pattrib = &pcmdframe->attrib;
1832                 update_mgntframe_attrib(padapter, pattrib);
1833                 pattrib->qsel = 0x10;
1834                 pattrib->pktlen = pattrib->last_txcmdsz = TotalPacketLen - TxDescOffset;
1835                 dump_mgntframe_and_wait(padapter, pcmdframe, 100);
1836         }
1837
1838         DBG_871X("%s: Set RSVD page location to Fw , TotalPacketLen(%d), TotalPageNum(%d)\n", __func__, TotalPacketLen, TotalPageNum);
1839         if (check_fwstate(pmlmepriv, _FW_LINKED)) {
1840                 rtl8723b_set_FwRsvdPage_cmd(padapter, &RsvdPageLoc);
1841                 rtl8723b_set_FwAoacRsvdPage_cmd(padapter, &RsvdPageLoc);
1842         } else {
1843                 rtl8723b_set_FwAoacRsvdPage_cmd(padapter, &RsvdPageLoc);
1844 #ifdef CONFIG_PNO_SUPPORT
1845                 if (pwrctl->pno_in_resume)
1846                         rtl8723b_set_FwScanOffloadInfo_cmd(padapter,
1847                                         &RsvdPageLoc, 0);
1848                 else
1849                         rtl8723b_set_FwScanOffloadInfo_cmd(padapter,
1850                                         &RsvdPageLoc, 1);
1851 #endif
1852         }
1853         return;
1854
1855 error:
1856
1857         rtw_free_xmitframe(pxmitpriv, pcmdframe);
1858 }
1859
1860 #ifdef CONFIG_AP_WOWLAN
1861 /*  */
1862 /* Description: Fill the reserved packets that FW will use to RSVD page. */
1863 /* Now we just send 2 types packet to rsvd page. (1)Beacon, (2)ProbeRsp. */
1864 /*  */
1865 /* Input: bDLFinished */
1866 /*  */
1867 /* false: At the first time we will send all the packets as a large packet to Hw, */
1868 /*       so we need to set the packet length to total lengh. */
1869 /*  */
1870 /* true: At the second time, we should send the first packet (default:beacon) */
1871 /*      to Hw again and set the lengh in descriptor to the real beacon lengh. */
1872 /*  2009.10.15 by tynli. */
1873 static void rtl8723b_set_AP_FwRsvdPagePkt(struct adapter *padapter,
1874                 bool bDLFinished)
1875 {
1876         struct hal_com_data *pHalData;
1877         struct xmit_frame       *pcmdframe;
1878         struct pkt_attrib       *pattrib;
1879         struct xmit_priv *pxmitpriv;
1880         struct mlme_ext_priv *pmlmeext;
1881         struct mlme_ext_info *pmlmeinfo;
1882         struct pwrctrl_priv *pwrctl;
1883         u32 BeaconLength = 0, ProbeRspLength = 0;
1884         u8 *ReservedPagePacket;
1885         u8 TxDescLen = TXDESC_SIZE, TxDescOffset = TXDESC_OFFSET;
1886         u8 TotalPageNum = 0, CurtPktPageNum = 0, RsvdPageNum = 0;
1887         u8 currentip[4];
1888         u16 BufIndex, PageSize = 128;
1889         u32 TotalPacketLen = 0, MaxRsvdPageBufSize = 0;
1890         RSVDPAGE_LOC    RsvdPageLoc;
1891
1892         /* DBG_871X("%s---->\n", __func__); */
1893         DBG_8192C("+" FUNC_ADPT_FMT ": iface_type =%d\n",
1894                 FUNC_ADPT_ARG(padapter), get_iface_type(padapter));
1895
1896         pHalData = GET_HAL_DATA(padapter);
1897         pxmitpriv = &padapter->xmitpriv;
1898         pmlmeext = &padapter->mlmeextpriv;
1899         pmlmeinfo = &pmlmeext->mlmext_info;
1900         pwrctl = adapter_to_pwrctl(padapter);
1901
1902         RsvdPageNum = BCNQ_PAGE_NUM_8723B + AP_WOWLAN_PAGE_NUM_8723B;
1903         MaxRsvdPageBufSize = RsvdPageNum*PageSize;
1904
1905         pcmdframe = rtw_alloc_cmdxmitframe(pxmitpriv);
1906         if (pcmdframe == NULL) {
1907                 DBG_871X("%s: alloc ReservedPagePacket fail!\n", __func__);
1908                 return;
1909         }
1910
1911         ReservedPagePacket = pcmdframe->buf_addr;
1912         memset(&RsvdPageLoc, 0, sizeof(RSVDPAGE_LOC));
1913
1914         /* 3 (1) beacon */
1915         BufIndex = TxDescOffset;
1916         ConstructBeacon(padapter, &ReservedPagePacket[BufIndex], &BeaconLength);
1917
1918         /*  When we count the first page size, we need to reserve description size for the RSVD */
1919         /*  packet, it will be filled in front of the packet in TXPKTBUF. */
1920         CurtPktPageNum = (u8)PageNum_128(TxDescLen + BeaconLength);
1921         /* If we don't add 1 more page, the WOWLAN function has a problem. Baron thinks it's a bug of firmware */
1922         if (CurtPktPageNum == 1)
1923         {
1924                 CurtPktPageNum += 1;
1925         }
1926         TotalPageNum += CurtPktPageNum;
1927
1928         BufIndex += (CurtPktPageNum*PageSize);
1929
1930         /* 2 (4) probe response */
1931         RsvdPageLoc.LocProbeRsp = TotalPageNum;
1932
1933         rtw_get_current_ip_address(padapter, currentip);
1934
1935         ConstructProbeRsp(
1936                 padapter,
1937                 &ReservedPagePacket[BufIndex],
1938                 &ProbeRspLength,
1939                 currentip,
1940                 false);
1941         rtl8723b_fill_fake_txdesc(padapter,
1942                         &ReservedPagePacket[BufIndex-TxDescLen],
1943                         ProbeRspLength,
1944                         false, false, false);
1945
1946         DBG_871X("%s(): HW_VAR_SET_TX_CMD: PROBE RSP %p %d\n",
1947                 __func__, &ReservedPagePacket[BufIndex-TxDescLen],
1948                 (ProbeRspLength+TxDescLen));
1949
1950         CurtPktPageNum = (u8)PageNum_128(TxDescLen + ProbeRspLength);
1951
1952         TotalPageNum += CurtPktPageNum;
1953
1954         BufIndex += (CurtPktPageNum*PageSize);
1955
1956         TotalPacketLen = BufIndex + ProbeRspLength;
1957
1958         if (TotalPacketLen > MaxRsvdPageBufSize) {
1959                 DBG_871X("%s(): ERROR: The rsvd page size is not enough \
1960                                 !!TotalPacketLen %d, MaxRsvdPageBufSize %d\n",
1961                                 __func__, TotalPacketLen, MaxRsvdPageBufSize);
1962                 goto error;
1963         } else {
1964                 /*  update attribute */
1965                 pattrib = &pcmdframe->attrib;
1966                 update_mgntframe_attrib(padapter, pattrib);
1967                 pattrib->qsel = 0x10;
1968                 pattrib->pktlen = TotalPacketLen - TxDescOffset;
1969                 pattrib->last_txcmdsz = TotalPacketLen - TxDescOffset;
1970                 dump_mgntframe_and_wait(padapter, pcmdframe, 100);
1971         }
1972
1973         DBG_871X("%s: Set RSVD page location to Fw , TotalPacketLen(%d), TotalPageNum(%d)\n", __func__, TotalPacketLen, TotalPageNum);
1974         rtl8723b_set_ap_wow_rsvdpage_cmd(padapter, &RsvdPageLoc);
1975
1976         return;
1977 error:
1978         rtw_free_xmitframe(pxmitpriv, pcmdframe);
1979 }
1980 #endif /* CONFIG_AP_WOWLAN */
1981
1982         void rtl8723b_download_rsvd_page(struct adapter *padapter, u8 mstatus)
1983 {
1984         struct hal_com_data     *pHalData = GET_HAL_DATA(padapter);
1985 #ifdef CONFIG_AP_WOWLAN
1986         struct pwrctrl_priv *pwrpriv = adapter_to_pwrctl(padapter);
1987 #endif
1988         struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
1989         struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
1990         bool            bcn_valid = false;
1991         u8 DLBcnCount = 0;
1992         u32 poll = 0;
1993         u8 val8;
1994
1995         DBG_8192C("+" FUNC_ADPT_FMT ": iface_type =%d mstatus(%x)\n",
1996                 FUNC_ADPT_ARG(padapter), get_iface_type(padapter), mstatus);
1997
1998         if (mstatus == RT_MEDIA_CONNECT)
1999         {
2000                 bool bRecover = false;
2001                 u8 v8;
2002
2003                 /*  We should set AID, correct TSF, HW seq enable before set JoinBssReport to Fw in 88/92C. */
2004                 /*  Suggested by filen. Added by tynli. */
2005                 rtw_write16(padapter, REG_BCN_PSR_RPT, (0xC000|pmlmeinfo->aid));
2006
2007                 /*  set REG_CR bit 8 */
2008                 v8 = rtw_read8(padapter, REG_CR+1);
2009                 v8 |= BIT(0); /*  ENSWBCN */
2010                 rtw_write8(padapter,  REG_CR+1, v8);
2011
2012                 /*  Disable Hw protection for a time which revserd for Hw sending beacon. */
2013                 /*  Fix download reserved page packet fail that access collision with the protection time. */
2014                 /*  2010.05.11. Added by tynli. */
2015                 val8 = rtw_read8(padapter, REG_BCN_CTRL);
2016                 val8 &= ~EN_BCN_FUNCTION;
2017                 val8 |= DIS_TSF_UDT;
2018                 rtw_write8(padapter, REG_BCN_CTRL, val8);
2019
2020                 /*  Set FWHW_TXQ_CTRL 0x422[6]= 0 to tell Hw the packet is not a real beacon frame. */
2021                 if (pHalData->RegFwHwTxQCtrl & BIT(6))
2022                         bRecover = true;
2023
2024                 /*  To tell Hw the packet is not a real beacon frame. */
2025                 rtw_write8(padapter, REG_FWHW_TXQ_CTRL+2, pHalData->RegFwHwTxQCtrl & ~BIT(6));
2026                 pHalData->RegFwHwTxQCtrl &= ~BIT(6);
2027
2028                 /*  Clear beacon valid check bit. */
2029                 rtw_hal_set_hwreg(padapter, HW_VAR_BCN_VALID, NULL);
2030                 rtw_hal_set_hwreg(padapter, HW_VAR_DL_BCN_SEL, NULL);
2031
2032                 DLBcnCount = 0;
2033                 poll = 0;
2034                 do {
2035 #ifdef CONFIG_AP_WOWLAN
2036                         if (pwrpriv->wowlan_ap_mode)
2037                                 rtl8723b_set_AP_FwRsvdPagePkt(padapter, 0);
2038                         else
2039                                 rtl8723b_set_FwRsvdPagePkt(padapter, 0);
2040 #else
2041                         /*  download rsvd page. */
2042                         rtl8723b_set_FwRsvdPagePkt(padapter, 0);
2043 #endif
2044                         DLBcnCount++;
2045                         do
2046                         {
2047                                 yield();
2048                                 /* mdelay(10); */
2049                                 /*  check rsvd page download OK. */
2050                                 rtw_hal_get_hwreg(padapter, HW_VAR_BCN_VALID, (u8 *)(&bcn_valid));
2051                                 poll++;
2052                         } while (!bcn_valid && (poll%10)!= 0 && !padapter->bSurpriseRemoved && !padapter->bDriverStopped);
2053
2054                 }while (!bcn_valid && DLBcnCount<= 100 && !padapter->bSurpriseRemoved && !padapter->bDriverStopped);
2055
2056                 if (padapter->bSurpriseRemoved || padapter->bDriverStopped)
2057                 {
2058                 }
2059                 else if (!bcn_valid)
2060                         DBG_871X(ADPT_FMT": 1 DL RSVD page failed! DLBcnCount:%u, poll:%u\n",
2061                                 ADPT_ARG(padapter) , DLBcnCount, poll);
2062                 else {
2063                         struct pwrctrl_priv *pwrctl = adapter_to_pwrctl(padapter);
2064                         pwrctl->fw_psmode_iface_id = padapter->iface_id;
2065                         DBG_871X(ADPT_FMT": 1 DL RSVD page success! DLBcnCount:%u, poll:%u\n",
2066                                 ADPT_ARG(padapter), DLBcnCount, poll);
2067                 }
2068
2069                 /*  2010.05.11. Added by tynli. */
2070                 val8 = rtw_read8(padapter, REG_BCN_CTRL);
2071                 val8 |= EN_BCN_FUNCTION;
2072                 val8 &= ~DIS_TSF_UDT;
2073                 rtw_write8(padapter, REG_BCN_CTRL, val8);
2074
2075                 /*  To make sure that if there exists an adapter which would like to send beacon. */
2076                 /*  If exists, the origianl value of 0x422[6] will be 1, we should check this to */
2077                 /*  prevent from setting 0x422[6] to 0 after download reserved page, or it will cause */
2078                 /*  the beacon cannot be sent by HW. */
2079                 /*  2010.06.23. Added by tynli. */
2080                 if (bRecover)
2081                 {
2082                         rtw_write8(padapter, REG_FWHW_TXQ_CTRL+2, pHalData->RegFwHwTxQCtrl | BIT(6));
2083                         pHalData->RegFwHwTxQCtrl |= BIT(6);
2084                 }
2085
2086                 /*  Clear CR[8] or beacon packet will not be send to TxBuf anymore. */
2087                 v8 = rtw_read8(padapter, REG_CR+1);
2088                 v8 &= ~BIT(0); /*  ~ENSWBCN */
2089                 rtw_write8(padapter, REG_CR+1, v8);
2090         }
2091 }
2092
2093 void rtl8723b_set_rssi_cmd(struct adapter *padapter, u8 *param)
2094 {
2095         rtl8723b_set_FwRssiSetting_cmd(padapter, param);
2096 }
2097
2098 void rtl8723b_set_FwJoinBssRpt_cmd(struct adapter *padapter, u8 mstatus)
2099 {
2100         if (mstatus == 1)
2101                 rtl8723b_download_rsvd_page(padapter, RT_MEDIA_CONNECT);
2102 }
2103
2104 /* arg[0] = macid */
2105 /* arg[1] = raid */
2106 /* arg[2] = shortGIrate */
2107 /* arg[3] = init_rate */
2108 void rtl8723b_Add_RateATid(struct adapter *padapter, u32 bitmap, u8 *arg, u8 rssi_level)
2109 {
2110         struct hal_com_data     *pHalData = GET_HAL_DATA(padapter);
2111         struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
2112         struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
2113         struct sta_info *psta;
2114         u8 mac_id = arg[0];
2115         u8 raid = arg[1];
2116         u8 shortGI = arg[2];
2117         u8 bw;
2118         u32 mask = bitmap&0x0FFFFFFF;
2119
2120         psta = pmlmeinfo->FW_sta_info[mac_id].psta;
2121         if (psta == NULL)
2122         {
2123                 return;
2124         }
2125
2126         bw = psta->bw_mode;
2127
2128         if (rssi_level != DM_RATR_STA_INIT)
2129                 mask = ODM_Get_Rate_Bitmap(&pHalData->odmpriv, mac_id, mask, rssi_level);
2130
2131         DBG_871X("%s(): mac_id =%d raid = 0x%x bw =%d mask = 0x%x\n", __func__, mac_id, raid, bw, mask);
2132         rtl8723b_set_FwMacIdConfig_cmd(padapter, mac_id, raid, bw, shortGI, mask);
2133 }
2134
2135 static void ConstructBtNullFunctionData(
2136         struct adapter *padapter,
2137         u8 *pframe,
2138         u32 *pLength,
2139         u8 *StaAddr,
2140         u8 bQoS,
2141         u8 AC,
2142         u8 bEosp,
2143         u8 bForcePowerSave)
2144 {
2145         struct ieee80211_hdr *pwlanhdr;
2146         __le16 *fctrl;
2147         u32 pktlen;
2148         struct mlme_ext_priv *pmlmeext;
2149         struct mlme_ext_info *pmlmeinfo;
2150         u8 bssid[ETH_ALEN];
2151
2152
2153         DBG_871X("+" FUNC_ADPT_FMT ": qos =%d eosp =%d ps =%d\n",
2154                 FUNC_ADPT_ARG(padapter), bQoS, bEosp, bForcePowerSave);
2155
2156         pwlanhdr = (struct ieee80211_hdr*)pframe;
2157         pmlmeext = &padapter->mlmeextpriv;
2158         pmlmeinfo = &pmlmeext->mlmext_info;
2159
2160         if (NULL == StaAddr)
2161         {
2162                 memcpy(bssid, myid(&padapter->eeprompriv), ETH_ALEN);
2163                 StaAddr = bssid;
2164         }
2165
2166         fctrl = &pwlanhdr->frame_control;
2167         *fctrl = 0;
2168         if (bForcePowerSave)
2169                 SetPwrMgt(fctrl);
2170
2171         SetFrDs(fctrl);
2172         memcpy(pwlanhdr->addr1, StaAddr, ETH_ALEN);
2173         memcpy(pwlanhdr->addr2, myid(&padapter->eeprompriv), ETH_ALEN);
2174         memcpy(pwlanhdr->addr3, myid(&padapter->eeprompriv), ETH_ALEN);
2175
2176         SetDuration(pwlanhdr, 0);
2177         SetSeqNum(pwlanhdr, 0);
2178
2179         if (bQoS == true)
2180         {
2181                 struct ieee80211_qos_hdr *pwlanqoshdr;
2182
2183                 SetFrameSubType(pframe, WIFI_QOS_DATA_NULL);
2184
2185                 pwlanqoshdr = (struct ieee80211_qos_hdr*)pframe;
2186                 SetPriority(&pwlanqoshdr->qos_ctrl, AC);
2187                 SetEOSP(&pwlanqoshdr->qos_ctrl, bEosp);
2188
2189                 pktlen = sizeof(struct ieee80211_qos_hdr);
2190         }
2191         else
2192         {
2193                 SetFrameSubType(pframe, WIFI_DATA_NULL);
2194
2195                 pktlen = sizeof(struct ieee80211_hdr_3addr);
2196         }
2197
2198         *pLength = pktlen;
2199 }
2200
2201 static void SetFwRsvdPagePkt_BTCoex(struct adapter *padapter)
2202 {
2203         struct hal_com_data *pHalData;
2204         struct xmit_frame *pcmdframe;
2205         struct pkt_attrib *pattrib;
2206         struct xmit_priv *pxmitpriv;
2207         struct mlme_ext_priv *pmlmeext;
2208         struct mlme_ext_info *pmlmeinfo;
2209         u32 BeaconLength = 0;
2210         u32 BTQosNullLength = 0;
2211         u8 *ReservedPagePacket;
2212         u8 TxDescLen, TxDescOffset;
2213         u8 TotalPageNum = 0, CurtPktPageNum = 0, RsvdPageNum = 0;
2214         u16 BufIndex, PageSize;
2215         u32 TotalPacketLen, MaxRsvdPageBufSize = 0;
2216         RSVDPAGE_LOC RsvdPageLoc;
2217
2218
2219 /*      DBG_8192C("+" FUNC_ADPT_FMT "\n", FUNC_ADPT_ARG(padapter)); */
2220
2221         pHalData = GET_HAL_DATA(padapter);
2222         pxmitpriv = &padapter->xmitpriv;
2223         pmlmeext = &padapter->mlmeextpriv;
2224         pmlmeinfo = &pmlmeext->mlmext_info;
2225         TxDescLen = TXDESC_SIZE;
2226         TxDescOffset = TXDESC_OFFSET;
2227         PageSize = PAGE_SIZE_TX_8723B;
2228
2229         RsvdPageNum = BCNQ_PAGE_NUM_8723B;
2230         MaxRsvdPageBufSize = RsvdPageNum*PageSize;
2231
2232         pcmdframe = rtw_alloc_cmdxmitframe(pxmitpriv);
2233         if (pcmdframe == NULL) {
2234                 DBG_8192C("%s: alloc ReservedPagePacket fail!\n", __func__);
2235                 return;
2236         }
2237
2238         ReservedPagePacket = pcmdframe->buf_addr;
2239         memset(&RsvdPageLoc, 0, sizeof(RSVDPAGE_LOC));
2240
2241         /* 3 (1) beacon */
2242         BufIndex = TxDescOffset;
2243         ConstructBeacon(padapter, &ReservedPagePacket[BufIndex], &BeaconLength);
2244
2245         /*  When we count the first page size, we need to reserve description size for the RSVD */
2246         /*  packet, it will be filled in front of the packet in TXPKTBUF. */
2247         CurtPktPageNum = (u8)PageNum_128(TxDescLen + BeaconLength);
2248         /* If we don't add 1 more page, the WOWLAN function has a problem. Baron thinks it's a bug of firmware */
2249         if (CurtPktPageNum == 1)
2250         {
2251                 CurtPktPageNum += 1;
2252         }
2253         TotalPageNum += CurtPktPageNum;
2254
2255         BufIndex += (CurtPktPageNum*PageSize);
2256
2257         /*  Jump to lastest page */
2258         if (BufIndex < (MaxRsvdPageBufSize - PageSize))
2259         {
2260                 BufIndex = TxDescOffset + (MaxRsvdPageBufSize - PageSize);
2261                 TotalPageNum = BCNQ_PAGE_NUM_8723B - 1;
2262         }
2263
2264         /* 3 (6) BT Qos null data */
2265         RsvdPageLoc.LocBTQosNull = TotalPageNum;
2266         ConstructBtNullFunctionData(
2267                 padapter,
2268                 &ReservedPagePacket[BufIndex],
2269                 &BTQosNullLength,
2270                 NULL,
2271                 true, 0, 0, false);
2272         rtl8723b_fill_fake_txdesc(padapter, &ReservedPagePacket[BufIndex-TxDescLen], BTQosNullLength, false, true, false);
2273
2274         CurtPktPageNum = (u8)PageNum_128(TxDescLen + BTQosNullLength);
2275
2276         TotalPageNum += CurtPktPageNum;
2277
2278         TotalPacketLen = BufIndex + BTQosNullLength;
2279         if (TotalPacketLen > MaxRsvdPageBufSize)
2280         {
2281                 DBG_8192C(FUNC_ADPT_FMT ": ERROR: The rsvd page size is not enough!!TotalPacketLen %d, MaxRsvdPageBufSize %d\n",
2282                         FUNC_ADPT_ARG(padapter), TotalPacketLen, MaxRsvdPageBufSize);
2283                 goto error;
2284         }
2285
2286         /*  update attribute */
2287         pattrib = &pcmdframe->attrib;
2288         update_mgntframe_attrib(padapter, pattrib);
2289         pattrib->qsel = 0x10;
2290         pattrib->pktlen = pattrib->last_txcmdsz = TotalPacketLen - TxDescOffset;
2291         dump_mgntframe_and_wait(padapter, pcmdframe, 100);
2292
2293 /*      DBG_8192C(FUNC_ADPT_FMT ": Set RSVD page location to Fw, TotalPacketLen(%d), TotalPageNum(%d)\n", */
2294 /*              FUNC_ADPT_ARG(padapter), TotalPacketLen, TotalPageNum); */
2295         rtl8723b_set_FwRsvdPage_cmd(padapter, &RsvdPageLoc);
2296         rtl8723b_set_FwAoacRsvdPage_cmd(padapter, &RsvdPageLoc);
2297
2298         return;
2299
2300 error:
2301         rtw_free_xmitframe(pxmitpriv, pcmdframe);
2302 }
2303
2304 void rtl8723b_download_BTCoex_AP_mode_rsvd_page(struct adapter *padapter)
2305 {
2306         struct hal_com_data *pHalData;
2307         struct mlme_ext_priv *pmlmeext;
2308         struct mlme_ext_info *pmlmeinfo;
2309         u8 bRecover = false;
2310         u8 bcn_valid = false;
2311         u8 DLBcnCount = 0;
2312         u32 poll = 0;
2313         u8 val8;
2314
2315
2316         DBG_8192C("+" FUNC_ADPT_FMT ": iface_type =%d fw_state = 0x%08X\n",
2317                 FUNC_ADPT_ARG(padapter), get_iface_type(padapter), get_fwstate(&padapter->mlmepriv));
2318
2319 #ifdef CONFIG_DEBUG
2320         if (check_fwstate(&padapter->mlmepriv, WIFI_AP_STATE) == false)
2321         {
2322                 DBG_8192C(FUNC_ADPT_FMT ": [WARNING] not in AP mode!!\n",
2323                         FUNC_ADPT_ARG(padapter));
2324         }
2325 #endif /*  CONFIG_DEBUG */
2326
2327         pHalData = GET_HAL_DATA(padapter);
2328         pmlmeext = &padapter->mlmeextpriv;
2329         pmlmeinfo = &pmlmeext->mlmext_info;
2330
2331         /*  We should set AID, correct TSF, HW seq enable before set JoinBssReport to Fw in 88/92C. */
2332         /*  Suggested by filen. Added by tynli. */
2333         rtw_write16(padapter, REG_BCN_PSR_RPT, (0xC000|pmlmeinfo->aid));
2334
2335         /*  set REG_CR bit 8 */
2336         val8 = rtw_read8(padapter, REG_CR+1);
2337         val8 |= BIT(0); /*  ENSWBCN */
2338         rtw_write8(padapter,  REG_CR+1, val8);
2339
2340         /*  Disable Hw protection for a time which revserd for Hw sending beacon. */
2341         /*  Fix download reserved page packet fail that access collision with the protection time. */
2342         /*  2010.05.11. Added by tynli. */
2343         val8 = rtw_read8(padapter, REG_BCN_CTRL);
2344         val8 &= ~EN_BCN_FUNCTION;
2345         val8 |= DIS_TSF_UDT;
2346         rtw_write8(padapter, REG_BCN_CTRL, val8);
2347
2348         /*  Set FWHW_TXQ_CTRL 0x422[6]= 0 to tell Hw the packet is not a real beacon frame. */
2349         if (pHalData->RegFwHwTxQCtrl & BIT(6))
2350                 bRecover = true;
2351
2352         /*  To tell Hw the packet is not a real beacon frame. */
2353         pHalData->RegFwHwTxQCtrl &= ~BIT(6);
2354         rtw_write8(padapter, REG_FWHW_TXQ_CTRL+2, pHalData->RegFwHwTxQCtrl);
2355
2356         /*  Clear beacon valid check bit. */
2357         rtw_hal_set_hwreg(padapter, HW_VAR_BCN_VALID, NULL);
2358         rtw_hal_set_hwreg(padapter, HW_VAR_DL_BCN_SEL, NULL);
2359
2360         DLBcnCount = 0;
2361         poll = 0;
2362         do {
2363                 SetFwRsvdPagePkt_BTCoex(padapter);
2364                 DLBcnCount++;
2365                 do {
2366                         yield();
2367 /*                      mdelay(10); */
2368                         /*  check rsvd page download OK. */
2369                         rtw_hal_get_hwreg(padapter, HW_VAR_BCN_VALID, &bcn_valid);
2370                         poll++;
2371                 } while (!bcn_valid && (poll%10)!= 0 && !padapter->bSurpriseRemoved && !padapter->bDriverStopped);
2372         } while (!bcn_valid && (DLBcnCount<= 100) && !padapter->bSurpriseRemoved && !padapter->bDriverStopped);
2373
2374         if (true == bcn_valid)
2375         {
2376                 struct pwrctrl_priv *pwrctl = adapter_to_pwrctl(padapter);
2377                 pwrctl->fw_psmode_iface_id = padapter->iface_id;
2378                 DBG_8192C(ADPT_FMT": DL RSVD page success! DLBcnCount:%d, poll:%d\n",
2379                         ADPT_ARG(padapter), DLBcnCount, poll);
2380         }
2381         else
2382         {
2383                 DBG_8192C(ADPT_FMT": DL RSVD page fail! DLBcnCount:%d, poll:%d\n",
2384                         ADPT_ARG(padapter), DLBcnCount, poll);
2385                 DBG_8192C(ADPT_FMT": DL RSVD page fail! bSurpriseRemoved =%d\n",
2386                         ADPT_ARG(padapter), padapter->bSurpriseRemoved);
2387                 DBG_8192C(ADPT_FMT": DL RSVD page fail! bDriverStopped =%d\n",
2388                         ADPT_ARG(padapter), padapter->bDriverStopped);
2389         }
2390
2391         /*  2010.05.11. Added by tynli. */
2392         val8 = rtw_read8(padapter, REG_BCN_CTRL);
2393         val8 |= EN_BCN_FUNCTION;
2394         val8 &= ~DIS_TSF_UDT;
2395         rtw_write8(padapter, REG_BCN_CTRL, val8);
2396
2397         /*  To make sure that if there exists an adapter which would like to send beacon. */
2398         /*  If exists, the origianl value of 0x422[6] will be 1, we should check this to */
2399         /*  prevent from setting 0x422[6] to 0 after download reserved page, or it will cause */
2400         /*  the beacon cannot be sent by HW. */
2401         /*  2010.06.23. Added by tynli. */
2402         if (bRecover)
2403         {
2404                 pHalData->RegFwHwTxQCtrl |= BIT(6);
2405                 rtw_write8(padapter, REG_FWHW_TXQ_CTRL+2, pHalData->RegFwHwTxQCtrl);
2406         }
2407
2408         /*  Clear CR[8] or beacon packet will not be send to TxBuf anymore. */
2409         val8 = rtw_read8(padapter, REG_CR+1);
2410         val8 &= ~BIT(0); /*  ~ENSWBCN */
2411         rtw_write8(padapter, REG_CR+1, val8);
2412 }