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