Add the rt linux 4.1.3-rt3 as base
[kvmfornfv.git] / kernel / drivers / staging / rtl8723au / hal / rtl8723a_bt-coexist.c
diff --git a/kernel/drivers/staging/rtl8723au/hal/rtl8723a_bt-coexist.c b/kernel/drivers/staging/rtl8723au/hal/rtl8723a_bt-coexist.c
new file mode 100644 (file)
index 0000000..cf15f80
--- /dev/null
@@ -0,0 +1,11297 @@
+/******************************************************************************
+ *
+ * Copyright(c) 2007 - 2012 Realtek Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of version 2 of the GNU General Public License as
+ *published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ ******************************************************************************/
+#include <drv_types.h>
+#include <rtl8723a_hal.h>
+#include <usb_ops_linux.h>
+
+#define DIS_PS_RX_BCN
+
+u32 BTCoexDbgLevel = _bt_dbg_off_;
+
+#define RTPRINT(_Comp, _Level, Fmt)\
+do {\
+       if ((BTCoexDbgLevel == _bt_dbg_on_)) {\
+               printk Fmt;\
+       }                                       \
+} while (0)
+
+#define RTPRINT_ADDR(dbgtype, dbgflag, printstr, _Ptr)\
+if ((BTCoexDbgLevel == _bt_dbg_on_)) {\
+       u32 __i;                                                \
+       u8 *ptr = (u8 *)_Ptr;   \
+       printk printstr;                                \
+       printk(" ");                                    \
+       for (__i = 0; __i < 6; __i++)           \
+               printk("%02X%s", ptr[__i], (__i == 5)?"":"-");          \
+       printk("\n");                                                   \
+}
+#define RTPRINT_DATA(dbgtype, dbgflag, _TitleString, _HexData, _HexDataLen)\
+if ((BTCoexDbgLevel == _bt_dbg_on_)) {\
+       u32 __i;                                                \
+       u8 *ptr = (u8 *)_HexData;                               \
+       printk(_TitleString);                                   \
+       for (__i = 0; __i < (u32)_HexDataLen; __i++) {          \
+               printk("%02X%s", ptr[__i], (((__i + 1) % 4) == 0)?"  ":" ");\
+               if (((__i + 1) % 16) == 0)                      \
+                       printk("\n");                           \
+       }                                                               \
+       printk("\n");                                                   \
+}
+/*  Added by Annie, 2005-11-22. */
+#define MAX_STR_LEN    64
+/*  I want to see ASCII 33 to 126 only. Otherwise, I print '?'. */
+#define PRINTABLE(_ch) (_ch >= ' ' && _ch <= '~')
+#define RT_PRINT_STR(_Comp, _Level, _TitleString, _Ptr, _Len)          \
+       {                                                               \
+               u32 __i;                                                \
+               u8 buffer[MAX_STR_LEN];                                 \
+               u32 length = (_Len < MAX_STR_LEN) ? _Len : (MAX_STR_LEN-1);\
+               memset(buffer, 0, MAX_STR_LEN);                         \
+               memcpy(buffer, (u8 *)_Ptr, length);                     \
+               for (__i = 0; __i < length; __i++) {                    \
+                       if (!PRINTABLE(buffer[__i]))                    \
+                               buffer[__i] = '?';                      \
+               }                                                       \
+               buffer[length] = '\0';                                  \
+               printk(_TitleString);                                   \
+               printk(": %d, <%s>\n", _Len, buffer);                   \
+       }
+
+#define DCMD_Printf(...)
+#define RT_ASSERT(...)
+
+#define rsprintf snprintf
+
+#define GetDefaultAdapter(padapter)    padapter
+
+#define PlatformZeroMemory(ptr, sz)    memset(ptr, 0, sz)
+
+#define PlatformProcessHCICommands(...)
+#define PlatformTxBTQueuedPackets(...)
+#define PlatformIndicateBTACLData(...) (RT_STATUS_SUCCESS)
+#define PlatformAcquireSpinLock(padapter, type)
+#define PlatformReleaseSpinLock(padapter, type)
+
+#define GET_UNDECORATED_AVERAGE_RSSI(padapter) \
+                       (GET_HAL_DATA(padapter)->dmpriv.EntryMinUndecoratedSmoothedPWDB)
+#define RT_RF_CHANGE_SOURCE u32
+
+enum {
+       RT_JOIN_INFRA   = 1,
+       RT_JOIN_IBSS  = 2,
+       RT_START_IBSS = 3,
+       RT_NO_ACTION  = 4,
+};
+
+/*  power saving */
+
+/*  ===== Below this line is sync from SD7 driver COMMOM/BT.c ===== */
+
+static u8 BT_Operation(struct rtw_adapter *padapter)
+{
+       struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
+       struct bt_mgnt *pBtMgnt = &pBTInfo->BtMgnt;
+
+       if (pBtMgnt->BtOperationOn)
+               return true;
+       else
+               return false;
+}
+
+static u8 BT_IsLegalChannel(struct rtw_adapter *padapter, u8 channel)
+{
+       struct rt_channel_info *pChanneList = NULL;
+       u8 channelLen, i;
+
+       pChanneList = padapter->mlmeextpriv.channel_set;
+       channelLen = padapter->mlmeextpriv.max_chan_nums;
+
+       for (i = 0; i < channelLen; i++) {
+               RTPRINT(FIOCTL, IOCTL_STATE,
+                       ("Check if chnl(%d) in channel plan contains bt target chnl(%d) for BT connection\n",
+                        pChanneList[i].ChannelNum, channel));
+               if ((channel == pChanneList[i].ChannelNum) ||
+                   (channel == pChanneList[i].ChannelNum + 2))
+                       return channel;
+       }
+       return 0;
+}
+
+void BT_SignalCompensation(struct rtw_adapter *padapter, u8 *rssi_wifi, u8 *rssi_bt)
+{
+       BTDM_SignalCompensation(padapter, rssi_wifi, rssi_bt);
+}
+
+void rtl8723a_BT_wifiscan_notify(struct rtw_adapter *padapter, u8 scanType)
+{
+       BTHCI_WifiScanNotify(padapter, scanType);
+       BTDM_CheckAntSelMode(padapter);
+       BTDM_WifiScanNotify(padapter, scanType);
+}
+
+void rtl8723a_BT_wifiassociate_notify(struct rtw_adapter *padapter, u8 action)
+{
+       /*  action : */
+       /*  true = associate start */
+       /*  false = associate finished */
+       if (action)
+               BTDM_CheckAntSelMode(padapter);
+
+       BTDM_WifiAssociateNotify(padapter, action);
+}
+
+void BT_HaltProcess(struct rtw_adapter *padapter)
+{
+       BTDM_ForHalt(padapter);
+}
+
+/*  ===== End of sync from SD7 driver COMMOM/BT.c ===== */
+
+#define i64fmt         "ll"
+#define UINT64_C(v)  (v)
+
+#define FillOctetString(_os, _octet, _len)             \
+       (_os).Octet = (u8 *)(_octet);                   \
+       (_os).Length = (_len);
+
+static enum rt_status PlatformIndicateBTEvent(
+       struct rtw_adapter *padapter,
+       void                                            *pEvntData,
+       u32                                             dataLen
+       )
+{
+       enum rt_status  rt_status = RT_STATUS_FAILURE;
+
+       RTPRINT(FIOCTL, IOCTL_BT_EVENT_DETAIL, ("BT event start, %d bytes data to Transferred!!\n", dataLen));
+       RTPRINT_DATA(FIOCTL, IOCTL_BT_EVENT_DETAIL, "To transfer Hex Data :\n",
+               pEvntData, dataLen);
+
+       BT_EventParse(padapter, pEvntData, dataLen);
+
+       printk(KERN_WARNING "%s: Linux has no way to report BT event!!\n", __func__);
+
+       RTPRINT(FIOCTL, IOCTL_BT_EVENT_DETAIL, ("BT event end, %s\n",
+               (rt_status == RT_STATUS_SUCCESS) ? "SUCCESS" : "FAIL"));
+
+       return rt_status;
+}
+
+/*  ===== Below this line is sync from SD7 driver COMMOM/bt_hci.c ===== */
+
+static u8 bthci_GetLocalChannel(struct rtw_adapter *padapter)
+{
+       return padapter->mlmeextpriv.cur_channel;
+}
+
+static u8 bthci_GetCurrentEntryNum(struct rtw_adapter *padapter, u8 PhyHandle)
+{
+       struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
+       u8 i;
+
+       for (i = 0; i < MAX_BT_ASOC_ENTRY_NUM; i++) {
+               if ((pBTInfo->BtAsocEntry[i].bUsed) &&
+                   (pBTInfo->BtAsocEntry[i].PhyLinkCmdData.BtPhyLinkhandle == PhyHandle))
+                       return i;
+       }
+
+       return 0xFF;
+}
+
+static void bthci_DecideBTChannel(struct rtw_adapter *padapter, u8 EntryNum)
+{
+/*PMGNT_INFO pMgntInfo = &padapter->MgntInfo; */
+       struct mlme_priv *pmlmepriv;
+       struct bt_30info *pBTInfo;
+       struct bt_mgnt *pBtMgnt;
+       struct bt_hci_info *pBtHciInfo;
+       struct chnl_txpower_triple *pTriple_subband = NULL;
+       struct common_triple *pTriple;
+       u8 i, j, localchnl, firstRemoteLegalChnlInTriplet = 0;
+       u8 regulatory_skipLen = 0;
+       u8 subbandTripletCnt = 0;
+
+       pmlmepriv = &padapter->mlmepriv;
+       pBTInfo = GET_BT_INFO(padapter);
+       pBtMgnt = &pBTInfo->BtMgnt;
+       pBtHciInfo = &pBTInfo->BtHciInfo;
+
+       pBtMgnt->CheckChnlIsSuit = true;
+       localchnl = bthci_GetLocalChannel(padapter);
+
+       pTriple = (struct common_triple *)
+               &pBtHciInfo->BTPreChnllist[COUNTRY_STR_LEN];
+
+       /*  contains country string, len is 3 */
+       for (i = 0; i < (pBtHciInfo->BtPreChnlListLen-COUNTRY_STR_LEN); i += 3, pTriple++) {
+               /*  */
+               /*  check every triplet, an triplet may be */
+               /*  regulatory extension identifier or sub-band triplet */
+               /*  */
+               if (pTriple->byte_1st == 0xc9) {
+                       /*  Regulatory Extension Identifier, skip it */
+                       RTPRINT(FIOCTL, (IOCTL_BT_HCICMD|IOCTL_BT_LOGO),
+                               ("Find Regulatory ID, regulatory class = %d\n", pTriple->byte_2nd));
+                       regulatory_skipLen += 3;
+                       pTriple_subband = NULL;
+                       continue;
+               } else {        /*  Sub-band triplet */
+                       RTPRINT(FIOCTL, (IOCTL_BT_HCICMD|IOCTL_BT_LOGO), ("Find Sub-band triplet \n"));
+                       subbandTripletCnt++;
+                       pTriple_subband = (struct chnl_txpower_triple *)pTriple;
+                       /*  if remote first legal channel not found, then find first remote channel */
+                       /*  and it's legal for our channel plan. */
+
+                       /*  search the sub-band triplet and find if remote channel is legal to our channel plan. */
+                       for (j = pTriple_subband->FirstChnl; j < (pTriple_subband->FirstChnl+pTriple_subband->NumChnls); j++) {
+                               RTPRINT(FIOCTL, (IOCTL_BT_HCICMD|IOCTL_BT_LOGO), (" Check if chnl(%d) is legal\n", j));
+                               if (BT_IsLegalChannel(padapter, j)) {
+                                       /*  remote channel is legal for our channel plan. */
+                                       firstRemoteLegalChnlInTriplet = j;
+                                       RTPRINT(FIOCTL, (IOCTL_BT_HCICMD|IOCTL_BT_LOGO),
+                                               ("Find first remote legal channel : %d\n",
+                                               firstRemoteLegalChnlInTriplet));
+
+                                       /*  If we find a remote legal channel in the sub-band triplet */
+                                       /*  and only BT connection is established(local not connect to any AP or IBSS), */
+                                       /*  then we just switch channel to remote channel. */
+                                       if (!(check_fwstate(pmlmepriv, WIFI_ASOC_STATE|WIFI_ADHOC_STATE|WIFI_AP_STATE) ||
+                                           BTHCI_HsConnectionEstablished(padapter))) {
+                                               pBtMgnt->BTChannel = firstRemoteLegalChnlInTriplet;
+                                               RTPRINT(FIOCTL, (IOCTL_BT_HCICMD|IOCTL_BT_LOGO), ("Remote legal channel (%d) is selected, Local not connect to any!!\n", pBtMgnt->BTChannel));
+                                               return;
+                                       } else {
+                                               if ((localchnl >= firstRemoteLegalChnlInTriplet) &&
+                                                   (localchnl < (pTriple_subband->FirstChnl+pTriple_subband->NumChnls))) {
+                                                       pBtMgnt->BTChannel = localchnl;
+                                                       RTPRINT(FIOCTL, (IOCTL_BT_HCICMD|IOCTL_BT_LOGO), ("Local channel (%d) is selected, wifi or BT connection exists\n", pBtMgnt->BTChannel));
+                                                       return;
+                                               }
+                                       }
+                                       break;
+                               }
+                       }
+               }
+       }
+
+       if (subbandTripletCnt) {
+               /* if any preferred channel triplet exists */
+               RTPRINT(FIOCTL, (IOCTL_BT_HCICMD|IOCTL_BT_LOGO), ("There are %d sub band triplet exists, ", subbandTripletCnt));
+               if (firstRemoteLegalChnlInTriplet == 0) {
+                       /* no legal channel is found, reject the connection. */
+                       RTPRINT(FIOCTL, (IOCTL_BT_HCICMD|IOCTL_BT_LOGO), ("no legal channel is found!!\n"));
+               } else {
+                       /*  Remote Legal channel is found but not match to local */
+                       /* wifi connection exists), so reject the connection. */
+                       RTPRINT(FIOCTL, (IOCTL_BT_HCICMD|IOCTL_BT_LOGO),
+                               ("Remote Legal channel is found but not match to local(wifi connection exists)!!\n"));
+               }
+               pBtMgnt->CheckChnlIsSuit = false;
+       } else {
+               /*  There are not any preferred channel triplet exists */
+               /*  Use current legal channel as the bt channel. */
+               RTPRINT(FIOCTL, (IOCTL_BT_HCICMD|IOCTL_BT_LOGO), ("No sub band triplet exists!!\n"));
+       }
+       pBtMgnt->BTChannel = localchnl;
+       RTPRINT(FIOCTL, (IOCTL_BT_HCICMD|IOCTL_BT_LOGO), ("Local channel (%d) is selected!!\n", pBtMgnt->BTChannel));
+}
+
+/* Success:return true */
+/* Fail:return false */
+static u8 bthci_GetAssocInfo(struct rtw_adapter *padapter, u8 EntryNum)
+{
+       struct bt_30info *pBTInfo;
+       struct bt_hci_info *pBtHciInfo;
+       u8 tempBuf[256];
+       u8 i = 0;
+       u8 BaseMemoryShift = 0;
+       u16     TotalLen = 0;
+       struct amp_assoc_structure *pAmpAsoc;
+
+       RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("GetAssocInfo start\n"));
+       pBTInfo = GET_BT_INFO(padapter);
+       pBtHciInfo = &pBTInfo->BtHciInfo;
+
+       if (pBTInfo->BtAsocEntry[EntryNum].AmpAsocCmdData.LenSoFar == 0) {
+               if (pBTInfo->BtAsocEntry[EntryNum].AmpAsocCmdData.AMPAssocRemLen < (MAX_AMP_ASSOC_FRAG_LEN))
+                       TotalLen = pBTInfo->BtAsocEntry[EntryNum].AmpAsocCmdData.AMPAssocRemLen;
+               else if (pBTInfo->BtAsocEntry[EntryNum].AmpAsocCmdData.AMPAssocRemLen == (MAX_AMP_ASSOC_FRAG_LEN))
+                       TotalLen = MAX_AMP_ASSOC_FRAG_LEN;
+       } else if (pBTInfo->BtAsocEntry[EntryNum].AmpAsocCmdData.LenSoFar > 0)
+               TotalLen = pBTInfo->BtAsocEntry[EntryNum].AmpAsocCmdData.LenSoFar;
+
+       while ((pBTInfo->BtAsocEntry[EntryNum].AmpAsocCmdData.LenSoFar >= BaseMemoryShift) || TotalLen > BaseMemoryShift) {
+               RTPRINT(FIOCTL, IOCTL_BT_HCICMD_DETAIL, ("GetAssocInfo, TotalLen =%d, BaseMemoryShift =%d\n", TotalLen, BaseMemoryShift));
+               memcpy(tempBuf,
+                       (u8 *)pBTInfo->BtAsocEntry[EntryNum].AmpAsocCmdData.AMPAssocfragment+BaseMemoryShift,
+                       TotalLen-BaseMemoryShift);
+               RTPRINT_DATA(FIOCTL, IOCTL_BT_HCICMD_DETAIL, "GetAssocInfo :\n",
+                       tempBuf, TotalLen-BaseMemoryShift);
+
+               pAmpAsoc = (struct amp_assoc_structure *)tempBuf;
+               le16_to_cpus(&pAmpAsoc->Length);
+               BaseMemoryShift += 3 + pAmpAsoc->Length;
+
+               RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("TypeID = 0x%x, ", pAmpAsoc->TypeID));
+               RTPRINT_DATA(FIOCTL, IOCTL_BT_HCICMD, "Hex Data: \n", pAmpAsoc->Data, pAmpAsoc->Length);
+               switch (pAmpAsoc->TypeID) {
+               case AMP_MAC_ADDR:
+                       RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("==> AMP_MAC_ADDR\n"));
+                       if (pAmpAsoc->Length > 6)
+                               return false;
+                       memcpy(pBTInfo->BtAsocEntry[EntryNum].BTRemoteMACAddr, pAmpAsoc->Data, 6);
+                       RTPRINT_ADDR(FIOCTL, IOCTL_BT_HCICMD, ("Remote Mac address \n"), pBTInfo->BtAsocEntry[EntryNum].BTRemoteMACAddr);
+                       break;
+               case AMP_PREFERRED_CHANNEL_LIST:
+                       RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("==> AMP_PREFERRED_CHANNEL_LIST\n"));
+                       pBtHciInfo->BtPreChnlListLen = pAmpAsoc->Length;
+                       memcpy(pBtHciInfo->BTPreChnllist,
+                               pAmpAsoc->Data,
+                               pBtHciInfo->BtPreChnlListLen);
+                       RTPRINT_DATA(FIOCTL, IOCTL_BT_HCICMD, "Preferred channel list : \n", pBtHciInfo->BTPreChnllist, pBtHciInfo->BtPreChnlListLen);
+                       bthci_DecideBTChannel(padapter, EntryNum);
+                       break;
+               case AMP_CONNECTED_CHANNEL:
+                       RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("==> AMP_CONNECTED_CHANNEL\n"));
+                       pBtHciInfo->BTConnectChnlListLen = pAmpAsoc->Length;
+                       memcpy(pBtHciInfo->BTConnectChnllist,
+                               pAmpAsoc->Data,
+                               pBtHciInfo->BTConnectChnlListLen);
+                       break;
+               case AMP_80211_PAL_CAP_LIST:
+                       RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("==> AMP_80211_PAL_CAP_LIST\n"));
+                       pBTInfo->BtAsocEntry[EntryNum].BTCapability = *(u32 *)(pAmpAsoc->Data);
+                       if (pBTInfo->BtAsocEntry[EntryNum].BTCapability & 0x00000001) {
+                               /*  TODO: */
+
+                               /* Signifies PAL capable of utilizing received activity reports. */
+                       }
+                       if (pBTInfo->BtAsocEntry[EntryNum].BTCapability & 0x00000002) {
+                               /*  TODO: */
+                               /* Signifies PAL is capable of utilizing scheduling information received in an activity reports. */
+                       }
+                       break;
+               case AMP_80211_PAL_VISION:
+                       pBtHciInfo->BTPalVersion = *(u8 *)(pAmpAsoc->Data);
+                       pBtHciInfo->BTPalCompanyID = *(u16 *)(((u8 *)(pAmpAsoc->Data))+1);
+                       pBtHciInfo->BTPalsubversion = *(u16 *)(((u8 *)(pAmpAsoc->Data))+3);
+                       RTPRINT(FIOCTL, (IOCTL_BT_HCICMD|IOCTL_BT_LOGO), ("==> AMP_80211_PAL_VISION PalVersion  0x%x, PalCompanyID  0x%x, Palsubversion 0x%x\n",
+                               pBtHciInfo->BTPalVersion,
+                               pBtHciInfo->BTPalCompanyID,
+                               pBtHciInfo->BTPalsubversion));
+                       break;
+               default:
+                       RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("==> Unsupport TypeID !!\n"));
+                       break;
+               }
+               i++;
+       }
+       RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("GetAssocInfo end\n"));
+
+       return true;
+}
+
+static u8 bthci_AddEntry(struct rtw_adapter *padapter)
+{
+       struct bt_30info *pBTInfo;
+       struct bt_mgnt *pBtMgnt;
+       u8 i;
+
+       pBTInfo = GET_BT_INFO(padapter);
+       pBtMgnt = &pBTInfo->BtMgnt;
+
+       for (i = 0; i < MAX_BT_ASOC_ENTRY_NUM; i++) {
+               if (pBTInfo->BtAsocEntry[i].bUsed == false) {
+                       pBTInfo->BtAsocEntry[i].bUsed = true;
+                       pBtMgnt->CurrentConnectEntryNum = i;
+                       break;
+               }
+       }
+
+       if (i == MAX_BT_ASOC_ENTRY_NUM) {
+               RTPRINT(FIOCTL, IOCTL_STATE, ("bthci_AddEntry(), Add entry fail!!\n"));
+               return false;
+       }
+       return true;
+}
+
+static u8 bthci_DiscardTxPackets(struct rtw_adapter *padapter, u16 LLH)
+{
+       return false;
+}
+
+static u8
+bthci_CheckLogLinkBehavior(
+       struct rtw_adapter *padapter,
+       struct hci_flow_spec                    TxFlowSpec
+       )
+{
+       u8 ID = TxFlowSpec.Identifier;
+       u8 ServiceType = TxFlowSpec.ServiceType;
+       u16     MaxSDUSize = TxFlowSpec.MaximumSDUSize;
+       u32     SDUInterArrivatime = TxFlowSpec.SDUInterArrivalTime;
+       u8 match = false;
+
+       switch (ID) {
+       case 1:
+               if (ServiceType == BT_LL_BE) {
+                       match = true;
+                       RTPRINT(FIOCTL, (IOCTL_BT_EVENT|IOCTL_BT_LOGO), ("Logical Link Type =  TX best effort flowspec\n"));
+               } else if ((ServiceType == BT_LL_GU) && (MaxSDUSize == 0xffff)) {
+                       match = true;
+                       RTPRINT(FIOCTL, (IOCTL_BT_EVENT|IOCTL_BT_LOGO), ("Logical Link Type =  RX guaranteed latency flowspec\n"));
+               } else if ((ServiceType == BT_LL_GU) && (MaxSDUSize == 2500)) {
+                       RTPRINT(FIOCTL, (IOCTL_BT_EVENT|IOCTL_BT_LOGO), ("Logical Link Type =  RX guaranteed Large latency flowspec\n"));
+               }
+               break;
+       case 2:
+               if (ServiceType == BT_LL_BE) {
+                       match = true;
+                       RTPRINT(FIOCTL, (IOCTL_BT_EVENT|IOCTL_BT_LOGO), ("Logical Link Type =  RX best effort flowspec\n"));
+
+               }
+               break;
+       case 3:
+               if ((ServiceType == BT_LL_GU) && (MaxSDUSize == 1492)) {
+                       match = true;
+                       RTPRINT(FIOCTL, (IOCTL_BT_EVENT|IOCTL_BT_LOGO), ("Logical Link Type =  TX guaranteed latency flowspec\n"));
+               } else if ((ServiceType == BT_LL_GU) && (MaxSDUSize == 2500)) {
+                       RTPRINT(FIOCTL, (IOCTL_BT_EVENT|IOCTL_BT_LOGO), ("Logical Link Type =  TX guaranteed Large latency flowspec\n"));
+               }
+               break;
+       case 4:
+               if (ServiceType == BT_LL_BE) {
+                       if ((SDUInterArrivatime == 0xffffffff) && (ServiceType == BT_LL_BE) && (MaxSDUSize == 1492)) {
+                               match = true;
+                               RTPRINT(FIOCTL, (IOCTL_BT_EVENT|IOCTL_BT_LOGO), ("Logical Link Type =  TX/RX aggregated best effort flowspec\n"));
+                       }
+               } else if (ServiceType == BT_LL_GU) {
+                       if (SDUInterArrivatime == 100) {
+                               match = true;
+                               RTPRINT(FIOCTL, (IOCTL_BT_EVENT|IOCTL_BT_LOGO), ("Logical Link Type =  TX/RX guaranteed bandwidth flowspec\n"));
+                       }
+               }
+               break;
+       default:
+               RTPRINT(FIOCTL, (IOCTL_BT_EVENT|IOCTL_BT_LOGO), ("Logical Link Type =  Unknow Type !!!!!!!!\n"));
+               break;
+       }
+
+       RTPRINT(FIOCTL, (IOCTL_BT_HCICMD|IOCTL_BT_LOGO),
+               ("ID = 0x%x, ServiceType = 0x%x, MaximumSDUSize = 0x%x, SDUInterArrivalTime = 0x%x, AccessLatency = 0x%x, FlushTimeout = 0x%x\n",
+               TxFlowSpec.Identifier, TxFlowSpec.ServiceType, MaxSDUSize,
+               SDUInterArrivatime, TxFlowSpec.AccessLatency, TxFlowSpec.FlushTimeout));
+       return match;
+}
+
+static u16 bthci_AssocMACAddr(struct rtw_adapter *padapter, void       *pbuf)
+{
+       struct amp_assoc_structure *pAssoStrc = (struct amp_assoc_structure *)pbuf;
+       pAssoStrc->TypeID = AMP_MAC_ADDR;
+       pAssoStrc->Length = 0x06;
+       memcpy(&pAssoStrc->Data[0], padapter->eeprompriv.mac_addr, 6);
+       RTPRINT_DATA(FIOCTL, (IOCTL_BT_HCICMD|IOCTL_BT_HCICMD_DETAIL|IOCTL_BT_LOGO),
+                    ("AssocMACAddr : \n"), pAssoStrc, pAssoStrc->Length+3);
+
+       return pAssoStrc->Length + 3;
+}
+
+static u16
+bthci_PALCapabilities(
+       struct rtw_adapter *padapter,
+       void    *pbuf
+       )
+{
+       struct amp_assoc_structure *pAssoStrc = (struct amp_assoc_structure *)pbuf;
+
+       pAssoStrc->TypeID = AMP_80211_PAL_CAP_LIST;
+       pAssoStrc->Length = 0x04;
+
+       pAssoStrc->Data[0] = 0x00;
+       pAssoStrc->Data[1] = 0x00;
+
+       RTPRINT_DATA(FIOCTL, IOCTL_BT_HCICMD_DETAIL, ("PALCapabilities:\n"), pAssoStrc, pAssoStrc->Length+3);
+       RTPRINT(FIOCTL, IOCTL_BT_LOGO, ("PALCapabilities \n"));
+
+       RTPRINT(FIOCTL, IOCTL_BT_LOGO, (" TypeID = 0x%x,\n Length = 0x%x,\n Content = 0x0000\n",
+               pAssoStrc->TypeID,
+               pAssoStrc->Length));
+
+       return pAssoStrc->Length + 3;
+}
+
+static u16 bthci_AssocPreferredChannelList(struct rtw_adapter *padapter,
+                                          void *pbuf, u8 EntryNum)
+{
+       struct bt_30info *pBTInfo;
+       struct amp_assoc_structure *pAssoStrc;
+       struct amp_pref_chnl_regulatory *pReg;
+       struct chnl_txpower_triple *pTriple;
+       char ctrString[3] = {'X', 'X', 'X'};
+       u32 len = 0;
+       u8 preferredChnl;
+
+       pBTInfo = GET_BT_INFO(padapter);
+       pAssoStrc = (struct amp_assoc_structure *)pbuf;
+       pReg = (struct amp_pref_chnl_regulatory *)&pAssoStrc->Data[3];
+
+       preferredChnl = bthci_GetLocalChannel(padapter);
+       pAssoStrc->TypeID = AMP_PREFERRED_CHANNEL_LIST;
+
+       /*  locale unknown */
+       memcpy(&pAssoStrc->Data[0], &ctrString[0], 3);
+       pReg->reXId = 201;
+       pReg->regulatoryClass = 254;
+       pReg->coverageClass = 0;
+       len += 6;
+       RTPRINT(FIOCTL, (IOCTL_BT_HCICMD | IOCTL_BT_LOGO), ("PREFERRED_CHNL_LIST\n"));
+       RTPRINT(FIOCTL, (IOCTL_BT_HCICMD | IOCTL_BT_LOGO), ("XXX, 201, 254, 0\n"));
+       /*  at the following, chnl 1~11 should be contained */
+       pTriple = (struct chnl_txpower_triple *)&pAssoStrc->Data[len];
+
+       /*  (1) if any wifi or bt HS connection exists */
+       if ((pBTInfo->BtAsocEntry[EntryNum].AMPRole == AMP_BTAP_CREATOR) ||
+           (check_fwstate(&padapter->mlmepriv, WIFI_ASOC_STATE |
+                          WIFI_ADHOC_STATE | WIFI_ADHOC_MASTER_STATE |
+                          WIFI_AP_STATE)) ||
+           BTHCI_HsConnectionEstablished(padapter)) {
+               pTriple->FirstChnl = preferredChnl;
+               pTriple->NumChnls = 1;
+               pTriple->MaxTxPowerInDbm = 20;
+               len += 3;
+               RTPRINT(FIOCTL, (IOCTL_BT_HCICMD | IOCTL_BT_LOGO), ("First Channel = %d, Channel Num = %d, MaxDbm = %d\n",
+                       pTriple->FirstChnl,
+                       pTriple->NumChnls,
+                       pTriple->MaxTxPowerInDbm));
+       }
+
+       pAssoStrc->Length = (u16)len;
+       RTPRINT_DATA(FIOCTL, IOCTL_BT_HCICMD, ("AssocPreferredChannelList : \n"), pAssoStrc, pAssoStrc->Length+3);
+
+       return pAssoStrc->Length + 3;
+}
+
+static u16 bthci_AssocPALVer(struct rtw_adapter *padapter, void *pbuf)
+{
+       struct amp_assoc_structure *pAssoStrc = (struct amp_assoc_structure *)pbuf;
+       u8 *pu1Tmp;
+       u16     *pu2Tmp;
+
+       pAssoStrc->TypeID = AMP_80211_PAL_VISION;
+       pAssoStrc->Length = 0x5;
+       pu1Tmp = &pAssoStrc->Data[0];
+       *pu1Tmp = 0x1;  /*  PAL Version */
+       pu2Tmp = (u16 *)&pAssoStrc->Data[1];
+       *pu2Tmp = 0x5D; /*  SIG Company identifier of 802.11 PAL vendor */
+       pu2Tmp = (u16 *)&pAssoStrc->Data[3];
+       *pu2Tmp = 0x1;  /*  PAL Sub-version specifier */
+
+       RTPRINT_DATA(FIOCTL, IOCTL_BT_HCICMD_DETAIL, ("AssocPALVer : \n"), pAssoStrc, pAssoStrc->Length+3);
+       RTPRINT(FIOCTL, IOCTL_BT_LOGO, ("AssocPALVer \n"));
+
+       RTPRINT(FIOCTL, IOCTL_BT_LOGO, (" TypeID = 0x%x,\n Length = 0x%x,\n PAL Version = 0x01,\n PAL vendor = 0x01,\n PAL Sub-version specifier = 0x01\n",
+               pAssoStrc->TypeID,
+               pAssoStrc->Length));
+       return pAssoStrc->Length + 3;
+}
+
+static u8 bthci_CheckRfStateBeforeConnect(struct rtw_adapter *padapter)
+{
+       struct bt_30info *pBTInfo;
+       enum rt_rf_power_state          RfState;
+
+       pBTInfo = GET_BT_INFO(padapter);
+
+       RfState = padapter->pwrctrlpriv.rf_pwrstate;
+
+       if (RfState != rf_on) {
+               mod_timer(&pBTInfo->BTPsDisableTimer,
+                         jiffies + msecs_to_jiffies(50));
+               return false;
+       }
+       return true;
+}
+
+static void bthci_ResponderStartToScan(struct rtw_adapter *padapter)
+{
+}
+
+static u8 bthci_PhyLinkConnectionInProgress(struct rtw_adapter *padapter, u8 PhyLinkHandle)
+{
+       struct bt_30info *pBTInfo;
+       struct bt_mgnt *pBtMgnt;
+
+       pBTInfo = GET_BT_INFO(padapter);
+       pBtMgnt = &pBTInfo->BtMgnt;
+
+       if (pBtMgnt->bPhyLinkInProgress &&
+               (pBtMgnt->BtCurrentPhyLinkhandle == PhyLinkHandle))
+               return true;
+       return false;
+}
+
+static void bthci_ResetFlowSpec(struct rtw_adapter *padapter, u8 EntryNum, u8 index)
+{
+       struct bt_30info *pBTinfo;
+
+       pBTinfo = GET_BT_INFO(padapter);
+
+       pBTinfo->BtAsocEntry[EntryNum].LogLinkCmdData[index].BtLogLinkhandle = 0;
+       pBTinfo->BtAsocEntry[EntryNum].LogLinkCmdData[index].BtPhyLinkhandle = 0;
+       pBTinfo->BtAsocEntry[EntryNum].LogLinkCmdData[index].bLLCompleteEventIsSet = false;
+       pBTinfo->BtAsocEntry[EntryNum].LogLinkCmdData[index].bLLCancelCMDIsSetandComplete = false;
+       pBTinfo->BtAsocEntry[EntryNum].LogLinkCmdData[index].BtTxFlowSpecID = 0;
+       pBTinfo->BtAsocEntry[EntryNum].LogLinkCmdData[index].TxPacketCount = 0;
+
+       pBTinfo->BtAsocEntry[EntryNum].LogLinkCmdData[index].Tx_Flow_Spec.Identifier = 0x01;
+       pBTinfo->BtAsocEntry[EntryNum].LogLinkCmdData[index].Tx_Flow_Spec.ServiceType = SERVICE_BEST_EFFORT;
+       pBTinfo->BtAsocEntry[EntryNum].LogLinkCmdData[index].Tx_Flow_Spec.MaximumSDUSize = 0xffff;
+       pBTinfo->BtAsocEntry[EntryNum].LogLinkCmdData[index].Tx_Flow_Spec.SDUInterArrivalTime = 0xffffffff;
+       pBTinfo->BtAsocEntry[EntryNum].LogLinkCmdData[index].Tx_Flow_Spec.AccessLatency = 0xffffffff;
+       pBTinfo->BtAsocEntry[EntryNum].LogLinkCmdData[index].Tx_Flow_Spec.FlushTimeout = 0xffffffff;
+
+       pBTinfo->BtAsocEntry[EntryNum].LogLinkCmdData[index].Rx_Flow_Spec.Identifier = 0x01;
+       pBTinfo->BtAsocEntry[EntryNum].LogLinkCmdData[index].Rx_Flow_Spec.ServiceType = SERVICE_BEST_EFFORT;
+       pBTinfo->BtAsocEntry[EntryNum].LogLinkCmdData[index].Rx_Flow_Spec.MaximumSDUSize = 0xffff;
+       pBTinfo->BtAsocEntry[EntryNum].LogLinkCmdData[index].Rx_Flow_Spec.SDUInterArrivalTime = 0xffffffff;
+       pBTinfo->BtAsocEntry[EntryNum].LogLinkCmdData[index].Rx_Flow_Spec.AccessLatency = 0xffffffff;
+       pBTinfo->BtAsocEntry[EntryNum].LogLinkCmdData[index].Rx_Flow_Spec.FlushTimeout = 0xffffffff;
+}
+
+static void bthci_ResetEntry(struct rtw_adapter *padapter, u8 EntryNum)
+{
+       struct bt_30info *pBTinfo;
+       struct bt_mgnt *pBtMgnt;
+       u8 j;
+
+       pBTinfo = GET_BT_INFO(padapter);
+       pBtMgnt = &pBTinfo->BtMgnt;
+
+       pBTinfo->BtAsocEntry[EntryNum].bUsed = false;
+       pBTinfo->BtAsocEntry[EntryNum].BtCurrentState = HCI_STATE_DISCONNECTED;
+       pBTinfo->BtAsocEntry[EntryNum].BtNextState = HCI_STATE_DISCONNECTED;
+
+       pBTinfo->BtAsocEntry[EntryNum].AmpAsocCmdData.AMPAssocRemLen = 0;
+       pBTinfo->BtAsocEntry[EntryNum].AmpAsocCmdData.BtPhyLinkhandle = 0;
+       if (pBTinfo->BtAsocEntry[EntryNum].AmpAsocCmdData.AMPAssocfragment != NULL)
+               memset(pBTinfo->BtAsocEntry[EntryNum].AmpAsocCmdData.AMPAssocfragment, 0, TOTAL_ALLOCIATE_ASSOC_LEN);
+       pBTinfo->BtAsocEntry[EntryNum].AmpAsocCmdData.LenSoFar = 0;
+
+       pBTinfo->BtAsocEntry[EntryNum].PhyLinkCmdData.BtAMPKeyType = 0;
+       pBTinfo->BtAsocEntry[EntryNum].PhyLinkCmdData.BtPhyLinkhandle = 0;
+       memset(pBTinfo->BtAsocEntry[EntryNum].PhyLinkCmdData.BtAMPKey, 0,
+              pBTinfo->BtAsocEntry[EntryNum].PhyLinkCmdData.BtAMPKeyLen);
+       pBTinfo->BtAsocEntry[EntryNum].PhyLinkCmdData.BtAMPKeyLen = 0;
+
+       /* 0x640; 0.625ms*1600 = 1000ms, 0.625ms*16000 = 10000ms */
+       pBTinfo->BtAsocEntry[EntryNum].PhyLinkCmdData.LinkSuperversionTimeout = 0x3e80;
+
+       pBTinfo->BtAsocEntry[EntryNum].AMPRole = AMP_BTAP_NONE;
+
+       pBTinfo->BtAsocEntry[EntryNum].mAssoc = false;
+       pBTinfo->BtAsocEntry[EntryNum].b4waySuccess = false;
+
+       /*  Reset BT WPA */
+       pBTinfo->BtAsocEntry[EntryNum].KeyReplayCounter = 0;
+       pBTinfo->BtAsocEntry[EntryNum].BTWPAAuthState = STATE_WPA_AUTH_UNINITIALIZED;
+
+       pBTinfo->BtAsocEntry[EntryNum].bSendSupervisionPacket = false;
+       pBTinfo->BtAsocEntry[EntryNum].NoRxPktCnt = 0;
+       pBTinfo->BtAsocEntry[EntryNum].ShortRangeMode = 0;
+       pBTinfo->BtAsocEntry[EntryNum].rxSuvpPktCnt = 0;
+
+       for (j = 0; j < MAX_LOGICAL_LINK_NUM; j++)
+               bthci_ResetFlowSpec(padapter, EntryNum, j);
+
+       pBtMgnt->BTAuthCount = 0;
+       pBtMgnt->BTAsocCount = 0;
+       pBtMgnt->BTCurrentConnectType = BT_DISCONNECT;
+       pBtMgnt->BTReceiveConnectPkt = BT_DISCONNECT;
+
+       HALBT_RemoveKey(padapter, EntryNum);
+}
+
+static void bthci_RemoveEntryByEntryNum(struct rtw_adapter *padapter, u8 EntryNum)
+{
+       struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
+       struct bt_mgnt *pBtMgnt = &pBTInfo->BtMgnt;
+
+       bthci_ResetEntry(padapter, EntryNum);
+
+       if (pBtMgnt->CurrentBTConnectionCnt > 0)
+               pBtMgnt->CurrentBTConnectionCnt--;
+
+       RTPRINT(FIOCTL, IOCTL_STATE, ("[BT Flag], CurrentBTConnectionCnt = %d!!\n",
+               pBtMgnt->CurrentBTConnectionCnt));
+
+       if (pBtMgnt->CurrentBTConnectionCnt > 0) {
+               pBtMgnt->BtOperationOn = true;
+       } else {
+               pBtMgnt->BtOperationOn = false;
+               RTPRINT(FIOCTL, IOCTL_STATE, ("[BT Flag], Bt Operation OFF!!\n"));
+       }
+
+       if (!pBtMgnt->BtOperationOn) {
+               del_timer_sync(&pBTInfo->BTHCIDiscardAclDataTimer);
+               del_timer_sync(&pBTInfo->BTBeaconTimer);
+               pBtMgnt->bStartSendSupervisionPkt = false;
+       }
+}
+
+static u8
+bthci_CommandCompleteHeader(
+       u8 *pbuf,
+       u16             OGF,
+       u16             OCF,
+       enum hci_status status
+       )
+{
+       struct packet_irp_hcievent_data *PPacketIrpEvent = (struct packet_irp_hcievent_data *)pbuf;
+       u8 NumHCI_Comm = 0x1;
+
+       PPacketIrpEvent->EventCode = HCI_EVENT_COMMAND_COMPLETE;
+       PPacketIrpEvent->Data[0] = NumHCI_Comm; /* packet # */
+       PPacketIrpEvent->Data[1] = HCIOPCODELOW(OCF, OGF);
+       PPacketIrpEvent->Data[2] = HCIOPCODEHIGHT(OCF, OGF);
+
+       if (OGF == OGF_EXTENSION) {
+               if (OCF == HCI_SET_RSSI_VALUE) {
+                       RTPRINT(FIOCTL, (IOCTL_BT_EVENT_PERIODICAL),
+                               ("[BT event], CommandComplete, Num_HCI_Comm = 0x%x, Opcode = 0x%02x%02x, status = 0x%x, OGF = 0x%x, OCF = 0x%x\n",
+                               NumHCI_Comm, (HCIOPCODEHIGHT(OCF, OGF)), (HCIOPCODELOW(OCF, OGF)), status, OGF, OCF));
+               } else {
+                       RTPRINT(FIOCTL, (IOCTL_BT_HCICMD_EXT),
+                               ("[BT event], CommandComplete, Num_HCI_Comm = 0x%x, Opcode = 0x%02x%02x, status = 0x%x, OGF = 0x%x, OCF = 0x%x\n",
+                               NumHCI_Comm, (HCIOPCODEHIGHT(OCF, OGF)), (HCIOPCODELOW(OCF, OGF)), status, OGF, OCF));
+               }
+       } else {
+               RTPRINT(FIOCTL, (IOCTL_BT_EVENT|IOCTL_BT_LOGO),
+                       ("[BT event], CommandComplete, Num_HCI_Comm = 0x%x, Opcode = 0x%02x%02x, status = 0x%x, OGF = 0x%x, OCF = 0x%x\n",
+                       NumHCI_Comm, (HCIOPCODEHIGHT(OCF, OGF)), (HCIOPCODELOW(OCF, OGF)), status, OGF, OCF));
+       }
+       return 3;
+}
+
+static u8 bthci_ExtensionEventHeaderRtk(u8 *pbuf, u8 extensionEvent)
+{
+       struct packet_irp_hcievent_data *PPacketIrpEvent = (struct packet_irp_hcievent_data *)pbuf;
+       PPacketIrpEvent->EventCode = HCI_EVENT_EXTENSION_RTK;
+       PPacketIrpEvent->Data[0] = extensionEvent;      /* extension event code */
+
+       return 1;
+}
+
+static enum rt_status
+bthci_IndicateEvent(
+       struct rtw_adapter *padapter,
+       void            *pEvntData,
+       u32             dataLen
+       )
+{
+       enum rt_status  rt_status;
+
+       rt_status = PlatformIndicateBTEvent(padapter, pEvntData, dataLen);
+
+       return rt_status;
+}
+
+static void
+bthci_EventWriteRemoteAmpAssoc(
+       struct rtw_adapter *padapter,
+       enum hci_status status,
+       u8 PLHandle
+       )
+{
+       u8 localBuf[TmpLocalBufSize] = "";
+       u8 *pRetPar;
+       u8 len = 0;
+       struct packet_irp_hcievent_data *PPacketIrpEvent;
+
+       PlatformZeroMemory(&localBuf[0], TmpLocalBufSize);
+       PPacketIrpEvent = (struct packet_irp_hcievent_data *)(&localBuf[0]);
+
+       len += bthci_CommandCompleteHeader(&localBuf[0],
+               OGF_STATUS_PARAMETERS,
+               HCI_WRITE_REMOTE_AMP_ASSOC,
+               status);
+       RTPRINT(FIOCTL, (IOCTL_BT_HCICMD|IOCTL_BT_LOGO), ("PhyLinkHandle = 0x%x, status = %d\n", PLHandle, status));
+       /*  Return parameters starts from here */
+       pRetPar = &PPacketIrpEvent->Data[len];
+       pRetPar[0] = status;            /* status */
+       pRetPar[1] = PLHandle;
+       len += 2;
+       PPacketIrpEvent->Length = len;
+
+       bthci_IndicateEvent(padapter, PPacketIrpEvent, len+2);
+}
+
+static void
+bthci_EventEnhancedFlushComplete(
+       struct rtw_adapter *padapter,
+       u16                                     LLH
+       )
+{
+       u8 localBuf[4] = "";
+       struct packet_irp_hcievent_data *PPacketIrpEvent;
+
+       RTPRINT(FIOCTL, IOCTL_BT_EVENT, ("EventEnhancedFlushComplete, LLH = 0x%x\n", LLH));
+
+       PPacketIrpEvent = (struct packet_irp_hcievent_data *)(&localBuf[0]);
+       PPacketIrpEvent->EventCode = HCI_EVENT_ENHANCED_FLUSH_COMPLETE;
+       PPacketIrpEvent->Length = 2;
+       /* Logical link handle */
+       PPacketIrpEvent->Data[0] = TWOBYTE_LOWBYTE(LLH);
+       PPacketIrpEvent->Data[1] = TWOBYTE_HIGHTBYTE(LLH);
+
+       bthci_IndicateEvent(padapter, PPacketIrpEvent, 4);
+}
+
+static void
+bthci_EventShortRangeModeChangeComplete(
+       struct rtw_adapter *padapter,
+       enum hci_status                         HciStatus,
+       u8              ShortRangeState,
+       u8              EntryNum
+       )
+{
+       struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
+       struct bt_hci_info *pBtHciInfo = &pBTInfo->BtHciInfo;
+       u8 localBuf[5] = "";
+       struct packet_irp_hcievent_data *PPacketIrpEvent;
+
+       if (!(pBtHciInfo->BTEventMaskPage2 & EMP2_HCI_EVENT_SHORT_RANGE_MODE_CHANGE_COMPLETE)) {
+               RTPRINT(FIOCTL, IOCTL_BT_EVENT,
+                       ("[BT event], Short Range Mode Change Complete, Ignore to send this event due to event mask page 2\n"));
+               return;
+       }
+       RTPRINT(FIOCTL, IOCTL_BT_EVENT, ("[BT event], Short Range Mode Change Complete, Status = %d\n , PLH = 0x%x\n, Short_Range_Mode_State = 0x%x\n",
+               HciStatus, pBTInfo->BtAsocEntry[EntryNum].PhyLinkCmdData.BtPhyLinkhandle, ShortRangeState));
+
+       PPacketIrpEvent = (struct packet_irp_hcievent_data *)(&localBuf[0]);
+       PPacketIrpEvent->EventCode = HCI_EVENT_SHORT_RANGE_MODE_CHANGE_COMPLETE;
+       PPacketIrpEvent->Length = 3;
+       PPacketIrpEvent->Data[0] = HciStatus;
+       PPacketIrpEvent->Data[1] = pBTInfo->BtAsocEntry[EntryNum].PhyLinkCmdData.BtPhyLinkhandle;
+       PPacketIrpEvent->Data[2] = ShortRangeState;
+       bthci_IndicateEvent(padapter, PPacketIrpEvent, 5);
+}
+
+static void bthci_EventSendFlowSpecModifyComplete(struct rtw_adapter *padapter,
+                                                 enum hci_status HciStatus,
+                                                 u16 logicHandle)
+{
+       u8 localBuf[5] = "";
+       struct packet_irp_hcievent_data *PPacketIrpEvent;
+       struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
+       struct bt_hci_info *pBtHciInfo = &pBTInfo->BtHciInfo;
+
+       if (!(pBtHciInfo->BTEventMaskPage2 & EMP2_HCI_EVENT_FLOW_SPEC_MODIFY_COMPLETE)) {
+               RTPRINT(FIOCTL, (IOCTL_BT_EVENT|IOCTL_BT_LOGO),
+                       ("[BT event], Flow Spec Modify Complete, Ignore to send this event due to event mask page 2\n"));
+               return;
+       }
+       RTPRINT(FIOCTL, (IOCTL_BT_EVENT|IOCTL_BT_LOGO),
+               ("[BT event], Flow Spec Modify Complete, status = 0x%x, LLH = 0x%x\n", HciStatus, logicHandle));
+       PPacketIrpEvent = (struct packet_irp_hcievent_data *)(&localBuf[0]);
+       PPacketIrpEvent->EventCode = HCI_EVENT_FLOW_SPEC_MODIFY_COMPLETE;
+       PPacketIrpEvent->Length = 3;
+
+       PPacketIrpEvent->Data[0] = HciStatus;
+       /* Logical link handle */
+       PPacketIrpEvent->Data[1] = TWOBYTE_LOWBYTE(logicHandle);
+       PPacketIrpEvent->Data[2] = TWOBYTE_HIGHTBYTE(logicHandle);
+
+       bthci_IndicateEvent(padapter, PPacketIrpEvent, 5);
+}
+
+static void
+bthci_EventExtWifiScanNotify(
+       struct rtw_adapter *padapter,
+       u8                      scanType
+       )
+{
+       struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
+       struct bt_mgnt *pBtMgnt = &pBTInfo->BtMgnt;
+       u8 len = 0;
+       u8 localBuf[7] = "";
+       u8 *pRetPar;
+       u8 *pu1Temp;
+       struct packet_irp_hcievent_data *PPacketIrpEvent;
+
+       if (!pBtMgnt->BtOperationOn)
+               return;
+
+       PPacketIrpEvent = (struct packet_irp_hcievent_data *)(&localBuf[0]);
+
+       len += bthci_ExtensionEventHeaderRtk(&localBuf[0], HCI_EVENT_EXT_WIFI_SCAN_NOTIFY);
+
+       /*  Return parameters starts from here */
+       pRetPar = &PPacketIrpEvent->Data[len];
+       pu1Temp = (u8 *)&pRetPar[0];
+       *pu1Temp = scanType;
+       len += 1;
+
+       PPacketIrpEvent->Length = len;
+
+       if (bthci_IndicateEvent(padapter, PPacketIrpEvent, len+2) == RT_STATUS_SUCCESS) {
+               RTPRINT(FIOCTL, IOCTL_BT_EVENT, ("[BT event], Wifi scan notify, scan type = %d\n",
+                       scanType));
+       }
+}
+
+static void
+bthci_EventAMPReceiverReport(
+       struct rtw_adapter *padapter,
+       u8 Reason
+       )
+{
+       struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
+       struct bt_hci_info *pBtHciInfo = &pBTInfo->BtHciInfo;
+
+       if (pBtHciInfo->bTestNeedReport) {
+               u8 localBuf[20] = "";
+               u32     *pu4Temp;
+               u16     *pu2Temp;
+               struct packet_irp_hcievent_data *PPacketIrpEvent;
+
+               RTPRINT(FIOCTL, (IOCTL_BT_EVENT|IOCTL_BT_LOGO), (" HCI_EVENT_AMP_RECEIVER_REPORT\n"));
+               PPacketIrpEvent = (struct packet_irp_hcievent_data *)(&localBuf[0]);
+               PPacketIrpEvent->EventCode = HCI_EVENT_AMP_RECEIVER_REPORT;
+               PPacketIrpEvent->Length = 2;
+
+               PPacketIrpEvent->Data[0] = pBtHciInfo->TestCtrType;
+
+               PPacketIrpEvent->Data[1] = Reason;
+
+               pu4Temp = (u32 *)&PPacketIrpEvent->Data[2];
+               *pu4Temp = pBtHciInfo->TestEventType;
+
+               pu2Temp = (u16 *)&PPacketIrpEvent->Data[6];
+               *pu2Temp = pBtHciInfo->TestNumOfFrame;
+
+               pu2Temp = (u16 *)&PPacketIrpEvent->Data[8];
+               *pu2Temp = pBtHciInfo->TestNumOfErrFrame;
+
+               pu4Temp = (u32 *)&PPacketIrpEvent->Data[10];
+               *pu4Temp = pBtHciInfo->TestNumOfBits;
+
+               pu4Temp = (u32 *)&PPacketIrpEvent->Data[14];
+               *pu4Temp = pBtHciInfo->TestNumOfErrBits;
+
+               bthci_IndicateEvent(padapter, PPacketIrpEvent, 20);
+
+               /* Return to Idel state with RX and TX off. */
+
+       }
+
+       pBtHciInfo->TestNumOfFrame = 0x00;
+}
+
+static void
+bthci_EventChannelSelected(
+       struct rtw_adapter *padapter,
+       u8      EntryNum
+       )
+{
+       struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
+       struct bt_hci_info *pBtHciInfo = &pBTInfo->BtHciInfo;
+       u8 localBuf[3] = "";
+       struct packet_irp_hcievent_data *PPacketIrpEvent;
+
+       if (!(pBtHciInfo->BTEventMaskPage2 & EMP2_HCI_EVENT_CHANNEL_SELECT)) {
+               RTPRINT(FIOCTL, IOCTL_BT_EVENT,
+                       ("[BT event], Channel Selected, Ignore to send this event due to event mask page 2\n"));
+               return;
+       }
+
+       RTPRINT(FIOCTL, IOCTL_BT_EVENT|IOCTL_STATE,
+               ("[BT event], Channel Selected, PhyLinkHandle %d\n",
+               pBTInfo->BtAsocEntry[EntryNum].PhyLinkCmdData.BtPhyLinkhandle));
+
+       PPacketIrpEvent = (struct packet_irp_hcievent_data *)(&localBuf[0]);
+       PPacketIrpEvent->EventCode = HCI_EVENT_CHANNEL_SELECT;
+       PPacketIrpEvent->Length = 1;
+       PPacketIrpEvent->Data[0] = pBTInfo->BtAsocEntry[EntryNum].PhyLinkCmdData.BtPhyLinkhandle;
+       bthci_IndicateEvent(padapter, PPacketIrpEvent, 3);
+}
+
+static void
+bthci_EventDisconnectPhyLinkComplete(
+       struct rtw_adapter *padapter,
+       enum hci_status                         HciStatus,
+       enum hci_status                         Reason,
+       u8              EntryNum
+       )
+{
+       struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
+       struct bt_hci_info *pBtHciInfo = &pBTInfo->BtHciInfo;
+       u8 localBuf[5] = "";
+       struct packet_irp_hcievent_data *PPacketIrpEvent;
+
+       if (!(pBtHciInfo->BTEventMaskPage2 & EMP2_HCI_EVENT_DISCONNECT_PHY_LINK_COMPLETE)) {
+               RTPRINT(FIOCTL, IOCTL_BT_EVENT,
+                       ("[BT event], Disconnect Physical Link Complete, Ignore to send this event due to event mask page 2\n"));
+               return;
+       }
+       RTPRINT(FIOCTL, IOCTL_BT_EVENT,
+               ("[BT event], Disconnect Physical Link Complete, Status = 0x%x, PLH = 0x%x Reason = 0x%x\n",
+               HciStatus, pBTInfo->BtAsocEntry[EntryNum].PhyLinkCmdData.BtPhyLinkhandle, Reason));
+       PPacketIrpEvent = (struct packet_irp_hcievent_data *)(&localBuf[0]);
+       PPacketIrpEvent->EventCode = HCI_EVENT_DISCONNECT_PHY_LINK_COMPLETE;
+       PPacketIrpEvent->Length = 3;
+       PPacketIrpEvent->Data[0] = HciStatus;
+       PPacketIrpEvent->Data[1] = pBTInfo->BtAsocEntry[EntryNum].PhyLinkCmdData.BtPhyLinkhandle;
+       PPacketIrpEvent->Data[2] = Reason;
+       bthci_IndicateEvent(padapter, PPacketIrpEvent, 5);
+}
+
+static void
+bthci_EventPhysicalLinkComplete(
+       struct rtw_adapter *padapter,
+       enum hci_status                         HciStatus,
+       u8              EntryNum,
+       u8              PLHandle
+       )
+{
+       struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
+       struct bt_mgnt *pBtMgnt = &pBTInfo->BtMgnt;
+       struct bt_hci_info *pBtHciInfo = &pBTInfo->BtHciInfo;
+       struct bt_dgb *pBtDbg = &pBTInfo->BtDbg;
+       u8 localBuf[4] = "";
+       struct packet_irp_hcievent_data *PPacketIrpEvent;
+       u8 PL_handle;
+
+       pBtMgnt->bPhyLinkInProgress = false;
+       pBtDbg->dbgHciInfo.hciCmdPhyLinkStatus = HciStatus;
+       if (!(pBtHciInfo->BTEventMaskPage2 & EMP2_HCI_EVENT_PHY_LINK_COMPLETE)) {
+               RTPRINT(FIOCTL, IOCTL_BT_EVENT,
+                       ("[BT event], Physical Link Complete, Ignore to send this event due to event mask page 2\n"));
+               return;
+       }
+
+       if (EntryNum == 0xff) {
+               /*  connection not started yet, just use the input physical link handle to response. */
+               PL_handle = PLHandle;
+       } else {
+               /*  connection is under progress, use the phy link handle we recorded. */
+               PL_handle  = pBTInfo->BtAsocEntry[EntryNum].PhyLinkCmdData.BtPhyLinkhandle;
+               pBTInfo->BtAsocEntry[EntryNum].bNeedPhysLinkCompleteEvent = false;
+       }
+
+       RTPRINT(FIOCTL, IOCTL_BT_EVENT, ("[BT event], Physical Link Complete, Status = 0x%x PhyLinkHandle = 0x%x\n", HciStatus,
+               PL_handle));
+
+       PPacketIrpEvent = (struct packet_irp_hcievent_data *)(&localBuf[0]);
+       PPacketIrpEvent->EventCode = HCI_EVENT_PHY_LINK_COMPLETE;
+       PPacketIrpEvent->Length = 2;
+
+       PPacketIrpEvent->Data[0] = HciStatus;
+       PPacketIrpEvent->Data[1] = PL_handle;
+       bthci_IndicateEvent(padapter, PPacketIrpEvent, 4);
+
+}
+
+static void
+bthci_EventCommandStatus(
+       struct rtw_adapter *padapter,
+       u8              OGF,
+       u16                                     OCF,
+       enum hci_status                         HciStatus
+       )
+{
+
+       u8 localBuf[6] = "";
+       struct packet_irp_hcievent_data *PPacketIrpEvent;
+       u8 Num_Hci_Comm = 0x1;
+       RTPRINT(FIOCTL, IOCTL_BT_EVENT,
+               ("[BT event], CommandStatus, Opcode = 0x%02x%02x, OGF = 0x%x,  OCF = 0x%x, Status = 0x%x, Num_HCI_COMM = 0x%x\n",
+               (HCIOPCODEHIGHT(OCF, OGF)), (HCIOPCODELOW(OCF, OGF)), OGF, OCF, HciStatus, Num_Hci_Comm));
+
+       PPacketIrpEvent = (struct packet_irp_hcievent_data *)(&localBuf[0]);
+       PPacketIrpEvent->EventCode = HCI_EVENT_COMMAND_STATUS;
+       PPacketIrpEvent->Length = 4;
+       PPacketIrpEvent->Data[0] = HciStatus;   /* current pending */
+       PPacketIrpEvent->Data[1] = Num_Hci_Comm;        /* packet # */
+       PPacketIrpEvent->Data[2] = HCIOPCODELOW(OCF, OGF);
+       PPacketIrpEvent->Data[3] = HCIOPCODEHIGHT(OCF, OGF);
+
+       bthci_IndicateEvent(padapter, PPacketIrpEvent, 6);
+
+}
+
+static void
+bthci_EventLogicalLinkComplete(
+       struct rtw_adapter *padapter,
+       enum hci_status                         HciStatus,
+       u8              PhyLinkHandle,
+       u16                                     LogLinkHandle,
+       u8              LogLinkIndex,
+       u8              EntryNum
+       )
+{
+/*PMGNT_INFO pMgntInfo = &padapter->MgntInfo; */
+       struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
+       struct bt_hci_info *pBtHciInfo = &pBTInfo->BtHciInfo;
+       u8 localBuf[7] = "";
+       struct packet_irp_hcievent_data *PPacketIrpEvent;
+
+       if (!(pBtHciInfo->BTEventMaskPage2 & EMP2_HCI_EVENT_LOGICAL_LINK_COMPLETE)) {
+               RTPRINT(FIOCTL, IOCTL_BT_EVENT,
+                       ("[BT event], Logical Link Complete, Ignore to send this event due to event mask page 2\n"));
+               return;
+       }
+       RTPRINT(FIOCTL, IOCTL_BT_EVENT, ("[BT event], Logical Link Complete, PhyLinkHandle = 0x%x,  LogLinkHandle = 0x%x, Status = 0x%x\n",
+               PhyLinkHandle, LogLinkHandle, HciStatus));
+
+       PPacketIrpEvent = (struct packet_irp_hcievent_data *)(&localBuf[0]);
+       PPacketIrpEvent->EventCode = HCI_EVENT_LOGICAL_LINK_COMPLETE;
+       PPacketIrpEvent->Length = 5;
+
+       PPacketIrpEvent->Data[0] = HciStatus;/* status code */
+       /* Logical link handle */
+       PPacketIrpEvent->Data[1] = TWOBYTE_LOWBYTE(LogLinkHandle);
+       PPacketIrpEvent->Data[2] = TWOBYTE_HIGHTBYTE(LogLinkHandle);
+       /* Physical link handle */
+       PPacketIrpEvent->Data[3] = TWOBYTE_LOWBYTE(PhyLinkHandle);
+       /* corresponding Tx flow spec ID */
+       if (HciStatus == HCI_STATUS_SUCCESS) {
+               PPacketIrpEvent->Data[4] =
+                       pBTInfo->BtAsocEntry[EntryNum].LogLinkCmdData[LogLinkIndex].Tx_Flow_Spec.Identifier;
+       } else {
+               PPacketIrpEvent->Data[4] = 0x0;
+       }
+
+       bthci_IndicateEvent(padapter, PPacketIrpEvent, 7);
+}
+
+static void
+bthci_EventDisconnectLogicalLinkComplete(
+       struct rtw_adapter *padapter,
+       enum hci_status                         HciStatus,
+       u16                                     LogLinkHandle,
+       enum hci_status                         Reason
+       )
+{
+       u8 localBuf[6] = "";
+       struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
+       struct bt_hci_info *pBtHciInfo = &pBTInfo->BtHciInfo;
+       struct packet_irp_hcievent_data *PPacketIrpEvent;
+
+       if (!(pBtHciInfo->BTEventMaskPage2 & EMP2_HCI_EVENT_DISCONNECT_LOGICAL_LINK_COMPLETE)) {
+               RTPRINT(FIOCTL, IOCTL_BT_EVENT, ("[BT event], Disconnect Logical Link Complete, Ignore to send this event due to event mask page 2\n"));
+               return;
+       }
+       RTPRINT(FIOCTL, IOCTL_BT_EVENT, ("[BT event], Disconnect Logical Link Complete, Status = 0x%x, LLH = 0x%x Reason = 0x%x\n", HciStatus, LogLinkHandle, Reason));
+
+       PPacketIrpEvent = (struct packet_irp_hcievent_data *)(&localBuf[0]);
+       PPacketIrpEvent->EventCode = HCI_EVENT_DISCONNECT_LOGICAL_LINK_COMPLETE;
+       PPacketIrpEvent->Length = 4;
+
+       PPacketIrpEvent->Data[0] = HciStatus;
+       /* Logical link handle */
+       PPacketIrpEvent->Data[1] = TWOBYTE_LOWBYTE(LogLinkHandle);
+       PPacketIrpEvent->Data[2] = TWOBYTE_HIGHTBYTE(LogLinkHandle);
+       /* Disconnect reason */
+       PPacketIrpEvent->Data[3] = Reason;
+
+       bthci_IndicateEvent(padapter, PPacketIrpEvent, 6);
+}
+
+static void
+bthci_EventFlushOccurred(
+       struct rtw_adapter *padapter,
+       u16                                     LogLinkHandle
+       )
+{
+       u8 localBuf[4] = "";
+       struct packet_irp_hcievent_data *PPacketIrpEvent;
+       RTPRINT(FIOCTL, IOCTL_BT_EVENT, ("bthci_EventFlushOccurred(), LLH = 0x%x\n", LogLinkHandle));
+
+       PPacketIrpEvent = (struct packet_irp_hcievent_data *)(&localBuf[0]);
+       PPacketIrpEvent->EventCode = HCI_EVENT_FLUSH_OCCRUED;
+       PPacketIrpEvent->Length = 2;
+       /* Logical link handle */
+       PPacketIrpEvent->Data[0] = TWOBYTE_LOWBYTE(LogLinkHandle);
+       PPacketIrpEvent->Data[1] = TWOBYTE_HIGHTBYTE(LogLinkHandle);
+
+       bthci_IndicateEvent(padapter, PPacketIrpEvent, 4);
+}
+
+static enum hci_status
+bthci_BuildPhysicalLink(
+       struct rtw_adapter *padapter,
+       struct packet_irp_hcicmd_data *pHciCmd,
+       u16     OCF
+)
+{
+       enum hci_status         status = HCI_STATUS_SUCCESS;
+       struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
+       struct bt_mgnt *pBtMgnt = &pBTInfo->BtMgnt;
+       u8 EntryNum, PLH;
+
+       /* Send HCI Command status event to AMP. */
+       bthci_EventCommandStatus(padapter,
+                       LINK_CONTROL_COMMANDS,
+                       OCF,
+                       HCI_STATUS_SUCCESS);
+
+       PLH = *((u8 *)pHciCmd->Data);
+
+       /*  Check if resource or bt connection is under progress, if yes, reject the link creation. */
+       if (!bthci_AddEntry(padapter)) {
+               status = HCI_STATUS_CONNECT_RJT_LIMIT_RESOURCE;
+               bthci_EventPhysicalLinkComplete(padapter, status, INVALID_ENTRY_NUM, PLH);
+               return status;
+       }
+
+       EntryNum = pBtMgnt->CurrentConnectEntryNum;
+       pBTInfo->BtAsocEntry[EntryNum].PhyLinkCmdData.BtPhyLinkhandle = PLH;
+       pBtMgnt->BtCurrentPhyLinkhandle = PLH;
+
+       if (pBTInfo->BtAsocEntry[EntryNum].AmpAsocCmdData.AMPAssocfragment == NULL) {
+               RTPRINT(FIOCTL, (IOCTL_BT_HCICMD|IOCTL_BT_LOGO), ("Create/Accept PhysicalLink, AMP controller is busy\n"));
+               status = HCI_STATUS_CONTROLLER_BUSY;
+               bthci_EventPhysicalLinkComplete(padapter, status, INVALID_ENTRY_NUM, PLH);
+               return status;
+       }
+
+       /*  Record Key and the info */
+       pBTInfo->BtAsocEntry[EntryNum].PhyLinkCmdData.BtAMPKeyLen = (*((u8 *)pHciCmd->Data+1));
+       pBTInfo->BtAsocEntry[EntryNum].PhyLinkCmdData.BtAMPKeyType = (*((u8 *)pHciCmd->Data+2));
+       memcpy(pBTInfo->BtAsocEntry[EntryNum].PhyLinkCmdData.BtAMPKey,
+               (((u8 *)pHciCmd->Data+3)), pBTInfo->BtAsocEntry[EntryNum].PhyLinkCmdData.BtAMPKeyLen);
+       memcpy(pBTInfo->BtAsocEntry[EntryNum].PMK, pBTInfo->BtAsocEntry[EntryNum].PhyLinkCmdData.BtAMPKey, PMK_LEN);
+       RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("BuildPhysicalLink, EntryNum = %d, PLH = 0x%x  KeyLen = 0x%x, KeyType = 0x%x\n",
+               EntryNum, pBTInfo->BtAsocEntry[EntryNum].PhyLinkCmdData.BtPhyLinkhandle,
+               pBTInfo->BtAsocEntry[EntryNum].PhyLinkCmdData.BtAMPKeyLen,
+               pBTInfo->BtAsocEntry[EntryNum].PhyLinkCmdData.BtAMPKeyType));
+       RTPRINT_DATA(FIOCTL, (IOCTL_BT_LOGO|IOCTL_BT_HCICMD), ("BtAMPKey\n"), pBTInfo->BtAsocEntry[EntryNum].PhyLinkCmdData.BtAMPKey,
+               pBTInfo->BtAsocEntry[EntryNum].PhyLinkCmdData.BtAMPKeyLen);
+       RTPRINT_DATA(FIOCTL, (IOCTL_BT_LOGO|IOCTL_BT_HCICMD), ("PMK\n"), pBTInfo->BtAsocEntry[EntryNum].PMK,
+               PMK_LEN);
+
+       if (OCF == HCI_CREATE_PHYSICAL_LINK) {
+               /* These macros require braces */
+               BTHCI_SM_WITH_INFO(padapter, HCI_STATE_DISCONNECTED, STATE_CMD_CREATE_PHY_LINK, EntryNum);
+       } else if (OCF == HCI_ACCEPT_PHYSICAL_LINK) {
+               BTHCI_SM_WITH_INFO(padapter, HCI_STATE_DISCONNECTED, STATE_CMD_ACCEPT_PHY_LINK, EntryNum);
+       }
+
+       return status;
+}
+
+static void
+bthci_BuildLogicalLink(
+       struct rtw_adapter *padapter,
+       struct packet_irp_hcicmd_data *pHciCmd,
+       u16 OCF
+       )
+{
+       enum hci_status status = HCI_STATUS_SUCCESS;
+       struct bt_30info *pBTinfo = GET_BT_INFO(padapter);
+       struct bt_mgnt *pBtMgnt = &pBTinfo->BtMgnt;
+       u8 PhyLinkHandle, EntryNum;
+       static u16 AssignLogHandle = 1;
+
+       struct hci_flow_spec    TxFlowSpec;
+       struct hci_flow_spec    RxFlowSpec;
+       u32     MaxSDUSize, ArriveTime, Bandwidth;
+
+       PhyLinkHandle = *((u8 *)pHciCmd->Data);
+
+       EntryNum = bthci_GetCurrentEntryNum(padapter, PhyLinkHandle);
+
+       memcpy(&TxFlowSpec,
+               &pHciCmd->Data[1], sizeof(struct hci_flow_spec));
+       memcpy(&RxFlowSpec,
+               &pHciCmd->Data[17], sizeof(struct hci_flow_spec));
+
+       MaxSDUSize = TxFlowSpec.MaximumSDUSize;
+       ArriveTime = TxFlowSpec.SDUInterArrivalTime;
+
+       if (bthci_CheckLogLinkBehavior(padapter, TxFlowSpec) && bthci_CheckLogLinkBehavior(padapter, RxFlowSpec))
+               Bandwidth = BTTOTALBANDWIDTH;
+       else if (MaxSDUSize == 0xffff && ArriveTime == 0xffffffff)
+               Bandwidth = BTTOTALBANDWIDTH;
+       else
+               Bandwidth = MaxSDUSize*8*1000/(ArriveTime+244);
+
+       RTPRINT(FIOCTL, IOCTL_BT_HCICMD,
+               ("BuildLogicalLink, PhyLinkHandle = 0x%x, MaximumSDUSize = 0x%x, SDUInterArrivalTime = 0x%x, Bandwidth = 0x%x\n",
+               PhyLinkHandle, MaxSDUSize, ArriveTime, Bandwidth));
+
+       if (EntryNum == 0xff) {
+               RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("Invalid Physical Link handle = 0x%x, status = HCI_STATUS_UNKNOW_CONNECT_ID, return\n", PhyLinkHandle));
+               status = HCI_STATUS_UNKNOW_CONNECT_ID;
+
+               /* When we receive Create/Accept logical link command, we should send command status event first. */
+               bthci_EventCommandStatus(padapter,
+                       LINK_CONTROL_COMMANDS,
+                       OCF,
+                       status);
+               return;
+       }
+
+       if (!pBtMgnt->bLogLinkInProgress) {
+               if (bthci_PhyLinkConnectionInProgress(padapter, PhyLinkHandle)) {
+                       RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("Physical link connection in progress, status = HCI_STATUS_CMD_DISALLOW, return\n"));
+                       status = HCI_STATUS_CMD_DISALLOW;
+
+                       pBtMgnt->bPhyLinkInProgressStartLL = true;
+                       /* When we receive Create/Accept logical link command, we should send command status event first. */
+                       bthci_EventCommandStatus(padapter,
+                               LINK_CONTROL_COMMANDS,
+                               OCF,
+                               status);
+
+                       return;
+               }
+
+               if (Bandwidth > BTTOTALBANDWIDTH) {
+                       RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("status = HCI_STATUS_QOS_REJECT, Bandwidth = 0x%x, return\n", Bandwidth));
+                       status = HCI_STATUS_QOS_REJECT;
+
+                       /* When we receive Create/Accept logical link command, we should send command status event first. */
+                       bthci_EventCommandStatus(padapter,
+                               LINK_CONTROL_COMMANDS,
+                               OCF,
+                               status);
+               } else {
+                       RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("status = HCI_STATUS_SUCCESS\n"));
+                       status = HCI_STATUS_SUCCESS;
+
+                       /* When we receive Create/Accept logical link command, we should send command status event first. */
+                       bthci_EventCommandStatus(padapter,
+                               LINK_CONTROL_COMMANDS,
+                               OCF,
+                               status);
+
+               }
+
+               if (pBTinfo->BtAsocEntry[EntryNum].BtCurrentState != HCI_STATE_CONNECTED) {
+                       bthci_EventLogicalLinkComplete(padapter,
+                               HCI_STATUS_CMD_DISALLOW, 0, 0, 0, EntryNum);
+               } else {
+                       u8 i, find = 0;
+
+                       pBtMgnt->bLogLinkInProgress = true;
+
+                       /*  find an unused logical link index and copy the data */
+                       for (i = 0; i < MAX_LOGICAL_LINK_NUM; i++) {
+                               if (pBTinfo->BtAsocEntry[EntryNum].LogLinkCmdData[i].BtLogLinkhandle == 0) {
+                                       enum hci_status LogCompEventstatus = HCI_STATUS_SUCCESS;
+
+                                       pBTinfo->BtAsocEntry[EntryNum].LogLinkCmdData[i].BtPhyLinkhandle = *((u8 *)pHciCmd->Data);
+                                       pBTinfo->BtAsocEntry[EntryNum].LogLinkCmdData[i].BtLogLinkhandle = AssignLogHandle;
+                                       RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("BuildLogicalLink, EntryNum = %d, physical link handle = 0x%x, logical link handle = 0x%x\n",
+                                               EntryNum, pBTinfo->BtAsocEntry[EntryNum].PhyLinkCmdData.BtPhyLinkhandle,
+                                                                 pBTinfo->BtAsocEntry[EntryNum].LogLinkCmdData[i].BtLogLinkhandle));
+                                       memcpy(&pBTinfo->BtAsocEntry[EntryNum].LogLinkCmdData[i].Tx_Flow_Spec,
+                                               &TxFlowSpec, sizeof(struct hci_flow_spec));
+                                       memcpy(&pBTinfo->BtAsocEntry[EntryNum].LogLinkCmdData[i].Rx_Flow_Spec,
+                                               &RxFlowSpec, sizeof(struct hci_flow_spec));
+
+                                       pBTinfo->BtAsocEntry[EntryNum].LogLinkCmdData[i].bLLCompleteEventIsSet = false;
+
+                                       if (pBTinfo->BtAsocEntry[EntryNum].LogLinkCmdData[i].bLLCancelCMDIsSetandComplete)
+                                               LogCompEventstatus = HCI_STATUS_UNKNOW_CONNECT_ID;
+                                       bthci_EventLogicalLinkComplete(padapter,
+                                               LogCompEventstatus,
+                                               pBTinfo->BtAsocEntry[EntryNum].LogLinkCmdData[i].BtPhyLinkhandle,
+                                               pBTinfo->BtAsocEntry[EntryNum].LogLinkCmdData[i].BtLogLinkhandle, i, EntryNum);
+
+                                       pBTinfo->BtAsocEntry[EntryNum].LogLinkCmdData[i].bLLCompleteEventIsSet = true;
+
+                                       find = 1;
+                                       pBtMgnt->BtCurrentLogLinkhandle = AssignLogHandle;
+                                       AssignLogHandle++;
+                                       break;
+                               }
+                       }
+
+                       if (!find) {
+                               bthci_EventLogicalLinkComplete(padapter,
+                                       HCI_STATUS_CONNECT_RJT_LIMIT_RESOURCE, 0, 0, 0, EntryNum);
+                       }
+                       pBtMgnt->bLogLinkInProgress = false;
+               }
+       } else {
+               bthci_EventLogicalLinkComplete(padapter,
+                       HCI_STATUS_CONTROLLER_BUSY, 0, 0, 0, EntryNum);
+       }
+
+}
+
+static void
+bthci_StartBeaconAndConnect(
+       struct rtw_adapter *padapter,
+       struct packet_irp_hcicmd_data *pHciCmd,
+       u8 CurrentAssocNum
+       )
+{
+/*PMGNT_INFO pMgntInfo = &padapter->MgntInfo; */
+       struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
+       struct bt_mgnt *pBtMgnt = &pBTInfo->BtMgnt;
+
+       RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("StartBeaconAndConnect, CurrentAssocNum =%d, AMPRole =%d\n",
+               CurrentAssocNum,
+               pBTInfo->BtAsocEntry[CurrentAssocNum].AMPRole));
+
+       if (!pBtMgnt->CheckChnlIsSuit) {
+               bthci_EventPhysicalLinkComplete(padapter, HCI_STATUS_CONNECT_REJ_NOT_SUIT_CHNL_FOUND, CurrentAssocNum, INVALID_PL_HANDLE);
+               bthci_RemoveEntryByEntryNum(padapter, CurrentAssocNum);
+               return;
+       }
+
+       if (pBTInfo->BtAsocEntry[CurrentAssocNum].AMPRole == AMP_BTAP_CREATOR) {
+               rsprintf((char *)pBTInfo->BtAsocEntry[CurrentAssocNum].BTSsidBuf, 32, "AMP-%02x-%02x-%02x-%02x-%02x-%02x",
+               padapter->eeprompriv.mac_addr[0],
+               padapter->eeprompriv.mac_addr[1],
+               padapter->eeprompriv.mac_addr[2],
+               padapter->eeprompriv.mac_addr[3],
+               padapter->eeprompriv.mac_addr[4],
+               padapter->eeprompriv.mac_addr[5]);
+       } else if (pBTInfo->BtAsocEntry[CurrentAssocNum].AMPRole == AMP_BTAP_JOINER) {
+               rsprintf((char *)pBTInfo->BtAsocEntry[CurrentAssocNum].BTSsidBuf, 32, "AMP-%02x-%02x-%02x-%02x-%02x-%02x",
+               pBTInfo->BtAsocEntry[CurrentAssocNum].BTRemoteMACAddr[0],
+               pBTInfo->BtAsocEntry[CurrentAssocNum].BTRemoteMACAddr[1],
+               pBTInfo->BtAsocEntry[CurrentAssocNum].BTRemoteMACAddr[2],
+               pBTInfo->BtAsocEntry[CurrentAssocNum].BTRemoteMACAddr[3],
+               pBTInfo->BtAsocEntry[CurrentAssocNum].BTRemoteMACAddr[4],
+               pBTInfo->BtAsocEntry[CurrentAssocNum].BTRemoteMACAddr[5]);
+       }
+
+       FillOctetString(pBTInfo->BtAsocEntry[CurrentAssocNum].BTSsid, pBTInfo->BtAsocEntry[CurrentAssocNum].BTSsidBuf, 21);
+       pBTInfo->BtAsocEntry[CurrentAssocNum].BTSsid.Length = 21;
+
+       /* To avoid set the start ap or connect twice, or the original connection will be disconnected. */
+       if (!pBtMgnt->bBTConnectInProgress) {
+               pBtMgnt->bBTConnectInProgress = true;
+               RTPRINT(FIOCTL, IOCTL_STATE, ("[BT Flag], BT Connect in progress ON!!\n"));
+               BTHCI_SM_WITH_INFO(padapter, HCI_STATE_STARTING, STATE_CMD_MAC_START_COMPLETE, CurrentAssocNum);
+
+               /*  20100325 Joseph: Check RF ON/OFF. */
+               /*  If RF OFF, it reschedule connecting operation after 50ms. */
+               if (!bthci_CheckRfStateBeforeConnect(padapter))
+                       return;
+
+               if (pBTInfo->BtAsocEntry[CurrentAssocNum].AMPRole == AMP_BTAP_CREATOR) {
+                       /* These macros need braces */
+                       BTHCI_SM_WITH_INFO(padapter, HCI_STATE_CONNECTING, STATE_CMD_MAC_CONNECT_COMPLETE, CurrentAssocNum);
+               } else if (pBTInfo->BtAsocEntry[CurrentAssocNum].AMPRole == AMP_BTAP_JOINER) {
+                       bthci_ResponderStartToScan(padapter);
+               }
+       }
+       RT_PRINT_STR(_module_rtl871x_mlme_c_, _drv_notice_,
+                    "StartBeaconAndConnect, SSID:\n",
+                    pBTInfo->BtAsocEntry[pBtMgnt->CurrentConnectEntryNum].BTSsid.Octet,
+                    pBTInfo->BtAsocEntry[pBtMgnt->CurrentConnectEntryNum].BTSsid.Length);
+}
+
+static void bthci_ResetBtMgnt(struct bt_mgnt *pBtMgnt)
+{
+       pBtMgnt->BtOperationOn = false;
+       pBtMgnt->bBTConnectInProgress = false;
+       pBtMgnt->bLogLinkInProgress = false;
+       pBtMgnt->bPhyLinkInProgress = false;
+       pBtMgnt->bPhyLinkInProgressStartLL = false;
+       pBtMgnt->DisconnectEntryNum = 0xff;
+       pBtMgnt->bStartSendSupervisionPkt = false;
+       pBtMgnt->JoinerNeedSendAuth = false;
+       pBtMgnt->CurrentBTConnectionCnt = 0;
+       pBtMgnt->BTCurrentConnectType = BT_DISCONNECT;
+       pBtMgnt->BTReceiveConnectPkt = BT_DISCONNECT;
+       pBtMgnt->BTAuthCount = 0;
+       pBtMgnt->btLogoTest = 0;
+}
+
+static void bthci_ResetBtHciInfo(struct bt_hci_info *pBtHciInfo)
+{
+       pBtHciInfo->BTEventMask = 0;
+       pBtHciInfo->BTEventMaskPage2 = 0;
+       pBtHciInfo->ConnAcceptTimeout =  10000;
+       pBtHciInfo->PageTimeout  =  0x30;
+       pBtHciInfo->LocationDomainAware = 0x0;
+       pBtHciInfo->LocationDomain = 0x5858;
+       pBtHciInfo->LocationDomainOptions = 0x58;
+       pBtHciInfo->LocationOptions = 0x0;
+       pBtHciInfo->FlowControlMode = 0x1;      /*  0:Packet based data flow control mode(BR/EDR), 1: Data block based data flow control mode(AMP). */
+
+       pBtHciInfo->enFlush_LLH = 0;
+       pBtHciInfo->FLTO_LLH = 0;
+
+       /* Test command only */
+       pBtHciInfo->bTestIsEnd = true;
+       pBtHciInfo->bInTestMode = false;
+       pBtHciInfo->bTestNeedReport = false;
+       pBtHciInfo->TestScenario = 0xff;
+       pBtHciInfo->TestReportInterval = 0x01;
+       pBtHciInfo->TestCtrType = 0x5d;
+       pBtHciInfo->TestEventType = 0x00;
+       pBtHciInfo->TestNumOfFrame = 0;
+       pBtHciInfo->TestNumOfErrFrame = 0;
+       pBtHciInfo->TestNumOfBits = 0;
+       pBtHciInfo->TestNumOfErrBits = 0;
+}
+
+static void bthci_ResetBtSec(struct rtw_adapter *padapter, struct bt_security *pBtSec)
+{
+/*PMGNT_INFO   pMgntInfo = &padapter->MgntInfo; */
+
+       /*  Set BT used HW or SW encrypt !! */
+       if (GET_HAL_DATA(padapter)->bBTMode)
+               pBtSec->bUsedHwEncrypt = true;
+       else
+               pBtSec->bUsedHwEncrypt = false;
+       RT_TRACE(_module_rtl871x_security_c_, _drv_info_,
+                "%s: bUsedHwEncrypt =%d\n", __func__, pBtSec->bUsedHwEncrypt);
+
+       pBtSec->RSNIE.Octet = pBtSec->RSNIEBuf;
+}
+
+static void bthci_ResetBtExtInfo(struct bt_mgnt *pBtMgnt)
+{
+       u8 i;
+
+       for (i = 0; i < MAX_BT_ASOC_ENTRY_NUM; i++) {
+               pBtMgnt->ExtConfig.linkInfo[i].ConnectHandle = 0;
+               pBtMgnt->ExtConfig.linkInfo[i].IncomingTrafficMode = 0;
+               pBtMgnt->ExtConfig.linkInfo[i].OutgoingTrafficMode = 0;
+               pBtMgnt->ExtConfig.linkInfo[i].BTProfile = BT_PROFILE_NONE;
+               pBtMgnt->ExtConfig.linkInfo[i].BTCoreSpec = BT_SPEC_2_1_EDR;
+               pBtMgnt->ExtConfig.linkInfo[i].BT_RSSI = 0;
+               pBtMgnt->ExtConfig.linkInfo[i].TrafficProfile = BT_PROFILE_NONE;
+               pBtMgnt->ExtConfig.linkInfo[i].linkRole = BT_LINK_MASTER;
+       }
+
+       pBtMgnt->ExtConfig.CurrentConnectHandle = 0;
+       pBtMgnt->ExtConfig.CurrentIncomingTrafficMode = 0;
+       pBtMgnt->ExtConfig.CurrentOutgoingTrafficMode = 0;
+       pBtMgnt->ExtConfig.MIN_BT_RSSI = 0;
+       pBtMgnt->ExtConfig.NumberOfHandle = 0;
+       pBtMgnt->ExtConfig.NumberOfSCO = 0;
+       pBtMgnt->ExtConfig.CurrentBTStatus = 0;
+       pBtMgnt->ExtConfig.HCIExtensionVer = 0;
+
+       pBtMgnt->ExtConfig.bManualControl = false;
+       pBtMgnt->ExtConfig.bBTBusy = false;
+       pBtMgnt->ExtConfig.bBTA2DPBusy = false;
+}
+
+static enum hci_status bthci_CmdReset(struct rtw_adapter *_padapter, u8 bNeedSendEvent)
+{
+       enum hci_status status = HCI_STATUS_SUCCESS;
+       struct rtw_adapter *padapter;
+/*PMGNT_INFO pMgntInfo = &padapter->MgntInfo; */
+       struct bt_30info *pBTInfo;
+       struct bt_mgnt *pBtMgnt;
+       struct bt_hci_info *pBtHciInfo;
+       struct bt_security *pBtSec;
+       struct bt_dgb *pBtDbg;
+       u8 i;
+
+       RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("bthci_CmdReset()\n"));
+
+       padapter = GetDefaultAdapter(_padapter);
+       pBTInfo = GET_BT_INFO(padapter);
+       pBtMgnt = &pBTInfo->BtMgnt;
+       pBtHciInfo = &pBTInfo->BtHciInfo;
+       pBtSec = &pBTInfo->BtSec;
+       pBtDbg = &pBTInfo->BtDbg;
+
+       pBTInfo->padapter = padapter;
+
+       for (i = 0; i < MAX_BT_ASOC_ENTRY_NUM; i++)
+               bthci_ResetEntry(padapter, i);
+
+       bthci_ResetBtMgnt(pBtMgnt);
+       bthci_ResetBtHciInfo(pBtHciInfo);
+       bthci_ResetBtSec(padapter, pBtSec);
+
+       pBtMgnt->BTChannel = BT_Default_Chnl;
+       pBtMgnt->CheckChnlIsSuit = true;
+
+       pBTInfo->BTBeaconTmrOn = false;
+
+       pBtMgnt->bCreateSpportQos = true;
+
+       del_timer_sync(&pBTInfo->BTHCIDiscardAclDataTimer);
+       del_timer_sync(&pBTInfo->BTBeaconTimer);
+
+       HALBT_SetRtsCtsNoLenLimit(padapter);
+       /*  */
+       /*  Maybe we need to take care Group != AES case !! */
+       /*  now we Pairwise and Group all used AES !! */
+
+       bthci_ResetBtExtInfo(pBtMgnt);
+
+       /* send command complete event here when all data are received. */
+       if (bNeedSendEvent) {
+               u8 localBuf[6] = "";
+               u8 *pRetPar;
+               u8 len = 0;
+               struct packet_irp_hcievent_data *PPacketIrpEvent;
+
+               PPacketIrpEvent = (struct packet_irp_hcievent_data *)(&localBuf[0]);
+
+               len += bthci_CommandCompleteHeader(&localBuf[0],
+                       OGF_SET_EVENT_MASK_COMMAND,
+                       HCI_RESET,
+                       status);
+
+               /*  Return parameters starts from here */
+               pRetPar = &PPacketIrpEvent->Data[len];
+               pRetPar[0] = status;            /* status */
+               len += 1;
+               PPacketIrpEvent->Length = len;
+
+               bthci_IndicateEvent(padapter, PPacketIrpEvent, len+2);
+       }
+
+       return status;
+}
+
+static enum hci_status
+bthci_CmdWriteRemoteAMPAssoc(
+       struct rtw_adapter *padapter,
+       struct packet_irp_hcicmd_data *pHciCmd
+       )
+{
+       enum hci_status status = HCI_STATUS_SUCCESS;
+       struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
+       struct bt_dgb *pBtDbg = &pBTInfo->BtDbg;
+       u8 CurrentAssocNum;
+       u8 PhyLinkHandle;
+
+       pBtDbg->dbgHciInfo.hciCmdCntWriteRemoteAmpAssoc++;
+       PhyLinkHandle = *((u8 *)pHciCmd->Data);
+       CurrentAssocNum = bthci_GetCurrentEntryNum(padapter, PhyLinkHandle);
+
+       if (CurrentAssocNum == 0xff) {
+               RTPRINT(FIOCTL, (IOCTL_BT_HCICMD|IOCTL_BT_LOGO), ("WriteRemoteAMPAssoc, No such Handle in the Entry\n"));
+               status = HCI_STATUS_UNKNOW_CONNECT_ID;
+               bthci_EventWriteRemoteAmpAssoc(padapter, status, PhyLinkHandle);
+               return status;
+       }
+
+       if (pBTInfo->BtAsocEntry[CurrentAssocNum].AmpAsocCmdData.AMPAssocfragment == NULL) {
+               RTPRINT(FIOCTL, (IOCTL_BT_HCICMD|IOCTL_BT_LOGO), ("WriteRemoteAMPAssoc, AMP controller is busy\n"));
+               status = HCI_STATUS_CONTROLLER_BUSY;
+               bthci_EventWriteRemoteAmpAssoc(padapter, status, PhyLinkHandle);
+               return status;
+       }
+
+       pBTInfo->BtAsocEntry[CurrentAssocNum].AmpAsocCmdData.BtPhyLinkhandle = PhyLinkHandle;/* u8 *)pHciCmd->Data); */
+       pBTInfo->BtAsocEntry[CurrentAssocNum].AmpAsocCmdData.LenSoFar = *((u16 *)((u8 *)pHciCmd->Data+1));
+       pBTInfo->BtAsocEntry[CurrentAssocNum].AmpAsocCmdData.AMPAssocRemLen = *((u16 *)((u8 *)pHciCmd->Data+3));
+
+       RTPRINT(FIOCTL, (IOCTL_BT_HCICMD_DETAIL|IOCTL_BT_LOGO), ("WriteRemoteAMPAssoc, LenSoFar = 0x%x, AssocRemLen = 0x%x\n",
+               pBTInfo->BtAsocEntry[CurrentAssocNum].AmpAsocCmdData.LenSoFar,
+               pBTInfo->BtAsocEntry[CurrentAssocNum].AmpAsocCmdData.AMPAssocRemLen));
+
+       RTPRINT_DATA(FIOCTL, (IOCTL_BT_HCICMD_DETAIL|IOCTL_BT_LOGO),
+                    ("WriteRemoteAMPAssoc fragment \n"),
+                    pHciCmd->Data,
+                    pBTInfo->BtAsocEntry[CurrentAssocNum].AmpAsocCmdData.AMPAssocRemLen+5);
+       if ((pBTInfo->BtAsocEntry[CurrentAssocNum].AmpAsocCmdData.AMPAssocRemLen) > MAX_AMP_ASSOC_FRAG_LEN) {
+               memcpy(((u8 *)pBTInfo->BtAsocEntry[CurrentAssocNum].AmpAsocCmdData.AMPAssocfragment+(pBTInfo->BtAsocEntry[CurrentAssocNum].AmpAsocCmdData.LenSoFar*(sizeof(u8)))),
+                       (u8 *)pHciCmd->Data+5,
+                       MAX_AMP_ASSOC_FRAG_LEN);
+       } else {
+               memcpy((u8 *)(pBTInfo->BtAsocEntry[CurrentAssocNum].AmpAsocCmdData.AMPAssocfragment)+(pBTInfo->BtAsocEntry[CurrentAssocNum].AmpAsocCmdData.LenSoFar*(sizeof(u8))),
+                       ((u8 *)pHciCmd->Data+5),
+                       (pBTInfo->BtAsocEntry[CurrentAssocNum].AmpAsocCmdData.AMPAssocRemLen));
+
+               RTPRINT_DATA(FIOCTL, (IOCTL_BT_HCICMD_DETAIL|IOCTL_BT_LOGO), "WriteRemoteAMPAssoc :\n",
+                       pHciCmd->Data+5, pBTInfo->BtAsocEntry[CurrentAssocNum].AmpAsocCmdData.AMPAssocRemLen);
+
+               if (!bthci_GetAssocInfo(padapter, CurrentAssocNum))
+                       status = HCI_STATUS_INVALID_HCI_CMD_PARA_VALUE;
+
+               bthci_EventWriteRemoteAmpAssoc(padapter, status, PhyLinkHandle);
+
+               bthci_StartBeaconAndConnect(padapter, pHciCmd, CurrentAssocNum);
+       }
+
+       return status;
+}
+
+/* 7.3.13 */
+static enum hci_status bthci_CmdReadConnectionAcceptTimeout(struct rtw_adapter *padapter)
+{
+       enum hci_status         status = HCI_STATUS_SUCCESS;
+/*PMGNT_INFO           pMgntInfo = &padapter->MgntInfo; */
+       struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
+       struct bt_hci_info *pBtHciInfo = &pBTInfo->BtHciInfo;
+       u8 localBuf[8] = "";
+       u8 *pRetPar;
+       u8 len = 0;
+       struct packet_irp_hcievent_data *PPacketIrpEvent;
+       u16 *pu2Temp;
+
+       PPacketIrpEvent = (struct packet_irp_hcievent_data *)(&localBuf[0]);
+
+       len += bthci_CommandCompleteHeader(&localBuf[0],
+               OGF_SET_EVENT_MASK_COMMAND,
+               HCI_READ_CONNECTION_ACCEPT_TIMEOUT,
+               status);
+
+       /*  Return parameters starts from here */
+       pRetPar = &PPacketIrpEvent->Data[len];
+       pRetPar[0] = status;            /* status */
+       pu2Temp = (u16 *)&pRetPar[1];           /*  Conn_Accept_Timeout */
+       *pu2Temp = pBtHciInfo->ConnAcceptTimeout;
+       len += 3;
+       PPacketIrpEvent->Length = len;
+
+       bthci_IndicateEvent(padapter, PPacketIrpEvent, len+2);
+
+       return status;
+}
+
+/* 7.3.14 */
+static enum hci_status
+bthci_CmdWriteConnectionAcceptTimeout(
+       struct rtw_adapter *padapter,
+       struct packet_irp_hcicmd_data *pHciCmd
+       )
+{
+       enum hci_status         status = HCI_STATUS_SUCCESS;
+       struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
+       struct bt_hci_info *pBtHciInfo = &pBTInfo->BtHciInfo;
+       u16     *pu2Temp;
+       u8 localBuf[6] = "";
+       u8 *pRetPar;
+       u8 len = 0;
+       struct packet_irp_hcievent_data *PPacketIrpEvent;
+
+       pu2Temp = (u16 *)&pHciCmd->Data[0];
+       pBtHciInfo->ConnAcceptTimeout = *pu2Temp;
+       RTPRINT(FIOCTL, IOCTL_BT_HCICMD_DETAIL, ("ConnAcceptTimeout = 0x%x",
+               pBtHciInfo->ConnAcceptTimeout));
+
+       /* send command complete event here when all data are received. */
+       PPacketIrpEvent = (struct packet_irp_hcievent_data *)(&localBuf[0]);
+
+       len += bthci_CommandCompleteHeader(&localBuf[0],
+               OGF_SET_EVENT_MASK_COMMAND,
+               HCI_WRITE_CONNECTION_ACCEPT_TIMEOUT,
+               status);
+
+       /*  Return parameters starts from here */
+       pRetPar = &PPacketIrpEvent->Data[len];
+       pRetPar[0] = status;            /* status */
+       len += 1;
+       PPacketIrpEvent->Length = len;
+
+       bthci_IndicateEvent(padapter, PPacketIrpEvent, len+2);
+
+       return status;
+}
+
+static enum hci_status
+bthci_CmdReadPageTimeout(
+       struct rtw_adapter *padapter,
+       struct packet_irp_hcicmd_data *pHciCmd
+       )
+{
+       enum hci_status         status = HCI_STATUS_SUCCESS;
+       struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
+       struct bt_hci_info *pBtHciInfo = &pBTInfo->BtHciInfo;
+       u8 localBuf[8] = "";
+       u8 *pRetPar;
+       u8 len = 0;
+       struct packet_irp_hcievent_data *PPacketIrpEvent;
+       u16 *pu2Temp;
+
+       PPacketIrpEvent = (struct packet_irp_hcievent_data *)(&localBuf[0]);
+
+       len += bthci_CommandCompleteHeader(&localBuf[0],
+               OGF_SET_EVENT_MASK_COMMAND,
+               HCI_READ_PAGE_TIMEOUT,
+               status);
+
+       RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("Read PageTimeout = 0x%x\n", pBtHciInfo->PageTimeout));
+       /*  Return parameters starts from here */
+       pRetPar = &PPacketIrpEvent->Data[len];
+       pRetPar[0] = status;            /* status */
+       pu2Temp = (u16 *)&pRetPar[1];           /*  Page_Timeout */
+       *pu2Temp = pBtHciInfo->PageTimeout;
+       len += 3;
+       PPacketIrpEvent->Length = len;
+
+       bthci_IndicateEvent(padapter, PPacketIrpEvent, len+2);
+
+       return status;
+}
+
+static enum hci_status
+bthci_CmdWritePageTimeout(
+       struct rtw_adapter *padapter,
+       struct packet_irp_hcicmd_data *pHciCmd
+       )
+{
+       enum hci_status         status = HCI_STATUS_SUCCESS;
+       struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
+       struct bt_hci_info *pBtHciInfo = &pBTInfo->BtHciInfo;
+       u16     *pu2Temp;
+
+       pu2Temp = (u16 *)&pHciCmd->Data[0];
+       pBtHciInfo->PageTimeout = *pu2Temp;
+       RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("Write PageTimeout = 0x%x\n",
+               pBtHciInfo->PageTimeout));
+
+       /* send command complete event here when all data are received. */
+       {
+               u8 localBuf[6] = "";
+               u8 *pRetPar;
+               u8 len = 0;
+               struct packet_irp_hcievent_data *PPacketIrpEvent;
+
+               PPacketIrpEvent = (struct packet_irp_hcievent_data *)(&localBuf[0]);
+
+               len += bthci_CommandCompleteHeader(&localBuf[0],
+                       OGF_SET_EVENT_MASK_COMMAND,
+                       HCI_WRITE_PAGE_TIMEOUT,
+                       status);
+
+               /*  Return parameters starts from here */
+               pRetPar = &PPacketIrpEvent->Data[len];
+               pRetPar[0] = status;            /* status */
+               len += 1;
+               PPacketIrpEvent->Length = len;
+
+               bthci_IndicateEvent(padapter, PPacketIrpEvent, len+2);
+       }
+
+       return status;
+}
+
+static enum hci_status
+bthci_CmdReadLinkSupervisionTimeout(
+       struct rtw_adapter *padapter,
+       struct packet_irp_hcicmd_data *pHciCmd
+       )
+{
+       enum hci_status status = HCI_STATUS_SUCCESS;
+       struct bt_30info *pBTinfo = GET_BT_INFO(padapter);
+       u8 physicalLinkHandle, EntryNum;
+
+       physicalLinkHandle = *((u8 *)pHciCmd->Data);
+
+       EntryNum = bthci_GetCurrentEntryNum(padapter, physicalLinkHandle);
+
+       if (EntryNum == 0xff) {
+               RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("ReadLinkSupervisionTimeout, No such Handle in the Entry\n"));
+               status = HCI_STATUS_UNKNOW_CONNECT_ID;
+               return status;
+       }
+
+       if (pBTinfo->BtAsocEntry[EntryNum].PhyLinkCmdData.BtPhyLinkhandle != physicalLinkHandle)
+               status = HCI_STATUS_UNKNOW_CONNECT_ID;
+
+       {
+               u8 localBuf[10] = "";
+               u8 *pRetPar;
+               u8 len = 0;
+               struct packet_irp_hcievent_data *PPacketIrpEvent;
+               u16 *pu2Temp;
+
+               PPacketIrpEvent = (struct packet_irp_hcievent_data *)(&localBuf[0]);
+
+               len += bthci_CommandCompleteHeader(&localBuf[0],
+                       OGF_SET_EVENT_MASK_COMMAND,
+                       HCI_READ_LINK_SUPERVISION_TIMEOUT,
+                       status);
+
+               /*  Return parameters starts from here */
+               pRetPar = &PPacketIrpEvent->Data[len];
+               pRetPar[0] = status;
+               pRetPar[1] = pBTinfo->BtAsocEntry[EntryNum].PhyLinkCmdData.BtPhyLinkhandle;
+               pRetPar[2] = 0;
+               pu2Temp = (u16 *)&pRetPar[3];           /*  Conn_Accept_Timeout */
+               *pu2Temp = pBTinfo->BtAsocEntry[EntryNum].PhyLinkCmdData.LinkSuperversionTimeout;
+               len += 5;
+               PPacketIrpEvent->Length = len;
+
+               bthci_IndicateEvent(padapter, PPacketIrpEvent, len+2);
+       }
+
+       return status;
+}
+
+static enum hci_status
+bthci_CmdWriteLinkSupervisionTimeout(
+       struct rtw_adapter *padapter,
+       struct packet_irp_hcicmd_data *pHciCmd
+       )
+{
+       enum hci_status status = HCI_STATUS_SUCCESS;
+       struct bt_30info *pBTinfo = GET_BT_INFO(padapter);
+       u8 physicalLinkHandle, EntryNum;
+
+       physicalLinkHandle = *((u8 *)pHciCmd->Data);
+
+       EntryNum = bthci_GetCurrentEntryNum(padapter, physicalLinkHandle);
+
+       if (EntryNum == 0xff) {
+               RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("WriteLinkSupervisionTimeout, No such Handle in the Entry\n"));
+               status = HCI_STATUS_UNKNOW_CONNECT_ID;
+       } else {
+               if (pBTinfo->BtAsocEntry[EntryNum].PhyLinkCmdData.BtPhyLinkhandle != physicalLinkHandle) {
+                       status = HCI_STATUS_UNKNOW_CONNECT_ID;
+               } else {
+                       pBTinfo->BtAsocEntry[EntryNum].PhyLinkCmdData.LinkSuperversionTimeout = *((u16 *)(((u8 *)pHciCmd->Data)+2));
+                       RTPRINT(FIOCTL, IOCTL_STATE, ("BT Write LinkSuperversionTimeout[%d] = 0x%x\n",
+                               EntryNum, pBTinfo->BtAsocEntry[EntryNum].PhyLinkCmdData.LinkSuperversionTimeout));
+               }
+       }
+
+       {
+               u8 localBuf[8] = "";
+               u8 *pRetPar;
+               u8 len = 0;
+               struct packet_irp_hcievent_data *PPacketIrpEvent;
+
+               PPacketIrpEvent = (struct packet_irp_hcievent_data *)(&localBuf[0]);
+
+               len += bthci_CommandCompleteHeader(&localBuf[0],
+                       OGF_SET_EVENT_MASK_COMMAND,
+                       HCI_WRITE_LINK_SUPERVISION_TIMEOUT,
+                       status);
+
+               /*  Return parameters starts from here */
+               pRetPar = &PPacketIrpEvent->Data[len];
+               pRetPar[0] = status;
+               pRetPar[1] = pBTinfo->BtAsocEntry[EntryNum].PhyLinkCmdData.BtPhyLinkhandle;
+               pRetPar[2] = 0;
+               len += 3;
+               PPacketIrpEvent->Length = len;
+
+               bthci_IndicateEvent(padapter, PPacketIrpEvent, len+2);
+       }
+
+       return status;
+}
+
+static enum hci_status
+bthci_CmdEnhancedFlush(
+       struct rtw_adapter *padapter,
+       struct packet_irp_hcicmd_data *pHciCmd
+       )
+{
+       enum hci_status         status = HCI_STATUS_SUCCESS;
+       struct bt_30info *pBTinfo = GET_BT_INFO(padapter);
+       struct bt_hci_info *pBtHciInfo = &pBTinfo->BtHciInfo;
+       u16             logicHandle;
+       u8 Packet_Type;
+
+       logicHandle = *((u16 *)&pHciCmd->Data[0]);
+       Packet_Type = pHciCmd->Data[2];
+
+       if (Packet_Type != 0)
+               status = HCI_STATUS_INVALID_HCI_CMD_PARA_VALUE;
+       else
+               pBtHciInfo->enFlush_LLH = logicHandle;
+
+       if (bthci_DiscardTxPackets(padapter, pBtHciInfo->enFlush_LLH))
+               bthci_EventFlushOccurred(padapter, pBtHciInfo->enFlush_LLH);
+
+       /*  should send command status event */
+       bthci_EventCommandStatus(padapter,
+                       OGF_SET_EVENT_MASK_COMMAND,
+                       HCI_ENHANCED_FLUSH,
+                       status);
+
+       if (pBtHciInfo->enFlush_LLH) {
+               bthci_EventEnhancedFlushComplete(padapter, pBtHciInfo->enFlush_LLH);
+               pBtHciInfo->enFlush_LLH = 0;
+       }
+
+       return status;
+}
+
+static enum hci_status
+bthci_CmdReadLogicalLinkAcceptTimeout(
+       struct rtw_adapter *padapter,
+       struct packet_irp_hcicmd_data *pHciCmd
+       )
+{
+       enum hci_status         status = HCI_STATUS_SUCCESS;
+/*PMGNT_INFO           pMgntInfo = &padapter->MgntInfo; */
+       struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
+       struct bt_hci_info *pBtHciInfo = &pBTInfo->BtHciInfo;
+       u8 localBuf[8] = "";
+       u8 *pRetPar;
+       u8 len = 0;
+       struct packet_irp_hcievent_data *PPacketIrpEvent;
+       u16 *pu2Temp;
+
+       PPacketIrpEvent = (struct packet_irp_hcievent_data *)(&localBuf[0]);
+
+       len += bthci_CommandCompleteHeader(&localBuf[0],
+               OGF_SET_EVENT_MASK_COMMAND,
+               HCI_READ_LOGICAL_LINK_ACCEPT_TIMEOUT,
+               status);
+
+       /*  Return parameters starts from here */
+       pRetPar = &PPacketIrpEvent->Data[len];
+       pRetPar[0] = status;
+
+       pu2Temp = (u16 *)&pRetPar[1];           /*  Conn_Accept_Timeout */
+       *pu2Temp = pBtHciInfo->LogicalAcceptTimeout;
+       len += 3;
+       PPacketIrpEvent->Length = len;
+
+       bthci_IndicateEvent(padapter, PPacketIrpEvent, len+2);
+
+       return status;
+}
+
+static enum hci_status
+bthci_CmdWriteLogicalLinkAcceptTimeout(
+       struct rtw_adapter *padapter,
+       struct packet_irp_hcicmd_data *pHciCmd
+       )
+{
+       enum hci_status         status = HCI_STATUS_SUCCESS;
+/*PMGNT_INFO           pMgntInfo = &padapter->MgntInfo; */
+       struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
+       struct bt_hci_info *pBtHciInfo = &pBTInfo->BtHciInfo;
+       u8 localBuf[6] = "";
+       u8 *pRetPar;
+       u8 len = 0;
+       struct packet_irp_hcievent_data *PPacketIrpEvent;
+
+       pBtHciInfo->LogicalAcceptTimeout = *((u16 *)pHciCmd->Data);
+
+       PPacketIrpEvent = (struct packet_irp_hcievent_data *)(&localBuf[0]);
+
+       len += bthci_CommandCompleteHeader(&localBuf[0],
+               OGF_SET_EVENT_MASK_COMMAND,
+               HCI_WRITE_LOGICAL_LINK_ACCEPT_TIMEOUT,
+               status);
+
+       /*  Return parameters starts from here */
+       pRetPar = &PPacketIrpEvent->Data[len];
+       pRetPar[0] = status;
+
+       len += 1;
+       PPacketIrpEvent->Length = len;
+
+       bthci_IndicateEvent(padapter, PPacketIrpEvent, len+2);
+       return status;
+}
+
+static enum hci_status
+bthci_CmdSetEventMask(
+       struct rtw_adapter *padapter,
+       struct packet_irp_hcicmd_data *pHciCmd
+       )
+{
+       enum hci_status         status = HCI_STATUS_SUCCESS;
+/*PMGNT_INFO           pMgntInfo = &padapter->MgntInfo; */
+       struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
+       struct bt_hci_info *pBtHciInfo = &pBTInfo->BtHciInfo;
+       u8 *pu8Temp;
+       u8 localBuf[6] = "";
+       u8 *pRetPar;
+       u8 len = 0;
+       struct packet_irp_hcievent_data *PPacketIrpEvent;
+
+       pu8Temp = (u8 *)&pHciCmd->Data[0];
+       pBtHciInfo->BTEventMask = *pu8Temp;
+       RTPRINT(FIOCTL, IOCTL_BT_HCICMD_DETAIL, ("BTEventMask = 0x%"i64fmt"x\n",
+               pBtHciInfo->BTEventMask));
+
+       /* send command complete event here when all data are received. */
+       PPacketIrpEvent = (struct packet_irp_hcievent_data *)(&localBuf[0]);
+
+       len += bthci_CommandCompleteHeader(&localBuf[0],
+               OGF_SET_EVENT_MASK_COMMAND,
+               HCI_SET_EVENT_MASK,
+               status);
+
+       /*  Return parameters starts from here */
+       pRetPar = &PPacketIrpEvent->Data[len];
+       pRetPar[0] = status;            /* status */
+       len += 1;
+       PPacketIrpEvent->Length = len;
+
+       bthci_IndicateEvent(padapter, PPacketIrpEvent, len+2);
+
+       return status;
+}
+
+/*  7.3.69 */
+static enum hci_status
+bthci_CmdSetEventMaskPage2(
+       struct rtw_adapter *padapter,
+       struct packet_irp_hcicmd_data *pHciCmd
+       )
+{
+       enum hci_status         status = HCI_STATUS_SUCCESS;
+       struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
+       struct bt_hci_info *pBtHciInfo = &pBTInfo->BtHciInfo;
+       u8 *pu8Temp;
+       u8 localBuf[6] = "";
+       u8 *pRetPar;
+       u8 len = 0;
+       struct packet_irp_hcievent_data *PPacketIrpEvent;
+
+       pu8Temp = (u8 *)&pHciCmd->Data[0];
+       pBtHciInfo->BTEventMaskPage2 = *pu8Temp;
+       RTPRINT(FIOCTL, (IOCTL_BT_HCICMD_DETAIL|IOCTL_BT_LOGO), ("BTEventMaskPage2 = 0x%"i64fmt"x\n",
+               pBtHciInfo->BTEventMaskPage2));
+
+       /* send command complete event here when all data are received. */
+       PPacketIrpEvent = (struct packet_irp_hcievent_data *)(&localBuf[0]);
+
+       len += bthci_CommandCompleteHeader(&localBuf[0],
+               OGF_SET_EVENT_MASK_COMMAND,
+               HCI_SET_EVENT_MASK_PAGE_2,
+               status);
+
+       /*  Return parameters starts from here */
+       pRetPar = &PPacketIrpEvent->Data[len];
+       pRetPar[0] = status;            /* status */
+       len += 1;
+       PPacketIrpEvent->Length = len;
+
+       bthci_IndicateEvent(padapter, PPacketIrpEvent, len+2);
+
+       return status;
+}
+
+static enum hci_status
+bthci_CmdReadLocationData(
+       struct rtw_adapter *padapter,
+       struct packet_irp_hcicmd_data *pHciCmd
+       )
+{
+       enum hci_status         status = HCI_STATUS_SUCCESS;
+       struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
+       struct bt_hci_info *pBtHciInfo = &pBTInfo->BtHciInfo;
+       u8 localBuf[12] = "";
+       u8 *pRetPar;
+       u8 len = 0;
+       struct packet_irp_hcievent_data *PPacketIrpEvent;
+       u16 *pu2Temp;
+
+       PPacketIrpEvent = (struct packet_irp_hcievent_data *)(&localBuf[0]);
+
+       len += bthci_CommandCompleteHeader(&localBuf[0],
+               OGF_SET_EVENT_MASK_COMMAND,
+               HCI_READ_LOCATION_DATA,
+               status);
+       RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("DomainAware = 0x%x\n", pBtHciInfo->LocationDomainAware));
+       RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("Domain = 0x%x\n", pBtHciInfo->LocationDomain));
+       RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("DomainOptions = 0x%x\n", pBtHciInfo->LocationDomainOptions));
+       RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("Options = 0x%x\n", pBtHciInfo->LocationOptions));
+
+       /*  Return parameters starts from here */
+       pRetPar = &PPacketIrpEvent->Data[len];
+       pRetPar[0] = status;
+
+       pRetPar[1] = pBtHciInfo->LocationDomainAware;   /* 0x0;  Location_Domain_Aware */
+       pu2Temp = (u16 *)&pRetPar[2];                                   /*  Location_Domain */
+       *pu2Temp = pBtHciInfo->LocationDomain;          /* 0x5858; */
+       pRetPar[4] = pBtHciInfo->LocationDomainOptions; /* 0x58;        Location_Domain_Options */
+       pRetPar[5] = pBtHciInfo->LocationOptions;               /* 0x0; Location_Options */
+       len += 6;
+       PPacketIrpEvent->Length = len;
+
+       bthci_IndicateEvent(padapter, PPacketIrpEvent, len+2);
+       return status;
+}
+
+static enum hci_status
+bthci_CmdWriteLocationData(
+       struct rtw_adapter *padapter,
+       struct packet_irp_hcicmd_data *pHciCmd
+       )
+{
+       enum hci_status status = HCI_STATUS_SUCCESS;
+       struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
+       struct bt_hci_info *pBtHciInfo = &pBTInfo->BtHciInfo;
+       u16     *pu2Temp;
+       u8 localBuf[6] = "";
+       u8 *pRetPar;
+       u8 len = 0;
+       struct packet_irp_hcievent_data *PPacketIrpEvent;
+
+       pBtHciInfo->LocationDomainAware = pHciCmd->Data[0];
+       pu2Temp = (u16 *)&pHciCmd->Data[1];
+       pBtHciInfo->LocationDomain = *pu2Temp;
+       pBtHciInfo->LocationDomainOptions = pHciCmd->Data[3];
+       pBtHciInfo->LocationOptions = pHciCmd->Data[4];
+       RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("DomainAware = 0x%x\n", pBtHciInfo->LocationDomainAware));
+       RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("Domain = 0x%x\n", pBtHciInfo->LocationDomain));
+       RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("DomainOptions = 0x%x\n", pBtHciInfo->LocationDomainOptions));
+       RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("Options = 0x%x\n", pBtHciInfo->LocationOptions));
+
+       /* send command complete event here when all data are received. */
+       PPacketIrpEvent = (struct packet_irp_hcievent_data *)(&localBuf[0]);
+
+       len += bthci_CommandCompleteHeader(&localBuf[0],
+               OGF_SET_EVENT_MASK_COMMAND,
+               HCI_WRITE_LOCATION_DATA,
+               status);
+
+       /*  Return parameters starts from here */
+       pRetPar = &PPacketIrpEvent->Data[len];
+       pRetPar[0] = status;            /* status */
+       len += 1;
+       PPacketIrpEvent->Length = len;
+
+       bthci_IndicateEvent(padapter, PPacketIrpEvent, len+2);
+
+       return status;
+}
+
+static enum hci_status
+bthci_CmdReadFlowControlMode(
+       struct rtw_adapter *padapter,
+       struct packet_irp_hcicmd_data *pHciCmd
+       )
+{
+       enum hci_status status = HCI_STATUS_SUCCESS;
+       struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
+       struct bt_hci_info *pBtHciInfo = &pBTInfo->BtHciInfo;
+       u8 localBuf[7] = "";
+       u8 *pRetPar;
+       u8 len = 0;
+       struct packet_irp_hcievent_data *PPacketIrpEvent;
+
+       PPacketIrpEvent = (struct packet_irp_hcievent_data *)(&localBuf[0]);
+
+       len += bthci_CommandCompleteHeader(&localBuf[0],
+               OGF_SET_EVENT_MASK_COMMAND,
+               HCI_READ_FLOW_CONTROL_MODE,
+               status);
+
+       /*  Return parameters starts from here */
+       pRetPar = &PPacketIrpEvent->Data[len];
+       pRetPar[0] = status;
+       pRetPar[1] = pBtHciInfo->FlowControlMode;       /*  Flow Control Mode */
+       len += 2;
+       PPacketIrpEvent->Length = len;
+
+       bthci_IndicateEvent(padapter, PPacketIrpEvent, len+2);
+       return status;
+}
+
+static enum hci_status
+bthci_CmdWriteFlowControlMode(
+       struct rtw_adapter *padapter,
+       struct packet_irp_hcicmd_data *pHciCmd
+       )
+{
+       enum hci_status status = HCI_STATUS_SUCCESS;
+       struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
+       struct bt_hci_info *pBtHciInfo = &pBTInfo->BtHciInfo;
+       u8 localBuf[6] = "";
+       u8 *pRetPar;
+       u8 len = 0;
+       struct packet_irp_hcievent_data *PPacketIrpEvent;
+
+       pBtHciInfo->FlowControlMode = pHciCmd->Data[0];
+
+       /* send command complete event here when all data are received. */
+       PPacketIrpEvent = (struct packet_irp_hcievent_data *)(&localBuf[0]);
+
+       len += bthci_CommandCompleteHeader(&localBuf[0],
+               OGF_SET_EVENT_MASK_COMMAND,
+               HCI_WRITE_FLOW_CONTROL_MODE,
+               status);
+
+       /*  Return parameters starts from here */
+       pRetPar = &PPacketIrpEvent->Data[len];
+       pRetPar[0] = status;            /* status */
+       len += 1;
+       PPacketIrpEvent->Length = len;
+
+       bthci_IndicateEvent(padapter, PPacketIrpEvent, len+2);
+
+       return status;
+}
+
+static enum hci_status
+bthci_CmdReadBestEffortFlushTimeout(
+       struct rtw_adapter *padapter,
+       struct packet_irp_hcicmd_data *pHciCmd
+       )
+{
+       enum hci_status status = HCI_STATUS_SUCCESS;
+       struct bt_30info *pBTinfo = GET_BT_INFO(padapter);
+       u16 i, j, logicHandle;
+       u32 BestEffortFlushTimeout = 0xffffffff;
+       u8 find = 0;
+
+       logicHandle = *((u16 *)pHciCmd->Data);
+       /*  find an matched logical link index and copy the data */
+       for (j = 0; j < MAX_BT_ASOC_ENTRY_NUM; j++) {
+               for (i = 0; i < MAX_LOGICAL_LINK_NUM; i++) {
+                       if (pBTinfo->BtAsocEntry[j].LogLinkCmdData[i].BtLogLinkhandle == logicHandle) {
+                               BestEffortFlushTimeout = pBTinfo->BtAsocEntry[j].LogLinkCmdData[i].BestEffortFlushTimeout;
+                               find = 1;
+                               break;
+                       }
+               }
+       }
+
+       if (!find)
+               status = HCI_STATUS_UNKNOW_CONNECT_ID;
+
+       {
+               u8 localBuf[10] = "";
+               u8 *pRetPar;
+               u8 len = 0;
+               struct packet_irp_hcievent_data *PPacketIrpEvent;
+               u32 *pu4Temp;
+
+               PPacketIrpEvent = (struct packet_irp_hcievent_data *)(&localBuf[0]);
+
+               len += bthci_CommandCompleteHeader(&localBuf[0],
+                       OGF_SET_EVENT_MASK_COMMAND,
+                       HCI_READ_BEST_EFFORT_FLUSH_TIMEOUT,
+                       status);
+
+               /*  Return parameters starts from here */
+               pRetPar = &PPacketIrpEvent->Data[len];
+               pRetPar[0] = status;
+               pu4Temp = (u32 *)&pRetPar[1];   /*  Best_Effort_Flush_Timeout */
+               *pu4Temp = BestEffortFlushTimeout;
+               len += 5;
+               PPacketIrpEvent->Length = len;
+
+               bthci_IndicateEvent(padapter, PPacketIrpEvent, len+2);
+       }
+       return status;
+}
+
+static enum hci_status
+bthci_CmdWriteBestEffortFlushTimeout(
+       struct rtw_adapter *padapter,
+       struct packet_irp_hcicmd_data *pHciCmd
+       )
+{
+       enum hci_status status = HCI_STATUS_SUCCESS;
+       struct bt_30info *pBTinfo = GET_BT_INFO(padapter);
+       u16 i, j, logicHandle;
+       u32 BestEffortFlushTimeout = 0xffffffff;
+       u8 find = 0;
+
+       logicHandle = *((u16 *)pHciCmd->Data);
+       BestEffortFlushTimeout = *((u32 *)(pHciCmd->Data+1));
+
+       /*  find an matched logical link index and copy the data */
+       for (j = 0; j < MAX_BT_ASOC_ENTRY_NUM; j++) {
+               for (i = 0; i < MAX_LOGICAL_LINK_NUM; i++) {
+                       if (pBTinfo->BtAsocEntry[j].LogLinkCmdData[i].BtLogLinkhandle == logicHandle) {
+                               pBTinfo->BtAsocEntry[j].LogLinkCmdData[i].BestEffortFlushTimeout = BestEffortFlushTimeout;
+                               find = 1;
+                               break;
+                       }
+               }
+       }
+
+       if (!find)
+               status = HCI_STATUS_UNKNOW_CONNECT_ID;
+
+       {
+               u8 localBuf[6] = "";
+               u8 *pRetPar;
+               u8 len = 0;
+               struct packet_irp_hcievent_data *PPacketIrpEvent;
+
+               PPacketIrpEvent = (struct packet_irp_hcievent_data *)(&localBuf[0]);
+
+               len += bthci_CommandCompleteHeader(&localBuf[0],
+                       OGF_SET_EVENT_MASK_COMMAND,
+                       HCI_WRITE_BEST_EFFORT_FLUSH_TIMEOUT,
+                       status);
+
+               /*  Return parameters starts from here */
+               pRetPar = &PPacketIrpEvent->Data[len];
+               pRetPar[0] = status;
+               len += 1;
+               PPacketIrpEvent->Length = len;
+
+               bthci_IndicateEvent(padapter, PPacketIrpEvent, len+2);
+       }
+       return status;
+}
+
+static enum hci_status
+bthci_CmdShortRangeMode(
+       struct rtw_adapter *padapter,
+       struct packet_irp_hcicmd_data *pHciCmd
+       )
+{
+       enum hci_status status = HCI_STATUS_SUCCESS;
+       struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
+       u8 PhyLinkHandle, EntryNum, ShortRangeMode;
+
+       PhyLinkHandle = pHciCmd->Data[0];
+       ShortRangeMode = pHciCmd->Data[1];
+       RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("PLH = 0x%x, Short_Range_Mode = 0x%x\n", PhyLinkHandle, ShortRangeMode));
+
+       EntryNum = bthci_GetCurrentEntryNum(padapter, PhyLinkHandle);
+       if (EntryNum != 0xff) {
+               pBTInfo->BtAsocEntry[EntryNum].ShortRangeMode = ShortRangeMode;
+       } else {
+               RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("No such PLH(0x%x)\n", PhyLinkHandle));
+               status = HCI_STATUS_UNKNOW_CONNECT_ID;
+       }
+
+       bthci_EventCommandStatus(padapter,
+                       OGF_SET_EVENT_MASK_COMMAND,
+                       HCI_SHORT_RANGE_MODE,
+                       status);
+
+       bthci_EventShortRangeModeChangeComplete(padapter, status, ShortRangeMode, EntryNum);
+
+       return status;
+}
+
+static enum hci_status bthci_CmdReadLocalSupportedCommands(struct rtw_adapter *padapter)
+{
+       enum hci_status status = HCI_STATUS_SUCCESS;
+       u8 localBuf[TmpLocalBufSize] = "";
+       u8 *pRetPar, *pSupportedCmds;
+       u8 len = 0;
+       struct packet_irp_hcievent_data *PPacketIrpEvent;
+
+       /*  send command complete event here when all data are received. */
+       PlatformZeroMemory(&localBuf[0], TmpLocalBufSize);
+       PPacketIrpEvent = (struct packet_irp_hcievent_data *)(&localBuf[0]);
+
+       len += bthci_CommandCompleteHeader(&localBuf[0],
+               OGF_INFORMATIONAL_PARAMETERS,
+               HCI_READ_LOCAL_SUPPORTED_COMMANDS,
+               status);
+
+       /*  Return parameters starts from here */
+       pRetPar = &PPacketIrpEvent->Data[len];
+       pRetPar[0] = status;            /* status */
+       len += 1;
+       pSupportedCmds = &pRetPar[1];
+       RTPRINT(FIOCTL, (IOCTL_BT_HCICMD|IOCTL_BT_LOGO), ("Octet[5]= 0xc0\nBit [6]= Set Event Mask, [7]= Reset\n"));
+       pSupportedCmds[5] = 0xc0;
+       RTPRINT(FIOCTL, (IOCTL_BT_HCICMD|IOCTL_BT_LOGO), ("Octet[6]= 0x01\nBit [0]= Set Event Filter\n"));
+       pSupportedCmds[6] = 0x01;
+       RTPRINT(FIOCTL, (IOCTL_BT_HCICMD|IOCTL_BT_LOGO), ("Octet[7]= 0x0c\nBit [2]= Read Connection Accept Timeout, [3]= Write Connection Accept Timeout\n"));
+       pSupportedCmds[7] = 0x0c;
+       RTPRINT(FIOCTL, (IOCTL_BT_HCICMD|IOCTL_BT_LOGO), ("Octet[10]= 0x80\nBit [7]= Host Number Of Completed Packets\n"));
+       pSupportedCmds[10] = 0x80;
+       RTPRINT(FIOCTL, (IOCTL_BT_HCICMD|IOCTL_BT_LOGO), ("Octet[11]= 0x03\nBit [0]= Read Link Supervision Timeout, [1]= Write Link Supervision Timeout\n"));
+       pSupportedCmds[11] = 0x03;
+       RTPRINT(FIOCTL, (IOCTL_BT_HCICMD|IOCTL_BT_LOGO), ("Octet[14]= 0xa8\nBit [3]= Read Local Version Information, [5]= Read Local Supported Features, [7]= Read Buffer Size\n"));
+       pSupportedCmds[14] = 0xa8;
+       RTPRINT(FIOCTL, (IOCTL_BT_HCICMD|IOCTL_BT_LOGO), ("Octet[15]= 0x1c\nBit [2]= Read Failed Contact Count, [3]= Reset Failed Contact Count, [4]= Get Link Quality\n"));
+       pSupportedCmds[15] = 0x1c;
+       /* pSupportedCmds[16] = 0x04; */
+       RTPRINT(FIOCTL, (IOCTL_BT_HCICMD|IOCTL_BT_LOGO), ("Octet[19]= 0x40\nBit [6]= Enhanced Flush\n"));
+       pSupportedCmds[19] = 0x40;
+       RTPRINT(FIOCTL, (IOCTL_BT_HCICMD|IOCTL_BT_LOGO), ("Octet[21]= 0xff\nBit [0]= Create Physical Link, [1]= Accept Physical Link, [2]= Disconnect Physical Link, [3]= Create Logical Link\n"));
+       RTPRINT(FIOCTL, (IOCTL_BT_HCICMD|IOCTL_BT_LOGO), ("     [4]= Accept Logical Link, [5]= Disconnect Logical Link, [6]= Logical Link Cancel, [7]= Flow Spec Modify\n"));
+       pSupportedCmds[21] = 0xff;
+       RTPRINT(FIOCTL, (IOCTL_BT_HCICMD|IOCTL_BT_LOGO), ("Octet[22]= 0xff\nBit [0]= Read Logical Link Accept Timeout, [1]= Write Logical Link Accept Timeout, [2]= Set Event Mask Page 2, [3]= Read Location Data\n"));
+       RTPRINT(FIOCTL, (IOCTL_BT_HCICMD|IOCTL_BT_LOGO), ("     [4]= Write Location Data, [5]= Read Local AMP Info, [6]= Read Local AMP_ASSOC, [7]= Write Remote AMP_ASSOC\n"));
+       pSupportedCmds[22] = 0xff;
+       RTPRINT(FIOCTL, (IOCTL_BT_HCICMD|IOCTL_BT_LOGO), ("Octet[23]= 0x07\nBit [0]= Read Flow Control Mode, [1]= Write Flow Control Mode, [2]= Read Data Block Size\n"));
+       pSupportedCmds[23] = 0x07;
+       RTPRINT(FIOCTL, (IOCTL_BT_HCICMD|IOCTL_BT_LOGO), ("Octet[24]= 0x1c\nBit [2]= Read Best Effort Flush Timeout, [3]= Write Best Effort Flush Timeout, [4]= Short Range Mode\n"));
+       pSupportedCmds[24] = 0x1c;
+       len += 64;
+       PPacketIrpEvent->Length = len;
+
+       bthci_IndicateEvent(padapter, PPacketIrpEvent, len+2);
+
+       return status;
+}
+
+static enum hci_status bthci_CmdReadLocalSupportedFeatures(struct rtw_adapter *padapter)
+{
+       enum hci_status status = HCI_STATUS_SUCCESS;
+       u8 localBuf[TmpLocalBufSize] = "";
+       u8 *pRetPar;
+       u8 len = 0;
+       struct packet_irp_hcievent_data *PPacketIrpEvent;
+
+       /* send command complete event here when all data are received. */
+       PlatformZeroMemory(&localBuf[0], TmpLocalBufSize);
+       PPacketIrpEvent = (struct packet_irp_hcievent_data *)(&localBuf[0]);
+
+       len += bthci_CommandCompleteHeader(&localBuf[0],
+               OGF_INFORMATIONAL_PARAMETERS,
+               HCI_READ_LOCAL_SUPPORTED_FEATURES,
+               status);
+
+       /*  Return parameters starts from here */
+       pRetPar = &PPacketIrpEvent->Data[len];
+       pRetPar[0] = status;            /* status */
+       len += 9;
+       PPacketIrpEvent->Length = len;
+
+       bthci_IndicateEvent(padapter, PPacketIrpEvent, len+2);
+       return status;
+}
+
+static enum hci_status bthci_CmdReadLocalAMPAssoc(struct rtw_adapter *padapter,
+       struct packet_irp_hcicmd_data *pHciCmd)
+{
+       enum hci_status status = HCI_STATUS_SUCCESS;
+       struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
+       struct bt_mgnt *pBtMgnt = &pBTInfo->BtMgnt;
+       struct bt_dgb *pBtDbg = &pBTInfo->BtDbg;
+       u8 PhyLinkHandle, EntryNum;
+
+       pBtDbg->dbgHciInfo.hciCmdCntReadLocalAmpAssoc++;
+       PhyLinkHandle = *((u8 *)pHciCmd->Data);
+       EntryNum = bthci_GetCurrentEntryNum(padapter, PhyLinkHandle);
+
+       if ((EntryNum == 0xff) && PhyLinkHandle != 0) {
+               RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("ReadLocalAMPAssoc, EntryNum = %d  !!!!!, physical link handle = 0x%x\n",
+               EntryNum, PhyLinkHandle));
+               status = HCI_STATUS_UNKNOW_CONNECT_ID;
+       } else if (pBtMgnt->bPhyLinkInProgressStartLL) {
+               status = HCI_STATUS_UNKNOW_CONNECT_ID;
+               pBtMgnt->bPhyLinkInProgressStartLL = false;
+       } else {
+               pBTInfo->BtAsocEntry[EntryNum].AmpAsocCmdData.BtPhyLinkhandle = *((u8 *)pHciCmd->Data);
+               pBTInfo->BtAsocEntry[EntryNum].AmpAsocCmdData.LenSoFar = *((u16 *)((u8 *)pHciCmd->Data+1));
+               pBTInfo->BtAsocEntry[EntryNum].AmpAsocCmdData.MaxRemoteASSOCLen = *((u16 *)((u8 *)pHciCmd->Data+3));
+               RTPRINT(FIOCTL, IOCTL_BT_HCICMD_DETAIL, ("ReadLocalAMPAssoc, LenSoFar =%d, MaxRemoteASSOCLen =%d\n",
+                       pBTInfo->BtAsocEntry[EntryNum].AmpAsocCmdData.LenSoFar,
+                       pBTInfo->BtAsocEntry[EntryNum].AmpAsocCmdData.MaxRemoteASSOCLen));
+       }
+
+       RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("ReadLocalAMPAssoc, EntryNum = %d  !!!!!, physical link handle = 0x%x, LengthSoFar = %x  \n",
+               EntryNum, PhyLinkHandle, pBTInfo->BtAsocEntry[EntryNum].AmpAsocCmdData.LenSoFar));
+
+       /* send command complete event here when all data are received. */
+       {
+               struct packet_irp_hcievent_data *PPacketIrpEvent;
+
+               /* PVOID buffer = padapter->IrpHCILocalbuf.Ptr; */
+               u8 localBuf[TmpLocalBufSize] = "";
+               u16     *pRemainLen;
+               u32     totalLen = 0;
+               u16     typeLen = 0, remainLen = 0, ret_index = 0;
+               u8 *pRetPar;
+
+               PlatformZeroMemory(&localBuf[0], TmpLocalBufSize);
+               /* PPacketIrpEvent = (struct packet_irp_hcievent_data *)(buffer); */
+               PPacketIrpEvent = (struct packet_irp_hcievent_data *)(&localBuf[0]);
+
+               totalLen += bthci_CommandCompleteHeader(&localBuf[0],
+                       OGF_STATUS_PARAMETERS,
+                       HCI_READ_LOCAL_AMP_ASSOC,
+                       status);
+               RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("ReadLocalAMPAssoc, Remaining_Len =%d  \n", remainLen));
+               /*  Return parameters starts from here */
+               pRetPar = &PPacketIrpEvent->Data[totalLen];
+               pRetPar[0] = status;            /* status */
+               pRetPar[1] = *((u8 *)pHciCmd->Data);
+               pRemainLen = (u16 *)&pRetPar[2];        /* AMP_ASSOC_Remaining_Length */
+               totalLen += 4;  /* 0]~[3] */
+               ret_index = 4;
+
+               typeLen = bthci_AssocMACAddr(padapter, &pRetPar[ret_index]);
+               totalLen += typeLen;
+               remainLen += typeLen;
+               ret_index += typeLen;
+               typeLen = bthci_AssocPreferredChannelList(padapter, &pRetPar[ret_index], EntryNum);
+               totalLen += typeLen;
+               remainLen += typeLen;
+               ret_index += typeLen;
+               typeLen = bthci_PALCapabilities(padapter, &pRetPar[ret_index]);
+               totalLen += typeLen;
+               remainLen += typeLen;
+               ret_index += typeLen;
+               typeLen = bthci_AssocPALVer(padapter, &pRetPar[ret_index]);
+               totalLen += typeLen;
+               remainLen += typeLen;
+               PPacketIrpEvent->Length = (u8)totalLen;
+               *pRemainLen = remainLen;        /*  AMP_ASSOC_Remaining_Length */
+               RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("ReadLocalAMPAssoc, Remaining_Len =%d  \n", remainLen));
+               RTPRINT_DATA(FIOCTL, (IOCTL_BT_HCICMD_DETAIL|IOCTL_BT_LOGO), ("AMP_ASSOC_fragment : \n"), PPacketIrpEvent->Data, totalLen);
+
+               bthci_IndicateEvent(padapter, PPacketIrpEvent, totalLen+2);
+       }
+
+       return status;
+}
+
+static enum hci_status bthci_CmdReadFailedContactCounter(struct rtw_adapter *padapter,
+                      struct packet_irp_hcicmd_data *pHciCmd)
+{
+
+       enum hci_status         status = HCI_STATUS_SUCCESS;
+       struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
+       struct bt_hci_info *pBtHciInfo = &pBTInfo->BtHciInfo;
+       u8 localBuf[TmpLocalBufSize] = "";
+       u8 *pRetPar;
+       u8 len = 0;
+       struct packet_irp_hcievent_data *PPacketIrpEvent;
+       u16 handle;
+
+       handle = *((u16 *)pHciCmd->Data);
+       /* send command complete event here when all data are received. */
+       PlatformZeroMemory(&localBuf[0], TmpLocalBufSize);
+       PPacketIrpEvent = (struct packet_irp_hcievent_data *)(&localBuf[0]);
+
+       len += bthci_CommandCompleteHeader(&localBuf[0],
+               OGF_STATUS_PARAMETERS,
+               HCI_READ_FAILED_CONTACT_COUNTER,
+               status);
+
+       /*  Return parameters starts from here */
+       pRetPar = &PPacketIrpEvent->Data[len];
+       pRetPar[0] = status;            /* status */
+       pRetPar[1] = TWOBYTE_LOWBYTE(handle);
+       pRetPar[2] = TWOBYTE_HIGHTBYTE(handle);
+       pRetPar[3] = TWOBYTE_LOWBYTE(pBtHciInfo->FailContactCount);
+       pRetPar[4] = TWOBYTE_HIGHTBYTE(pBtHciInfo->FailContactCount);
+       len += 5;
+       PPacketIrpEvent->Length = len;
+
+       bthci_IndicateEvent(padapter, PPacketIrpEvent, len+2);
+
+       return status;
+}
+
+static enum hci_status
+bthci_CmdResetFailedContactCounter(
+       struct rtw_adapter *padapter,
+       struct packet_irp_hcicmd_data *pHciCmd
+       )
+{
+       enum hci_status         status = HCI_STATUS_SUCCESS;
+/*PMGNT_INFO           pMgntInfo = &padapter->MgntInfo; */
+       struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
+       struct bt_hci_info *pBtHciInfo = &pBTInfo->BtHciInfo;
+       u16             handle;
+       u8 localBuf[TmpLocalBufSize] = "";
+       u8 *pRetPar;
+       u8 len = 0;
+       struct packet_irp_hcievent_data *PPacketIrpEvent;
+
+       handle = *((u16 *)pHciCmd->Data);
+       pBtHciInfo->FailContactCount = 0;
+
+       /* send command complete event here when all data are received. */
+       PlatformZeroMemory(&localBuf[0], TmpLocalBufSize);
+       /* PPacketIrpEvent = (struct packet_irp_hcievent_data *)(buffer); */
+       PPacketIrpEvent = (struct packet_irp_hcievent_data *)(&localBuf[0]);
+
+       len += bthci_CommandCompleteHeader(&localBuf[0],
+               OGF_STATUS_PARAMETERS,
+               HCI_RESET_FAILED_CONTACT_COUNTER,
+               status);
+
+       /*  Return parameters starts from here */
+       pRetPar = &PPacketIrpEvent->Data[len];
+       pRetPar[0] = status;            /* status */
+       pRetPar[1] = TWOBYTE_LOWBYTE(handle);
+       pRetPar[2] = TWOBYTE_HIGHTBYTE(handle);
+       len += 3;
+       PPacketIrpEvent->Length = len;
+
+       bthci_IndicateEvent(padapter, PPacketIrpEvent, len+2);
+       return status;
+}
+
+/*  */
+/*  BT 3.0+HS [Vol 2] 7.4.1 */
+/*  */
+static enum hci_status
+bthci_CmdReadLocalVersionInformation(
+       struct rtw_adapter *padapter
+       )
+{
+       enum hci_status status = HCI_STATUS_SUCCESS;
+       /* send command complete event here when all data are received. */
+       u8 localBuf[TmpLocalBufSize] = "";
+       u8 *pRetPar;
+       u8 len = 0;
+       struct packet_irp_hcievent_data *PPacketIrpEvent;
+       u16 *pu2Temp;
+
+       PlatformZeroMemory(&localBuf[0], TmpLocalBufSize);
+       PPacketIrpEvent = (struct packet_irp_hcievent_data *)(&localBuf[0]);
+
+       len += bthci_CommandCompleteHeader(&localBuf[0],
+               OGF_INFORMATIONAL_PARAMETERS,
+               HCI_READ_LOCAL_VERSION_INFORMATION,
+               status);
+
+       /*  Return parameters starts from here */
+       pRetPar = &PPacketIrpEvent->Data[len];
+       pRetPar[0] = status;            /* status */
+       pRetPar[1] = 0x05;                      /*  HCI_Version */
+       pu2Temp = (u16 *)&pRetPar[2];           /*  HCI_Revision */
+       *pu2Temp = 0x0001;
+       pRetPar[4] = 0x05;                      /*  LMP/PAL_Version */
+       pu2Temp = (u16 *)&pRetPar[5];           /*  Manufacturer_Name */
+       *pu2Temp = 0x005d;
+       pu2Temp = (u16 *)&pRetPar[7];           /*  LMP/PAL_Subversion */
+       *pu2Temp = 0x0001;
+       len += 9;
+       PPacketIrpEvent->Length = len;
+
+       RTPRINT(FIOCTL, (IOCTL_BT_HCICMD_DETAIL|IOCTL_BT_LOGO), ("LOCAL_VERSION_INFORMATION\n"));
+       RTPRINT(FIOCTL, (IOCTL_BT_HCICMD_DETAIL|IOCTL_BT_LOGO), ("Status  %x\n", status));
+       RTPRINT(FIOCTL, (IOCTL_BT_HCICMD_DETAIL|IOCTL_BT_LOGO), ("HCI_Version = 0x05\n"));
+       RTPRINT(FIOCTL, (IOCTL_BT_HCICMD_DETAIL|IOCTL_BT_LOGO), ("HCI_Revision = 0x0001\n"));
+       RTPRINT(FIOCTL, (IOCTL_BT_HCICMD_DETAIL|IOCTL_BT_LOGO), ("LMP/PAL_Version = 0x05\n"));
+       RTPRINT(FIOCTL, (IOCTL_BT_HCICMD_DETAIL|IOCTL_BT_LOGO), ("Manufacturer_Name = 0x0001\n"));
+       RTPRINT(FIOCTL, (IOCTL_BT_HCICMD_DETAIL|IOCTL_BT_LOGO), ("LMP/PAL_Subversion = 0x0001\n"));
+
+       bthci_IndicateEvent(padapter, PPacketIrpEvent, len+2);
+
+       return status;
+}
+
+/* 7.4.7 */
+static enum hci_status bthci_CmdReadDataBlockSize(struct rtw_adapter *padapter)
+{
+       enum hci_status                 status = HCI_STATUS_SUCCESS;
+       u8 localBuf[TmpLocalBufSize] = "";
+       u8 *pRetPar;
+       u8 len = 0;
+       struct packet_irp_hcievent_data *PPacketIrpEvent;
+       u16 *pu2Temp;
+
+       PlatformZeroMemory(&localBuf[0], TmpLocalBufSize);
+       PPacketIrpEvent = (struct packet_irp_hcievent_data *)(&localBuf[0]);
+
+       len += bthci_CommandCompleteHeader(&localBuf[0],
+               OGF_INFORMATIONAL_PARAMETERS,
+               HCI_READ_DATA_BLOCK_SIZE,
+               status);
+
+       /*  Return parameters starts from here */
+       pRetPar = &PPacketIrpEvent->Data[len];
+       pRetPar[0] = HCI_STATUS_SUCCESS;        /* status */
+       pu2Temp = (u16 *)&pRetPar[1];           /*  Max_ACL_Data_Packet_Length */
+       *pu2Temp = Max80211PALPDUSize;
+
+       pu2Temp = (u16 *)&pRetPar[3];           /*  Data_Block_Length */
+       *pu2Temp = Max80211PALPDUSize;
+       pu2Temp = (u16 *)&pRetPar[5];           /*  Total_Num_Data_Blocks */
+       *pu2Temp = BTTotalDataBlockNum;
+       len += 7;
+       PPacketIrpEvent->Length = len;
+
+       bthci_IndicateEvent(padapter, PPacketIrpEvent, len+2);
+
+       return status;
+}
+
+/*  7.4.5 */
+static enum hci_status bthci_CmdReadBufferSize(struct rtw_adapter *padapter)
+{
+       enum hci_status status = HCI_STATUS_SUCCESS;
+       u8 localBuf[TmpLocalBufSize] = "";
+       u8 *pRetPar;
+       u8 len = 0;
+       struct packet_irp_hcievent_data *PPacketIrpEvent;
+       u16 *pu2Temp;
+
+       PlatformZeroMemory(&localBuf[0], TmpLocalBufSize);
+       /* PPacketIrpEvent = (struct packet_irp_hcievent_data *)(buffer); */
+       PPacketIrpEvent = (struct packet_irp_hcievent_data *)(&localBuf[0]);
+
+       len += bthci_CommandCompleteHeader(&localBuf[0],
+               OGF_INFORMATIONAL_PARAMETERS,
+               HCI_READ_BUFFER_SIZE,
+               status);
+       RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("Synchronous_Data_Packet_Length = 0x%x\n", BTSynDataPacketLength));
+       RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("Total_Num_ACL_Data_Packets = 0x%x\n", BTTotalDataBlockNum));
+       RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("Total_Num_Synchronous_Data_Packets = 0x%x\n", BTTotalDataBlockNum));
+       /*  Return parameters starts from here */
+       pRetPar = &PPacketIrpEvent->Data[len];
+       pRetPar[0] = status;            /* status */
+       pu2Temp = (u16 *)&pRetPar[1];           /*  HC_ACL_Data_Packet_Length */
+       *pu2Temp = Max80211PALPDUSize;
+
+       pRetPar[3] = BTSynDataPacketLength;     /*  HC_Synchronous_Data_Packet_Length */
+       pu2Temp = (u16 *)&pRetPar[4];           /*  HC_Total_Num_ACL_Data_Packets */
+       *pu2Temp = BTTotalDataBlockNum;
+       pu2Temp = (u16 *)&pRetPar[6];           /*  HC_Total_Num_Synchronous_Data_Packets */
+       *pu2Temp = BTTotalDataBlockNum;
+       len += 8;
+       PPacketIrpEvent->Length = len;
+
+       bthci_IndicateEvent(padapter, PPacketIrpEvent, len+2);
+
+       return status;
+}
+
+static enum hci_status bthci_CmdReadLocalAMPInfo(struct rtw_adapter *padapter)
+{
+       enum hci_status status = HCI_STATUS_SUCCESS;
+       struct pwrctrl_priv *ppwrctrl = &padapter->pwrctrlpriv;
+       u8 localBuf[TmpLocalBufSize] = "";
+       u8 *pRetPar;
+       u8 len = 0;
+       struct packet_irp_hcievent_data *PPacketIrpEvent;
+       u16 *pu2Temp;
+       u32 *pu4Temp;
+       u32     TotalBandwidth = BTTOTALBANDWIDTH, MaxBandGUBandwidth = BTMAXBANDGUBANDWIDTH;
+       u8 ControlType = 0x01, AmpStatus = 0x01;
+       u32     MaxFlushTimeout = 10000, BestEffortFlushTimeout = 5000;
+       u16 MaxPDUSize = Max80211PALPDUSize, PalCap = 0x1, AmpAssocLen = Max80211AMPASSOCLen, MinLatency = 20;
+
+       if ((ppwrctrl->rfoff_reason & RF_CHANGE_BY_HW) ||
+           (ppwrctrl->rfoff_reason & RF_CHANGE_BY_SW)) {
+               AmpStatus = AMP_STATUS_NO_CAPACITY_FOR_BT;
+       }
+
+       PlatformZeroMemory(&localBuf[0], TmpLocalBufSize);
+       /* PPacketIrpEvent = (struct packet_irp_hcievent_data *)(buffer); */
+       PPacketIrpEvent = (struct packet_irp_hcievent_data *)(&localBuf[0]);
+
+       len += bthci_CommandCompleteHeader(&localBuf[0],
+               OGF_STATUS_PARAMETERS,
+               HCI_READ_LOCAL_AMP_INFO,
+               status);
+
+       /*  Return parameters starts from here */
+       pRetPar = &PPacketIrpEvent->Data[len];
+       pRetPar[0] = status;                    /* status */
+       pRetPar[1] = AmpStatus;                 /*  AMP_Status */
+       pu4Temp = (u32 *)&pRetPar[2];           /*  Total_Bandwidth */
+       *pu4Temp = TotalBandwidth;              /* 0x19bfcc00;0x7530; */
+       pu4Temp = (u32 *)&pRetPar[6];           /*  Max_Guaranteed_Bandwidth */
+       *pu4Temp = MaxBandGUBandwidth;          /* 0x19bfcc00;0x4e20; */
+       pu4Temp = (u32 *)&pRetPar[10];          /*  Min_Latency */
+       *pu4Temp = MinLatency;                  /* 150; */
+       pu4Temp = (u32 *)&pRetPar[14];          /*  Max_PDU_Size */
+       *pu4Temp = MaxPDUSize;
+       pRetPar[18] = ControlType;              /*  Controller_Type */
+       pu2Temp = (u16 *)&pRetPar[19];          /*  PAL_Capabilities */
+       *pu2Temp = PalCap;
+       pu2Temp = (u16 *)&pRetPar[21];          /*  AMP_ASSOC_Length */
+       *pu2Temp = AmpAssocLen;
+       pu4Temp = (u32 *)&pRetPar[23];          /*  Max_Flush_Timeout */
+       *pu4Temp = MaxFlushTimeout;
+       pu4Temp = (u32 *)&pRetPar[27];          /*  Best_Effort_Flush_Timeout */
+       *pu4Temp = BestEffortFlushTimeout;
+       len += 31;
+       PPacketIrpEvent->Length = len;
+       RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("AmpStatus = 0x%x\n",
+               AmpStatus));
+       RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("TotalBandwidth = 0x%x, MaxBandGUBandwidth = 0x%x, MinLatency = 0x%x, \n MaxPDUSize = 0x%x, ControlType = 0x%x\n",
+               TotalBandwidth, MaxBandGUBandwidth, MinLatency, MaxPDUSize, ControlType));
+       RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("PalCap = 0x%x, AmpAssocLen = 0x%x, MaxFlushTimeout = 0x%x, BestEffortFlushTimeout = 0x%x\n",
+               PalCap, AmpAssocLen, MaxFlushTimeout, BestEffortFlushTimeout));
+       bthci_IndicateEvent(padapter, PPacketIrpEvent, len+2);
+       return status;
+}
+
+static enum hci_status
+bthci_CmdCreatePhysicalLink(
+       struct rtw_adapter *padapter,
+       struct packet_irp_hcicmd_data *pHciCmd
+       )
+{
+       enum hci_status status;
+       struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
+       struct bt_dgb *pBtDbg = &pBTInfo->BtDbg;
+
+       pBtDbg->dbgHciInfo.hciCmdCntCreatePhyLink++;
+
+       status = bthci_BuildPhysicalLink(padapter,
+               pHciCmd, HCI_CREATE_PHYSICAL_LINK);
+
+       return status;
+}
+
+static enum hci_status
+bthci_CmdReadLinkQuality(
+       struct rtw_adapter *padapter,
+       struct packet_irp_hcicmd_data *pHciCmd
+       )
+{
+       enum hci_status                 status = HCI_STATUS_SUCCESS;
+       struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
+       u16                             PLH;
+       u8      EntryNum, LinkQuality = 0x55;
+
+       PLH = *((u16 *)&pHciCmd->Data[0]);
+       RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("PLH = 0x%x\n", PLH));
+
+       EntryNum = bthci_GetCurrentEntryNum(padapter, (u8)PLH);
+       if (EntryNum == 0xff) {
+               RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("No such PLH(0x%x)\n", PLH));
+               status = HCI_STATUS_UNKNOW_CONNECT_ID;
+       }
+
+       {
+               u8 localBuf[11] = "";
+               u8 *pRetPar;
+               u8 len = 0;
+               struct packet_irp_hcievent_data *PPacketIrpEvent;
+
+               PPacketIrpEvent = (struct packet_irp_hcievent_data *)(&localBuf[0]);
+
+               len += bthci_CommandCompleteHeader(&localBuf[0],
+                       OGF_STATUS_PARAMETERS,
+                       HCI_READ_LINK_QUALITY,
+                       status);
+
+               RTPRINT(FIOCTL, IOCTL_BT_HCICMD, (" PLH = 0x%x\n Link Quality = 0x%x\n", PLH, LinkQuality));
+
+               /*  Return parameters starts from here */
+               pRetPar = &PPacketIrpEvent->Data[len];
+               pRetPar[0] = status;                    /* status */
+               *((u16 *)&pRetPar[1]) = pBTInfo->BtAsocEntry[EntryNum].PhyLinkCmdData.BtPhyLinkhandle;  /*  Handle */
+               pRetPar[3] = 0x55;      /* Link Quailty */
+               len += 4;
+               PPacketIrpEvent->Length = len;
+
+               bthci_IndicateEvent(padapter, PPacketIrpEvent, len+2);
+       }
+
+       return status;
+}
+
+static enum hci_status
+bthci_CmdCreateLogicalLink(
+       struct rtw_adapter *padapter,
+       struct packet_irp_hcicmd_data *pHciCmd
+       )
+{
+       struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
+       struct bt_dgb *pBtDbg = &pBTInfo->BtDbg;
+
+       pBtDbg->dbgHciInfo.hciCmdCntCreateLogLink++;
+
+       bthci_BuildLogicalLink(padapter, pHciCmd,
+               HCI_CREATE_LOGICAL_LINK);
+
+       return HCI_STATUS_SUCCESS;
+}
+
+static enum hci_status
+bthci_CmdAcceptLogicalLink(
+       struct rtw_adapter *padapter,
+       struct packet_irp_hcicmd_data *pHciCmd
+       )
+{
+       struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
+       struct bt_dgb *pBtDbg = &pBTInfo->BtDbg;
+
+       pBtDbg->dbgHciInfo.hciCmdCntAcceptLogLink++;
+
+       bthci_BuildLogicalLink(padapter, pHciCmd,
+               HCI_ACCEPT_LOGICAL_LINK);
+
+       return HCI_STATUS_SUCCESS;
+}
+
+static enum hci_status
+bthci_CmdDisconnectLogicalLink(
+       struct rtw_adapter *padapter,
+       struct packet_irp_hcicmd_data *pHciCmd
+       )
+{
+       enum hci_status status = HCI_STATUS_SUCCESS;
+/*PMGNT_INFO pMgntInfo = &padapter->MgntInfo; */
+       struct bt_30info *pBTinfo = GET_BT_INFO(padapter);
+       struct bt_mgnt *pBtMgnt = &pBTinfo->BtMgnt;
+       struct bt_dgb *pBtDbg = &pBTinfo->BtDbg;
+       u16     logicHandle;
+       u8 i, j, find = 0, LogLinkCount = 0;
+
+       pBtDbg->dbgHciInfo.hciCmdCntDisconnectLogLink++;
+
+       logicHandle = *((u16 *)pHciCmd->Data);
+       RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("DisconnectLogicalLink, logicHandle = 0x%x\n", logicHandle));
+
+       /*  find an created logical link index and clear the data */
+       for (j = 0; j < MAX_BT_ASOC_ENTRY_NUM; j++) {
+               for (i = 0; i < MAX_LOGICAL_LINK_NUM; i++) {
+                       if (pBTinfo->BtAsocEntry[j].LogLinkCmdData[i].BtLogLinkhandle == logicHandle) {
+                               RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("DisconnectLogicalLink, logicHandle is matched  0x%x\n", logicHandle));
+                               bthci_ResetFlowSpec(padapter, j, i);
+                               find = 1;
+                               pBtMgnt->DisconnectEntryNum = j;
+                               break;
+                       }
+               }
+       }
+
+       if (!find)
+               status = HCI_STATUS_UNKNOW_CONNECT_ID;
+
+       /*  To check each */
+       for (i = 0; i < MAX_LOGICAL_LINK_NUM; i++) {
+               if (pBTinfo->BtAsocEntry[pBtMgnt->DisconnectEntryNum].LogLinkCmdData[i].BtLogLinkhandle != 0)
+                       LogLinkCount++;
+       }
+
+       /* When we receive Create logical link command, we should send command status event first. */
+       bthci_EventCommandStatus(padapter,
+                       LINK_CONTROL_COMMANDS,
+                       HCI_DISCONNECT_LOGICAL_LINK,
+                       status);
+       /*  */
+       /* When we determines the logical link is established, we should send command complete event. */
+       /*  */
+       if (status == HCI_STATUS_SUCCESS) {
+               bthci_EventDisconnectLogicalLinkComplete(padapter, status,
+                       logicHandle, HCI_STATUS_CONNECT_TERMINATE_LOCAL_HOST);
+       }
+
+       if (LogLinkCount == 0)
+               mod_timer(&pBTinfo->BTDisconnectPhyLinkTimer,
+                         jiffies + msecs_to_jiffies(100));
+
+       return status;
+}
+
+static enum hci_status
+bthci_CmdLogicalLinkCancel(struct rtw_adapter *padapter,
+                          struct packet_irp_hcicmd_data *pHciCmd)
+{
+       enum hci_status status = HCI_STATUS_SUCCESS;
+       struct bt_30info *pBTinfo = GET_BT_INFO(padapter);
+       struct bt_mgnt *pBtMgnt = &pBTinfo->BtMgnt;
+       u8 CurrentEntryNum, CurrentLogEntryNum;
+
+       u8 physicalLinkHandle, TxFlowSpecID, i;
+       u16     CurrentLogicalHandle;
+
+       physicalLinkHandle = *((u8 *)pHciCmd->Data);
+       TxFlowSpecID = *(((u8 *)pHciCmd->Data)+1);
+
+       RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("LogicalLinkCancel, physicalLinkHandle = 0x%x, TxFlowSpecID = 0x%x\n",
+               physicalLinkHandle, TxFlowSpecID));
+
+       CurrentEntryNum = pBtMgnt->CurrentConnectEntryNum;
+       CurrentLogicalHandle = pBtMgnt->BtCurrentLogLinkhandle;
+
+       RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("CurrentEntryNum = 0x%x, CurrentLogicalHandle = 0x%x\n",
+               CurrentEntryNum, CurrentLogicalHandle));
+
+       CurrentLogEntryNum = 0xff;
+       for (i = 0; i < MAX_LOGICAL_LINK_NUM; i++) {
+               if ((CurrentLogicalHandle == pBTinfo->BtAsocEntry[CurrentEntryNum].LogLinkCmdData[i].BtLogLinkhandle) &&
+                       (physicalLinkHandle == pBTinfo->BtAsocEntry[CurrentEntryNum].LogLinkCmdData[i].BtPhyLinkhandle)) {
+                       CurrentLogEntryNum = i;
+                       break;
+               }
+       }
+
+       if (CurrentLogEntryNum == 0xff) {
+               RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("LogicalLinkCancel, CurrentLogEntryNum == 0xff !!!!\n"));
+               status = HCI_STATUS_UNKNOW_CONNECT_ID;
+               return status;
+       } else {
+               if (pBTinfo->BtAsocEntry[CurrentEntryNum].LogLinkCmdData[CurrentLogEntryNum].bLLCompleteEventIsSet) {
+                       RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("LogicalLinkCancel, LLCompleteEventIsSet!!!!\n"));
+                       status = HCI_STATUS_ACL_CONNECT_EXISTS;
+               }
+       }
+
+       {
+               u8 localBuf[8] = "";
+               u8 *pRetPar;
+               u8 len = 0;
+               struct packet_irp_hcievent_data *PPacketIrpEvent;
+
+               PPacketIrpEvent = (struct packet_irp_hcievent_data *)(&localBuf[0]);
+
+               len += bthci_CommandCompleteHeader(&localBuf[0],
+                       LINK_CONTROL_COMMANDS,
+                       HCI_LOGICAL_LINK_CANCEL,
+                       status);
+
+               /*  Return parameters starts from here */
+               pRetPar = &PPacketIrpEvent->Data[len];
+               pRetPar[0] = status;            /* status */
+               pRetPar[1] = pBTinfo->BtAsocEntry[CurrentEntryNum].LogLinkCmdData[CurrentLogEntryNum].BtPhyLinkhandle;
+               pRetPar[2] = pBTinfo->BtAsocEntry[CurrentEntryNum].LogLinkCmdData[CurrentLogEntryNum].BtTxFlowSpecID;
+               len += 3;
+               PPacketIrpEvent->Length = len;
+
+               bthci_IndicateEvent(padapter, PPacketIrpEvent, len+2);
+       }
+
+       pBTinfo->BtAsocEntry[CurrentEntryNum].LogLinkCmdData[CurrentLogEntryNum].bLLCancelCMDIsSetandComplete = true;
+
+       return status;
+}
+
+static enum hci_status
+bthci_CmdFlowSpecModify(struct rtw_adapter *padapter,
+                       struct packet_irp_hcicmd_data *pHciCmd)
+{
+       enum hci_status status = HCI_STATUS_SUCCESS;
+/*PMGNT_INFO pMgntInfo = &padapter->MgntInfo; */
+       struct bt_30info *pBTinfo = GET_BT_INFO(padapter);
+       u8 i, j, find = 0;
+       u16 logicHandle;
+
+       logicHandle = *((u16 *)pHciCmd->Data);
+       /*  find an matched logical link index and copy the data */
+       for (j = 0; j < MAX_BT_ASOC_ENTRY_NUM; j++) {
+               for (i = 0; i < MAX_LOGICAL_LINK_NUM; i++) {
+                       if (pBTinfo->BtAsocEntry[j].LogLinkCmdData[i].BtLogLinkhandle == logicHandle) {
+                               memcpy(&pBTinfo->BtAsocEntry[j].LogLinkCmdData[i].Tx_Flow_Spec,
+                                       &pHciCmd->Data[2], sizeof(struct hci_flow_spec));
+                               memcpy(&pBTinfo->BtAsocEntry[j].LogLinkCmdData[i].Rx_Flow_Spec,
+                                       &pHciCmd->Data[18], sizeof(struct hci_flow_spec));
+
+                               bthci_CheckLogLinkBehavior(padapter, pBTinfo->BtAsocEntry[j].LogLinkCmdData[i].Tx_Flow_Spec);
+                               find = 1;
+                               break;
+                       }
+               }
+       }
+       RTPRINT(FIOCTL, IOCTL_BT_LOGO, ("FlowSpecModify, LLH = 0x%x, \n", logicHandle));
+
+       /* When we receive Flow Spec Modify command, we should send command status event first. */
+       bthci_EventCommandStatus(padapter,
+               LINK_CONTROL_COMMANDS,
+               HCI_FLOW_SPEC_MODIFY,
+               HCI_STATUS_SUCCESS);
+
+       if (!find)
+               status = HCI_STATUS_UNKNOW_CONNECT_ID;
+
+       bthci_EventSendFlowSpecModifyComplete(padapter, status, logicHandle);
+
+       return status;
+}
+
+static enum hci_status
+bthci_CmdAcceptPhysicalLink(struct rtw_adapter *padapter,
+                           struct packet_irp_hcicmd_data *pHciCmd)
+{
+       enum hci_status status;
+       struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
+       struct bt_dgb *pBtDbg = &pBTInfo->BtDbg;
+
+       pBtDbg->dbgHciInfo.hciCmdCntAcceptPhyLink++;
+
+       status = bthci_BuildPhysicalLink(padapter,
+               pHciCmd, HCI_ACCEPT_PHYSICAL_LINK);
+
+       return status;
+}
+
+static enum hci_status
+bthci_CmdDisconnectPhysicalLink(struct rtw_adapter *padapter,
+                               struct packet_irp_hcicmd_data *pHciCmd)
+{
+       enum hci_status status = HCI_STATUS_SUCCESS;
+       struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
+       struct bt_dgb *pBtDbg = &pBTInfo->BtDbg;
+       u8 PLH, CurrentEntryNum, PhysLinkDisconnectReason;
+
+       pBtDbg->dbgHciInfo.hciCmdCntDisconnectPhyLink++;
+
+       PLH = *((u8 *)pHciCmd->Data);
+       PhysLinkDisconnectReason = *((u8 *)pHciCmd->Data+1);
+       RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_DISCONNECT_PHYSICAL_LINK  PhyHandle = 0x%x, Reason = 0x%x\n",
+               PLH, PhysLinkDisconnectReason));
+
+       CurrentEntryNum = bthci_GetCurrentEntryNum(padapter, PLH);
+
+       if (CurrentEntryNum == 0xff) {
+               RTPRINT(FIOCTL, IOCTL_BT_HCICMD,
+                       ("DisconnectPhysicalLink, No such Handle in the Entry\n"));
+               status = HCI_STATUS_UNKNOW_CONNECT_ID;
+       } else {
+               pBTInfo->BtAsocEntry[CurrentEntryNum].PhyLinkDisconnectReason =
+                       (enum hci_status)PhysLinkDisconnectReason;
+       }
+       /* Send HCI Command status event to AMP. */
+       bthci_EventCommandStatus(padapter, LINK_CONTROL_COMMANDS,
+                                HCI_DISCONNECT_PHYSICAL_LINK, status);
+
+       if (status != HCI_STATUS_SUCCESS)
+               return status;
+
+       /* The macros below require { and } in the if statement */
+       if (pBTInfo->BtAsocEntry[CurrentEntryNum].BtCurrentState == HCI_STATE_DISCONNECTED) {
+               BTHCI_SM_WITH_INFO(padapter, HCI_STATE_DISCONNECTED, STATE_CMD_DISCONNECT_PHY_LINK, CurrentEntryNum);
+       } else {
+               BTHCI_SM_WITH_INFO(padapter, HCI_STATE_DISCONNECTING, STATE_CMD_DISCONNECT_PHY_LINK, CurrentEntryNum);
+       }
+       return status;
+}
+
+static enum hci_status
+bthci_CmdSetACLLinkDataFlowMode(struct rtw_adapter *padapter,
+                               struct packet_irp_hcicmd_data *pHciCmd)
+{
+       enum hci_status status = HCI_STATUS_SUCCESS;
+       struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
+       struct bt_mgnt *pBtMgnt = &pBTInfo->BtMgnt;
+       u8 localBuf[8] = "";
+       u8 *pRetPar;
+       u8 len = 0;
+       struct packet_irp_hcievent_data *PPacketIrpEvent;
+       u16 *pu2Temp;
+
+       pBtMgnt->ExtConfig.CurrentConnectHandle = *((u16 *)pHciCmd->Data);
+       pBtMgnt->ExtConfig.CurrentIncomingTrafficMode = *((u8 *)pHciCmd->Data)+2;
+       pBtMgnt->ExtConfig.CurrentOutgoingTrafficMode = *((u8 *)pHciCmd->Data)+3;
+       RTPRINT(FIOCTL, IOCTL_BT_HCICMD_EXT, ("Connection Handle = 0x%x, Incoming Traffic mode = 0x%x, Outgoing Traffic mode = 0x%x",
+               pBtMgnt->ExtConfig.CurrentConnectHandle,
+               pBtMgnt->ExtConfig.CurrentIncomingTrafficMode,
+               pBtMgnt->ExtConfig.CurrentOutgoingTrafficMode));
+
+
+       PPacketIrpEvent = (struct packet_irp_hcievent_data *)(&localBuf[0]);
+
+       len += bthci_CommandCompleteHeader(&localBuf[0],
+               OGF_EXTENSION,
+               HCI_SET_ACL_LINK_DATA_FLOW_MODE,
+               status);
+
+       /*  Return parameters starts from here */
+       pRetPar = &PPacketIrpEvent->Data[len];
+       pRetPar[0] = status;            /* status */
+
+       pu2Temp = (u16 *)&pRetPar[1];
+       *pu2Temp = pBtMgnt->ExtConfig.CurrentConnectHandle;
+       len += 3;
+       PPacketIrpEvent->Length = len;
+
+       bthci_IndicateEvent(padapter, PPacketIrpEvent, len+2);
+       return status;
+}
+
+static enum hci_status
+bthci_CmdSetACLLinkStatus(struct rtw_adapter *padapter,
+                         struct packet_irp_hcicmd_data *pHciCmd)
+{
+       enum hci_status status = HCI_STATUS_SUCCESS;
+       struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
+       struct bt_mgnt *pBtMgnt = &pBTInfo->BtMgnt;
+       struct bt_dgb *pBtDbg = &pBTInfo->BtDbg;
+       u8 i;
+       u8 *pTriple;
+
+       pBtDbg->dbgHciInfo.hciCmdCntSetAclLinkStatus++;
+       RTPRINT_DATA(FIOCTL, IOCTL_BT_HCICMD_EXT, "SetACLLinkStatus, Hex Data :\n",
+                       &pHciCmd->Data[0], pHciCmd->Length);
+
+       /*  Only Core Stack v251 and later version support this command. */
+       pBtMgnt->bSupportProfile = true;
+
+       pBtMgnt->ExtConfig.NumberOfHandle = *((u8 *)pHciCmd->Data);
+       RTPRINT(FIOCTL, IOCTL_BT_HCICMD_EXT, ("NumberOfHandle = 0x%x\n", pBtMgnt->ExtConfig.NumberOfHandle));
+
+       pTriple = &pHciCmd->Data[1];
+       for (i = 0; i < pBtMgnt->ExtConfig.NumberOfHandle; i++) {
+               pBtMgnt->ExtConfig.linkInfo[i].ConnectHandle = *((u16 *)&pTriple[0]);
+               pBtMgnt->ExtConfig.linkInfo[i].IncomingTrafficMode = pTriple[2];
+               pBtMgnt->ExtConfig.linkInfo[i].OutgoingTrafficMode = pTriple[3];
+               RTPRINT(FIOCTL, IOCTL_BT_HCICMD_EXT,
+                       ("Connection_Handle = 0x%x, Incoming Traffic mode = 0x%x, Outgoing Traffic Mode = 0x%x\n",
+                       pBtMgnt->ExtConfig.linkInfo[i].ConnectHandle,
+                       pBtMgnt->ExtConfig.linkInfo[i].IncomingTrafficMode,
+                       pBtMgnt->ExtConfig.linkInfo[i].OutgoingTrafficMode));
+               pTriple += 4;
+       }
+
+       {
+               u8 localBuf[6] = "";
+               u8 *pRetPar;
+               u8 len = 0;
+               struct packet_irp_hcievent_data *PPacketIrpEvent;
+
+               PPacketIrpEvent = (struct packet_irp_hcievent_data *)(&localBuf[0]);
+
+               len += bthci_CommandCompleteHeader(&localBuf[0],
+                       OGF_EXTENSION,
+                       HCI_SET_ACL_LINK_STATUS,
+                       status);
+
+               /*  Return parameters starts from here */
+               pRetPar = &PPacketIrpEvent->Data[len];
+               pRetPar[0] = status;            /* status */
+
+               len += 1;
+               PPacketIrpEvent->Length = len;
+
+               bthci_IndicateEvent(padapter, PPacketIrpEvent, len+2);
+       }
+
+       return status;
+}
+
+static enum hci_status
+bthci_CmdSetSCOLinkStatus(
+       struct rtw_adapter *padapter,
+       struct packet_irp_hcicmd_data *pHciCmd
+       )
+{
+       enum hci_status status = HCI_STATUS_SUCCESS;
+       struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
+       struct bt_mgnt *pBtMgnt = &pBTInfo->BtMgnt;
+       struct bt_dgb *pBtDbg = &pBTInfo->BtDbg;
+
+       pBtDbg->dbgHciInfo.hciCmdCntSetScoLinkStatus++;
+       pBtMgnt->ExtConfig.NumberOfSCO = *((u8 *)pHciCmd->Data);
+       RTPRINT(FIOCTL, IOCTL_BT_HCICMD_EXT, ("NumberOfSCO = 0x%x\n",
+               pBtMgnt->ExtConfig.NumberOfSCO));
+
+       {
+               u8 localBuf[6] = "";
+               u8 *pRetPar;
+               u8 len = 0;
+               struct packet_irp_hcievent_data *PPacketIrpEvent;
+
+               PPacketIrpEvent = (struct packet_irp_hcievent_data *)(&localBuf[0]);
+
+               len += bthci_CommandCompleteHeader(&localBuf[0],
+                       OGF_EXTENSION,
+                       HCI_SET_SCO_LINK_STATUS,
+                       status);
+
+               /*  Return parameters starts from here */
+               pRetPar = &PPacketIrpEvent->Data[len];
+               pRetPar[0] = status;            /* status */
+
+               len += 1;
+               PPacketIrpEvent->Length = len;
+
+               bthci_IndicateEvent(padapter, PPacketIrpEvent, len+2);
+       }
+
+       return status;
+}
+
+static enum hci_status
+bthci_CmdSetRSSIValue(
+       struct rtw_adapter *padapter,
+       struct packet_irp_hcicmd_data *pHciCmd
+       )
+{
+       enum hci_status status = HCI_STATUS_SUCCESS;
+       struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
+       struct bt_mgnt *pBtMgnt = &pBTInfo->BtMgnt;
+       s8              min_bt_rssi = 0;
+       u8 i;
+       for (i = 0; i < pBtMgnt->ExtConfig.NumberOfHandle; i++) {
+               if (pBtMgnt->ExtConfig.linkInfo[i].ConnectHandle == *((u16 *)&pHciCmd->Data[0])) {
+                       pBtMgnt->ExtConfig.linkInfo[i].BT_RSSI = (s8)(pHciCmd->Data[2]);
+                       RTPRINT(FIOCTL, IOCTL_BT_EVENT_PERIODICAL,
+                       ("Connection_Handle = 0x%x, RSSI = %d \n",
+                       pBtMgnt->ExtConfig.linkInfo[i].ConnectHandle,
+                       pBtMgnt->ExtConfig.linkInfo[i].BT_RSSI));
+               }
+               /*  get the minimum bt rssi value */
+               if (pBtMgnt->ExtConfig.linkInfo[i].BT_RSSI <= min_bt_rssi)
+                       min_bt_rssi = pBtMgnt->ExtConfig.linkInfo[i].BT_RSSI;
+       }
+
+       pBtMgnt->ExtConfig.MIN_BT_RSSI = min_bt_rssi;
+       RTPRINT(FBT, BT_TRACE, ("[bt rssi], the min rssi is %d\n", min_bt_rssi));
+
+       {
+               u8 localBuf[6] = "";
+               u8 *pRetPar;
+               u8 len = 0;
+               struct packet_irp_hcievent_data *PPacketIrpEvent;
+
+               PPacketIrpEvent = (struct packet_irp_hcievent_data *)(&localBuf[0]);
+
+               len += bthci_CommandCompleteHeader(&localBuf[0],
+                       OGF_EXTENSION,
+                       HCI_SET_RSSI_VALUE,
+                       status);
+
+               /*  Return parameters starts from here */
+               pRetPar = &PPacketIrpEvent->Data[len];
+               pRetPar[0] = status;            /* status */
+
+               len += 1;
+               PPacketIrpEvent->Length = len;
+
+               bthci_IndicateEvent(padapter, PPacketIrpEvent, len+2);
+       }
+
+       return status;
+}
+
+static enum hci_status
+bthci_CmdSetCurrentBluetoothStatus(
+       struct rtw_adapter *padapter,
+       struct packet_irp_hcicmd_data *pHciCmd
+       )
+{
+       enum hci_status status = HCI_STATUS_SUCCESS;
+/*PMGNT_INFO   pMgntInfo = &padapter->MgntInfo; */
+       struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
+       struct bt_mgnt *pBtMgnt = &pBTInfo->BtMgnt;
+
+       pBtMgnt->ExtConfig.CurrentBTStatus = *((u8 *)&pHciCmd->Data[0]);
+       RTPRINT(FIOCTL, IOCTL_BT_HCICMD_EXT, ("SetCurrentBluetoothStatus, CurrentBTStatus = 0x%x\n",
+               pBtMgnt->ExtConfig.CurrentBTStatus));
+
+       {
+               u8 localBuf[6] = "";
+               u8 *pRetPar;
+               u8 len = 0;
+               struct packet_irp_hcievent_data *PPacketIrpEvent;
+
+               PPacketIrpEvent = (struct packet_irp_hcievent_data *)(&localBuf[0]);
+
+               len += bthci_CommandCompleteHeader(&localBuf[0],
+                       OGF_EXTENSION,
+                       HCI_SET_CURRENT_BLUETOOTH_STATUS,
+                       status);
+
+               /*  Return parameters starts from here */
+               pRetPar = &PPacketIrpEvent->Data[len];
+               pRetPar[0] = status;            /* status */
+               len += 1;
+
+               PPacketIrpEvent->Length = len;
+
+               bthci_IndicateEvent(padapter, PPacketIrpEvent, len+2);
+       }
+
+       return status;
+}
+
+static enum hci_status
+bthci_CmdExtensionVersionNotify(
+       struct rtw_adapter *padapter,
+       struct packet_irp_hcicmd_data *pHciCmd
+       )
+{
+       enum hci_status status = HCI_STATUS_SUCCESS;
+       struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
+       struct bt_mgnt *pBtMgnt = &pBTInfo->BtMgnt;
+       struct bt_dgb *pBtDbg = &pBTInfo->BtDbg;
+
+       pBtDbg->dbgHciInfo.hciCmdCntExtensionVersionNotify++;
+       RTPRINT_DATA(FIOCTL, IOCTL_BT_HCICMD_EXT, "ExtensionVersionNotify, Hex Data :\n",
+                       &pHciCmd->Data[0], pHciCmd->Length);
+
+       pBtMgnt->ExtConfig.HCIExtensionVer = *((u16 *)&pHciCmd->Data[0]);
+       RTPRINT(FIOCTL, IOCTL_BT_HCICMD_EXT, ("HCIExtensionVer = 0x%x\n", pBtMgnt->ExtConfig.HCIExtensionVer));
+
+       {
+               u8 localBuf[6] = "";
+               u8 *pRetPar;
+               u8 len = 0;
+               struct packet_irp_hcievent_data *PPacketIrpEvent;
+
+               PPacketIrpEvent = (struct packet_irp_hcievent_data *)(&localBuf[0]);
+
+               len += bthci_CommandCompleteHeader(&localBuf[0],
+                       OGF_EXTENSION,
+                       HCI_EXTENSION_VERSION_NOTIFY,
+                       status);
+
+               /*  Return parameters starts from here */
+               pRetPar = &PPacketIrpEvent->Data[len];
+               pRetPar[0] = status;            /* status */
+
+               len += 1;
+               PPacketIrpEvent->Length = len;
+
+               bthci_IndicateEvent(padapter, PPacketIrpEvent, len+2);
+       }
+
+       return status;
+}
+
+static enum hci_status
+bthci_CmdLinkStatusNotify(
+       struct rtw_adapter *padapter,
+       struct packet_irp_hcicmd_data *pHciCmd
+       )
+{
+       enum hci_status status = HCI_STATUS_SUCCESS;
+       struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
+       struct bt_mgnt *pBtMgnt = &pBTInfo->BtMgnt;
+       struct bt_dgb *pBtDbg = &pBTInfo->BtDbg;
+       u8 i;
+       u8 *pTriple;
+
+       pBtDbg->dbgHciInfo.hciCmdCntLinkStatusNotify++;
+       RTPRINT_DATA(FIOCTL, IOCTL_BT_HCICMD_EXT, "LinkStatusNotify, Hex Data :\n",
+                       &pHciCmd->Data[0], pHciCmd->Length);
+
+       /*  Current only RTL8723 support this command. */
+       pBtMgnt->bSupportProfile = true;
+
+       pBtMgnt->ExtConfig.NumberOfHandle = *((u8 *)pHciCmd->Data);
+       RTPRINT(FIOCTL, IOCTL_BT_HCICMD_EXT, ("NumberOfHandle = 0x%x\n", pBtMgnt->ExtConfig.NumberOfHandle));
+       RTPRINT(FIOCTL, IOCTL_BT_HCICMD_EXT, ("HCIExtensionVer = %d\n", pBtMgnt->ExtConfig.HCIExtensionVer));
+
+       pTriple = &pHciCmd->Data[1];
+       for (i = 0; i < pBtMgnt->ExtConfig.NumberOfHandle; i++) {
+               if (pBtMgnt->ExtConfig.HCIExtensionVer < 1) {
+                       pBtMgnt->ExtConfig.linkInfo[i].ConnectHandle = *((u16 *)&pTriple[0]);
+                       pBtMgnt->ExtConfig.linkInfo[i].BTProfile = pTriple[2];
+                       pBtMgnt->ExtConfig.linkInfo[i].BTCoreSpec = pTriple[3];
+                       RTPRINT(FIOCTL, IOCTL_BT_HCICMD_EXT,
+                               ("Connection_Handle = 0x%x, BTProfile =%d, BTSpec =%d\n",
+                               pBtMgnt->ExtConfig.linkInfo[i].ConnectHandle,
+                               pBtMgnt->ExtConfig.linkInfo[i].BTProfile,
+                               pBtMgnt->ExtConfig.linkInfo[i].BTCoreSpec));
+                       pTriple += 4;
+               } else if (pBtMgnt->ExtConfig.HCIExtensionVer >= 1) {
+                       pBtMgnt->ExtConfig.linkInfo[i].ConnectHandle = *((u16 *)&pTriple[0]);
+                       pBtMgnt->ExtConfig.linkInfo[i].BTProfile = pTriple[2];
+                       pBtMgnt->ExtConfig.linkInfo[i].BTCoreSpec = pTriple[3];
+                       pBtMgnt->ExtConfig.linkInfo[i].linkRole = pTriple[4];
+                       RTPRINT(FIOCTL, IOCTL_BT_HCICMD_EXT,
+                               ("Connection_Handle = 0x%x, BTProfile =%d, BTSpec =%d, LinkRole =%d\n",
+                               pBtMgnt->ExtConfig.linkInfo[i].ConnectHandle,
+                               pBtMgnt->ExtConfig.linkInfo[i].BTProfile,
+                               pBtMgnt->ExtConfig.linkInfo[i].BTCoreSpec,
+                               pBtMgnt->ExtConfig.linkInfo[i].linkRole));
+                       pTriple += 5;
+               }
+
+       }
+       BTHCI_UpdateBTProfileRTKToMoto(padapter);
+       {
+               u8 localBuf[6] = "";
+               u8 *pRetPar;
+               u8 len = 0;
+               struct packet_irp_hcievent_data *PPacketIrpEvent;
+
+               PPacketIrpEvent = (struct packet_irp_hcievent_data *)(&localBuf[0]);
+
+               len += bthci_CommandCompleteHeader(&localBuf[0],
+                       OGF_EXTENSION,
+                       HCI_LINK_STATUS_NOTIFY,
+                       status);
+
+               /*  Return parameters starts from here */
+               pRetPar = &PPacketIrpEvent->Data[len];
+               pRetPar[0] = status;            /* status */
+
+               len += 1;
+               PPacketIrpEvent->Length = len;
+
+               bthci_IndicateEvent(padapter, PPacketIrpEvent, len+2);
+       }
+
+       return status;
+}
+
+static enum hci_status
+bthci_CmdBtOperationNotify(
+       struct rtw_adapter *padapter,
+       struct packet_irp_hcicmd_data *pHciCmd
+       )
+{
+       enum hci_status status = HCI_STATUS_SUCCESS;
+       struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
+       struct bt_mgnt *pBtMgnt = &pBTInfo->BtMgnt;
+
+       RTPRINT_DATA(FIOCTL, IOCTL_BT_HCICMD_EXT, "Bt Operation notify, Hex Data :\n",
+                       &pHciCmd->Data[0], pHciCmd->Length);
+
+       pBtMgnt->ExtConfig.btOperationCode = *((u8 *)pHciCmd->Data);
+       RTPRINT(FIOCTL, IOCTL_BT_HCICMD_EXT, ("btOperationCode = 0x%x\n", pBtMgnt->ExtConfig.btOperationCode));
+       switch (pBtMgnt->ExtConfig.btOperationCode) {
+       case HCI_BT_OP_NONE:
+               RTPRINT(FIOCTL, IOCTL_BT_HCICMD_EXT, ("[bt operation] : Operation None!!\n"));
+               break;
+       case HCI_BT_OP_INQUIRY_START:
+               RTPRINT(FIOCTL, IOCTL_BT_HCICMD_EXT, ("[bt operation] : Inquire start!!\n"));
+               break;
+       case HCI_BT_OP_INQUIRY_FINISH:
+               RTPRINT(FIOCTL, IOCTL_BT_HCICMD_EXT, ("[bt operation] : Inquire finished!!\n"));
+               break;
+       case HCI_BT_OP_PAGING_START:
+               RTPRINT(FIOCTL, IOCTL_BT_HCICMD_EXT, ("[bt operation] : Paging is started!!\n"));
+               break;
+       case HCI_BT_OP_PAGING_SUCCESS:
+               RTPRINT(FIOCTL, IOCTL_BT_HCICMD_EXT, ("[bt operation] : Paging complete successfully!!\n"));
+               break;
+       case HCI_BT_OP_PAGING_UNSUCCESS:
+               RTPRINT(FIOCTL, IOCTL_BT_HCICMD_EXT, ("[bt operation] : Paging complete unsuccessfully!!\n"));
+               break;
+       case HCI_BT_OP_PAIRING_START:
+               RTPRINT(FIOCTL, IOCTL_BT_HCICMD_EXT, ("[bt operation] : Pairing start!!\n"));
+               break;
+       case HCI_BT_OP_PAIRING_FINISH:
+               RTPRINT(FIOCTL, IOCTL_BT_HCICMD_EXT, ("[bt operation] : Pairing finished!!\n"));
+               break;
+       case HCI_BT_OP_BT_DEV_ENABLE:
+               RTPRINT(FIOCTL, IOCTL_BT_HCICMD_EXT, ("[bt operation] : BT Device is enabled!!\n"));
+               break;
+       case HCI_BT_OP_BT_DEV_DISABLE:
+               RTPRINT(FIOCTL, IOCTL_BT_HCICMD_EXT, ("[bt operation] : BT Device is disabled!!\n"));
+               break;
+       default:
+               RTPRINT(FIOCTL, IOCTL_BT_HCICMD_EXT, ("[bt operation] : Unknown, error!!\n"));
+               break;
+       }
+       BTDM_AdjustForBtOperation(padapter);
+       {
+               u8 localBuf[6] = "";
+               u8 *pRetPar;
+               u8 len = 0;
+               struct packet_irp_hcievent_data *PPacketIrpEvent;
+
+               PPacketIrpEvent = (struct packet_irp_hcievent_data *)(&localBuf[0]);
+
+               len += bthci_CommandCompleteHeader(&localBuf[0],
+                       OGF_EXTENSION,
+                       HCI_BT_OPERATION_NOTIFY,
+                       status);
+
+               /*  Return parameters starts from here */
+               pRetPar = &PPacketIrpEvent->Data[len];
+               pRetPar[0] = status;            /* status */
+
+               len += 1;
+               PPacketIrpEvent->Length = len;
+
+               bthci_IndicateEvent(padapter, PPacketIrpEvent, len+2);
+       }
+
+       return status;
+}
+
+static enum hci_status
+bthci_CmdEnableWifiScanNotify(struct rtw_adapter *padapter,
+                             struct packet_irp_hcicmd_data *pHciCmd)
+{
+       enum hci_status status = HCI_STATUS_SUCCESS;
+       struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
+       struct bt_mgnt *pBtMgnt = &pBTInfo->BtMgnt;
+
+       RTPRINT_DATA(FIOCTL, IOCTL_BT_HCICMD_EXT, "Enable Wifi scan notify, Hex Data :\n",
+                       &pHciCmd->Data[0], pHciCmd->Length);
+
+       pBtMgnt->ExtConfig.bEnableWifiScanNotify = *((u8 *)pHciCmd->Data);
+       RTPRINT(FIOCTL, IOCTL_BT_HCICMD_EXT, ("bEnableWifiScanNotify = %d\n", pBtMgnt->ExtConfig.bEnableWifiScanNotify));
+
+       {
+               u8 localBuf[6] = "";
+               u8 *pRetPar;
+               u8 len = 0;
+               struct packet_irp_hcievent_data *PPacketIrpEvent;
+
+               PPacketIrpEvent = (struct packet_irp_hcievent_data *)(&localBuf[0]);
+
+               len += bthci_CommandCompleteHeader(&localBuf[0],
+                       OGF_EXTENSION,
+                       HCI_ENABLE_WIFI_SCAN_NOTIFY,
+                       status);
+
+               /*  Return parameters starts from here */
+               pRetPar = &PPacketIrpEvent->Data[len];
+               pRetPar[0] = status;            /* status */
+
+               len += 1;
+               PPacketIrpEvent->Length = len;
+
+               bthci_IndicateEvent(padapter, PPacketIrpEvent, len+2);
+       }
+
+       return status;
+}
+
+static enum hci_status
+bthci_CmdWIFICurrentChannel(struct rtw_adapter *padapter,
+                           struct packet_irp_hcicmd_data *pHciCmd)
+{
+       enum hci_status status = HCI_STATUS_SUCCESS;
+       struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
+       u8 chnl = pmlmeext->cur_channel;
+
+       if (pmlmeext->cur_bwmode == HT_CHANNEL_WIDTH_40) {
+               if (pmlmeext->cur_ch_offset == HAL_PRIME_CHNL_OFFSET_UPPER)
+                       chnl += 2;
+               else if (pmlmeext->cur_ch_offset == HAL_PRIME_CHNL_OFFSET_LOWER)
+                       chnl -= 2;
+       }
+
+       RTPRINT(FIOCTL, IOCTL_BT_HCICMD_EXT, ("Current Channel  = 0x%x\n", chnl));
+
+       {
+               u8 localBuf[8] = "";
+               u8 *pRetPar;
+               u8 len = 0;
+               struct packet_irp_hcievent_data *PPacketIrpEvent;
+
+               PPacketIrpEvent = (struct packet_irp_hcievent_data *)(&localBuf[0]);
+
+               len += bthci_CommandCompleteHeader(&localBuf[0],
+                       OGF_EXTENSION,
+                       HCI_WIFI_CURRENT_CHANNEL,
+                       status);
+
+               /*  Return parameters starts from here */
+               pRetPar = &PPacketIrpEvent->Data[len];
+               pRetPar[0] = status;            /* status */
+               pRetPar[1] = chnl;                      /* current channel */
+               len += 2;
+               PPacketIrpEvent->Length = len;
+
+               bthci_IndicateEvent(padapter, PPacketIrpEvent, len+2);
+       }
+
+       return status;
+}
+
+static enum hci_status
+bthci_CmdWIFICurrentBandwidth(struct rtw_adapter *padapter,
+                             struct packet_irp_hcicmd_data *pHciCmd)
+{
+       enum hci_status status = HCI_STATUS_SUCCESS;
+       enum ht_channel_width bw;
+       u8 CurrentBW = 0;
+
+       bw = padapter->mlmeextpriv.cur_bwmode;
+
+       if (bw == HT_CHANNEL_WIDTH_20)
+               CurrentBW = 0;
+       else if (bw == HT_CHANNEL_WIDTH_40)
+               CurrentBW = 1;
+
+       RTPRINT(FIOCTL, IOCTL_BT_HCICMD_EXT, ("Current BW = 0x%x\n",
+               CurrentBW));
+
+       {
+               u8 localBuf[8] = "";
+               u8 *pRetPar;
+               u8 len = 0;
+               struct packet_irp_hcievent_data *PPacketIrpEvent;
+
+               PPacketIrpEvent = (struct packet_irp_hcievent_data *)(&localBuf[0]);
+
+               len += bthci_CommandCompleteHeader(&localBuf[0],
+                       OGF_EXTENSION,
+                       HCI_WIFI_CURRENT_BANDWIDTH,
+                       status);
+
+               /*  Return parameters starts from here */
+               pRetPar = &PPacketIrpEvent->Data[len];
+               pRetPar[0] = status;            /* status */
+               pRetPar[1] = CurrentBW;         /* current BW */
+               len += 2;
+               PPacketIrpEvent->Length = len;
+
+               bthci_IndicateEvent(padapter, PPacketIrpEvent, len+2);
+       }
+
+       return status;
+}
+
+static enum hci_status
+bthci_CmdWIFIConnectionStatus(
+       struct rtw_adapter *padapter,
+       struct packet_irp_hcicmd_data *pHciCmd
+       )
+{
+       enum hci_status status = HCI_STATUS_SUCCESS;
+       u8 connectStatus = HCI_WIFI_NOT_CONNECTED;
+
+       if (check_fwstate(&padapter->mlmepriv, WIFI_AP_STATE)) {
+               if (padapter->stapriv.asoc_sta_count >= 3)
+                       connectStatus = HCI_WIFI_CONNECTED;
+               else
+                       connectStatus = HCI_WIFI_NOT_CONNECTED;
+       } else if (check_fwstate(&padapter->mlmepriv, WIFI_ADHOC_STATE|WIFI_ADHOC_MASTER_STATE|WIFI_ASOC_STATE)) {
+               connectStatus = HCI_WIFI_CONNECTED;
+       } else if (check_fwstate(&padapter->mlmepriv, WIFI_UNDER_LINKING)) {
+               connectStatus = HCI_WIFI_CONNECT_IN_PROGRESS;
+       } else {
+               connectStatus = HCI_WIFI_NOT_CONNECTED;
+       }
+
+       {
+               u8 localBuf[8] = "";
+               u8 *pRetPar;
+               u8 len = 0;
+               struct packet_irp_hcievent_data *PPacketIrpEvent;
+
+               PPacketIrpEvent = (struct packet_irp_hcievent_data *)(&localBuf[0]);
+
+               len += bthci_CommandCompleteHeader(&localBuf[0],
+                       OGF_EXTENSION,
+                       HCI_WIFI_CONNECTION_STATUS,
+                       status);
+
+               /*  Return parameters starts from here */
+               pRetPar = &PPacketIrpEvent->Data[len];
+               pRetPar[0] = status;                    /* status */
+               pRetPar[1] = connectStatus;     /* connect status */
+               len += 2;
+               PPacketIrpEvent->Length = len;
+
+               bthci_IndicateEvent(padapter, PPacketIrpEvent, len+2);
+       }
+
+       return status;
+}
+
+static enum hci_status
+bthci_CmdEnableDeviceUnderTestMode(
+       struct rtw_adapter *padapter,
+       struct packet_irp_hcicmd_data *pHciCmd
+       )
+{
+       enum hci_status status = HCI_STATUS_SUCCESS;
+       struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
+       struct bt_hci_info *pBtHciInfo = &pBTInfo->BtHciInfo;
+
+       pBtHciInfo->bInTestMode = true;
+       pBtHciInfo->bTestIsEnd = false;
+
+       /* send command complete event here when all data are received. */
+       {
+               u8 localBuf[6] = "";
+               u8 *pRetPar;
+               u8 len = 0;
+               struct packet_irp_hcievent_data *PPacketIrpEvent;
+
+               PPacketIrpEvent = (struct packet_irp_hcievent_data *)(&localBuf[0]);
+
+               len += bthci_CommandCompleteHeader(&localBuf[0],
+                       OGF_TESTING_COMMANDS,
+                       HCI_ENABLE_DEVICE_UNDER_TEST_MODE,
+                       status);
+
+               /*  Return parameters starts from here */
+               pRetPar = &PPacketIrpEvent->Data[len];
+               pRetPar[0] = status;            /* status */
+               len += 1;
+               PPacketIrpEvent->Length = len;
+
+               bthci_IndicateEvent(padapter, PPacketIrpEvent, len+2);
+       }
+
+       return status;
+}
+
+static enum hci_status
+bthci_CmdAMPTestEnd(struct rtw_adapter *padapter,
+                   struct packet_irp_hcicmd_data *pHciCmd)
+{
+       enum hci_status status = HCI_STATUS_SUCCESS;
+       struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
+       struct bt_hci_info *pBtHciInfo = &pBTInfo->BtHciInfo;
+
+       if (!pBtHciInfo->bInTestMode) {
+               RTPRINT(FIOCTL, (IOCTL_BT_EVENT|IOCTL_BT_LOGO), ("Not in Test mode, return status = HCI_STATUS_CMD_DISALLOW\n"));
+               status = HCI_STATUS_CMD_DISALLOW;
+               return status;
+       }
+
+       pBtHciInfo->bTestIsEnd = true;
+
+       del_timer_sync(&pBTInfo->BTTestSendPacketTimer);
+
+       rtl8723a_check_bssid(padapter, true);
+
+       /* send command complete event here when all data are received. */
+       {
+               u8 localBuf[4] = "";
+               struct packet_irp_hcievent_data *PPacketIrpEvent;
+
+               RTPRINT(FIOCTL, (IOCTL_BT_EVENT|IOCTL_BT_LOGO), ("AMP Test End Event \n"));
+               PPacketIrpEvent = (struct packet_irp_hcievent_data *)(&localBuf[0]);
+               PPacketIrpEvent->EventCode = HCI_EVENT_AMP_TEST_END;
+               PPacketIrpEvent->Length = 2;
+
+               PPacketIrpEvent->Data[0] = status;
+               PPacketIrpEvent->Data[1] = pBtHciInfo->TestScenario;
+
+               bthci_IndicateEvent(padapter, PPacketIrpEvent, 4);
+       }
+
+       bthci_EventAMPReceiverReport(padapter, 0x01);
+
+       return status;
+}
+
+static enum hci_status
+bthci_CmdAMPTestCommand(struct rtw_adapter *padapter,
+                       struct packet_irp_hcicmd_data *pHciCmd)
+{
+       enum hci_status status = HCI_STATUS_SUCCESS;
+       struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
+       struct bt_hci_info *pBtHciInfo = &pBTInfo->BtHciInfo;
+
+       if (!pBtHciInfo->bInTestMode) {
+               RTPRINT(FIOCTL, (IOCTL_BT_EVENT|IOCTL_BT_LOGO), ("Not in Test mode, return status = HCI_STATUS_CMD_DISALLOW\n"));
+               status = HCI_STATUS_CMD_DISALLOW;
+               return status;
+       }
+
+       pBtHciInfo->TestScenario = *((u8 *)pHciCmd->Data);
+
+       if (pBtHciInfo->TestScenario == 0x01)
+               RTPRINT(FIOCTL, (IOCTL_BT_EVENT|IOCTL_BT_LOGO), ("TX Single Test \n"));
+       else if (pBtHciInfo->TestScenario == 0x02)
+               RTPRINT(FIOCTL, (IOCTL_BT_EVENT|IOCTL_BT_LOGO), ("Receive Frame Test \n"));
+       else
+               RTPRINT(FIOCTL, (IOCTL_BT_EVENT|IOCTL_BT_LOGO), ("No Such Test !!!!!!!!!!!!!!!!!! \n"));
+
+       if (pBtHciInfo->bTestIsEnd) {
+               u8 localBuf[5] = "";
+               struct packet_irp_hcievent_data *PPacketIrpEvent;
+
+               RTPRINT(FIOCTL, (IOCTL_BT_EVENT|IOCTL_BT_LOGO), ("AMP Test End Event \n"));
+               PPacketIrpEvent = (struct packet_irp_hcievent_data *)(&localBuf[0]);
+               PPacketIrpEvent->EventCode = HCI_EVENT_AMP_TEST_END;
+               PPacketIrpEvent->Length = 2;
+
+               PPacketIrpEvent->Data[0] = status;
+               PPacketIrpEvent->Data[1] = pBtHciInfo->TestScenario ;
+
+               bthci_IndicateEvent(padapter, PPacketIrpEvent, 4);
+
+               /* Return to Idel state with RX and TX off. */
+
+               return status;
+       }
+
+       /*  should send command status event */
+       bthci_EventCommandStatus(padapter,
+                       OGF_TESTING_COMMANDS,
+                       HCI_AMP_TEST_COMMAND,
+                       status);
+
+       /* The HCI_AMP_Start Test Event shall be generated when the */
+       /* HCI_AMP_Test_Command has completed and the first data is ready to be sent */
+       /* or received. */
+
+       {
+               u8 localBuf[5] = "";
+               struct packet_irp_hcievent_data *PPacketIrpEvent;
+
+               RTPRINT(FIOCTL, (IOCTL_BT_EVENT|IOCTL_BT_LOGO), (" HCI_AMP_Start Test Event \n"));
+               PPacketIrpEvent = (struct packet_irp_hcievent_data *)(&localBuf[0]);
+               PPacketIrpEvent->EventCode = HCI_EVENT_AMP_START_TEST;
+               PPacketIrpEvent->Length = 2;
+
+               PPacketIrpEvent->Data[0] = status;
+               PPacketIrpEvent->Data[1] = pBtHciInfo->TestScenario ;
+
+               bthci_IndicateEvent(padapter, PPacketIrpEvent, 4);
+
+               /* Return to Idel state with RX and TX off. */
+       }
+
+       if (pBtHciInfo->TestScenario == 0x01) {
+               /*
+                       When in a transmitter test scenario and the frames/bursts count have been
+                       transmitted the HCI_AMP_Test_End event shall be sent.
+               */
+               mod_timer(&pBTInfo->BTTestSendPacketTimer,
+                         jiffies + msecs_to_jiffies(50));
+               RTPRINT(FIOCTL, (IOCTL_BT_EVENT|IOCTL_BT_LOGO), ("TX Single Test \n"));
+       } else if (pBtHciInfo->TestScenario == 0x02) {
+               rtl8723a_check_bssid(padapter, false);
+               RTPRINT(FIOCTL, (IOCTL_BT_EVENT|IOCTL_BT_LOGO), ("Receive Frame Test \n"));
+       }
+
+       return status;
+}
+
+static enum hci_status
+bthci_CmdEnableAMPReceiverReports(struct rtw_adapter *padapter,
+                                 struct packet_irp_hcicmd_data *pHciCmd)
+{
+       enum hci_status status = HCI_STATUS_SUCCESS;
+       struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
+       struct bt_hci_info *pBtHciInfo = &pBTInfo->BtHciInfo;
+
+       if (!pBtHciInfo->bInTestMode) {
+               status = HCI_STATUS_CMD_DISALLOW;
+               /* send command complete event here when all data are received. */
+               {
+                       u8 localBuf[6] = "";
+                       u8 *pRetPar;
+                       u8 len = 0;
+                       struct packet_irp_hcievent_data *PPacketIrpEvent;
+
+                       PPacketIrpEvent = (struct packet_irp_hcievent_data *)(&localBuf[0]);
+
+                       len += bthci_CommandCompleteHeader(&localBuf[0],
+                               OGF_TESTING_COMMANDS,
+                               HCI_ENABLE_AMP_RECEIVER_REPORTS,
+                               status);
+
+                       /*  Return parameters starts from here */
+                       pRetPar = &PPacketIrpEvent->Data[len];
+                       pRetPar[0] = status;            /* status */
+                       len += 1;
+                       PPacketIrpEvent->Length = len;
+
+                       bthci_IndicateEvent(padapter, PPacketIrpEvent, len+2);
+               }
+               return status;
+       }
+
+       pBtHciInfo->bTestNeedReport = *((u8 *)pHciCmd->Data);
+       pBtHciInfo->TestReportInterval = (*((u8 *)pHciCmd->Data+2));
+
+       bthci_EventAMPReceiverReport(padapter, 0x00);
+
+       /* send command complete event here when all data are received. */
+       {
+               u8 localBuf[6] = "";
+               u8 *pRetPar;
+               u8 len = 0;
+               struct packet_irp_hcievent_data *PPacketIrpEvent;
+
+               PPacketIrpEvent = (struct packet_irp_hcievent_data *)(&localBuf[0]);
+
+               len += bthci_CommandCompleteHeader(&localBuf[0],
+                       OGF_TESTING_COMMANDS,
+                       HCI_ENABLE_AMP_RECEIVER_REPORTS,
+                       status);
+
+               /*  Return parameters starts from here */
+               pRetPar = &PPacketIrpEvent->Data[len];
+               pRetPar[0] = status;            /* status */
+               len += 1;
+               PPacketIrpEvent->Length = len;
+
+               bthci_IndicateEvent(padapter, PPacketIrpEvent, len+2);
+       }
+
+       return status;
+}
+
+static enum hci_status
+bthci_CmdHostBufferSize(struct rtw_adapter *padapter,
+                       struct packet_irp_hcicmd_data *pHciCmd)
+{
+       struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
+       struct bt_mgnt *pBtMgnt = &pBTInfo->BtMgnt;
+       struct packet_irp_hcievent_data *PPacketIrpEvent;
+       enum hci_status status = HCI_STATUS_SUCCESS;
+       u8 localBuf[6] = "";
+       u8 *pRetPar;
+       u8 len = 0;
+
+       pBTInfo->BtAsocEntry[pBtMgnt->CurrentConnectEntryNum].ACLPacketsData.ACLDataPacketLen = *((u16 *)pHciCmd->Data);
+       pBTInfo->BtAsocEntry[pBtMgnt->CurrentConnectEntryNum].SyncDataPacketLen = *((u8 *)(pHciCmd->Data+2));
+       pBTInfo->BtAsocEntry[pBtMgnt->CurrentConnectEntryNum].TotalNumACLDataPackets = *((u16 *)(pHciCmd->Data+3));
+       pBTInfo->BtAsocEntry[pBtMgnt->CurrentConnectEntryNum].TotalSyncNumDataPackets = *((u16 *)(pHciCmd->Data+5));
+
+       /* send command complete event here when all data are received. */
+       PPacketIrpEvent = (struct packet_irp_hcievent_data *)(&localBuf[0]);
+
+       len += bthci_CommandCompleteHeader(&localBuf[0],
+               OGF_SET_EVENT_MASK_COMMAND,
+               HCI_HOST_BUFFER_SIZE,
+               status);
+
+       /*  Return parameters starts from here */
+       pRetPar = &PPacketIrpEvent->Data[len];
+       pRetPar[0] = status;            /* status */
+       len += 1;
+       PPacketIrpEvent->Length = len;
+
+       bthci_IndicateEvent(padapter, PPacketIrpEvent, len+2);
+
+       return status;
+}
+
+static enum hci_status
+bthci_UnknownCMD(struct rtw_adapter *padapter, struct packet_irp_hcicmd_data *pHciCmd)
+{
+       enum hci_status status = HCI_STATUS_UNKNOW_HCI_CMD;
+       struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
+       struct bt_dgb *pBtDbg = &pBTInfo->BtDbg;
+
+       pBtDbg->dbgHciInfo.hciCmdCntUnknown++;
+       bthci_EventCommandStatus(padapter,
+                       (u8)pHciCmd->OGF,
+                       pHciCmd->OCF,
+                       status);
+
+       return status;
+}
+
+static enum hci_status
+bthci_HandleOGFInformationalParameters(struct rtw_adapter *padapter,
+                                      struct packet_irp_hcicmd_data *pHciCmd)
+{
+       enum hci_status status = HCI_STATUS_SUCCESS;
+
+       switch (pHciCmd->OCF) {
+       case HCI_READ_LOCAL_VERSION_INFORMATION:
+               RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_READ_LOCAL_VERSION_INFORMATION\n"));
+               status = bthci_CmdReadLocalVersionInformation(padapter);
+               break;
+       case HCI_READ_LOCAL_SUPPORTED_COMMANDS:
+               RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_READ_LOCAL_SUPPORTED_COMMANDS\n"));
+               status = bthci_CmdReadLocalSupportedCommands(padapter);
+               break;
+       case HCI_READ_LOCAL_SUPPORTED_FEATURES:
+               RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_READ_LOCAL_SUPPORTED_FEATURES\n"));
+               status = bthci_CmdReadLocalSupportedFeatures(padapter);
+               break;
+       case HCI_READ_BUFFER_SIZE:
+               RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_READ_BUFFER_SIZE\n"));
+               status = bthci_CmdReadBufferSize(padapter);
+               break;
+       case HCI_READ_DATA_BLOCK_SIZE:
+               RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_READ_DATA_BLOCK_SIZE\n"));
+               status = bthci_CmdReadDataBlockSize(padapter);
+               break;
+       default:
+               RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("bthci_HandleOGFInformationalParameters(), Unknown case = 0x%x\n", pHciCmd->OCF));
+               RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_UNKNOWN_COMMAND\n"));
+               status = bthci_UnknownCMD(padapter, pHciCmd);
+               break;
+       }
+       return status;
+}
+
+static enum hci_status
+bthci_HandleOGFSetEventMaskCMD(struct rtw_adapter *padapter,
+                              struct packet_irp_hcicmd_data *pHciCmd)
+{
+       enum hci_status status = HCI_STATUS_SUCCESS;
+
+       switch (pHciCmd->OCF) {
+       case HCI_SET_EVENT_MASK:
+               RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_SET_EVENT_MASK\n"));
+               status = bthci_CmdSetEventMask(padapter, pHciCmd);
+               break;
+       case HCI_RESET:
+               RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_RESET\n"));
+               status = bthci_CmdReset(padapter, true);
+               break;
+       case HCI_READ_CONNECTION_ACCEPT_TIMEOUT:
+               RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_READ_CONNECTION_ACCEPT_TIMEOUT\n"));
+               status = bthci_CmdReadConnectionAcceptTimeout(padapter);
+               break;
+       case HCI_SET_EVENT_FILTER:
+               RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_SET_EVENT_FILTER\n"));
+               break;
+       case HCI_WRITE_CONNECTION_ACCEPT_TIMEOUT:
+               RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_WRITE_CONNECTION_ACCEPT_TIMEOUT\n"));
+               status = bthci_CmdWriteConnectionAcceptTimeout(padapter, pHciCmd);
+               break;
+       case HCI_READ_PAGE_TIMEOUT:
+               RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_READ_PAGE_TIMEOUT\n"));
+               status = bthci_CmdReadPageTimeout(padapter, pHciCmd);
+               break;
+       case HCI_WRITE_PAGE_TIMEOUT:
+               RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_WRITE_PAGE_TIMEOUT\n"));
+               status = bthci_CmdWritePageTimeout(padapter, pHciCmd);
+               break;
+       case HCI_HOST_NUMBER_OF_COMPLETED_PACKETS:
+               RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_HOST_NUMBER_OF_COMPLETED_PACKETS\n"));
+               break;
+       case HCI_READ_LINK_SUPERVISION_TIMEOUT:
+               RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_READ_LINK_SUPERVISION_TIMEOUT\n"));
+               status = bthci_CmdReadLinkSupervisionTimeout(padapter, pHciCmd);
+               break;
+       case HCI_WRITE_LINK_SUPERVISION_TIMEOUT:
+               RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_WRITE_LINK_SUPERVISION_TIMEOUT\n"));
+               status = bthci_CmdWriteLinkSupervisionTimeout(padapter, pHciCmd);
+               break;
+       case HCI_ENHANCED_FLUSH:
+               RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_ENHANCED_FLUSH\n"));
+               status = bthci_CmdEnhancedFlush(padapter, pHciCmd);
+               break;
+       case HCI_READ_LOGICAL_LINK_ACCEPT_TIMEOUT:
+               RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_READ_LOGICAL_LINK_ACCEPT_TIMEOUT\n"));
+               status = bthci_CmdReadLogicalLinkAcceptTimeout(padapter, pHciCmd);
+               break;
+       case HCI_WRITE_LOGICAL_LINK_ACCEPT_TIMEOUT:
+               RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_WRITE_LOGICAL_LINK_ACCEPT_TIMEOUT\n"));
+               status = bthci_CmdWriteLogicalLinkAcceptTimeout(padapter, pHciCmd);
+               break;
+       case HCI_SET_EVENT_MASK_PAGE_2:
+               RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_SET_EVENT_MASK_PAGE_2\n"));
+               status = bthci_CmdSetEventMaskPage2(padapter, pHciCmd);
+               break;
+       case HCI_READ_LOCATION_DATA:
+               RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_READ_LOCATION_DATA\n"));
+               status = bthci_CmdReadLocationData(padapter, pHciCmd);
+               break;
+       case HCI_WRITE_LOCATION_DATA:
+               RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_WRITE_LOCATION_DATA\n"));
+               status = bthci_CmdWriteLocationData(padapter, pHciCmd);
+               break;
+       case HCI_READ_FLOW_CONTROL_MODE:
+               RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_READ_FLOW_CONTROL_MODE\n"));
+               status = bthci_CmdReadFlowControlMode(padapter, pHciCmd);
+               break;
+       case HCI_WRITE_FLOW_CONTROL_MODE:
+               RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_WRITE_FLOW_CONTROL_MODE\n"));
+               status = bthci_CmdWriteFlowControlMode(padapter, pHciCmd);
+               break;
+       case HCI_READ_BEST_EFFORT_FLUSH_TIMEOUT:
+               RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_READ_BEST_EFFORT_FLUSH_TIMEOUT\n"));
+               status = bthci_CmdReadBestEffortFlushTimeout(padapter, pHciCmd);
+               break;
+       case HCI_WRITE_BEST_EFFORT_FLUSH_TIMEOUT:
+               RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_WRITE_BEST_EFFORT_FLUSH_TIMEOUT\n"));
+               status = bthci_CmdWriteBestEffortFlushTimeout(padapter, pHciCmd);
+               break;
+       case HCI_SHORT_RANGE_MODE:
+               RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_SHORT_RANGE_MODE\n"));
+               status = bthci_CmdShortRangeMode(padapter, pHciCmd);
+               break;
+       case HCI_HOST_BUFFER_SIZE:
+               RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_HOST_BUFFER_SIZE\n"));
+               status = bthci_CmdHostBufferSize(padapter, pHciCmd);
+               break;
+       default:
+               RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("bthci_HandleOGFSetEventMaskCMD(), Unknown case = 0x%x\n", pHciCmd->OCF));
+               RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_UNKNOWN_COMMAND\n"));
+               status = bthci_UnknownCMD(padapter, pHciCmd);
+               break;
+       }
+       return status;
+}
+
+static enum hci_status
+bthci_HandleOGFStatusParameters(struct rtw_adapter *padapter,
+                               struct packet_irp_hcicmd_data *pHciCmd)
+{
+       enum hci_status status = HCI_STATUS_SUCCESS;
+
+       switch (pHciCmd->OCF) {
+       case HCI_READ_FAILED_CONTACT_COUNTER:
+               RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_READ_FAILED_CONTACT_COUNTER\n"));
+               status = bthci_CmdReadFailedContactCounter(padapter, pHciCmd);
+               break;
+       case HCI_RESET_FAILED_CONTACT_COUNTER:
+               RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_RESET_FAILED_CONTACT_COUNTER\n"));
+               status = bthci_CmdResetFailedContactCounter(padapter, pHciCmd);
+               break;
+       case HCI_READ_LINK_QUALITY:
+               RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_READ_LINK_QUALITY\n"));
+               status = bthci_CmdReadLinkQuality(padapter, pHciCmd);
+               break;
+       case HCI_READ_RSSI:
+               RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_READ_RSSI\n"));
+               break;
+       case HCI_READ_LOCAL_AMP_INFO:
+               RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_READ_LOCAL_AMP_INFO\n"));
+               status = bthci_CmdReadLocalAMPInfo(padapter);
+               break;
+       case HCI_READ_LOCAL_AMP_ASSOC:
+               RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_READ_LOCAL_AMP_ASSOC\n"));
+               status = bthci_CmdReadLocalAMPAssoc(padapter, pHciCmd);
+               break;
+       case HCI_WRITE_REMOTE_AMP_ASSOC:
+               RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_WRITE_REMOTE_AMP_ASSOC\n"));
+               status = bthci_CmdWriteRemoteAMPAssoc(padapter, pHciCmd);
+               break;
+       default:
+               RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("bthci_HandleOGFStatusParameters(), Unknown case = 0x%x\n", pHciCmd->OCF));
+               RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_UNKNOWN_COMMAND\n"));
+               status = bthci_UnknownCMD(padapter, pHciCmd);
+               break;
+       }
+       return status;
+}
+
+static enum hci_status
+bthci_HandleOGFLinkControlCMD(struct rtw_adapter *padapter,
+                             struct packet_irp_hcicmd_data *pHciCmd)
+{
+       enum hci_status status = HCI_STATUS_SUCCESS;
+
+       switch (pHciCmd->OCF) {
+       case HCI_CREATE_PHYSICAL_LINK:
+               RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_CREATE_PHYSICAL_LINK\n"));
+               status = bthci_CmdCreatePhysicalLink(padapter, pHciCmd);
+               break;
+       case HCI_ACCEPT_PHYSICAL_LINK:
+               RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_ACCEPT_PHYSICAL_LINK\n"));
+               status = bthci_CmdAcceptPhysicalLink(padapter, pHciCmd);
+               break;
+       case HCI_DISCONNECT_PHYSICAL_LINK:
+               RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_DISCONNECT_PHYSICAL_LINK\n"));
+               status = bthci_CmdDisconnectPhysicalLink(padapter, pHciCmd);
+               break;
+       case HCI_CREATE_LOGICAL_LINK:
+               RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_CREATE_LOGICAL_LINK\n"));
+               status = bthci_CmdCreateLogicalLink(padapter, pHciCmd);
+               break;
+       case HCI_ACCEPT_LOGICAL_LINK:
+               RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_ACCEPT_LOGICAL_LINK\n"));
+               status = bthci_CmdAcceptLogicalLink(padapter, pHciCmd);
+               break;
+       case HCI_DISCONNECT_LOGICAL_LINK:
+               RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_DISCONNECT_LOGICAL_LINK\n"));
+               status = bthci_CmdDisconnectLogicalLink(padapter, pHciCmd);
+               break;
+       case HCI_LOGICAL_LINK_CANCEL:
+               RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_LOGICAL_LINK_CANCEL\n"));
+               status = bthci_CmdLogicalLinkCancel(padapter, pHciCmd);
+               break;
+       case HCI_FLOW_SPEC_MODIFY:
+               RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_FLOW_SPEC_MODIFY\n"));
+               status = bthci_CmdFlowSpecModify(padapter, pHciCmd);
+               break;
+       default:
+               RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("bthci_HandleOGFLinkControlCMD(), Unknown case = 0x%x\n", pHciCmd->OCF));
+               RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_UNKNOWN_COMMAND\n"));
+               status = bthci_UnknownCMD(padapter, pHciCmd);
+               break;
+       }
+       return status;
+}
+
+static enum hci_status
+bthci_HandleOGFTestingCMD(struct rtw_adapter *padapter,
+                         struct packet_irp_hcicmd_data *pHciCmd)
+{
+       enum hci_status status = HCI_STATUS_SUCCESS;
+       switch (pHciCmd->OCF) {
+       case HCI_ENABLE_DEVICE_UNDER_TEST_MODE:
+               RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_ENABLE_DEVICE_UNDER_TEST_MODE\n"));
+               bthci_CmdEnableDeviceUnderTestMode(padapter, pHciCmd);
+               break;
+       case HCI_AMP_TEST_END:
+               RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_AMP_TEST_END\n"));
+               bthci_CmdAMPTestEnd(padapter, pHciCmd);
+               break;
+       case HCI_AMP_TEST_COMMAND:
+               RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_AMP_TEST_COMMAND\n"));
+               bthci_CmdAMPTestCommand(padapter, pHciCmd);
+               break;
+       case HCI_ENABLE_AMP_RECEIVER_REPORTS:
+               RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_ENABLE_AMP_RECEIVER_REPORTS\n"));
+               bthci_CmdEnableAMPReceiverReports(padapter, pHciCmd);
+               break;
+       default:
+               RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_UNKNOWN_COMMAND\n"));
+               status = bthci_UnknownCMD(padapter, pHciCmd);
+               break;
+       }
+       return status;
+}
+
+static enum hci_status
+bthci_HandleOGFExtension(struct rtw_adapter *padapter,
+                        struct packet_irp_hcicmd_data *pHciCmd)
+{
+       enum hci_status status = HCI_STATUS_SUCCESS;
+       switch (pHciCmd->OCF) {
+       case HCI_SET_ACL_LINK_DATA_FLOW_MODE:
+               RTPRINT(FIOCTL, IOCTL_BT_HCICMD_EXT, ("HCI_SET_ACL_LINK_DATA_FLOW_MODE\n"));
+               status = bthci_CmdSetACLLinkDataFlowMode(padapter, pHciCmd);
+               break;
+       case HCI_SET_ACL_LINK_STATUS:
+               RTPRINT(FIOCTL, IOCTL_BT_HCICMD_EXT, ("HCI_SET_ACL_LINK_STATUS\n"));
+               status = bthci_CmdSetACLLinkStatus(padapter, pHciCmd);
+               break;
+       case HCI_SET_SCO_LINK_STATUS:
+               RTPRINT(FIOCTL, IOCTL_BT_HCICMD_EXT, ("HCI_SET_SCO_LINK_STATUS\n"));
+               status = bthci_CmdSetSCOLinkStatus(padapter, pHciCmd);
+               break;
+       case HCI_SET_RSSI_VALUE:
+               RTPRINT(FIOCTL, IOCTL_BT_EVENT_PERIODICAL, ("HCI_SET_RSSI_VALUE\n"));
+               status = bthci_CmdSetRSSIValue(padapter, pHciCmd);
+               break;
+       case HCI_SET_CURRENT_BLUETOOTH_STATUS:
+               RTPRINT(FIOCTL, IOCTL_BT_HCICMD_EXT, ("HCI_SET_CURRENT_BLUETOOTH_STATUS\n"));
+               status = bthci_CmdSetCurrentBluetoothStatus(padapter, pHciCmd);
+               break;
+       /* The following is for RTK8723 */
+
+       case HCI_EXTENSION_VERSION_NOTIFY:
+               RTPRINT(FIOCTL, IOCTL_BT_HCICMD_EXT, ("HCI_EXTENSION_VERSION_NOTIFY\n"));
+               status = bthci_CmdExtensionVersionNotify(padapter, pHciCmd);
+               break;
+       case HCI_LINK_STATUS_NOTIFY:
+               RTPRINT(FIOCTL, IOCTL_BT_HCICMD_EXT, ("HCI_LINK_STATUS_NOTIFY\n"));
+               status = bthci_CmdLinkStatusNotify(padapter, pHciCmd);
+               break;
+       case HCI_BT_OPERATION_NOTIFY:
+               RTPRINT(FIOCTL, IOCTL_BT_HCICMD_EXT, ("HCI_BT_OPERATION_NOTIFY\n"));
+               status = bthci_CmdBtOperationNotify(padapter, pHciCmd);
+               break;
+       case HCI_ENABLE_WIFI_SCAN_NOTIFY:
+               RTPRINT(FIOCTL, IOCTL_BT_HCICMD_EXT, ("HCI_ENABLE_WIFI_SCAN_NOTIFY\n"));
+               status = bthci_CmdEnableWifiScanNotify(padapter, pHciCmd);
+               break;
+
+       /* The following is for IVT */
+       case HCI_WIFI_CURRENT_CHANNEL:
+               RTPRINT(FIOCTL, IOCTL_BT_HCICMD_EXT, ("HCI_WIFI_CURRENT_CHANNEL\n"));
+               status = bthci_CmdWIFICurrentChannel(padapter, pHciCmd);
+               break;
+       case HCI_WIFI_CURRENT_BANDWIDTH:
+               RTPRINT(FIOCTL, IOCTL_BT_HCICMD_EXT, ("HCI_WIFI_CURRENT_BANDWIDTH\n"));
+               status = bthci_CmdWIFICurrentBandwidth(padapter, pHciCmd);
+               break;
+       case HCI_WIFI_CONNECTION_STATUS:
+               RTPRINT(FIOCTL, IOCTL_BT_HCICMD_EXT, ("HCI_WIFI_CONNECTION_STATUS\n"));
+               status = bthci_CmdWIFIConnectionStatus(padapter, pHciCmd);
+               break;
+
+       default:
+               RTPRINT(FIOCTL, IOCTL_BT_HCICMD_EXT, ("HCI_UNKNOWN_COMMAND\n"));
+               status = bthci_UnknownCMD(padapter, pHciCmd);
+               break;
+       }
+       return status;
+}
+
+static void
+bthci_StateStarting(struct rtw_adapter *padapter,
+                   enum hci_state_with_cmd StateCmd, u8 EntryNum)
+{
+       struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
+       struct bt_mgnt *pBtMgnt = &pBTInfo->BtMgnt;
+
+       RTPRINT(FIOCTL, IOCTL_STATE, ("[BT state], [Starting], "));
+       switch (StateCmd) {
+       case STATE_CMD_CONNECT_ACCEPT_TIMEOUT:
+               RTPRINT(FIOCTL, IOCTL_STATE, ("STATE_CMD_CONNECT_ACCEPT_TIMEOUT\n"));
+               pBTInfo->BtAsocEntry[EntryNum].PhysLinkCompleteStatus = HCI_STATUS_CONNECT_ACCEPT_TIMEOUT;
+               pBtMgnt->bNeedNotifyAMPNoCap = true;
+               BTHCI_DisconnectPeer(padapter, EntryNum);
+               break;
+       case STATE_CMD_DISCONNECT_PHY_LINK:
+               RTPRINT(FIOCTL, IOCTL_STATE, ("STATE_CMD_DISCONNECT_PHY_LINK\n"));
+
+               bthci_EventDisconnectPhyLinkComplete(padapter,
+               HCI_STATUS_SUCCESS,
+               pBTInfo->BtAsocEntry[EntryNum].PhyLinkDisconnectReason,
+               EntryNum);
+
+               del_timer_sync(&pBTInfo->BTHCIJoinTimeoutTimer);
+
+               pBTInfo->BtAsocEntry[EntryNum].PhysLinkCompleteStatus = HCI_STATUS_UNKNOW_CONNECT_ID;
+
+               BTHCI_DisconnectPeer(padapter, EntryNum);
+               break;
+       case STATE_CMD_MAC_START_COMPLETE:
+               RTPRINT(FIOCTL, IOCTL_STATE, ("STATE_CMD_MAC_START_COMPLETE\n"));
+               if (pBTInfo->BtAsocEntry[EntryNum].AMPRole == AMP_BTAP_CREATOR)
+                       bthci_EventChannelSelected(padapter, EntryNum);
+               break;
+       default:
+               RTPRINT(FIOCTL, IOCTL_STATE, ("State command(%d) is Wrong !!!\n", StateCmd));
+               break;
+       }
+}
+
+static void
+bthci_StateConnecting(struct rtw_adapter *padapter,
+                     enum hci_state_with_cmd StateCmd, u8 EntryNum)
+{
+       struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
+       struct bt_mgnt *pBtMgnt = &pBTInfo->BtMgnt;
+
+       RTPRINT(FIOCTL, IOCTL_STATE, ("[BT state], [Connecting], "));
+       switch (StateCmd) {
+       case STATE_CMD_CONNECT_ACCEPT_TIMEOUT:
+               RTPRINT(FIOCTL, IOCTL_STATE, ("STATE_CMD_CONNECT_ACCEPT_TIMEOUT\n"));
+               pBTInfo->BtAsocEntry[EntryNum].PhysLinkCompleteStatus = HCI_STATUS_CONNECT_ACCEPT_TIMEOUT;
+               pBtMgnt->bNeedNotifyAMPNoCap = true;
+               BTHCI_DisconnectPeer(padapter, EntryNum);
+               break;
+       case STATE_CMD_MAC_CONNECT_COMPLETE:
+               RTPRINT(FIOCTL, IOCTL_STATE, ("STATE_CMD_MAC_CONNECT_COMPLETE\n"));
+
+               if (pBTInfo->BtAsocEntry[EntryNum].AMPRole == AMP_BTAP_JOINER) {
+                       RT_TRACE(_module_rtl871x_security_c_, _drv_info_,
+                                "StateConnecting\n");
+               }
+               break;
+       case STATE_CMD_DISCONNECT_PHY_LINK:
+               RTPRINT(FIOCTL, IOCTL_STATE, ("STATE_CMD_DISCONNECT_PHY_LINK\n"));
+
+               bthci_EventDisconnectPhyLinkComplete(padapter,
+               HCI_STATUS_SUCCESS,
+               pBTInfo->BtAsocEntry[EntryNum].PhyLinkDisconnectReason,
+               EntryNum);
+
+               pBTInfo->BtAsocEntry[EntryNum].PhysLinkCompleteStatus = HCI_STATUS_UNKNOW_CONNECT_ID;
+
+               del_timer_sync(&pBTInfo->BTHCIJoinTimeoutTimer);
+
+               BTHCI_DisconnectPeer(padapter, EntryNum);
+
+               break;
+       case STATE_CMD_MAC_CONNECT_CANCEL_INDICATE:
+               RTPRINT(FIOCTL, IOCTL_STATE, ("STATE_CMD_MAC_CONNECT_CANCEL_INDICATE\n"));
+               pBTInfo->BtAsocEntry[EntryNum].PhysLinkCompleteStatus = HCI_STATUS_CONTROLLER_BUSY;
+               /*  Because this state cmd is caused by the BTHCI_EventAMPStatusChange(), */
+               /*  we don't need to send event in the following BTHCI_DisconnectPeer() again. */
+               pBtMgnt->bNeedNotifyAMPNoCap = false;
+               BTHCI_DisconnectPeer(padapter, EntryNum);
+               break;
+       default:
+               RTPRINT(FIOCTL, IOCTL_STATE, ("State command(%d) is Wrong !!!\n", StateCmd));
+               break;
+       }
+}
+
+static void
+bthci_StateConnected(struct rtw_adapter *padapter,
+                    enum hci_state_with_cmd StateCmd, u8 EntryNum)
+{
+/*PMGNT_INFO pMgntInfo = &padapter->MgntInfo; */
+       struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
+       struct bt_mgnt *pBtMgnt = &pBTInfo->BtMgnt;
+       u8 i;
+       u16 logicHandle = 0;
+
+       RTPRINT(FIOCTL, IOCTL_STATE, ("[BT state], [Connected], "));
+       switch (StateCmd) {
+       case STATE_CMD_DISCONNECT_PHY_LINK:
+               RTPRINT(FIOCTL, IOCTL_STATE, ("STATE_CMD_DISCONNECT_PHY_LINK\n"));
+
+               /* When we are trying to disconnect the phy link, we should disconnect log link first, */
+               for (i = 0; i < MAX_LOGICAL_LINK_NUM; i++) {
+                       if (pBTInfo->BtAsocEntry[EntryNum].LogLinkCmdData->BtLogLinkhandle != 0) {
+                               logicHandle = pBTInfo->BtAsocEntry[EntryNum].LogLinkCmdData->BtLogLinkhandle;
+
+                               bthci_EventDisconnectLogicalLinkComplete(padapter, HCI_STATUS_SUCCESS,
+                                       logicHandle, pBTInfo->BtAsocEntry[EntryNum].PhyLinkDisconnectReason);
+
+                               pBTInfo->BtAsocEntry[EntryNum].LogLinkCmdData->BtLogLinkhandle = 0;
+                       }
+               }
+
+               bthci_EventDisconnectPhyLinkComplete(padapter,
+               HCI_STATUS_SUCCESS,
+               pBTInfo->BtAsocEntry[EntryNum].PhyLinkDisconnectReason,
+               EntryNum);
+
+               del_timer_sync(&pBTInfo->BTHCIJoinTimeoutTimer);
+
+               BTHCI_DisconnectPeer(padapter, EntryNum);
+               break;
+
+       case STATE_CMD_MAC_DISCONNECT_INDICATE:
+               RTPRINT(FIOCTL, IOCTL_STATE, ("STATE_CMD_MAC_DISCONNECT_INDICATE\n"));
+
+               bthci_EventDisconnectPhyLinkComplete(padapter,
+               HCI_STATUS_SUCCESS,
+               /*  TODO: Remote Host not local host */
+               HCI_STATUS_CONNECT_TERMINATE_LOCAL_HOST,
+               EntryNum);
+               BTHCI_DisconnectPeer(padapter, EntryNum);
+
+               break;
+       case STATE_CMD_ENTER_STATE:
+               RTPRINT(FIOCTL, IOCTL_STATE, ("STATE_CMD_ENTER_STATE\n"));
+
+               if (pBtMgnt->bBTConnectInProgress) {
+                       pBtMgnt->bBTConnectInProgress = false;
+                       RTPRINT(FIOCTL, IOCTL_STATE, ("[BT Flag], BT Connect in progress OFF!!\n"));
+               }
+               pBTInfo->BtAsocEntry[EntryNum].BtCurrentState = HCI_STATE_CONNECTED;
+               pBTInfo->BtAsocEntry[EntryNum].b4waySuccess = true;
+               pBtMgnt->bStartSendSupervisionPkt = true;
+
+               /*  for rate adaptive */
+
+               rtl8723a_update_ramask(padapter,
+                                      MAX_FW_SUPPORT_MACID_NUM-1-EntryNum, 0);
+
+               HalSetBrateCfg23a(padapter, padapter->mlmepriv.cur_network.network.SupportedRates);
+               BTDM_SetFwChnlInfo(padapter, RT_MEDIA_CONNECT);
+               break;
+       default:
+               RTPRINT(FIOCTL, IOCTL_STATE, ("State command(%d) is Wrong !!!\n", StateCmd));
+               break;
+       }
+}
+
+static void
+bthci_StateAuth(struct rtw_adapter *padapter, enum hci_state_with_cmd StateCmd,
+               u8 EntryNum)
+{
+       struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
+       struct bt_mgnt *pBtMgnt = &pBTInfo->BtMgnt;
+
+       RTPRINT(FIOCTL, IOCTL_STATE, ("[BT state], [Authenticating], "));
+       switch (StateCmd) {
+       case STATE_CMD_CONNECT_ACCEPT_TIMEOUT:
+               RTPRINT(FIOCTL, IOCTL_STATE, ("STATE_CMD_CONNECT_ACCEPT_TIMEOUT\n"));
+               pBTInfo->BtAsocEntry[EntryNum].PhysLinkCompleteStatus = HCI_STATUS_CONNECT_ACCEPT_TIMEOUT;
+               pBtMgnt->bNeedNotifyAMPNoCap = true;
+               BTHCI_DisconnectPeer(padapter, EntryNum);
+               break;
+       case STATE_CMD_DISCONNECT_PHY_LINK:
+               RTPRINT(FIOCTL, IOCTL_STATE, ("STATE_CMD_DISCONNECT_PHY_LINK\n"));
+               bthci_EventDisconnectPhyLinkComplete(padapter,
+               HCI_STATUS_SUCCESS,
+               pBTInfo->BtAsocEntry[EntryNum].PhyLinkDisconnectReason,
+               EntryNum);
+
+               pBTInfo->BtAsocEntry[EntryNum].PhysLinkCompleteStatus = HCI_STATUS_UNKNOW_CONNECT_ID;
+
+               del_timer_sync(&pBTInfo->BTHCIJoinTimeoutTimer);
+
+               BTHCI_DisconnectPeer(padapter, EntryNum);
+               break;
+       case STATE_CMD_4WAY_FAILED:
+               RTPRINT(FIOCTL, IOCTL_STATE, ("STATE_CMD_4WAY_FAILED\n"));
+
+               pBTInfo->BtAsocEntry[EntryNum].PhysLinkCompleteStatus = HCI_STATUS_AUTH_FAIL;
+               pBtMgnt->bNeedNotifyAMPNoCap = true;
+
+               BTHCI_DisconnectPeer(padapter, EntryNum);
+
+               del_timer_sync(&pBTInfo->BTHCIJoinTimeoutTimer);
+               break;
+       case STATE_CMD_4WAY_SUCCESSED:
+               RTPRINT(FIOCTL, IOCTL_STATE, ("STATE_CMD_4WAY_SUCCESSED\n"));
+
+               bthci_EventPhysicalLinkComplete(padapter, HCI_STATUS_SUCCESS, EntryNum, INVALID_PL_HANDLE);
+
+               del_timer_sync(&pBTInfo->BTHCIJoinTimeoutTimer);
+
+               BTHCI_SM_WITH_INFO(padapter, HCI_STATE_CONNECTED, STATE_CMD_ENTER_STATE, EntryNum);
+               break;
+       default:
+               RTPRINT(FIOCTL, IOCTL_STATE, ("State command(%d) is Wrong !!!\n", StateCmd));
+               break;
+       }
+}
+
+static void
+bthci_StateDisconnecting(struct rtw_adapter *padapter,
+                        enum hci_state_with_cmd StateCmd, u8 EntryNum)
+{
+       struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
+       struct bt_mgnt *pBtMgnt = &pBTInfo->BtMgnt;
+
+       RTPRINT(FIOCTL, IOCTL_STATE, ("[BT state], [Disconnecting], "));
+       switch (StateCmd) {
+       case STATE_CMD_MAC_CONNECT_CANCEL_INDICATE:
+               RTPRINT(FIOCTL, IOCTL_STATE, ("STATE_CMD_MAC_CONNECT_CANCEL_INDICATE\n"));
+               if (pBTInfo->BtAsocEntry[EntryNum].bNeedPhysLinkCompleteEvent) {
+                       bthci_EventPhysicalLinkComplete(padapter,
+                               pBTInfo->BtAsocEntry[EntryNum].PhysLinkCompleteStatus,
+                               EntryNum, INVALID_PL_HANDLE);
+               }
+
+               if (pBtMgnt->bBTConnectInProgress) {
+                       pBtMgnt->bBTConnectInProgress = false;
+                       RTPRINT(FIOCTL, IOCTL_STATE, ("[BT Flag], BT Connect in progress OFF!!\n"));
+               }
+
+               BTHCI_SM_WITH_INFO(padapter, HCI_STATE_DISCONNECTED, STATE_CMD_ENTER_STATE, EntryNum);
+               break;
+       case STATE_CMD_DISCONNECT_PHY_LINK:
+               RTPRINT(FIOCTL, IOCTL_STATE, ("STATE_CMD_DISCONNECT_PHY_LINK\n"));
+
+               bthci_EventDisconnectPhyLinkComplete(padapter,
+               HCI_STATUS_SUCCESS,
+               pBTInfo->BtAsocEntry[EntryNum].PhyLinkDisconnectReason,
+               EntryNum);
+
+               del_timer_sync(&pBTInfo->BTHCIJoinTimeoutTimer);
+
+               BTHCI_DisconnectPeer(padapter, EntryNum);
+               break;
+       default:
+               RTPRINT(FIOCTL, IOCTL_STATE, ("State command(%d) is Wrong !!!\n", StateCmd));
+               break;
+       }
+}
+
+static void
+bthci_StateDisconnected(struct rtw_adapter *padapter,
+                       enum hci_state_with_cmd StateCmd, u8 EntryNum)
+{
+/*PMGNT_INFO pMgntInfo = &padapter->MgntInfo; */
+       struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
+       struct bt_hci_info *pBtHciInfo = &pBTInfo->BtHciInfo;
+       struct bt_mgnt *pBtMgnt = &pBTInfo->BtMgnt;
+
+       RTPRINT(FIOCTL, IOCTL_STATE, ("[BT state], [Disconnected], "));
+       switch (StateCmd) {
+       case STATE_CMD_CREATE_PHY_LINK:
+       case STATE_CMD_ACCEPT_PHY_LINK:
+               if (StateCmd == STATE_CMD_CREATE_PHY_LINK)
+                       RTPRINT(FIOCTL, IOCTL_STATE, ("STATE_CMD_CREATE_PHY_LINK\n"));
+               else
+                       RTPRINT(FIOCTL, IOCTL_STATE, ("STATE_CMD_ACCEPT_PHY_LINK\n"));
+
+               RTPRINT(FIOCTL, IOCTL_STATE, ("[BT PS], Disable IPS and LPS\n"));
+               ips_leave23a(padapter);
+               LPS_Leave23a(padapter);
+
+               pBtMgnt->bPhyLinkInProgress = true;
+               pBtMgnt->BTCurrentConnectType = BT_DISCONNECT;
+               pBtMgnt->CurrentBTConnectionCnt++;
+               RTPRINT(FIOCTL, IOCTL_STATE, ("[BT Flag], CurrentBTConnectionCnt = %d\n",
+                       pBtMgnt->CurrentBTConnectionCnt));
+               pBtMgnt->BtOperationOn = true;
+               RTPRINT(FIOCTL, IOCTL_STATE, ("[BT Flag], Bt Operation ON!! CurrentConnectEntryNum = %d\n",
+                       pBtMgnt->CurrentConnectEntryNum));
+
+               if (pBtMgnt->bBTConnectInProgress) {
+                       bthci_EventPhysicalLinkComplete(padapter, HCI_STATUS_CONTROLLER_BUSY, INVALID_ENTRY_NUM, pBtMgnt->BtCurrentPhyLinkhandle);
+                       bthci_RemoveEntryByEntryNum(padapter, EntryNum);
+                       return;
+               }
+
+               if (StateCmd == STATE_CMD_CREATE_PHY_LINK)
+                       pBTInfo->BtAsocEntry[EntryNum].AMPRole = AMP_BTAP_CREATOR;
+               else
+                       pBTInfo->BtAsocEntry[EntryNum].AMPRole = AMP_BTAP_JOINER;
+
+               /*  1. MAC not yet in selected channel */
+               while (check_fwstate(&padapter->mlmepriv, WIFI_ASOC_STATE|WIFI_SITE_MONITOR)) {
+                       RTPRINT(FIOCTL, IOCTL_STATE, ("Scan/Roaming/Wifi Link is in Progress, wait 200 ms\n"));
+                       mdelay(200);
+               }
+               /*  2. MAC already in selected channel */
+               RTPRINT(FIOCTL, IOCTL_STATE, ("Channel is Ready\n"));
+               mod_timer(&pBTInfo->BTHCIJoinTimeoutTimer,
+                         jiffies + msecs_to_jiffies(pBtHciInfo->ConnAcceptTimeout));
+
+               pBTInfo->BtAsocEntry[EntryNum].bNeedPhysLinkCompleteEvent = true;
+               break;
+       case STATE_CMD_DISCONNECT_PHY_LINK:
+               RTPRINT(FIOCTL, IOCTL_STATE, ("STATE_CMD_DISCONNECT_PHY_LINK\n"));
+
+               del_timer_sync(&pBTInfo->BTHCIJoinTimeoutTimer);
+
+               bthci_EventDisconnectPhyLinkComplete(padapter,
+               HCI_STATUS_SUCCESS,
+               pBTInfo->BtAsocEntry[EntryNum].PhyLinkDisconnectReason,
+               EntryNum);
+
+               if (pBTInfo->BtAsocEntry[EntryNum].bNeedPhysLinkCompleteEvent) {
+                       bthci_EventPhysicalLinkComplete(padapter,
+                               HCI_STATUS_UNKNOW_CONNECT_ID,
+                               EntryNum, INVALID_PL_HANDLE);
+               }
+
+               if (pBtMgnt->bBTConnectInProgress) {
+                       pBtMgnt->bBTConnectInProgress = false;
+                       RTPRINT(FIOCTL, IOCTL_STATE, ("[BT Flag], BT Connect in progress OFF!!\n"));
+               }
+               BTHCI_SM_WITH_INFO(padapter, HCI_STATE_DISCONNECTED, STATE_CMD_ENTER_STATE, EntryNum);
+               bthci_RemoveEntryByEntryNum(padapter, EntryNum);
+               break;
+       case STATE_CMD_ENTER_STATE:
+               RTPRINT(FIOCTL, IOCTL_STATE, ("STATE_CMD_ENTER_STATE\n"));
+               break;
+       default:
+               RTPRINT(FIOCTL, IOCTL_STATE, ("State command(%d) is Wrong !!!\n", StateCmd));
+               break;
+       }
+}
+
+void BTHCI_EventParse(struct rtw_adapter *padapter, void *pEvntData, u32 dataLen)
+{
+}
+
+u8 BTHCI_HsConnectionEstablished(struct rtw_adapter *padapter)
+{
+       u8 bBtConnectionExist = false;
+       struct bt_30info *pBtinfo = GET_BT_INFO(padapter);
+       u8 i;
+
+       for (i = 0; i < MAX_BT_ASOC_ENTRY_NUM; i++) {
+               if (pBtinfo->BtAsocEntry[i].b4waySuccess) {
+                       bBtConnectionExist = true;
+                       break;
+               }
+       }
+
+/*RTPRINT(FIOCTL, IOCTL_STATE, (" BTHCI_HsConnectionEstablished(), connection exist = %d\n", bBtConnectionExist)); */
+
+       return bBtConnectionExist;
+}
+
+static u8
+BTHCI_CheckProfileExist(struct rtw_adapter *padapter,
+                       enum bt_traffic_mode_profile Profile)
+{
+       struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
+       struct bt_mgnt *pBtMgnt = &pBTInfo->BtMgnt;
+       u8 IsPRofile = false;
+       u8 i = 0;
+
+       for (i = 0; i < pBtMgnt->ExtConfig.NumberOfHandle; i++) {
+               if (pBtMgnt->ExtConfig.linkInfo[i].TrafficProfile == Profile) {
+                       IsPRofile = true;
+                       break;
+               }
+       }
+
+       return IsPRofile;
+}
+
+void BTHCI_UpdateBTProfileRTKToMoto(struct rtw_adapter *padapter)
+{
+       struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
+       struct bt_mgnt *pBtMgnt = &pBTInfo->BtMgnt;
+       u8 i = 0;
+
+       pBtMgnt->ExtConfig.NumberOfSCO = 0;
+
+       for (i = 0; i < pBtMgnt->ExtConfig.NumberOfHandle; i++) {
+               pBtMgnt->ExtConfig.linkInfo[i].TrafficProfile = BT_PROFILE_NONE;
+
+               if (pBtMgnt->ExtConfig.linkInfo[i].BTProfile == BT_PROFILE_SCO)
+                       pBtMgnt->ExtConfig.NumberOfSCO++;
+
+               pBtMgnt->ExtConfig.linkInfo[i].TrafficProfile = pBtMgnt->ExtConfig.linkInfo[i].BTProfile;
+               switch (pBtMgnt->ExtConfig.linkInfo[i].TrafficProfile) {
+               case BT_PROFILE_SCO:
+                       break;
+               case BT_PROFILE_PAN:
+                       pBtMgnt->ExtConfig.linkInfo[i].IncomingTrafficMode = BT_MOTOR_EXT_BE;
+                       pBtMgnt->ExtConfig.linkInfo[i].OutgoingTrafficMode = BT_MOTOR_EXT_BE;
+                       break;
+               case BT_PROFILE_A2DP:
+                       pBtMgnt->ExtConfig.linkInfo[i].IncomingTrafficMode = BT_MOTOR_EXT_GULB;
+                       pBtMgnt->ExtConfig.linkInfo[i].OutgoingTrafficMode = BT_MOTOR_EXT_GULB;
+                       break;
+               case BT_PROFILE_HID:
+                       pBtMgnt->ExtConfig.linkInfo[i].IncomingTrafficMode = BT_MOTOR_EXT_GUL;
+                       pBtMgnt->ExtConfig.linkInfo[i].OutgoingTrafficMode = BT_MOTOR_EXT_BE;
+                       break;
+               default:
+                       break;
+               }
+       }
+
+       RTPRINT(FBT, BT_TRACE, ("[DM][BT], RTK, NumberOfHandle = %d, NumberOfSCO = %d\n",
+               pBtMgnt->ExtConfig.NumberOfHandle, pBtMgnt->ExtConfig.NumberOfSCO));
+}
+
+void BTHCI_WifiScanNotify(struct rtw_adapter *padapter, u8 scanType)
+{
+       struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
+       struct bt_mgnt *pBtMgnt = &pBTInfo->BtMgnt;
+
+       if (pBtMgnt->ExtConfig.bEnableWifiScanNotify)
+               bthci_EventExtWifiScanNotify(padapter, scanType);
+}
+
+void
+BTHCI_StateMachine(
+       struct rtw_adapter *padapter,
+       u8              StateToEnter,
+       enum hci_state_with_cmd         StateCmd,
+       u8              EntryNum
+       )
+{
+       struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
+       struct bt_mgnt *pBtMgnt = &pBTInfo->BtMgnt;
+
+       if (EntryNum == 0xff) {
+               RTPRINT(FIOCTL, IOCTL_STATE, (" StateMachine, error EntryNum = 0x%x \n", EntryNum));
+               return;
+       }
+       RTPRINT(FIOCTL, IOCTL_STATE, (" StateMachine, EntryNum = 0x%x, CurrentState = 0x%x, BtNextState = 0x%x,  StateCmd = 0x%x , StateToEnter = 0x%x\n",
+               EntryNum, pBTInfo->BtAsocEntry[EntryNum].BtCurrentState, pBTInfo->BtAsocEntry[EntryNum].BtNextState, StateCmd, StateToEnter));
+
+       if (pBTInfo->BtAsocEntry[EntryNum].BtNextState & StateToEnter) {
+               pBTInfo->BtAsocEntry[EntryNum].BtCurrentState = StateToEnter;
+
+               switch (StateToEnter) {
+               case HCI_STATE_STARTING:
+                       pBTInfo->BtAsocEntry[EntryNum].BtNextState = HCI_STATE_DISCONNECTING | HCI_STATE_CONNECTING;
+                       bthci_StateStarting(padapter, StateCmd, EntryNum);
+                       break;
+               case HCI_STATE_CONNECTING:
+                       pBTInfo->BtAsocEntry[EntryNum].BtNextState = HCI_STATE_CONNECTING | HCI_STATE_DISCONNECTING | HCI_STATE_AUTHENTICATING;
+                       bthci_StateConnecting(padapter, StateCmd, EntryNum);
+                       break;
+               case HCI_STATE_AUTHENTICATING:
+                       pBTInfo->BtAsocEntry[EntryNum].BtNextState = HCI_STATE_DISCONNECTING | HCI_STATE_CONNECTED;
+                       bthci_StateAuth(padapter, StateCmd, EntryNum);
+                       break;
+               case HCI_STATE_CONNECTED:
+                       pBTInfo->BtAsocEntry[EntryNum].BtNextState = HCI_STATE_CONNECTED | HCI_STATE_DISCONNECTING;
+                       bthci_StateConnected(padapter, StateCmd, EntryNum);
+                       break;
+               case HCI_STATE_DISCONNECTING:
+                       pBTInfo->BtAsocEntry[EntryNum].BtNextState = HCI_STATE_DISCONNECTED | HCI_STATE_DISCONNECTING;
+                       bthci_StateDisconnecting(padapter, StateCmd, EntryNum);
+                       break;
+               case HCI_STATE_DISCONNECTED:
+                       pBTInfo->BtAsocEntry[EntryNum].BtNextState = HCI_STATE_DISCONNECTED | HCI_STATE_STARTING | HCI_STATE_CONNECTING;
+                       bthci_StateDisconnected(padapter, StateCmd, EntryNum);
+                       break;
+               default:
+                       RTPRINT(FIOCTL, IOCTL_STATE, (" StateMachine, Unknown state to enter!!!\n"));
+                       break;
+               }
+       } else {
+               RTPRINT(FIOCTL, IOCTL_STATE, (" StateMachine, Wrong state to enter\n"));
+       }
+
+       /*  20100325 Joseph: Disable/Enable IPS/LPS according to BT status. */
+       if (!pBtMgnt->bBTConnectInProgress && !pBtMgnt->BtOperationOn) {
+               RTPRINT(FIOCTL, IOCTL_STATE, ("[BT PS], ips_enter23a()\n"));
+               ips_enter23a(padapter);
+       }
+}
+
+void BTHCI_DisconnectPeer(struct rtw_adapter *padapter, u8 EntryNum)
+{
+       struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
+       struct bt_mgnt *pBtMgnt = &pBTInfo->BtMgnt;
+
+       RTPRINT(FIOCTL, IOCTL_BT_HCICMD, (" BTHCI_DisconnectPeer()\n"));
+
+       BTHCI_SM_WITH_INFO(padapter, HCI_STATE_DISCONNECTING, STATE_CMD_MAC_CONNECT_CANCEL_INDICATE, EntryNum);
+
+       if (pBTInfo->BtAsocEntry[EntryNum].bUsed) {
+/*BTPKT_SendDeauthentication(padapter, pBTInfo->BtAsocEntry[EntryNum].BTRemoteMACAddr, unspec_reason); not porting yet */
+       }
+
+       if (pBtMgnt->bBTConnectInProgress) {
+               pBtMgnt->bBTConnectInProgress = false;
+               RTPRINT(FIOCTL, IOCTL_STATE, ("[BT Flag], BT Connect in progress OFF!!\n"));
+       }
+
+       bthci_RemoveEntryByEntryNum(padapter, EntryNum);
+
+       if (pBtMgnt->bNeedNotifyAMPNoCap) {
+               RTPRINT(FIOCTL, IOCTL_STATE, ("[BT AMPStatus], set to invalid in BTHCI_DisconnectPeer()\n"));
+               BTHCI_EventAMPStatusChange(padapter, AMP_STATUS_NO_CAPACITY_FOR_BT);
+       }
+}
+
+void BTHCI_EventNumOfCompletedDataBlocks(struct rtw_adapter *padapter)
+{
+/*PMGNT_INFO pMgntInfo = &padapter->MgntInfo; */
+       struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
+       struct bt_hci_info *pBtHciInfo = &pBTInfo->BtHciInfo;
+       u8 localBuf[TmpLocalBufSize] = "";
+       u8 *pRetPar, *pTriple;
+       u8 len = 0, i, j, handleNum = 0;
+       struct packet_irp_hcievent_data *PPacketIrpEvent;
+       u16 *pu2Temp, *pPackets, *pHandle, *pDblocks;
+       u8 sent = 0;
+
+       PPacketIrpEvent = (struct packet_irp_hcievent_data *)(&localBuf[0]);
+
+       if (!(pBtHciInfo->BTEventMaskPage2 & EMP2_HCI_EVENT_NUM_OF_COMPLETE_DATA_BLOCKS)) {
+               RTPRINT(FIOCTL, IOCTL_BT_EVENT, ("[BT event], Num Of Completed DataBlocks, Ignore to send NumOfCompletedDataBlocksEvent due to event mask page 2\n"));
+               return;
+       }
+
+       /*  Return parameters starts from here */
+       pRetPar = &PPacketIrpEvent->Data[0];
+       pTriple = &pRetPar[3];
+       for (j = 0; j < MAX_BT_ASOC_ENTRY_NUM; j++) {
+
+               for (i = 0; i < MAX_LOGICAL_LINK_NUM; i++) {
+                       if (pBTInfo->BtAsocEntry[j].LogLinkCmdData[i].BtLogLinkhandle) {
+                               handleNum++;
+                               pHandle = (u16 *)&pTriple[0];   /*  Handle[i] */
+                               pPackets = (u16 *)&pTriple[2];  /*  Num_Of_Completed_Packets[i] */
+                               pDblocks = (u16 *)&pTriple[4];  /*  Num_Of_Completed_Blocks[i] */
+                               *pHandle = pBTInfo->BtAsocEntry[j].LogLinkCmdData[i].BtLogLinkhandle;
+                               *pPackets = (u16)pBTInfo->BtAsocEntry[j].LogLinkCmdData[i].TxPacketCount;
+                               *pDblocks = (u16)pBTInfo->BtAsocEntry[j].LogLinkCmdData[i].TxPacketCount;
+                               if (pBTInfo->BtAsocEntry[j].LogLinkCmdData[i].TxPacketCount) {
+                                       sent = 1;
+                                       RTPRINT(FIOCTL, IOCTL_BT_EVENT_DETAIL,
+                                               ("[BT event], Num Of Completed DataBlocks, Handle = 0x%x, Num_Of_Completed_Packets = 0x%x, Num_Of_Completed_Blocks = 0x%x\n",
+                                       *pHandle, *pPackets, *pDblocks));
+                               }
+                               pBTInfo->BtAsocEntry[j].LogLinkCmdData[i].TxPacketCount = 0;
+                               len += 6;
+                               pTriple += len;
+                       }
+               }
+       }
+
+       pRetPar[2] = handleNum;                         /*  Number_of_Handles */
+       len += 1;
+       pu2Temp = (u16 *)&pRetPar[0];
+       *pu2Temp = BTTotalDataBlockNum;
+       len += 2;
+
+       PPacketIrpEvent->EventCode = HCI_EVENT_NUM_OF_COMPLETE_DATA_BLOCKS;
+       PPacketIrpEvent->Length = len;
+       if (handleNum && sent)
+               bthci_IndicateEvent(padapter, PPacketIrpEvent, len+2);
+}
+
+void BTHCI_EventAMPStatusChange(struct rtw_adapter *padapter, u8 AMP_Status)
+{
+       struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
+       struct bt_mgnt *pBtMgnt = &pBTInfo->BtMgnt;
+       struct packet_irp_hcievent_data *PPacketIrpEvent;
+       u8 len = 0;
+       u8 localBuf[7] = "";
+       u8 *pRetPar;
+
+       if (AMP_Status == AMP_STATUS_NO_CAPACITY_FOR_BT) {
+               pBtMgnt->BTNeedAMPStatusChg = true;
+               pBtMgnt->bNeedNotifyAMPNoCap = false;
+
+               BTHCI_DisconnectAll(padapter);
+       } else if (AMP_Status == AMP_STATUS_FULL_CAPACITY_FOR_BT) {
+               pBtMgnt->BTNeedAMPStatusChg = false;
+       }
+
+       PPacketIrpEvent = (struct packet_irp_hcievent_data *)(&localBuf[0]);
+       /*  Return parameters starts from here */
+       pRetPar = &PPacketIrpEvent->Data[0];
+
+       pRetPar[0] = 0; /*  Status */
+       len += 1;
+       pRetPar[1] = AMP_Status;        /*  AMP_Status */
+       len += 1;
+
+       PPacketIrpEvent->EventCode = HCI_EVENT_AMP_STATUS_CHANGE;
+       PPacketIrpEvent->Length = len;
+       if (bthci_IndicateEvent(padapter, PPacketIrpEvent, len+2) == RT_STATUS_SUCCESS)
+               RTPRINT(FIOCTL, (IOCTL_BT_EVENT|IOCTL_STATE), ("[BT event], AMP Status Change, AMP_Status = %d\n", AMP_Status));
+}
+
+void BTHCI_DisconnectAll(struct rtw_adapter *padapter)
+{
+       struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
+       u8 i;
+
+       RTPRINT(FIOCTL, IOCTL_STATE, (" DisconnectALL()\n"));
+
+       for (i = 0; i < MAX_BT_ASOC_ENTRY_NUM; i++) {
+               if (pBTInfo->BtAsocEntry[i].b4waySuccess) {
+                       BTHCI_SM_WITH_INFO(padapter, HCI_STATE_CONNECTED, STATE_CMD_DISCONNECT_PHY_LINK, i);
+               } else if (pBTInfo->BtAsocEntry[i].bUsed) {
+                       if (pBTInfo->BtAsocEntry[i].BtCurrentState == HCI_STATE_CONNECTING) {
+                               BTHCI_SM_WITH_INFO(padapter, HCI_STATE_CONNECTING, STATE_CMD_MAC_CONNECT_CANCEL_INDICATE, i);
+                       } else if (pBTInfo->BtAsocEntry[i].BtCurrentState == HCI_STATE_DISCONNECTING) {
+                               BTHCI_SM_WITH_INFO(padapter, HCI_STATE_DISCONNECTING, STATE_CMD_MAC_CONNECT_CANCEL_INDICATE, i);
+                       }
+               }
+       }
+}
+
+enum hci_status
+BTHCI_HandleHCICMD(
+       struct rtw_adapter *padapter,
+       struct packet_irp_hcicmd_data *pHciCmd
+       )
+{
+       enum hci_status status = HCI_STATUS_SUCCESS;
+       struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
+       struct bt_dgb *pBtDbg = &pBTInfo->BtDbg;
+
+       RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("\n"));
+       RTPRINT(FIOCTL, (IOCTL_BT_HCICMD_DETAIL|IOCTL_BT_LOGO), ("HCI Command start, OGF = 0x%x, OCF = 0x%x, Length = 0x%x\n",
+               pHciCmd->OGF, pHciCmd->OCF, pHciCmd->Length));
+       if (pHciCmd->Length) {
+               RTPRINT_DATA(FIOCTL, (IOCTL_BT_HCICMD_DETAIL|IOCTL_BT_LOGO), "HCI Command, Hex Data :\n",
+                       &pHciCmd->Data[0], pHciCmd->Length);
+       }
+       if (pHciCmd->OGF == OGF_EXTENSION) {
+               if (pHciCmd->OCF == HCI_SET_RSSI_VALUE)
+                       RTPRINT(FIOCTL, IOCTL_BT_EVENT_PERIODICAL, ("[BT cmd], "));
+               else
+                       RTPRINT(FIOCTL, IOCTL_BT_HCICMD_EXT, ("[BT cmd], "));
+       } else {
+               RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("[BT cmd], "));
+       }
+
+       pBtDbg->dbgHciInfo.hciCmdCnt++;
+
+       switch (pHciCmd->OGF) {
+       case LINK_CONTROL_COMMANDS:
+               status = bthci_HandleOGFLinkControlCMD(padapter, pHciCmd);
+               break;
+       case HOLD_MODE_COMMAND:
+               break;
+       case OGF_SET_EVENT_MASK_COMMAND:
+               status = bthci_HandleOGFSetEventMaskCMD(padapter, pHciCmd);
+               break;
+       case OGF_INFORMATIONAL_PARAMETERS:
+               status = bthci_HandleOGFInformationalParameters(padapter, pHciCmd);
+               break;
+       case OGF_STATUS_PARAMETERS:
+               status = bthci_HandleOGFStatusParameters(padapter, pHciCmd);
+               break;
+       case OGF_TESTING_COMMANDS:
+               status = bthci_HandleOGFTestingCMD(padapter, pHciCmd);
+               break;
+       case OGF_EXTENSION:
+               status = bthci_HandleOGFExtension(padapter, pHciCmd);
+               break;
+       default:
+               RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI Command(), Unknown OGF = 0x%x\n", pHciCmd->OGF));
+               RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_UNKNOWN_COMMAND\n"));
+               status = bthci_UnknownCMD(padapter, pHciCmd);
+               break;
+       }
+       RTPRINT(FIOCTL, IOCTL_BT_HCICMD_DETAIL, ("HCI Command execution end!!\n"));
+
+       return status;
+}
+
+/*  ===== End of sync from SD7 driver COMMOM/bt_hci.c ===== */
+
+static const char *const BtStateString[] = {
+       "BT_DISABLED",
+       "BT_NO_CONNECTION",
+       "BT_CONNECT_IDLE",
+       "BT_INQ_OR_PAG",
+       "BT_ACL_ONLY_BUSY",
+       "BT_SCO_ONLY_BUSY",
+       "BT_ACL_SCO_BUSY",
+       "BT_ACL_INQ_OR_PAG",
+       "BT_STATE_NOT_DEFINED"
+};
+
+/*  ===== Below this line is sync from SD7 driver HAL/BTCoexist/HalBtc87231Ant.c ===== */
+
+static void btdm_SetFwIgnoreWlanAct(struct rtw_adapter *padapter, u8 bEnable)
+{
+       struct hal_data_8723a *pHalData = GET_HAL_DATA(padapter);
+       u8 H2C_Parameter[1] = {0};
+
+       if (bEnable) {
+               RTPRINT(FBT, BT_TRACE, ("[BTCoex], BT Ignore Wlan_Act !!\n"));
+               H2C_Parameter[0] |= BIT(0);             /*  function enable */
+               pHalData->bt_coexist.bFWCoexistAllOff = false;
+       } else {
+               RTPRINT(FBT, BT_TRACE, ("[BTCoex], BT don't ignore Wlan_Act !!\n"));
+       }
+
+       RTPRINT(FBT, BT_TRACE, ("[BTCoex], set FW for BT Ignore Wlan_Act, write 0x25 = 0x%02x\n",
+               H2C_Parameter[0]));
+
+       FillH2CCmd(padapter, BT_IGNORE_WLAN_ACT_EID, 1, H2C_Parameter);
+}
+
+static void btdm_NotifyFwScan(struct rtw_adapter *padapter, u8 scanType)
+{
+       u8 H2C_Parameter[1] = {0};
+
+       if (scanType == true)
+               H2C_Parameter[0] = 0x1;
+
+       RTPRINT(FBT, BT_TRACE, ("[BTCoex], Notify FW for wifi scan, write 0x3b = 0x%02x\n",
+               H2C_Parameter[0]));
+
+       FillH2CCmd(padapter, 0x3b, 1, H2C_Parameter);
+}
+
+static void btdm_1AntSetPSMode(struct rtw_adapter *padapter,
+                              u8 enable, u8 smartps, u8 mode)
+{
+       struct pwrctrl_priv *pwrctrl;
+
+       RTPRINT(FBT, BT_TRACE, ("[BTCoex], Current LPS(%s, %d), smartps =%d\n", enable == true?"ON":"OFF", mode, smartps));
+
+       pwrctrl = &padapter->pwrctrlpriv;
+
+       if (enable == true) {
+               rtw_set_ps_mode23a(padapter, PS_MODE_MIN, smartps, mode);
+       } else {
+               rtw_set_ps_mode23a(padapter, PS_MODE_ACTIVE, 0, 0);
+               LPS_RF_ON_check23a(padapter, 100);
+       }
+}
+
+static void btdm_1AntTSFSwitch(struct rtw_adapter *padapter, u8 enable)
+{
+       u8 oldVal, newVal;
+
+       oldVal = rtl8723au_read8(padapter, 0x550);
+
+       if (enable)
+               newVal = oldVal | EN_BCN_FUNCTION;
+       else
+               newVal = oldVal & ~EN_BCN_FUNCTION;
+
+       if (oldVal != newVal)
+               rtl8723au_write8(padapter, 0x550, newVal);
+}
+
+static u8 btdm_Is1AntPsTdmaStateChange(struct rtw_adapter *padapter)
+{
+       struct hal_data_8723a *pHalData = GET_HAL_DATA(padapter);
+       struct btdm_8723a_1ant *pBtdm8723 = &pHalData->bt_coexist.halCoex8723.btdm1Ant;
+
+       if ((pBtdm8723->bPrePsTdmaOn != pBtdm8723->bCurPsTdmaOn) ||
+               (pBtdm8723->prePsTdma != pBtdm8723->curPsTdma))
+               return true;
+       else
+               return false;
+}
+
+/*  Before enter TDMA, make sure Power Saving is enable! */
+static void
+btdm_1AntPsTdma(
+       struct rtw_adapter *padapter,
+       u8 bTurnOn,
+       u8 type
+       )
+{
+       struct hal_data_8723a *pHalData = GET_HAL_DATA(padapter);
+       struct btdm_8723a_1ant *pBtdm8723 = &pHalData->bt_coexist.halCoex8723.btdm1Ant;
+
+       pBtdm8723->bCurPsTdmaOn = bTurnOn;
+       pBtdm8723->curPsTdma = type;
+       if (bTurnOn) {
+               switch (type) {
+               case 1: /*  A2DP Level-1 or FTP/OPP */
+               default:
+                       if (btdm_Is1AntPsTdmaStateChange(padapter)) {
+                               /*  wide duration for WiFi */
+                               BTDM_SetFw3a(padapter, 0xd3, 0x1a, 0x1a, 0x0, 0x58);
+                       }
+                       break;
+               case 2: /*  A2DP Level-2 */
+                       if (btdm_Is1AntPsTdmaStateChange(padapter)) {
+                               /*  normal duration for WiFi */
+                               BTDM_SetFw3a(padapter, 0xd3, 0x12, 0x12, 0x0, 0x58);
+                       }
+                       break;
+               case 3: /*  BT FTP/OPP */
+                       if (btdm_Is1AntPsTdmaStateChange(padapter)) {
+                               /*  normal duration for WiFi */
+                               BTDM_SetFw3a(padapter, 0xd3, 0x30, 0x03, 0x10, 0x58);
+
+                       }
+                       break;
+               case 4: /*  for wifi scan & BT is connected */
+                       if (btdm_Is1AntPsTdmaStateChange(padapter)) {
+                               /*  protect 3 beacons in 3-beacon period & no Tx pause at BT slot */
+                               BTDM_SetFw3a(padapter, 0x93, 0x15, 0x03, 0x14, 0x0);
+                       }
+                       break;
+               case 5: /*  for WiFi connected-busy & BT is Non-Connected-Idle */
+                       if (btdm_Is1AntPsTdmaStateChange(padapter)) {
+                               /*  SCO mode, Ant fixed at WiFi, WLAN_Act toggle */
+                               BTDM_SetFw3a(padapter, 0x61, 0x15, 0x03, 0x31, 0x00);
+                       }
+                       break;
+               case 9: /*  ACL high-retry type - 2 */
+                       if (btdm_Is1AntPsTdmaStateChange(padapter)) {
+                               /*  narrow duration for WiFi */
+                               BTDM_SetFw3a(padapter, 0xd3, 0xa, 0xa, 0x0, 0x58); /* narrow duration for WiFi */
+                       }
+                       break;
+               case 10: /*  for WiFi connect idle & BT ACL busy or WiFi Connected-Busy & BT is Inquiry */
+                       if (btdm_Is1AntPsTdmaStateChange(padapter))
+                               BTDM_SetFw3a(padapter, 0x13, 0xa, 0xa, 0x0, 0x40);
+                       break;
+               case 11: /*  ACL high-retry type - 3 */
+                       if (btdm_Is1AntPsTdmaStateChange(padapter)) {
+                               /*  narrow duration for WiFi */
+                               BTDM_SetFw3a(padapter, 0xd3, 0x05, 0x05, 0x00, 0x58);
+                       }
+                       break;
+               case 12: /*  for WiFi Connected-Busy & BT is Connected-Idle */
+                       if (btdm_Is1AntPsTdmaStateChange(padapter)) {
+                               /*  Allow High-Pri BT */
+                               BTDM_SetFw3a(padapter, 0xeb, 0x0a, 0x03, 0x31, 0x18);
+                       }
+                       break;
+               case 20: /*  WiFi only busy , TDMA mode for power saving */
+                       if (btdm_Is1AntPsTdmaStateChange(padapter))
+                               BTDM_SetFw3a(padapter, 0x13, 0x25, 0x25, 0x00, 0x00);
+                       break;
+               case 27: /*  WiFi DHCP/Site Survey & BT SCO busy */
+                       if (btdm_Is1AntPsTdmaStateChange(padapter))
+                               BTDM_SetFw3a(padapter, 0xa3, 0x25, 0x03, 0x31, 0x98);
+                       break;
+               case 28: /*  WiFi DHCP/Site Survey & BT idle */
+                       if (btdm_Is1AntPsTdmaStateChange(padapter))
+                               BTDM_SetFw3a(padapter, 0x69, 0x25, 0x03, 0x31, 0x00);
+                       break;
+               case 29: /*  WiFi DHCP/Site Survey & BT ACL busy */
+                       if (btdm_Is1AntPsTdmaStateChange(padapter)) {
+                               BTDM_SetFw3a(padapter, 0xeb, 0x1a, 0x1a, 0x01, 0x18);
+                               rtl8723au_write32(padapter, 0x6c0, 0x5afa5afa);
+                               rtl8723au_write32(padapter, 0x6c4, 0x5afa5afa);
+                       }
+                       break;
+               case 30: /*  WiFi idle & BT Inquiry */
+                       if (btdm_Is1AntPsTdmaStateChange(padapter))
+                               BTDM_SetFw3a(padapter, 0x93, 0x15, 0x03, 0x14, 0x00);
+                       break;
+               case 31:  /*  BT HID */
+                       if (btdm_Is1AntPsTdmaStateChange(padapter))
+                               BTDM_SetFw3a(padapter, 0xd3, 0x1a, 0x1a, 0x00, 0x58);
+                       break;
+               case 32:  /*  BT SCO & Inquiry */
+                       if (btdm_Is1AntPsTdmaStateChange(padapter))
+                               BTDM_SetFw3a(padapter, 0xab, 0x0a, 0x03, 0x11, 0x98);
+                       break;
+               case 33:  /*  BT SCO & WiFi site survey */
+                       if (btdm_Is1AntPsTdmaStateChange(padapter))
+                               BTDM_SetFw3a(padapter, 0xa3, 0x25, 0x03, 0x30, 0x98);
+                       break;
+               case 34:  /*  BT HID & WiFi site survey */
+                       if (btdm_Is1AntPsTdmaStateChange(padapter))
+                               BTDM_SetFw3a(padapter, 0xd3, 0x1a, 0x1a, 0x00, 0x18);
+                       break;
+               case 35:  /*  BT HID & WiFi Connecting */
+                       if (btdm_Is1AntPsTdmaStateChange(padapter))
+                               BTDM_SetFw3a(padapter, 0xe3, 0x1a, 0x1a, 0x00, 0x18);
+                       break;
+               }
+       } else {
+               /*  disable PS-TDMA */
+               switch (type) {
+               case 8:
+                       if (btdm_Is1AntPsTdmaStateChange(padapter)) {
+                               /*  Antenna control by PTA, 0x870 = 0x310 */
+                               BTDM_SetFw3a(padapter, 0x8, 0x0, 0x0, 0x0, 0x0);
+                       }
+                       break;
+               case 0:
+               default:
+                       if (btdm_Is1AntPsTdmaStateChange(padapter)) {
+                               /*  Antenna control by PTA, 0x870 = 0x310 */
+                               BTDM_SetFw3a(padapter, 0x0, 0x0, 0x0, 0x8, 0x0);
+                       }
+                       /*  Switch Antenna to BT */
+                       rtl8723au_write16(padapter, 0x860, 0x210);
+                       RTPRINT(FBT, BT_TRACE, ("[BTCoex], 0x860 = 0x210, Switch Antenna to BT\n"));
+                       break;
+               case 9:
+                       if (btdm_Is1AntPsTdmaStateChange(padapter)) {
+                               /*  Antenna control by PTA, 0x870 = 0x310 */
+                               BTDM_SetFw3a(padapter, 0x0, 0x0, 0x0, 0x8, 0x0);
+                       }
+                       /*  Switch Antenna to WiFi */
+                       rtl8723au_write16(padapter, 0x860, 0x110);
+                       RTPRINT(FBT, BT_TRACE, ("[BTCoex], 0x860 = 0x110, Switch Antenna to WiFi\n"));
+                       break;
+               }
+       }
+
+       RTPRINT(FBT, BT_TRACE, ("[BTCoex], Current TDMA(%s, %d)\n",
+               pBtdm8723->bCurPsTdmaOn?"ON":"OFF", pBtdm8723->curPsTdma));
+
+       /*  update pre state */
+       pBtdm8723->bPrePsTdmaOn = pBtdm8723->bCurPsTdmaOn;
+       pBtdm8723->prePsTdma = pBtdm8723->curPsTdma;
+}
+
+static void
+_btdm_1AntSetPSTDMA(struct rtw_adapter *padapter, u8 bPSEn, u8 smartps,
+                   u8 psOption, u8 bTDMAOn, u8 tdmaType)
+{
+       struct pwrctrl_priv *pwrctrl;
+       struct hal_data_8723a *pHalData;
+       struct btdm_8723a_1ant *pBtdm8723;
+       u8 psMode;
+       u8 bSwitchPS;
+
+       if (!check_fwstate(&padapter->mlmepriv, WIFI_STATION_STATE) &&
+           (get_fwstate(&padapter->mlmepriv) != WIFI_NULL_STATE)) {
+               btdm_1AntPsTdma(padapter, bTDMAOn, tdmaType);
+               return;
+       }
+       psOption &= ~BIT(0);
+
+       RTPRINT(FBT, BT_TRACE,
+               ("[BTCoex], Set LPS(%s, %d) TDMA(%s, %d)\n",
+               bPSEn == true?"ON":"OFF", psOption,
+               bTDMAOn == true?"ON":"OFF", tdmaType));
+
+       pwrctrl = &padapter->pwrctrlpriv;
+       pHalData = GET_HAL_DATA(padapter);
+       pBtdm8723 = &pHalData->bt_coexist.halCoex8723.btdm1Ant;
+
+       if (bPSEn) {
+               if (pBtdm8723->bWiFiHalt) {
+                       RTPRINT(FBT, BT_TRACE, ("[BTCoex], Enable PS Fail, WiFi in Halt!!\n"));
+                       return;
+               }
+
+               if (pwrctrl->bInSuspend) {
+                       RTPRINT(FBT, BT_TRACE, ("[BTCoex], Enable PS Fail, WiFi in Suspend!!\n"));
+                       return;
+               }
+
+               if (padapter->bDriverStopped) {
+                       RTPRINT(FBT, BT_TRACE, ("[BTCoex], Enable PS Fail, WiFi driver stopped!!\n"));
+                       return;
+               }
+
+               if (padapter->bSurpriseRemoved) {
+                       RTPRINT(FBT, BT_TRACE, ("[BTCoex], Enable PS Fail, WiFi Surprise Removed!!\n"));
+                       return;
+               }
+
+               psMode = PS_MODE_MIN;
+       } else {
+               psMode = PS_MODE_ACTIVE;
+               psOption = 0;
+       }
+
+       if (psMode != pwrctrl->pwr_mode) {
+               bSwitchPS = true;
+       } else if (psMode != PS_MODE_ACTIVE) {
+               if (psOption != pwrctrl->bcn_ant_mode)
+                       bSwitchPS = true;
+               else if (smartps != pwrctrl->smart_ps)
+                       bSwitchPS = true;
+               else
+                       bSwitchPS = false;
+       } else {
+               bSwitchPS = false;
+       }
+
+       if (bSwitchPS) {
+               /*  disable TDMA */
+               if (pBtdm8723->bCurPsTdmaOn) {
+                       if (!bTDMAOn) {
+                               btdm_1AntPsTdma(padapter, false, tdmaType);
+                       } else {
+                               if (!rtl8723a_BT_enabled(padapter) ||
+                                   (pHalData->bt_coexist.halCoex8723.c2hBtInfo == BT_INFO_STATE_NO_CONNECTION) ||
+                                   (pHalData->bt_coexist.halCoex8723.c2hBtInfo == BT_INFO_STATE_CONNECT_IDLE) ||
+                                   (tdmaType == 29))
+                                       btdm_1AntPsTdma(padapter, false, 9);
+                               else
+                                       btdm_1AntPsTdma(padapter, false, 0);
+                       }
+               }
+
+               /*  change Power Save State */
+               btdm_1AntSetPSMode(padapter, bPSEn, smartps, psOption);
+       }
+
+       btdm_1AntPsTdma(padapter, bTDMAOn, tdmaType);
+}
+
+static void
+btdm_1AntSetPSTDMA(struct rtw_adapter *padapter, u8 bPSEn,
+                  u8 psOption, u8 bTDMAOn, u8 tdmaType)
+{
+       _btdm_1AntSetPSTDMA(padapter, bPSEn, 0, psOption, bTDMAOn, tdmaType);
+}
+
+static void btdm_1AntWifiParaAdjust(struct rtw_adapter *padapter, u8 bEnable)
+{
+       struct hal_data_8723a *pHalData = GET_HAL_DATA(padapter);
+       struct btdm_8723a_1ant *pBtdm8723 = &pHalData->bt_coexist.halCoex8723.btdm1Ant;
+
+       if (bEnable) {
+               pBtdm8723->curWifiPara = 1;
+               if (pBtdm8723->preWifiPara != pBtdm8723->curWifiPara)
+                       BTDM_SetSwPenaltyTxRateAdaptive(padapter, BT_TX_RATE_ADAPTIVE_LOW_PENALTY);
+       } else {
+               pBtdm8723->curWifiPara = 2;
+               if (pBtdm8723->preWifiPara != pBtdm8723->curWifiPara)
+                       BTDM_SetSwPenaltyTxRateAdaptive(padapter, BT_TX_RATE_ADAPTIVE_NORMAL);
+       }
+
+}
+
+static void btdm_1AntPtaParaReload(struct rtw_adapter *padapter)
+{
+       /*  PTA parameter */
+       rtl8723au_write8(padapter, 0x6cc, 0x0);         /*  1-Ant coex */
+       rtl8723au_write32(padapter, 0x6c8, 0xffff);     /*  wifi break table */
+       rtl8723au_write32(padapter, 0x6c4, 0x55555555); /*  coex table */
+
+       /*  Antenna switch control parameter */
+       rtl8723au_write32(padapter, 0x858, 0xaaaaaaaa);
+       if (IS_8723A_A_CUT(GET_HAL_DATA(padapter)->VersionID)) {
+               /*  SPDT(connected with TRSW) control by hardware PTA */
+               rtl8723au_write32(padapter, 0x870, 0x0);
+               rtl8723au_write8(padapter, 0x40, 0x24);
+       } else {
+               rtl8723au_write8(padapter, 0x40, 0x20);
+               /*  set antenna at bt side if ANTSW is software control */
+               rtl8723au_write16(padapter, 0x860, 0x210);
+               /*  SPDT(connected with TRSW) control by hardware PTA */
+               rtl8723au_write32(padapter, 0x870, 0x300);
+               /*  ANTSW keep by GNT_BT */
+               rtl8723au_write32(padapter, 0x874, 0x22804000);
+       }
+
+       /*  coexistence parameters */
+       rtl8723au_write8(padapter, 0x778, 0x1); /*  enable RTK mode PTA */
+
+       /*  BT don't ignore WLAN_Act */
+       btdm_SetFwIgnoreWlanAct(padapter, false);
+}
+
+/*
+ * Return
+ *1: upgrade (add WiFi duration time)
+ *0: keep
+ *-1: downgrade (add BT duration time)
+ */
+static s8 btdm_1AntTdmaJudgement(struct rtw_adapter *padapter, u8 retry)
+{
+       struct hal_data_8723a *pHalData;
+       struct btdm_8723a_1ant *pBtdm8723;
+       static s8 up, dn, m = 1, n = 3, WaitCount;
+       s8 ret;
+
+       pHalData = GET_HAL_DATA(padapter);
+       pBtdm8723 = &pHalData->bt_coexist.halCoex8723.btdm1Ant;
+       ret = 0;
+
+       if (pBtdm8723->psTdmaMonitorCnt == 0) {
+               up = 0;
+               dn = 0;
+               m = 1;
+               n = 3;
+               WaitCount = 0;
+       } else {
+               WaitCount++;
+       }
+
+       if (retry == 0) {
+       /*  no retry in the last 2-second duration */
+               up++;
+               dn--;
+               if (dn < 0)
+                       dn = 0;
+               if (up >= 3*m) {
+                       /*  retry = 0 in consecutive 3m*(2s), add WiFi duration */
+                       ret = 1;
+
+                       n = 3;
+                       up = 0;
+                       dn = 0;
+                       WaitCount = 0;
+               }
+       } else if (retry <= 3) {
+               /*  retry<= 3 in the last 2-second duration */
+               up--;
+               dn++;
+               if (up < 0)
+                       up = 0;
+
+               if (dn == 2) {
+                       /*  retry<= 3 in consecutive 2*(2s), minus WiFi duration (add BT duration) */
+                       ret = -1;
+
+                       /*  record how many time downgrad WiFi duration */
+                       if (WaitCount <= 2)
+                               m++;
+                       else
+                               m = 1;
+                       /*  the max number of m is 20 */
+                       /*  the longest time of upgrade WiFi duration is 20*3*2s = 120s */
+                       if (m >= 20)
+                               m = 20;
+                       up = 0;
+                       dn = 0;
+                       WaitCount = 0;
+               }
+       } else {
+               /*  retry count > 3 */
+               /*  retry>3, minus WiFi duration (add BT duration) */
+               ret = -1;
+
+               /*  record how many time downgrad WiFi duration */
+               if (WaitCount == 1)
+                       m++;
+               else
+                       m = 1;
+               if (m >= 20)
+                       m = 20;
+
+               up = 0;
+               dn = 0;
+               WaitCount = 0;
+       }
+       return ret;
+}
+
+static void btdm_1AntTdmaDurationAdjustForACL(struct rtw_adapter *padapter)
+{
+       struct hal_data_8723a *pHalData = GET_HAL_DATA(padapter);
+       struct btdm_8723a_1ant *pBtdm8723 = &pHalData->bt_coexist.halCoex8723.btdm1Ant;
+
+       if (pBtdm8723->psTdmaGlobalCnt != pBtdm8723->psTdmaMonitorCnt) {
+               pBtdm8723->psTdmaMonitorCnt = 0;
+               pBtdm8723->psTdmaGlobalCnt = 0;
+       }
+       if (pBtdm8723->psTdmaMonitorCnt == 0) {
+               btdm_1AntSetPSTDMA(padapter, true, 0, true, 2);
+               pBtdm8723->psTdmaDuAdjType = 2;
+       } else {
+               /*  Now we only have 4 level Ps Tdma, */
+               /*  if that's not the following 4 level(will changed by wifi scan, dhcp...), */
+               /*  then we have to adjust it back to the previous record one. */
+               if ((pBtdm8723->curPsTdma != 1) &&
+                   (pBtdm8723->curPsTdma != 2) &&
+                   (pBtdm8723->curPsTdma != 9) &&
+                   (pBtdm8723->curPsTdma != 11)) {
+                       btdm_1AntSetPSTDMA(padapter, true, 0, true, pBtdm8723->psTdmaDuAdjType);
+               } else {
+                       s32 judge = 0;
+
+                       judge = btdm_1AntTdmaJudgement(padapter, pHalData->bt_coexist.halCoex8723.btRetryCnt);
+                       if (judge == -1) {
+                               if (pBtdm8723->curPsTdma == 1) {
+                                       /*  Decrease WiFi duration for high BT retry */
+                                       if (pHalData->bt_coexist.halCoex8723.btInfoExt)
+                                               pBtdm8723->psTdmaDuAdjType = 9;
+                                       else
+                                               pBtdm8723->psTdmaDuAdjType = 2;
+                                       btdm_1AntSetPSTDMA(padapter, true, 0, true, pBtdm8723->psTdmaDuAdjType);
+                               } else if (pBtdm8723->curPsTdma == 2) {
+                                       btdm_1AntSetPSTDMA(padapter, true, 0, true, 9);
+                                       pBtdm8723->psTdmaDuAdjType = 9;
+                               } else if (pBtdm8723->curPsTdma == 9) {
+                                       btdm_1AntSetPSTDMA(padapter, true, 0, true, 11);
+                                       pBtdm8723->psTdmaDuAdjType = 11;
+                               }
+                       } else if (judge == 1) {
+                               if (pBtdm8723->curPsTdma == 11) {
+                                       btdm_1AntSetPSTDMA(padapter, true, 0, true, 9);
+                                       pBtdm8723->psTdmaDuAdjType = 9;
+                               } else if (pBtdm8723->curPsTdma == 9) {
+                                       if (pHalData->bt_coexist.halCoex8723.btInfoExt)
+                                               pBtdm8723->psTdmaDuAdjType = 9;
+                                       else
+                                               pBtdm8723->psTdmaDuAdjType = 2;
+                                       btdm_1AntSetPSTDMA(padapter, true, 0, true, pBtdm8723->psTdmaDuAdjType);
+                               } else if (pBtdm8723->curPsTdma == 2) {
+                                       if (pHalData->bt_coexist.halCoex8723.btInfoExt)
+                                               pBtdm8723->psTdmaDuAdjType = 9;
+                                       else
+                                               pBtdm8723->psTdmaDuAdjType = 1;
+                                       btdm_1AntSetPSTDMA(padapter, true, 0, true, pBtdm8723->psTdmaDuAdjType);
+                               }
+                       }
+               }
+               RTPRINT(FBT, BT_TRACE,
+                       ("[BTCoex], ACL current TDMA(%s, %d)\n",
+                       (pBtdm8723->bCurPsTdmaOn ? "ON" : "OFF"), pBtdm8723->curPsTdma));
+       }
+       pBtdm8723->psTdmaMonitorCnt++;
+}
+
+static void btdm_1AntCoexProcessForWifiConnect(struct rtw_adapter *padapter)
+{
+       struct mlme_priv *pmlmepriv;
+       struct hal_data_8723a *pHalData;
+       struct bt_coexist_8723a *pBtCoex;
+       struct btdm_8723a_1ant *pBtdm8723;
+       u8 BtState;
+
+       pmlmepriv = &padapter->mlmepriv;
+       pHalData = GET_HAL_DATA(padapter);
+       pBtCoex = &pHalData->bt_coexist.halCoex8723;
+       pBtdm8723 = &pBtCoex->btdm1Ant;
+       BtState = pBtCoex->c2hBtInfo;
+
+       RTPRINT(FBT, BT_TRACE, ("[BTCoex], WiFi is %s\n",
+                               BTDM_IsWifiBusy(padapter)?"Busy":"IDLE"));
+       RTPRINT(FBT, BT_TRACE, ("[BTCoex], BT is %s\n",
+                               BtStateString[BtState]));
+
+       padapter->pwrctrlpriv.btcoex_rfon = false;
+
+       if (!BTDM_IsWifiBusy(padapter) &&
+           !check_fwstate(&padapter->mlmepriv, WIFI_AP_STATE) &&
+           (BtState == BT_INFO_STATE_NO_CONNECTION ||
+            BtState == BT_INFO_STATE_CONNECT_IDLE)) {
+               switch (BtState) {
+               case BT_INFO_STATE_NO_CONNECTION:
+                       _btdm_1AntSetPSTDMA(padapter, true, 2, 0x26, false, 9);
+                       break;
+               case BT_INFO_STATE_CONNECT_IDLE:
+                       _btdm_1AntSetPSTDMA(padapter, true, 2, 0x26, false, 0);
+                       break;
+               }
+       } else {
+               switch (BtState) {
+               case BT_INFO_STATE_NO_CONNECTION:
+               case BT_INFO_STATE_CONNECT_IDLE:
+                       /*  WiFi is Busy */
+                       btdm_1AntSetPSTDMA(padapter, false, 0, true, 5);
+                       rtl8723au_write32(padapter, 0x6c0, 0x5a5a5a5a);
+                       rtl8723au_write32(padapter, 0x6c4, 0x5a5a5a5a);
+                       break;
+               case BT_INFO_STATE_ACL_INQ_OR_PAG:
+                       RTPRINT(FBT, BT_TRACE,
+                               ("[BTCoex], BT PROFILE is "
+                                "BT_INFO_STATE_ACL_INQ_OR_PAG\n"));
+               case BT_INFO_STATE_INQ_OR_PAG:
+                       padapter->pwrctrlpriv.btcoex_rfon = true;
+                       btdm_1AntSetPSTDMA(padapter, true, 0, true, 30);
+                       break;
+               case BT_INFO_STATE_SCO_ONLY_BUSY:
+               case BT_INFO_STATE_ACL_SCO_BUSY:
+                       if (true == pBtCoex->bC2hBtInquiryPage)
+                               btdm_1AntSetPSTDMA(padapter, false, 0,
+                                                  true, 32);
+                       else {
+#ifdef BTCOEX_CMCC_TEST
+                               btdm_1AntSetPSTDMA(padapter, false, 0,
+                                                  true, 23);
+#else /*  !BTCOEX_CMCC_TEST */
+                               btdm_1AntSetPSTDMA(padapter, false, 0,
+                                                  false, 8);
+                               rtl8723au_write32(padapter, 0x6c0, 0x5a5a5a5a);
+                               rtl8723au_write32(padapter, 0x6c4, 0x5a5a5a5a);
+#endif /*  !BTCOEX_CMCC_TEST */
+                       }
+                       break;
+               case BT_INFO_STATE_ACL_ONLY_BUSY:
+                       padapter->pwrctrlpriv.btcoex_rfon = true;
+                       if (pBtCoex->c2hBtProfile == BT_INFO_HID) {
+                               RTPRINT(FBT, BT_TRACE,
+                                       ("[BTCoex], BT PROFILE is HID\n"));
+                               btdm_1AntSetPSTDMA(padapter, true, 0, true, 31);
+                       } else if (pBtCoex->c2hBtProfile == BT_INFO_FTP) {
+                               RTPRINT(FBT, BT_TRACE,
+                                       ("[BTCoex], BT PROFILE is FTP/OPP\n"));
+                               btdm_1AntSetPSTDMA(padapter, true, 0, true, 3);
+                       } else if (pBtCoex->c2hBtProfile == (BT_INFO_A2DP|BT_INFO_FTP)) {
+                               RTPRINT(FBT, BT_TRACE,
+                                       ("[BTCoex], BT PROFILE is A2DP_FTP\n"));
+                               btdm_1AntSetPSTDMA(padapter, true, 0, true, 11);
+                       } else {
+                               if (pBtCoex->c2hBtProfile == BT_INFO_A2DP)
+                                       RTPRINT(FBT, BT_TRACE,
+                                               ("[BTCoex], BT PROFILE is "
+                                                "A2DP\n"));
+                               else
+                                       RTPRINT(FBT, BT_TRACE,
+                                               ("[BTCoex], BT PROFILE is "
+                                                "UNKNOWN(0x%02X)! Use A2DP "
+                                                "Profile\n",
+                                                pBtCoex->c2hBtProfile));
+                               btdm_1AntTdmaDurationAdjustForACL(padapter);
+                       }
+                       break;
+               }
+       }
+
+       pBtdm8723->psTdmaGlobalCnt++;
+}
+
+static void
+btdm_1AntUpdateHalRAMask(struct rtw_adapter *padapter, u32 mac_id, u32 filter)
+{
+       u8 init_rate = 0;
+       u8 raid, arg;
+       u32 mask;
+       u8 shortGIrate = false;
+       int supportRateNum = 0;
+       struct sta_info *psta;
+       struct hal_data_8723a *pHalData;
+       struct dm_priv *pdmpriv;
+       struct mlme_ext_priv *pmlmeext;
+       struct mlme_ext_info *pmlmeinfo;
+       struct wlan_bssid_ex *cur_network;
+
+       RTPRINT(FBT, BT_TRACE, ("[BTCoex], %s, MACID =%d, filter = 0x%08x!!\n",
+                               __func__, mac_id, filter));
+
+       pHalData = GET_HAL_DATA(padapter);
+       pdmpriv = &pHalData->dmpriv;
+       pmlmeext = &padapter->mlmeextpriv;
+       pmlmeinfo = &pmlmeext->mlmext_info;
+       cur_network = &pmlmeinfo->network;
+
+       if (mac_id >= NUM_STA) { /* CAM_SIZE */
+               RTPRINT(FBT, BT_TRACE, ("[BTCoex], %s, MACID =%d illegal!!\n",
+                                       __func__, mac_id));
+               return;
+       }
+
+       psta = pmlmeinfo->FW_sta_info[mac_id].psta;
+       if (!psta) {
+               RTPRINT(FBT, BT_TRACE, ("[BTCoex], %s, Can't find station!!\n",
+                                       __func__));
+               return;
+       }
+
+       raid = psta->raid;
+
+       switch (mac_id) {
+       case 0:/*  for infra mode */
+               supportRateNum =
+                       rtw_get_rateset_len23a(cur_network->SupportedRates);
+               mask = update_supported_rate23a(cur_network->SupportedRates,
+                                               supportRateNum);
+               mask |= (pmlmeinfo->HT_enable) ?
+                       update_MSC_rate23a(&pmlmeinfo->ht_cap):0;
+               if (support_short_GI23a(padapter, &pmlmeinfo->ht_cap))
+                       shortGIrate = true;
+               break;
+       case 1:/* for broadcast/multicast */
+               supportRateNum = rtw_get_rateset_len23a(
+                       pmlmeinfo->FW_sta_info[mac_id].SupportedRates);
+               mask = update_basic_rate23a(cur_network->SupportedRates,
+                                           supportRateNum);
+               break;
+       default: /* for each sta in IBSS */
+               supportRateNum = rtw_get_rateset_len23a(
+                       pmlmeinfo->FW_sta_info[mac_id].SupportedRates);
+               mask = update_supported_rate23a(cur_network->SupportedRates,
+                                               supportRateNum);
+               break;
+       }
+       mask |= ((raid<<28)&0xf0000000);
+       mask &= 0xffffffff;
+       mask &= ~filter;
+       init_rate = get_highest_rate_idx23a(mask)&0x3f;
+
+       arg = mac_id&0x1f;/* MACID */
+       arg |= BIT(7);
+       if (true == shortGIrate)
+               arg |= BIT(5);
+
+       RTPRINT(FBT, BT_TRACE,
+               ("[BTCoex], Update FW RAID entry, MASK = 0x%08x, "
+                "arg = 0x%02x\n", mask, arg));
+
+       rtl8723a_set_raid_cmd(padapter, mask, arg);
+
+       psta->init_rate = init_rate;
+       pdmpriv->INIDATA_RATE[mac_id] = init_rate;
+}
+
+static void
+btdm_1AntUpdateHalRAMaskForSCO(struct rtw_adapter *padapter, u8 forceUpdate)
+{
+       struct btdm_8723a_1ant *pBtdm8723;
+       struct sta_priv *pstapriv;
+       struct wlan_bssid_ex *cur_network;
+       struct sta_info *psta;
+       u32 macid;
+       u32 filter = 0;
+
+       pBtdm8723 = &GET_HAL_DATA(padapter)->bt_coexist.halCoex8723.btdm1Ant;
+
+       if (pBtdm8723->bRAChanged == true && forceUpdate == false)
+               return;
+
+       pstapriv = &padapter->stapriv;
+       cur_network = &padapter->mlmeextpriv.mlmext_info.network;
+       psta = rtw_get_stainfo23a(pstapriv, cur_network->MacAddress);
+       macid = psta->mac_id;
+
+       filter |= BIT(_1M_RATE_);
+       filter |= BIT(_2M_RATE_);
+       filter |= BIT(_5M_RATE_);
+       filter |= BIT(_11M_RATE_);
+       filter |= BIT(_6M_RATE_);
+       filter |= BIT(_9M_RATE_);
+
+       btdm_1AntUpdateHalRAMask(padapter, macid, filter);
+
+       pBtdm8723->bRAChanged = true;
+}
+
+static void btdm_1AntRecoverHalRAMask(struct rtw_adapter *padapter)
+{
+       struct btdm_8723a_1ant *pBtdm8723;
+       struct sta_priv *pstapriv;
+       struct wlan_bssid_ex *cur_network;
+       struct sta_info *psta;
+
+       pBtdm8723 = &GET_HAL_DATA(padapter)->bt_coexist.halCoex8723.btdm1Ant;
+
+       if (pBtdm8723->bRAChanged == false)
+               return;
+
+       pstapriv = &padapter->stapriv;
+       cur_network = &padapter->mlmeextpriv.mlmext_info.network;
+       psta = rtw_get_stainfo23a(pstapriv, cur_network->MacAddress);
+
+       Update_RA_Entry23a(padapter, psta);
+
+       pBtdm8723->bRAChanged = false;
+}
+
+static void
+btdm_1AntBTStateChangeHandler(struct rtw_adapter *padapter,
+                             enum bt_state_1ant oldState,
+                             enum bt_state_1ant newState)
+{
+       struct hal_data_8723a *phaldata;
+       RTPRINT(FBT, BT_TRACE, ("[BTCoex], BT state change, %s => %s\n",
+                               BtStateString[oldState],
+                               BtStateString[newState]));
+
+       /*  BT default ignore wlan active, */
+       /*  WiFi MUST disable this when BT is enable */
+       if (newState > BT_INFO_STATE_DISABLED)
+               btdm_SetFwIgnoreWlanAct(padapter, false);
+
+       if ((check_fwstate(&padapter->mlmepriv, WIFI_STATION_STATE)) &&
+           (BTDM_IsWifiConnectionExist(padapter))) {
+               if ((newState == BT_INFO_STATE_SCO_ONLY_BUSY) ||
+                   (newState == BT_INFO_STATE_ACL_SCO_BUSY)) {
+                       btdm_1AntUpdateHalRAMaskForSCO(padapter, false);
+               } else {
+                       /*  Recover original RA setting */
+                       btdm_1AntRecoverHalRAMask(padapter);
+               }
+       } else {
+               phaldata = GET_HAL_DATA(padapter);
+               phaldata->bt_coexist.halCoex8723.btdm1Ant.bRAChanged = false;
+       }
+
+       if (oldState == newState)
+               return;
+
+       if (oldState == BT_INFO_STATE_ACL_ONLY_BUSY) {
+               struct hal_data_8723a *Hal = GET_HAL_DATA(padapter);
+               Hal->bt_coexist.halCoex8723.btdm1Ant.psTdmaMonitorCnt = 0;
+               Hal->bt_coexist.halCoex8723.btdm1Ant.psTdmaMonitorCntForSCO = 0;
+       }
+
+       if ((oldState == BT_INFO_STATE_SCO_ONLY_BUSY) ||
+           (oldState == BT_INFO_STATE_ACL_SCO_BUSY)) {
+               struct hal_data_8723a *Hal = GET_HAL_DATA(padapter);
+               Hal->bt_coexist.halCoex8723.btdm1Ant.psTdmaMonitorCntForSCO = 0;
+       }
+
+       /*  Active 2Ant mechanism when BT Connected */
+       if ((oldState == BT_INFO_STATE_DISABLED) ||
+           (oldState == BT_INFO_STATE_NO_CONNECTION)) {
+               if ((newState != BT_INFO_STATE_DISABLED) &&
+                   (newState != BT_INFO_STATE_NO_CONNECTION)) {
+                       BTDM_SetSwRfRxLpfCorner(padapter,
+                                               BT_RF_RX_LPF_CORNER_SHRINK);
+                       BTDM_AGCTable(padapter, BT_AGCTABLE_ON);
+                       BTDM_BBBackOffLevel(padapter, BT_BB_BACKOFF_ON);
+               }
+       } else {
+               if ((newState == BT_INFO_STATE_DISABLED) ||
+                   (newState == BT_INFO_STATE_NO_CONNECTION)) {
+                       BTDM_SetSwRfRxLpfCorner(padapter,
+                                               BT_RF_RX_LPF_CORNER_RESUME);
+                       BTDM_AGCTable(padapter, BT_AGCTABLE_OFF);
+                       BTDM_BBBackOffLevel(padapter, BT_BB_BACKOFF_OFF);
+               }
+       }
+}
+
+static void btdm_1AntBtCoexistHandler(struct rtw_adapter *padapter)
+{
+       struct hal_data_8723a *pHalData;
+       struct bt_coexist_8723a *pBtCoex8723;
+       struct btdm_8723a_1ant *pBtdm8723;
+
+       pHalData = GET_HAL_DATA(padapter);
+       pBtCoex8723 = &pHalData->bt_coexist.halCoex8723;
+       pBtdm8723 = &pBtCoex8723->btdm1Ant;
+       padapter->pwrctrlpriv.btcoex_rfon = false;
+       if (!rtl8723a_BT_enabled(padapter)) {
+               RTPRINT(FBT, BT_TRACE, ("[BTCoex], BT is disabled\n"));
+
+               if (BTDM_IsWifiConnectionExist(padapter)) {
+                       RTPRINT(FBT, BT_TRACE,
+                               ("[BTCoex], wifi is connected\n"));
+
+                       if (BTDM_IsWifiBusy(padapter)) {
+                               RTPRINT(FBT, BT_TRACE,
+                                       ("[BTCoex], Wifi is busy\n"));
+                               btdm_1AntSetPSTDMA(padapter, false, 0,
+                                                  false, 9);
+                       } else {
+                               RTPRINT(FBT, BT_TRACE,
+                                       ("[BTCoex], Wifi is idle\n"));
+                               _btdm_1AntSetPSTDMA(padapter, true, 2, 1,
+                                                   false, 9);
+                       }
+               } else {
+                       RTPRINT(FBT, BT_TRACE,
+                               ("[BTCoex], wifi is disconnected\n"));
+
+                       btdm_1AntSetPSTDMA(padapter, false, 0, false, 9);
+               }
+       } else {
+               RTPRINT(FBT, BT_TRACE, ("[BTCoex], BT is enabled\n"));
+
+               if (BTDM_IsWifiConnectionExist(padapter)) {
+                       RTPRINT(FBT, BT_TRACE,
+                               ("[BTCoex], wifi is connected\n"));
+
+                       btdm_1AntWifiParaAdjust(padapter, true);
+                       btdm_1AntCoexProcessForWifiConnect(padapter);
+               } else {
+                       RTPRINT(FBT, BT_TRACE,
+                               ("[BTCoex], wifi is disconnected\n"));
+
+                       /*  Antenna switch at BT side(0x870 = 0x300,
+                           0x860 = 0x210) after PSTDMA off */
+                       btdm_1AntWifiParaAdjust(padapter, false);
+                       btdm_1AntSetPSTDMA(padapter, false, 0, false, 0);
+               }
+       }
+
+       btdm_1AntBTStateChangeHandler(padapter, pBtCoex8723->prec2hBtInfo,
+                                     pBtCoex8723->c2hBtInfo);
+       pBtCoex8723->prec2hBtInfo = pBtCoex8723->c2hBtInfo;
+}
+
+void BTDM_1AntSignalCompensation(struct rtw_adapter *padapter,
+                                u8 *rssi_wifi, u8 *rssi_bt)
+{
+       struct hal_data_8723a *pHalData;
+       struct btdm_8723a_1ant *pBtdm8723;
+       u8 RSSI_WiFi_Cmpnstn, RSSI_BT_Cmpnstn;
+
+       pHalData = GET_HAL_DATA(padapter);
+       pBtdm8723 = &pHalData->bt_coexist.halCoex8723.btdm1Ant;
+       RSSI_WiFi_Cmpnstn = 0;
+       RSSI_BT_Cmpnstn = 0;
+
+       switch (pBtdm8723->curPsTdma) {
+       case 1: /*  WiFi 52ms */
+               RSSI_WiFi_Cmpnstn = 11; /*  22*0.48 */
+               break;
+       case 2: /*  WiFi 36ms */
+               RSSI_WiFi_Cmpnstn = 14; /*  22*0.64 */
+               break;
+       case 9: /*  WiFi 20ms */
+               RSSI_WiFi_Cmpnstn = 18; /*  22*0.80 */
+               break;
+       case 11: /*  WiFi 10ms */
+               RSSI_WiFi_Cmpnstn = 20; /*  22*0.90 */
+               break;
+       case 4: /*  WiFi 21ms */
+               RSSI_WiFi_Cmpnstn = 17; /*  22*0.79 */
+               break;
+       case 16: /*  WiFi 24ms */
+               RSSI_WiFi_Cmpnstn = 18; /*  22*0.76 */
+               break;
+       case 18: /*  WiFi 37ms */
+               RSSI_WiFi_Cmpnstn = 14; /*  22*0.64 */
+               break;
+       case 23: /* Level-1, Antenna switch to BT at all time */
+       case 24: /* Level-2, Antenna switch to BT at all time */
+       case 25: /* Level-3a, Antenna switch to BT at all time */
+       case 26: /* Level-3b, Antenna switch to BT at all time */
+       case 27: /* Level-3b, Antenna switch to BT at all time */
+       case 33: /* BT SCO & WiFi site survey */
+               RSSI_WiFi_Cmpnstn = 22;
+               break;
+       default:
+               break;
+       }
+
+       if (rssi_wifi && RSSI_WiFi_Cmpnstn) {
+               RTPRINT(FBT, BT_TRACE,
+                       ("[BTCoex], 1AntSgnlCmpnstn, case %d, WiFiCmpnstn "
+                        "=%d(%d => %d)\n", pBtdm8723->curPsTdma,
+                        RSSI_WiFi_Cmpnstn, *rssi_wifi,
+                        *rssi_wifi+RSSI_WiFi_Cmpnstn));
+               *rssi_wifi += RSSI_WiFi_Cmpnstn;
+       }
+
+       if (rssi_bt && RSSI_BT_Cmpnstn) {
+               RTPRINT(FBT, BT_TRACE,
+                       ("[BTCoex], 1AntSgnlCmpnstn, case %d, BTCmpnstn "
+                        "=%d(%d => %d)\n", pBtdm8723->curPsTdma,
+                        RSSI_BT_Cmpnstn, *rssi_bt, *rssi_bt+RSSI_BT_Cmpnstn));
+               *rssi_bt += RSSI_BT_Cmpnstn;
+       }
+}
+
+static void BTDM_1AntParaInit(struct rtw_adapter *padapter)
+{
+       struct hal_data_8723a *pHalData;
+       struct bt_coexist_8723a *pBtCoex;
+       struct btdm_8723a_1ant *pBtdm8723;
+
+       pHalData = GET_HAL_DATA(padapter);
+       pBtCoex = &pHalData->bt_coexist.halCoex8723;
+       pBtdm8723 = &pBtCoex->btdm1Ant;
+
+       /*  Enable counter statistics */
+       rtl8723au_write8(padapter, 0x76e, 0x4);
+       btdm_1AntPtaParaReload(padapter);
+
+       pBtdm8723->wifiRssiThresh = 48;
+
+       pBtdm8723->bWiFiHalt = false;
+       pBtdm8723->bRAChanged = false;
+
+       if ((pBtCoex->c2hBtInfo != BT_INFO_STATE_DISABLED) &&
+           (pBtCoex->c2hBtInfo != BT_INFO_STATE_NO_CONNECTION)) {
+               BTDM_SetSwRfRxLpfCorner(padapter, BT_RF_RX_LPF_CORNER_SHRINK);
+               BTDM_AGCTable(padapter, BT_AGCTABLE_ON);
+               BTDM_BBBackOffLevel(padapter, BT_BB_BACKOFF_ON);
+       }
+}
+
+static void BTDM_1AntForHalt(struct rtw_adapter *padapter)
+{
+       RTPRINT(FBT, BT_TRACE, ("\n[BTCoex], 1Ant for halt\n"));
+
+       GET_HAL_DATA(padapter)->bt_coexist.halCoex8723.btdm1Ant.bWiFiHalt =
+               true;
+
+       btdm_1AntWifiParaAdjust(padapter, false);
+
+       /*  don't use btdm_1AntSetPSTDMA() here */
+       /*  it will call rtw_set_ps_mode23a() and request pwrpriv->lock. */
+       /*  This will lead to deadlock, if this function is called in IPS */
+       /*  Lucas@20130205 */
+       btdm_1AntPsTdma(padapter, false, 0);
+
+       btdm_SetFwIgnoreWlanAct(padapter, true);
+}
+
+static void BTDM_1AntLpsLeave(struct rtw_adapter *padapter)
+{
+       RTPRINT(FBT, BT_TRACE, ("\n[BTCoex], 1Ant for LPS Leave\n"));
+
+       /*  Prevent from entering LPS again */
+       GET_HAL_DATA(padapter)->bt_coexist.halCoex8723.btdm1Ant.bWiFiHalt =
+               true;
+
+       btdm_1AntSetPSTDMA(padapter, false, 0, false, 8);
+/*btdm_1AntPsTdma(padapter, false, 8); */
+}
+
+static void BTDM_1AntWifiAssociateNotify(struct rtw_adapter *padapter, u8 type)
+{
+       struct hal_data_8723a *pHalData = GET_HAL_DATA(padapter);
+
+       RTPRINT(FBT, BT_TRACE,
+               ("\n[BTCoex], 1Ant for associate, type =%d\n", type));
+
+       if (type) {
+               rtl8723a_CheckAntenna_Selection(padapter);
+               if (!rtl8723a_BT_enabled(padapter))
+                       btdm_1AntSetPSTDMA(padapter, false, 0, false, 9);
+               else {
+                       struct bt_coexist_8723a *pBtCoex;
+                       u8 BtState;
+
+                       pBtCoex = &pHalData->bt_coexist.halCoex8723;
+                       BtState = pBtCoex->c2hBtInfo;
+
+                       btdm_1AntTSFSwitch(padapter, true);
+
+                       if (BtState == BT_INFO_STATE_NO_CONNECTION ||
+                           BtState == BT_INFO_STATE_CONNECT_IDLE) {
+                               btdm_1AntSetPSTDMA(padapter, false, 0,
+                                                  true, 28);
+                       } else if (BtState == BT_INFO_STATE_SCO_ONLY_BUSY ||
+                                  BtState == BT_INFO_STATE_ACL_SCO_BUSY) {
+                               btdm_1AntSetPSTDMA(padapter, false, 0,
+                                                  false, 8);
+                               rtl8723au_write32(padapter, 0x6c0, 0x5a5a5a5a);
+                               rtl8723au_write32(padapter, 0x6c4, 0x5a5a5a5a);
+                       } else if (BtState == BT_INFO_STATE_ACL_ONLY_BUSY ||
+                                  BtState == BT_INFO_STATE_ACL_INQ_OR_PAG) {
+                               if (pBtCoex->c2hBtProfile == BT_INFO_HID)
+                                       btdm_1AntSetPSTDMA(padapter, false, 0,
+                                                          true, 35);
+                               else
+                                       btdm_1AntSetPSTDMA(padapter, false, 0,
+                                                          true, 29);
+                       }
+               }
+       } else {
+               if (!rtl8723a_BT_enabled(padapter)) {
+                       if (!BTDM_IsWifiConnectionExist(padapter)) {
+                               btdm_1AntPsTdma(padapter, false, 0);
+                               btdm_1AntTSFSwitch(padapter, false);
+                       }
+               }
+
+               btdm_1AntBtCoexistHandler(padapter);
+       }
+}
+
+static void
+BTDM_1AntMediaStatusNotify(struct rtw_adapter *padapter,
+                          enum rt_media_status mstatus)
+{
+       struct bt_coexist_8723a *pBtCoex;
+
+       pBtCoex = &GET_HAL_DATA(padapter)->bt_coexist.halCoex8723;
+
+       RTPRINT(FBT, BT_TRACE,
+               ("\n\n[BTCoex]******************************\n"));
+       RTPRINT(FBT, BT_TRACE, ("[BTCoex], MediaStatus, WiFi %s !!\n",
+                       mstatus == RT_MEDIA_CONNECT?"CONNECT":"DISCONNECT"));
+       RTPRINT(FBT, BT_TRACE, ("[BTCoex]******************************\n"));
+
+       if (RT_MEDIA_CONNECT == mstatus) {
+               if (check_fwstate(&padapter->mlmepriv, WIFI_STATION_STATE)) {
+                       if (pBtCoex->c2hBtInfo == BT_INFO_STATE_SCO_ONLY_BUSY ||
+                           pBtCoex->c2hBtInfo == BT_INFO_STATE_ACL_SCO_BUSY)
+                               btdm_1AntUpdateHalRAMaskForSCO(padapter, true);
+               }
+
+               padapter->pwrctrlpriv.DelayLPSLastTimeStamp = jiffies;
+               BTDM_1AntForDhcp(padapter);
+       } else {
+               /* DBG_8723A("%s rtl8723a_DeinitAntenna_Selection\n",
+                  __func__); */
+               rtl8723a_DeinitAntenna_Selection(padapter);
+               btdm_1AntBtCoexistHandler(padapter);
+               pBtCoex->btdm1Ant.bRAChanged = false;
+       }
+}
+
+void BTDM_1AntForDhcp(struct rtw_adapter *padapter)
+{
+       struct hal_data_8723a *pHalData;
+       u8 BtState;
+       struct bt_coexist_8723a *pBtCoex;
+       struct btdm_8723a_1ant *pBtdm8723;
+
+       pHalData = GET_HAL_DATA(padapter);
+       pBtCoex = &pHalData->bt_coexist.halCoex8723;
+       BtState = pBtCoex->c2hBtInfo;
+       pBtdm8723 = &pBtCoex->btdm1Ant;
+
+       RTPRINT(FBT, BT_TRACE, ("\n[BTCoex], 1Ant for DHCP\n"));
+       RTPRINT(FBT, BT_TRACE, ("[BTCoex], 1Ant for DHCP, WiFi is %s\n",
+                               BTDM_IsWifiBusy(padapter)?"Busy":"IDLE"));
+       RTPRINT(FBT, BT_TRACE, ("[BTCoex], 1Ant for DHCP, %s\n",
+                               BtStateString[BtState]));
+
+       BTDM_1AntWifiAssociateNotify(padapter, true);
+}
+
+static void BTDM_1AntWifiScanNotify(struct rtw_adapter *padapter, u8 scanType)
+{
+       struct hal_data_8723a *pHalData;
+       u8 BtState;
+       struct bt_coexist_8723a *pBtCoex;
+       struct btdm_8723a_1ant *pBtdm8723;
+
+       pHalData = GET_HAL_DATA(padapter);
+       BtState = pHalData->bt_coexist.halCoex8723.c2hBtInfo;
+       pBtCoex = &pHalData->bt_coexist.halCoex8723;
+       pBtdm8723 = &pBtCoex->btdm1Ant;
+
+       RTPRINT(FBT, BT_TRACE, ("\n[BTCoex], 1Ant for wifi scan =%d!!\n",
+                               scanType));
+       RTPRINT(FBT, BT_TRACE, ("[BTCoex], 1Ant for wifi scan, WiFi is %s\n",
+                               BTDM_IsWifiBusy(padapter)?"Busy":"IDLE"));
+       RTPRINT(FBT, BT_TRACE, ("[BTCoex], 1Ant for wifi scan, %s\n",
+                               BtStateString[BtState]));
+
+       if (scanType) {
+               rtl8723a_CheckAntenna_Selection(padapter);
+               if (!rtl8723a_BT_enabled(padapter)) {
+                       btdm_1AntSetPSTDMA(padapter, false, 0, false, 9);
+               } else if (BTDM_IsWifiConnectionExist(padapter) == false) {
+                       BTDM_1AntWifiAssociateNotify(padapter, true);
+               } else {
+                       if ((BtState == BT_INFO_STATE_SCO_ONLY_BUSY) ||
+                           (BtState == BT_INFO_STATE_ACL_SCO_BUSY)) {
+                               if (pBtCoex->bC2hBtInquiryPage) {
+                                       btdm_1AntSetPSTDMA(padapter, false, 0,
+                                                          true, 32);
+                               } else {
+                                       padapter->pwrctrlpriv.btcoex_rfon =
+                                               true;
+                                       btdm_1AntSetPSTDMA(padapter, true, 0,
+                                                          true, 33);
+                               }
+                       } else if (true == pBtCoex->bC2hBtInquiryPage) {
+                               padapter->pwrctrlpriv.btcoex_rfon = true;
+                               btdm_1AntSetPSTDMA(padapter, true, 0, true, 30);
+                       } else if (BtState == BT_INFO_STATE_ACL_ONLY_BUSY) {
+                               padapter->pwrctrlpriv.btcoex_rfon = true;
+                               if (pBtCoex->c2hBtProfile == BT_INFO_HID)
+                                       btdm_1AntSetPSTDMA(padapter, true, 0,
+                                                          true, 34);
+                               else
+                                       btdm_1AntSetPSTDMA(padapter, true, 0,
+                                                          true, 4);
+                       } else {
+                               padapter->pwrctrlpriv.btcoex_rfon = true;
+                               btdm_1AntSetPSTDMA(padapter, true, 0, true, 5);
+                       }
+               }
+
+               btdm_NotifyFwScan(padapter, 1);
+       } else {
+               /*  WiFi_Finish_Scan */
+               btdm_NotifyFwScan(padapter, 0);
+               btdm_1AntBtCoexistHandler(padapter);
+       }
+}
+
+static void BTDM_1AntFwC2hBtInfo8723A(struct rtw_adapter *padapter)
+{
+       struct hal_data_8723a *pHalData;
+       struct bt_30info *pBTInfo;
+       struct bt_mgnt *pBtMgnt;
+       struct bt_coexist_8723a *pBtCoex;
+       u8 u1tmp, btState;
+
+       pHalData = GET_HAL_DATA(padapter);
+       pBTInfo = GET_BT_INFO(padapter);
+       pBtMgnt = &pBTInfo->BtMgnt;
+       pBtCoex = &pHalData->bt_coexist.halCoex8723;
+
+       u1tmp = pBtCoex->c2hBtInfoOriginal;
+       /*  sco BUSY bit is not used on voice over PCM platform */
+       btState = u1tmp & 0xF;
+       pBtCoex->c2hBtProfile = u1tmp & 0xE0;
+
+       /*  default set bt to idle state. */
+       pBtMgnt->ExtConfig.bBTBusy = false;
+       pHalData->bt_coexist.CurrentState |= BT_COEX_STATE_BT_IDLE;
+
+       /*  check BIT2 first ==> check if bt is under inquiry or page scan */
+       if (btState & BIT(2))
+               pBtCoex->bC2hBtInquiryPage = true;
+       else
+               pBtCoex->bC2hBtInquiryPage = false;
+       btState &= ~BIT(2);
+
+       if (!(btState & BIT(0)))
+               pBtCoex->c2hBtInfo = BT_INFO_STATE_NO_CONNECTION;
+       else {
+               if (btState == 0x1)
+                       pBtCoex->c2hBtInfo = BT_INFO_STATE_CONNECT_IDLE;
+               else if (btState == 0x9) {
+                       if (pBtCoex->bC2hBtInquiryPage == true)
+                               pBtCoex->c2hBtInfo =
+                                       BT_INFO_STATE_ACL_INQ_OR_PAG;
+                       else
+                               pBtCoex->c2hBtInfo =
+                                       BT_INFO_STATE_ACL_ONLY_BUSY;
+                       pBtMgnt->ExtConfig.bBTBusy = true;
+               } else if (btState == 0x3) {
+                       pBtCoex->c2hBtInfo = BT_INFO_STATE_SCO_ONLY_BUSY;
+                       pBtMgnt->ExtConfig.bBTBusy = true;
+               } else if (btState == 0xb) {
+                       pBtCoex->c2hBtInfo = BT_INFO_STATE_ACL_SCO_BUSY;
+                       pBtMgnt->ExtConfig.bBTBusy = true;
+               } else
+                       pBtCoex->c2hBtInfo = BT_INFO_STATE_MAX;
+               if (pBtMgnt->ExtConfig.bBTBusy)
+                       pHalData->bt_coexist.CurrentState &=
+                               ~BT_COEX_STATE_BT_IDLE;
+       }
+
+       if (BT_INFO_STATE_NO_CONNECTION == pBtCoex->c2hBtInfo ||
+           BT_INFO_STATE_CONNECT_IDLE == pBtCoex->c2hBtInfo) {
+               if (pBtCoex->bC2hBtInquiryPage)
+                       pBtCoex->c2hBtInfo = BT_INFO_STATE_INQ_OR_PAG;
+       }
+
+       RTPRINT(FBT, BT_TRACE, ("[BTC2H], %s(%d)\n",
+                       BtStateString[pBtCoex->c2hBtInfo], pBtCoex->c2hBtInfo));
+
+       if (pBtCoex->c2hBtProfile != BT_INFO_HID)
+               pBtCoex->c2hBtProfile &= ~BT_INFO_HID;
+}
+
+void BTDM_1AntBtCoexist8723A(struct rtw_adapter *padapter)
+{
+       struct mlme_priv *pmlmepriv;
+       struct hal_data_8723a *pHalData;
+       unsigned long delta_time;
+
+       pmlmepriv = &padapter->mlmepriv;
+       pHalData = GET_HAL_DATA(padapter);
+
+       if (check_fwstate(pmlmepriv, WIFI_SITE_MONITOR)) {
+               /*  already done in BTDM_1AntForScan() */
+               RTPRINT(FBT, BT_TRACE,
+                       ("[BTCoex], wifi is under scan progress!!\n"));
+               return;
+       }
+
+       if (check_fwstate(pmlmepriv, WIFI_UNDER_LINKING)) {
+               RTPRINT(FBT, BT_TRACE,
+                       ("[BTCoex], wifi is under link progress!!\n"));
+               return;
+       }
+
+       /*  under DHCP(Special packet) */
+       delta_time = jiffies - padapter->pwrctrlpriv.DelayLPSLastTimeStamp;
+       delta_time = jiffies_to_msecs(delta_time);
+       if (delta_time < 500) {
+               RTPRINT(FBT, BT_TRACE, ("[BTCoex], wifi is under DHCP "
+                                       "progress(%li ms)!!\n", delta_time));
+               return;
+       }
+
+       BTDM_CheckWiFiState(padapter);
+
+       btdm_1AntBtCoexistHandler(padapter);
+}
+
+/*  ===== End of sync from SD7 driver HAL/BTCoexist/HalBtc87231Ant.c ===== */
+
+/*  ===== Below this line is sync from SD7 driver HAL/BTCoexist/HalBtc87232Ant.c ===== */
+
+/*  local function start with btdm_ */
+static u8 btdm_ActionAlgorithm(struct rtw_adapter *padapter)
+{
+       struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
+       struct bt_mgnt *pBtMgnt = &pBTInfo->BtMgnt;
+       struct hal_data_8723a *pHalData = GET_HAL_DATA(padapter);
+       struct btdm_8723a_2ant *pBtdm8723 = &pHalData->bt_coexist.halCoex8723.btdm2Ant;
+       u8 bScoExist = false, bBtLinkExist = false, bBtHsModeExist = false;
+       u8 algorithm = BT_2ANT_COEX_ALGO_UNDEFINED;
+
+       if (pBtMgnt->ExtConfig.NumberOfHandle)
+               bBtLinkExist = true;
+       if (pBtMgnt->ExtConfig.NumberOfSCO)
+               bScoExist = true;
+       if (BT_HsConnectionEstablished(padapter))
+               bBtHsModeExist = true;
+
+       /*  here we get BT status first */
+       /*  1) initialize */
+       pBtdm8723->btStatus = BT_2ANT_BT_STATUS_IDLE;
+
+       if ((bScoExist) || (bBtHsModeExist) ||
+           (BTHCI_CheckProfileExist(padapter, BT_PROFILE_HID))) {
+               RTPRINT(FBT, BT_TRACE, ("[BTCoex], SCO or HID or HS exists, set BT non-idle !!!\n"));
+               pBtdm8723->btStatus = BT_2ANT_BT_STATUS_NON_IDLE;
+       } else {
+               /*  A2dp profile */
+               if ((pBtMgnt->ExtConfig.NumberOfHandle == 1) &&
+                   (BTHCI_CheckProfileExist(padapter, BT_PROFILE_A2DP))) {
+                       if (BTDM_BtTxRxCounterL(padapter) < 100) {
+                               RTPRINT(FBT, BT_TRACE, ("[BTCoex], A2DP, low priority tx+rx < 100, set BT connected-idle!!!\n"));
+                               pBtdm8723->btStatus = BT_2ANT_BT_STATUS_CONNECTED_IDLE;
+                       } else {
+                               RTPRINT(FBT, BT_TRACE, ("[BTCoex], A2DP, low priority tx+rx >= 100, set BT non-idle!!!\n"));
+                               pBtdm8723->btStatus = BT_2ANT_BT_STATUS_NON_IDLE;
+                       }
+               }
+               /*  Pan profile */
+               if ((pBtMgnt->ExtConfig.NumberOfHandle == 1) &&
+                   (BTHCI_CheckProfileExist(padapter, BT_PROFILE_PAN))) {
+                       if (BTDM_BtTxRxCounterL(padapter) < 600) {
+                               RTPRINT(FBT, BT_TRACE, ("[BTCoex], PAN, low priority tx+rx < 600, set BT connected-idle!!!\n"));
+                               pBtdm8723->btStatus = BT_2ANT_BT_STATUS_CONNECTED_IDLE;
+                       } else {
+                               if (pHalData->bt_coexist.halCoex8723.lowPriorityTx) {
+                                       if ((pHalData->bt_coexist.halCoex8723.lowPriorityRx /
+                                           pHalData->bt_coexist.halCoex8723.lowPriorityTx) > 9) {
+                                               RTPRINT(FBT, BT_TRACE, ("[BTCoex], PAN, low priority rx/tx > 9, set BT connected-idle!!!\n"));
+                                               pBtdm8723->btStatus = BT_2ANT_BT_STATUS_CONNECTED_IDLE;
+                                       }
+                               }
+                       }
+                       if (BT_2ANT_BT_STATUS_CONNECTED_IDLE != pBtdm8723->btStatus) {
+                               RTPRINT(FBT, BT_TRACE, ("[BTCoex], PAN, set BT non-idle!!!\n"));
+                               pBtdm8723->btStatus = BT_2ANT_BT_STATUS_NON_IDLE;
+                       }
+               }
+               /*  Pan+A2dp profile */
+               if ((pBtMgnt->ExtConfig.NumberOfHandle == 2) &&
+                   (BTHCI_CheckProfileExist(padapter, BT_PROFILE_A2DP)) &&
+                   (BTHCI_CheckProfileExist(padapter, BT_PROFILE_PAN))) {
+                       if (BTDM_BtTxRxCounterL(padapter) < 600) {
+                               RTPRINT(FBT, BT_TRACE, ("[BTCoex], PAN+A2DP, low priority tx+rx < 600, set BT connected-idle!!!\n"));
+                               pBtdm8723->btStatus = BT_2ANT_BT_STATUS_CONNECTED_IDLE;
+                       } else {
+                               if (pHalData->bt_coexist.halCoex8723.lowPriorityTx) {
+                                       if ((pHalData->bt_coexist.halCoex8723.lowPriorityRx /
+                                           pHalData->bt_coexist.halCoex8723.lowPriorityTx) > 9) {
+                                               RTPRINT(FBT, BT_TRACE, ("[BTCoex], PAN+A2DP, low priority rx/tx > 9, set BT connected-idle!!!\n"));
+                                               pBtdm8723->btStatus = BT_2ANT_BT_STATUS_CONNECTED_IDLE;
+                                       }
+                               }
+                       }
+                       if (BT_2ANT_BT_STATUS_CONNECTED_IDLE != pBtdm8723->btStatus) {
+                               RTPRINT(FBT, BT_TRACE, ("[BTCoex], PAN+A2DP, set BT non-idle!!!\n"));
+                               pBtdm8723->btStatus = BT_2ANT_BT_STATUS_NON_IDLE;
+                       }
+               }
+       }
+       if (BT_2ANT_BT_STATUS_IDLE != pBtdm8723->btStatus)
+               pBtMgnt->ExtConfig.bBTBusy = true;
+       else
+               pBtMgnt->ExtConfig.bBTBusy = false;
+
+       if (!bBtLinkExist) {
+               RTPRINT(FBT, BT_TRACE, ("[BTCoex], No profile exists!!!\n"));
+               return algorithm;
+       }
+
+       if (pBtMgnt->ExtConfig.NumberOfHandle == 1) {
+               if (bScoExist) {
+                       RTPRINT(FBT, BT_TRACE, ("[BTCoex], SCO only\n"));
+                       algorithm = BT_2ANT_COEX_ALGO_SCO;
+               } else {
+                       if (BTHCI_CheckProfileExist(padapter, BT_PROFILE_HID)) {
+                               RTPRINT(FBT, BT_TRACE, ("[BTCoex], HID only\n"));
+                               algorithm = BT_2ANT_COEX_ALGO_HID;
+                       } else if (BTHCI_CheckProfileExist(padapter, BT_PROFILE_A2DP)) {
+                               RTPRINT(FBT, BT_TRACE, ("[BTCoex], A2DP only\n"));
+                               algorithm = BT_2ANT_COEX_ALGO_A2DP;
+                       } else if (BTHCI_CheckProfileExist(padapter, BT_PROFILE_PAN)) {
+                               if (bBtHsModeExist) {
+                                       RTPRINT(FBT, BT_TRACE, ("[BTCoex], PAN(HS) only\n"));
+                                       algorithm = BT_2ANT_COEX_ALGO_PANHS;
+                               } else {
+                                       RTPRINT(FBT, BT_TRACE, ("[BTCoex], PAN(EDR) only\n"));
+                                       algorithm = BT_2ANT_COEX_ALGO_PANEDR;
+                               }
+                       } else {
+                               RTPRINT(FBT, BT_TRACE, ("[BTCoex], Error!!! NO matched profile for NumberOfHandle =%d \n",
+                               pBtMgnt->ExtConfig.NumberOfHandle));
+                       }
+               }
+       } else if (pBtMgnt->ExtConfig.NumberOfHandle == 2) {
+               if (bScoExist) {
+                       if (BTHCI_CheckProfileExist(padapter, BT_PROFILE_HID)) {
+                               RTPRINT(FBT, BT_TRACE, ("[BTCoex], SCO + HID\n"));
+                               algorithm = BT_2ANT_COEX_ALGO_HID;
+                       } else if (BTHCI_CheckProfileExist(padapter, BT_PROFILE_A2DP)) {
+                               RTPRINT(FBT, BT_TRACE, ("[BTCoex], Error!!! SCO + A2DP\n"));
+                       } else if (BTHCI_CheckProfileExist(padapter, BT_PROFILE_PAN)) {
+                               if (bBtHsModeExist) {
+                                       RTPRINT(FBT, BT_TRACE, ("[BTCoex], SCO + PAN(HS)\n"));
+                                       algorithm = BT_2ANT_COEX_ALGO_SCO;
+                               } else {
+                                       RTPRINT(FBT, BT_TRACE, ("[BTCoex], SCO + PAN(EDR)\n"));
+                                       algorithm = BT_2ANT_COEX_ALGO_PANEDR_HID;
+                               }
+                       } else {
+                               RTPRINT(FBT, BT_TRACE, ("[BTCoex], Error!!! SCO exists but why NO matched ACL profile for NumberOfHandle =%d\n",
+                               pBtMgnt->ExtConfig.NumberOfHandle));
+                       }
+               } else {
+                       if (BTHCI_CheckProfileExist(padapter, BT_PROFILE_HID) &&
+                           BTHCI_CheckProfileExist(padapter, BT_PROFILE_A2DP)) {
+                               RTPRINT(FBT, BT_TRACE, ("[BTCoex], HID + A2DP\n"));
+                               algorithm = BT_2ANT_COEX_ALGO_HID_A2DP;
+               } else if (BTHCI_CheckProfileExist(padapter, BT_PROFILE_HID) &&
+                          BTHCI_CheckProfileExist(padapter, BT_PROFILE_PAN)) {
+                               if (bBtHsModeExist) {
+                                       RTPRINT(FBT, BT_TRACE, ("[BTCoex], HID + PAN(HS)\n"));
+                                       algorithm = BT_2ANT_COEX_ALGO_HID_A2DP;
+                               } else {
+                                       RTPRINT(FBT, BT_TRACE, ("[BTCoex], HID + PAN(EDR)\n"));
+                                       algorithm = BT_2ANT_COEX_ALGO_PANEDR_HID;
+                               }
+                       } else if (BTHCI_CheckProfileExist(padapter, BT_PROFILE_PAN) &&
+                                  BTHCI_CheckProfileExist(padapter, BT_PROFILE_A2DP)) {
+                               if (bBtHsModeExist) {
+                                       RTPRINT(FBT, BT_TRACE, ("[BTCoex], A2DP + PAN(HS)\n"));
+                                       algorithm = BT_2ANT_COEX_ALGO_A2DP;
+                               } else {
+                                       RTPRINT(FBT, BT_TRACE, ("[BTCoex], A2DP + PAN(EDR)\n"));
+                                       algorithm = BT_2ANT_COEX_ALGO_PANEDR_A2DP;
+                               }
+                       } else {
+                               RTPRINT(FBT, BT_TRACE, ("[BTCoex], Error!!! NO matched profile for NumberOfHandle =%d\n",
+                                       pBtMgnt->ExtConfig.NumberOfHandle));
+                       }
+               }
+       } else if (pBtMgnt->ExtConfig.NumberOfHandle == 3) {
+               if (bScoExist) {
+                       if (BTHCI_CheckProfileExist(padapter, BT_PROFILE_HID) &&
+                           BTHCI_CheckProfileExist(padapter, BT_PROFILE_A2DP)) {
+                               RTPRINT(FBT, BT_TRACE, ("[BTCoex], Error!!! SCO + HID + A2DP\n"));
+                       } else if (BTHCI_CheckProfileExist(padapter, BT_PROFILE_HID) &&
+                                  BTHCI_CheckProfileExist(padapter, BT_PROFILE_PAN)) {
+                               if (bBtHsModeExist) {
+                                       RTPRINT(FBT, BT_TRACE, ("[BTCoex], SCO + HID + PAN(HS)\n"));
+                                       algorithm = BT_2ANT_COEX_ALGO_HID_A2DP;
+                               } else {
+                                       RTPRINT(FBT, BT_TRACE, ("[BTCoex], SCO + HID + PAN(EDR)\n"));
+                                       algorithm = BT_2ANT_COEX_ALGO_PANEDR_HID;
+                               }
+                       } else if (BTHCI_CheckProfileExist(padapter, BT_PROFILE_PAN) &&
+                                  BTHCI_CheckProfileExist(padapter, BT_PROFILE_A2DP)) {
+                               if (bBtHsModeExist) {
+                                       RTPRINT(FBT, BT_TRACE, ("[BTCoex], Error!!! SCO + A2DP + PAN(HS)\n"));
+                                       algorithm = BT_2ANT_COEX_ALGO_SCO;
+                               } else {
+                                       RTPRINT(FBT, BT_TRACE, ("[BTCoex], Error!!! SCO + A2DP + PAN(EDR)\n"));
+                               }
+                       } else {
+                               RTPRINT(FBT, BT_TRACE, ("[BTCoex], Error!!! SCO exists but why NO matched profile for NumberOfHandle =%d\n",
+                                       pBtMgnt->ExtConfig.NumberOfHandle));
+                       }
+               } else {
+                       if (BTHCI_CheckProfileExist(padapter, BT_PROFILE_HID) &&
+                           BTHCI_CheckProfileExist(padapter, BT_PROFILE_PAN) &&
+                           BTHCI_CheckProfileExist(padapter, BT_PROFILE_A2DP)) {
+                               if (bBtHsModeExist) {
+                                       RTPRINT(FBT, BT_TRACE, ("[BTCoex], HID + A2DP + PAN(HS)\n"));
+                                       algorithm = BT_2ANT_COEX_ALGO_HID_A2DP_PANHS;
+                               } else {
+                                       RTPRINT(FBT, BT_TRACE, ("[BTCoex], HID + A2DP + PAN(EDR)\n"));
+                                       algorithm = BT_2ANT_COEX_ALGO_HID_A2DP_PANEDR;
+                               }
+                       } else {
+                               RTPRINT(FBT, BT_TRACE, ("[BTCoex], Error!!! NO matched profile for NumberOfHandle =%d\n",
+                                       pBtMgnt->ExtConfig.NumberOfHandle));
+                       }
+               }
+       } else if (pBtMgnt->ExtConfig.NumberOfHandle >= 3) {
+               if (bScoExist) {
+                       if (BTHCI_CheckProfileExist(padapter, BT_PROFILE_HID) &&
+                           BTHCI_CheckProfileExist(padapter, BT_PROFILE_PAN) &&
+                           BTHCI_CheckProfileExist(padapter, BT_PROFILE_A2DP)) {
+                               if (bBtHsModeExist)
+                                       RTPRINT(FBT, BT_TRACE, ("[BTCoex], Error!!! SCO + HID + A2DP + PAN(HS)\n"));
+                               else
+                                       RTPRINT(FBT, BT_TRACE, ("[BTCoex], Error!!! SCO + HID + A2DP + PAN(EDR)\n"));
+                       } else {
+                               RTPRINT(FBT, BT_TRACE, ("[BTCoex], Error!!! SCO exists but why NO matched profile for NumberOfHandle =%d\n",
+                                       pBtMgnt->ExtConfig.NumberOfHandle));
+                       }
+               } else {
+                       RTPRINT(FBT, BT_TRACE, ("[BTCoex], Error!!! NO matched profile for NumberOfHandle =%d\n",
+                               pBtMgnt->ExtConfig.NumberOfHandle));
+               }
+       }
+       return algorithm;
+}
+
+static u8 btdm_NeedToDecBtPwr(struct rtw_adapter *padapter)
+{
+       struct hal_data_8723a *pHalData = GET_HAL_DATA(padapter);
+       u8 bRet = false;
+
+       if (BT_Operation(padapter)) {
+               if (pHalData->dmpriv.EntryMinUndecoratedSmoothedPWDB > 47) {
+                       RTPRINT(FBT, BT_TRACE, ("Need to decrease bt power for HS mode!!\n"));
+                       bRet = true;
+               } else {
+                       RTPRINT(FBT, BT_TRACE, ("NO Need to decrease bt power for HS mode!!\n"));
+               }
+       } else {
+               if (BTDM_IsWifiConnectionExist(padapter)) {
+                       RTPRINT(FBT, BT_TRACE, ("Need to decrease bt power for Wifi is connected!!\n"));
+                       bRet = true;
+               }
+       }
+       return bRet;
+}
+
+static void
+btdm_SetCoexTable(struct rtw_adapter *padapter, u32 val0x6c0,
+                 u32 val0x6c8, u8 val0x6cc)
+{
+       RTPRINT(FBT, BT_TRACE, ("set coex table, set 0x6c0 = 0x%x\n", val0x6c0));
+       rtl8723au_write32(padapter, 0x6c0, val0x6c0);
+
+       RTPRINT(FBT, BT_TRACE, ("set coex table, set 0x6c8 = 0x%x\n", val0x6c8));
+       rtl8723au_write32(padapter, 0x6c8, val0x6c8);
+
+       RTPRINT(FBT, BT_TRACE, ("set coex table, set 0x6cc = 0x%x\n", val0x6cc));
+       rtl8723au_write8(padapter, 0x6cc, val0x6cc);
+}
+
+static void
+btdm_SetSwFullTimeDacSwing(struct rtw_adapter *padapter, u8 bSwDacSwingOn,
+                          u32 swDacSwingLvl)
+{
+       struct hal_data_8723a *pHalData = GET_HAL_DATA(padapter);
+
+       if (bSwDacSwingOn) {
+               RTPRINT(FBT, BT_TRACE, ("[BTCoex], SwDacSwing = 0x%x\n", swDacSwingLvl));
+               PHY_SetBBReg(padapter, 0x880, 0xff000000, swDacSwingLvl);
+               pHalData->bt_coexist.bSWCoexistAllOff = false;
+       } else {
+               RTPRINT(FBT, BT_TRACE, ("[BTCoex], SwDacSwing Off!\n"));
+               PHY_SetBBReg(padapter, 0x880, 0xff000000, 0xc0);
+       }
+}
+
+static void
+btdm_SetFwDacSwingLevel(struct rtw_adapter *padapter, u8 dacSwingLvl)
+{
+       u8 H2C_Parameter[1] = {0};
+
+       H2C_Parameter[0] = dacSwingLvl;
+
+       RTPRINT(FBT, BT_TRACE, ("[BTCoex], Set Dac Swing Level = 0x%x\n", dacSwingLvl));
+       RTPRINT(FBT, BT_TRACE, ("[BTCoex], write 0x29 = 0x%x\n", H2C_Parameter[0]));
+
+       FillH2CCmd(padapter, 0x29, 1, H2C_Parameter);
+}
+
+static void btdm_2AntDecBtPwr(struct rtw_adapter *padapter, u8 bDecBtPwr)
+{
+       struct hal_data_8723a *pHalData = GET_HAL_DATA(padapter);
+       struct btdm_8723a_2ant *pBtdm8723 = &pHalData->bt_coexist.halCoex8723.btdm2Ant;
+
+       RTPRINT(FBT, BT_TRACE,
+               ("[BTCoex], Dec BT power = %s\n",
+               ((bDecBtPwr) ? "ON" : "OFF")));
+       pBtdm8723->bCurDecBtPwr = bDecBtPwr;
+
+       if (pBtdm8723->bPreDecBtPwr == pBtdm8723->bCurDecBtPwr)
+               return;
+
+       BTDM_SetFwDecBtPwr(padapter, pBtdm8723->bCurDecBtPwr);
+
+       pBtdm8723->bPreDecBtPwr = pBtdm8723->bCurDecBtPwr;
+}
+
+static void
+btdm_2AntFwDacSwingLvl(struct rtw_adapter *padapter, u8 fwDacSwingLvl)
+{
+       struct hal_data_8723a *pHalData = GET_HAL_DATA(padapter);
+       struct btdm_8723a_2ant *pBtdm8723 = &pHalData->bt_coexist.halCoex8723.btdm2Ant;
+
+       RTPRINT(FBT, BT_TRACE, ("[BTCoex], set FW Dac Swing level = %d\n",  fwDacSwingLvl));
+       pBtdm8723->curFwDacSwingLvl = fwDacSwingLvl;
+
+       /* RTPRINT(FBT, BT_TRACE, ("[BTCoex], preFwDacSwingLvl =%d, curFwDacSwingLvl =%d\n", */
+       /*pBtdm8723->preFwDacSwingLvl, pBtdm8723->curFwDacSwingLvl)); */
+
+       if (pBtdm8723->preFwDacSwingLvl == pBtdm8723->curFwDacSwingLvl)
+               return;
+
+       btdm_SetFwDacSwingLevel(padapter, pBtdm8723->curFwDacSwingLvl);
+
+       pBtdm8723->preFwDacSwingLvl = pBtdm8723->curFwDacSwingLvl;
+}
+
+static void
+btdm_2AntRfShrink(struct rtw_adapter *padapter, u8 bRxRfShrinkOn)
+{
+       struct hal_data_8723a *pHalData = GET_HAL_DATA(padapter);
+       struct btdm_8723a_2ant *pBtdm8723 = &pHalData->bt_coexist.halCoex8723.btdm2Ant;
+
+       RTPRINT(FBT, BT_TRACE,
+               ("[BTCoex], turn Rx RF Shrink = %s\n",
+               ((bRxRfShrinkOn) ? "ON" : "OFF")));
+       pBtdm8723->bCurRfRxLpfShrink = bRxRfShrinkOn;
+
+       /* RTPRINT(FBT, BT_TRACE, ("[BTCoex], bPreRfRxLpfShrink =%d, bCurRfRxLpfShrink =%d\n", */
+       /*pBtdm8723->bPreRfRxLpfShrink, pBtdm8723->bCurRfRxLpfShrink)); */
+
+       if (pBtdm8723->bPreRfRxLpfShrink == pBtdm8723->bCurRfRxLpfShrink)
+               return;
+
+       BTDM_SetSwRfRxLpfCorner(padapter, (u8)pBtdm8723->bCurRfRxLpfShrink);
+
+       pBtdm8723->bPreRfRxLpfShrink = pBtdm8723->bCurRfRxLpfShrink;
+}
+
+static void
+btdm_2AntLowPenaltyRa(struct rtw_adapter *padapter, u8 bLowPenaltyRa)
+{
+       struct hal_data_8723a *pHalData = GET_HAL_DATA(padapter);
+       struct btdm_8723a_2ant *pBtdm8723 = &pHalData->bt_coexist.halCoex8723.btdm2Ant;
+
+       RTPRINT(FBT, BT_TRACE,
+               ("[BTCoex], turn LowPenaltyRA = %s\n",
+               ((bLowPenaltyRa) ? "ON" : "OFF")));
+       pBtdm8723->bCurLowPenaltyRa = bLowPenaltyRa;
+
+       /* RTPRINT(FBT, BT_TRACE, ("[BTCoex], bPreLowPenaltyRa =%d, bCurLowPenaltyRa =%d\n", */
+       /*pBtdm8723->bPreLowPenaltyRa, pBtdm8723->bCurLowPenaltyRa)); */
+
+       if (pBtdm8723->bPreLowPenaltyRa == pBtdm8723->bCurLowPenaltyRa)
+               return;
+
+       BTDM_SetSwPenaltyTxRateAdaptive(padapter, (u8)pBtdm8723->bCurLowPenaltyRa);
+
+       pBtdm8723->bPreLowPenaltyRa = pBtdm8723->bCurLowPenaltyRa;
+}
+
+static void
+btdm_2AntDacSwing(struct rtw_adapter *padapter,
+                 u8 bDacSwingOn, u32 dacSwingLvl)
+{
+       struct hal_data_8723a *pHalData = GET_HAL_DATA(padapter);
+       struct btdm_8723a_2ant *pBtdm8723 = &pHalData->bt_coexist.halCoex8723.btdm2Ant;
+
+       RTPRINT(FBT, BT_TRACE,
+               ("[BTCoex], turn DacSwing =%s, dacSwingLvl = 0x%x\n",
+               (bDacSwingOn ? "ON" : "OFF"), dacSwingLvl));
+       pBtdm8723->bCurDacSwingOn = bDacSwingOn;
+       pBtdm8723->curDacSwingLvl = dacSwingLvl;
+
+       if ((pBtdm8723->bPreDacSwingOn == pBtdm8723->bCurDacSwingOn) &&
+           (pBtdm8723->preDacSwingLvl == pBtdm8723->curDacSwingLvl))
+               return;
+
+       mdelay(30);
+       btdm_SetSwFullTimeDacSwing(padapter, bDacSwingOn, dacSwingLvl);
+
+       pBtdm8723->bPreDacSwingOn = pBtdm8723->bCurDacSwingOn;
+       pBtdm8723->preDacSwingLvl = pBtdm8723->curDacSwingLvl;
+}
+
+static void btdm_2AntAdcBackOff(struct rtw_adapter *padapter, u8 bAdcBackOff)
+{
+       struct hal_data_8723a *pHalData = GET_HAL_DATA(padapter);
+       struct btdm_8723a_2ant *pBtdm8723 = &pHalData->bt_coexist.halCoex8723.btdm2Ant;
+
+       RTPRINT(FBT, BT_TRACE,
+               ("[BTCoex], turn AdcBackOff = %s\n",
+               ((bAdcBackOff) ? "ON" : "OFF")));
+       pBtdm8723->bCurAdcBackOff = bAdcBackOff;
+
+       if (pBtdm8723->bPreAdcBackOff == pBtdm8723->bCurAdcBackOff)
+               return;
+
+       BTDM_BBBackOffLevel(padapter, (u8)pBtdm8723->bCurAdcBackOff);
+
+       pBtdm8723->bPreAdcBackOff = pBtdm8723->bCurAdcBackOff;
+}
+
+static void btdm_2AntAgcTable(struct rtw_adapter *padapter, u8 bAgcTableEn)
+{
+       struct hal_data_8723a *pHalData = GET_HAL_DATA(padapter);
+       struct btdm_8723a_2ant *pBtdm8723 = &pHalData->bt_coexist.halCoex8723.btdm2Ant;
+
+       RTPRINT(FBT, BT_TRACE,
+               ("[BTCoex], %s Agc Table\n", ((bAgcTableEn) ? "Enable" : "Disable")));
+       pBtdm8723->bCurAgcTableEn = bAgcTableEn;
+
+       /* RTPRINT(FBT, BT_TRACE, ("[BTCoex], bPreAgcTableEn =%d, bCurAgcTableEn =%d\n", */
+       /*pBtdm8723->bPreAgcTableEn, pBtdm8723->bCurAgcTableEn)); */
+
+       if (pBtdm8723->bPreAgcTableEn == pBtdm8723->bCurAgcTableEn)
+               return;
+
+       BTDM_AGCTable(padapter, (u8)bAgcTableEn);
+
+       pBtdm8723->bPreAgcTableEn = pBtdm8723->bCurAgcTableEn;
+}
+
+static void
+btdm_2AntCoexTable(struct rtw_adapter *padapter,
+                  u32 val0x6c0, u32 val0x6c8, u8 val0x6cc)
+{
+       struct hal_data_8723a *pHalData = GET_HAL_DATA(padapter);
+       struct btdm_8723a_2ant *pBtdm8723 = &pHalData->bt_coexist.halCoex8723.btdm2Ant;
+
+       RTPRINT(FBT, BT_TRACE, ("[BTCoex], write Coex Table 0x6c0 = 0x%x, 0x6c8 = 0x%x, 0x6cc = 0x%x\n",
+               val0x6c0, val0x6c8, val0x6cc));
+       pBtdm8723->curVal0x6c0 = val0x6c0;
+       pBtdm8723->curVal0x6c8 = val0x6c8;
+       pBtdm8723->curVal0x6cc = val0x6cc;
+
+       /* RTPRINT(FBT, BT_TRACE, ("[BTCoex], preVal0x6c0 = 0x%x, preVal0x6c8 = 0x%x, preVal0x6cc = 0x%x !!\n", */
+       /*pBtdm8723->preVal0x6c0, pBtdm8723->preVal0x6c8, pBtdm8723->preVal0x6cc)); */
+       /* RTPRINT(FBT, BT_TRACE, ("[BTCoex], curVal0x6c0 = 0x%x, curVal0x6c8 = 0x%x, curVal0x6cc = 0x%x !!\n", */
+       /*pBtdm8723->curVal0x6c0, pBtdm8723->curVal0x6c8, pBtdm8723->curVal0x6cc)); */
+
+       if ((pBtdm8723->preVal0x6c0 == pBtdm8723->curVal0x6c0) &&
+           (pBtdm8723->preVal0x6c8 == pBtdm8723->curVal0x6c8) &&
+           (pBtdm8723->preVal0x6cc == pBtdm8723->curVal0x6cc))
+               return;
+
+       btdm_SetCoexTable(padapter, val0x6c0, val0x6c8, val0x6cc);
+
+       pBtdm8723->preVal0x6c0 = pBtdm8723->curVal0x6c0;
+       pBtdm8723->preVal0x6c8 = pBtdm8723->curVal0x6c8;
+       pBtdm8723->preVal0x6cc = pBtdm8723->curVal0x6cc;
+}
+
+static void btdm_2AntIgnoreWlanAct(struct rtw_adapter *padapter, u8 bEnable)
+{
+       struct hal_data_8723a *pHalData = GET_HAL_DATA(padapter);
+       struct btdm_8723a_2ant *pBtdm8723 = &pHalData->bt_coexist.halCoex8723.btdm2Ant;
+
+       RTPRINT(FBT, BT_TRACE,
+               ("[BTCoex], turn Ignore WlanAct %s\n", (bEnable ? "ON" : "OFF")));
+       pBtdm8723->bCurIgnoreWlanAct = bEnable;
+
+
+       if (pBtdm8723->bPreIgnoreWlanAct == pBtdm8723->bCurIgnoreWlanAct)
+               return;
+
+       btdm_SetFwIgnoreWlanAct(padapter, bEnable);
+       pBtdm8723->bPreIgnoreWlanAct = pBtdm8723->bCurIgnoreWlanAct;
+}
+
+static void
+btdm_2AntSetFw3a(struct rtw_adapter *padapter, u8 byte1, u8 byte2,
+                u8 byte3, u8 byte4, u8 byte5)
+{
+       u8 H2C_Parameter[5] = {0};
+
+       struct hal_data_8723a *pHalData = GET_HAL_DATA(padapter);
+
+       /*  byte1[1:0] != 0 means enable pstdma */
+       /*  for 2Ant bt coexist, if byte1 != 0 means enable pstdma */
+       if (byte1)
+               pHalData->bt_coexist.bFWCoexistAllOff = false;
+       H2C_Parameter[0] = byte1;
+       H2C_Parameter[1] = byte2;
+       H2C_Parameter[2] = byte3;
+       H2C_Parameter[3] = byte4;
+       H2C_Parameter[4] = byte5;
+
+       pHalData->bt_coexist.fw3aVal[0] = byte1;
+       pHalData->bt_coexist.fw3aVal[1] = byte2;
+       pHalData->bt_coexist.fw3aVal[2] = byte3;
+       pHalData->bt_coexist.fw3aVal[3] = byte4;
+       pHalData->bt_coexist.fw3aVal[4] = byte5;
+
+       RTPRINT(FBT, BT_TRACE, ("[BTCoex], FW write 0x3a(5bytes) = 0x%x%08x\n",
+               H2C_Parameter[0],
+               H2C_Parameter[1]<<24|H2C_Parameter[2]<<16|H2C_Parameter[3]<<8|H2C_Parameter[4]));
+
+       FillH2CCmd(padapter, 0x3a, 5, H2C_Parameter);
+       }
+
+static void btdm_2AntPsTdma(struct rtw_adapter *padapter, u8 bTurnOn, u8 type)
+{
+       struct hal_data_8723a *pHalData = GET_HAL_DATA(padapter);
+       struct btdm_8723a_2ant *pBtdm8723 = &pHalData->bt_coexist.halCoex8723.btdm2Ant;
+       u32                     btTxRxCnt = 0;
+       u8 bTurnOnByCnt = false;
+       u8 psTdmaTypeByCnt = 0;
+
+       btTxRxCnt = BTDM_BtTxRxCounterH(padapter)+BTDM_BtTxRxCounterL(padapter);
+       RTPRINT(FBT, BT_TRACE, ("[BTCoex], BT TxRx Counters = %d\n", btTxRxCnt));
+       if (btTxRxCnt > 3000) {
+               bTurnOnByCnt = true;
+               psTdmaTypeByCnt = 8;
+
+               RTPRINT(FBT, BT_TRACE,
+                       ("[BTCoex], For BTTxRxCounters, turn %s PS TDMA, type =%d\n",
+                       (bTurnOnByCnt ? "ON" : "OFF"), psTdmaTypeByCnt));
+               pBtdm8723->bCurPsTdmaOn = bTurnOnByCnt;
+               pBtdm8723->curPsTdma = psTdmaTypeByCnt;
+       } else {
+               RTPRINT(FBT, BT_TRACE,
+                       ("[BTCoex], turn %s PS TDMA, type =%d\n",
+                       (bTurnOn ? "ON" : "OFF"), type));
+               pBtdm8723->bCurPsTdmaOn = bTurnOn;
+               pBtdm8723->curPsTdma = type;
+       }
+
+       if ((pBtdm8723->bPrePsTdmaOn == pBtdm8723->bCurPsTdmaOn) &&
+           (pBtdm8723->prePsTdma == pBtdm8723->curPsTdma))
+               return;
+
+       if (bTurnOn) {
+               switch (type) {
+               case 1:
+               default:
+                       btdm_2AntSetFw3a(padapter, 0xe3, 0x1a, 0x1a, 0xa1, 0x98);
+                       break;
+               case 2:
+                       btdm_2AntSetFw3a(padapter, 0xe3, 0x12, 0x12, 0xa1, 0x98);
+                       break;
+               case 3:
+                       btdm_2AntSetFw3a(padapter, 0xe3, 0xa, 0xa, 0xa1, 0x98);
+                       break;
+               case 4:
+                       btdm_2AntSetFw3a(padapter, 0xa3, 0x5, 0x5, 0xa1, 0x80);
+                       break;
+               case 5:
+                       btdm_2AntSetFw3a(padapter, 0xe3, 0x1a, 0x1a, 0x20, 0x98);
+                       break;
+               case 6:
+                       btdm_2AntSetFw3a(padapter, 0xe3, 0x12, 0x12, 0x20, 0x98);
+                       break;
+               case 7:
+                       btdm_2AntSetFw3a(padapter, 0xe3, 0xa, 0xa, 0x20, 0x98);
+                       break;
+               case 8:
+                       btdm_2AntSetFw3a(padapter, 0xa3, 0x5, 0x5, 0x20, 0x80);
+                       break;
+               case 9:
+                       btdm_2AntSetFw3a(padapter, 0xe3, 0x1a, 0x1a, 0xa1, 0x98);
+                       break;
+               case 10:
+                       btdm_2AntSetFw3a(padapter, 0xe3, 0x12, 0x12, 0xa1, 0x98);
+                       break;
+               case 11:
+                       btdm_2AntSetFw3a(padapter, 0xe3, 0xa, 0xa, 0xa1, 0x98);
+                       break;
+               case 12:
+                       btdm_2AntSetFw3a(padapter, 0xe3, 0x5, 0x5, 0xa1, 0x98);
+                       break;
+               case 13:
+                       btdm_2AntSetFw3a(padapter, 0xe3, 0x1a, 0x1a, 0x20, 0x98);
+                       break;
+               case 14:
+                       btdm_2AntSetFw3a(padapter, 0xe3, 0x12, 0x12, 0x20, 0x98);
+                       break;
+               case 15:
+                       btdm_2AntSetFw3a(padapter, 0xe3, 0xa, 0xa, 0x20, 0x98);
+                       break;
+               case 16:
+                       btdm_2AntSetFw3a(padapter, 0xe3, 0x5, 0x5, 0x20, 0x98);
+                       break;
+               case 17:
+                       btdm_2AntSetFw3a(padapter, 0xa3, 0x2f, 0x2f, 0x20, 0x80);
+                       break;
+               case 18:
+                       btdm_2AntSetFw3a(padapter, 0xe3, 0x5, 0x5, 0xa1, 0x98);
+                       break;
+               case 19:
+                       btdm_2AntSetFw3a(padapter, 0xe3, 0x25, 0x25, 0xa1, 0x98);
+                       break;
+               case 20:
+                       btdm_2AntSetFw3a(padapter, 0xe3, 0x25, 0x25, 0x20, 0x98);
+                       break;
+               }
+       } else {
+               /*  disable PS tdma */
+               switch (type) {
+               case 0:
+                       btdm_2AntSetFw3a(padapter, 0x0, 0x0, 0x0, 0x8, 0x0);
+                       break;
+               case 1:
+                       btdm_2AntSetFw3a(padapter, 0x0, 0x0, 0x0, 0x0, 0x0);
+                       break;
+               default:
+                       btdm_2AntSetFw3a(padapter, 0x0, 0x0, 0x0, 0x8, 0x0);
+                       break;
+               }
+       }
+
+       /*  update pre state */
+       pBtdm8723->bPrePsTdmaOn =  pBtdm8723->bCurPsTdmaOn;
+       pBtdm8723->prePsTdma = pBtdm8723->curPsTdma;
+}
+
+static void btdm_2AntBtInquiryPage(struct rtw_adapter *padapter)
+{
+       btdm_2AntCoexTable(padapter, 0x55555555, 0xffff, 0x3);
+       btdm_2AntIgnoreWlanAct(padapter, false);
+       btdm_2AntPsTdma(padapter, true, 8);
+}
+
+static u8 btdm_HoldForBtInqPage(struct rtw_adapter *padapter)
+{
+       struct hal_data_8723a *pHalData = GET_HAL_DATA(padapter);
+       u32 curTime = jiffies;
+
+       if (pHalData->bt_coexist.halCoex8723.bC2hBtInquiryPage) {
+               /*  bt inquiry or page is started. */
+               if (pHalData->bt_coexist.halCoex8723.btInqPageStartTime == 0) {
+                       pHalData->bt_coexist.halCoex8723.btInqPageStartTime = curTime;
+                       RTPRINT(FBT, BT_TRACE, ("[BTCoex], BT Inquiry/page is started at time : 0x%lx \n",
+                       pHalData->bt_coexist.halCoex8723.btInqPageStartTime));
+               }
+       }
+       RTPRINT(FBT, BT_TRACE, ("[BTCoex], BT Inquiry/page started time : 0x%lx, curTime : 0x%x \n",
+               pHalData->bt_coexist.halCoex8723.btInqPageStartTime, curTime));
+
+       if (pHalData->bt_coexist.halCoex8723.btInqPageStartTime) {
+               if (((curTime - pHalData->bt_coexist.halCoex8723.btInqPageStartTime)/1000000) >= 10) {
+                       RTPRINT(FBT, BT_TRACE, ("[BTCoex], BT Inquiry/page >= 10sec!!!"));
+                       pHalData->bt_coexist.halCoex8723.btInqPageStartTime = 0;
+               }
+       }
+
+       if (pHalData->bt_coexist.halCoex8723.btInqPageStartTime) {
+               btdm_2AntCoexTable(padapter, 0x55555555, 0xffff, 0x3);
+               btdm_2AntIgnoreWlanAct(padapter, false);
+               btdm_2AntPsTdma(padapter, true, 8);
+               return true;
+       } else {
+               return false;
+       }
+}
+
+static u8 btdm_Is2Ant8723ACommonAction(struct rtw_adapter *padapter)
+{
+       struct hal_data_8723a *pHalData = GET_HAL_DATA(padapter);
+       struct btdm_8723a_2ant *pBtdm8723 = &pHalData->bt_coexist.halCoex8723.btdm2Ant;
+       u8 bCommon = false;
+
+       RTPRINT(FBT, BT_TRACE, ("%s :BTDM_IsWifiConnectionExist =%x check_fwstate =%x pmlmepriv->fw_state = 0x%x\n", __func__, BTDM_IsWifiConnectionExist(padapter), check_fwstate(&padapter->mlmepriv, (_FW_UNDER_SURVEY|_FW_UNDER_LINKING)), padapter->mlmepriv.fw_state));
+
+       if ((!BTDM_IsWifiConnectionExist(padapter)) &&
+           (!check_fwstate(&padapter->mlmepriv, (_FW_UNDER_SURVEY|_FW_UNDER_LINKING))) &&
+           (BT_2ANT_BT_STATUS_IDLE == pBtdm8723->btStatus)) {
+               RTPRINT(FBT, BT_TRACE, ("Wifi idle + Bt idle!!\n"));
+
+               btdm_2AntLowPenaltyRa(padapter, false);
+               btdm_2AntRfShrink(padapter, false);
+               btdm_2AntCoexTable(padapter, 0x55555555, 0xffff, 0x3);
+
+               btdm_2AntIgnoreWlanAct(padapter, false);
+               btdm_2AntPsTdma(padapter, false, 0);
+               btdm_2AntFwDacSwingLvl(padapter, 0x20);
+               btdm_2AntDecBtPwr(padapter, false);
+
+               btdm_2AntAgcTable(padapter, false);
+               btdm_2AntAdcBackOff(padapter, false);
+               btdm_2AntDacSwing(padapter, false, 0xc0);
+
+               bCommon = true;
+       } else if (((BTDM_IsWifiConnectionExist(padapter)) ||
+                  (check_fwstate(&padapter->mlmepriv, (_FW_UNDER_SURVEY|_FW_UNDER_LINKING)))) &&
+                  (BT_2ANT_BT_STATUS_IDLE == pBtdm8723->btStatus)) {
+               RTPRINT(FBT, BT_TRACE, ("Wifi non-idle + BT idle!!\n"));
+
+               btdm_2AntLowPenaltyRa(padapter, true);
+               btdm_2AntRfShrink(padapter, false);
+               btdm_2AntCoexTable(padapter, 0x55555555, 0xffff, 0x3);
+
+               btdm_2AntIgnoreWlanAct(padapter, false);
+               btdm_2AntPsTdma(padapter, false, 0);
+               btdm_2AntFwDacSwingLvl(padapter, 0x20);
+               btdm_2AntDecBtPwr(padapter, true);
+
+               btdm_2AntAgcTable(padapter, false);
+               btdm_2AntAdcBackOff(padapter, false);
+               btdm_2AntDacSwing(padapter, false, 0xc0);
+
+               bCommon = true;
+       } else if ((!BTDM_IsWifiConnectionExist(padapter)) &&
+                  (!check_fwstate(&padapter->mlmepriv, (_FW_UNDER_SURVEY|_FW_UNDER_LINKING))) &&
+                  (BT_2ANT_BT_STATUS_CONNECTED_IDLE == pBtdm8723->btStatus)) {
+               RTPRINT(FBT, BT_TRACE, ("Wifi idle + Bt connected idle!!\n"));
+
+               btdm_2AntLowPenaltyRa(padapter, true);
+               btdm_2AntRfShrink(padapter, true);
+               btdm_2AntCoexTable(padapter, 0x55555555, 0xffff, 0x3);
+
+               btdm_2AntIgnoreWlanAct(padapter, false);
+               btdm_2AntPsTdma(padapter, false, 0);
+               btdm_2AntFwDacSwingLvl(padapter, 0x20);
+               btdm_2AntDecBtPwr(padapter, false);
+
+               btdm_2AntAgcTable(padapter, false);
+               btdm_2AntAdcBackOff(padapter, false);
+               btdm_2AntDacSwing(padapter, false, 0xc0);
+
+               bCommon = true;
+       } else if (((BTDM_IsWifiConnectionExist(padapter)) ||
+                  (check_fwstate(&padapter->mlmepriv, (_FW_UNDER_SURVEY|_FW_UNDER_LINKING)))) &&
+                  (BT_2ANT_BT_STATUS_CONNECTED_IDLE == pBtdm8723->btStatus)) {
+               RTPRINT(FBT, BT_TRACE, ("Wifi non-idle + Bt connected idle!!\n"));
+
+               btdm_2AntLowPenaltyRa(padapter, true);
+               btdm_2AntRfShrink(padapter, true);
+               btdm_2AntCoexTable(padapter, 0x55555555, 0xffff, 0x3);
+
+               btdm_2AntIgnoreWlanAct(padapter, false);
+               btdm_2AntPsTdma(padapter, false, 0);
+               btdm_2AntFwDacSwingLvl(padapter, 0x20);
+               btdm_2AntDecBtPwr(padapter, true);
+
+               btdm_2AntAgcTable(padapter, false);
+               btdm_2AntAdcBackOff(padapter, false);
+               btdm_2AntDacSwing(padapter, false, 0xc0);
+
+               bCommon = true;
+       } else if ((!BTDM_IsWifiConnectionExist(padapter)) &&
+                  (!check_fwstate(&padapter->mlmepriv, (_FW_UNDER_SURVEY|_FW_UNDER_LINKING))) &&
+                  (BT_2ANT_BT_STATUS_NON_IDLE == pBtdm8723->btStatus)) {
+               RTPRINT(FBT, BT_TRACE, ("Wifi idle + BT non-idle!!\n"));
+
+               btdm_2AntLowPenaltyRa(padapter, true);
+               btdm_2AntRfShrink(padapter, true);
+               btdm_2AntCoexTable(padapter, 0x55555555, 0xffff, 0x3);
+
+               btdm_2AntIgnoreWlanAct(padapter, false);
+               btdm_2AntPsTdma(padapter, false, 0);
+               btdm_2AntFwDacSwingLvl(padapter, 0x20);
+               btdm_2AntDecBtPwr(padapter, false);
+
+               btdm_2AntAgcTable(padapter, false);
+               btdm_2AntAdcBackOff(padapter, false);
+               btdm_2AntDacSwing(padapter, false, 0xc0);
+
+               bCommon = true;
+       } else {
+               RTPRINT(FBT, BT_TRACE, ("Wifi non-idle + BT non-idle!!\n"));
+               btdm_2AntLowPenaltyRa(padapter, true);
+               btdm_2AntRfShrink(padapter, true);
+               btdm_2AntCoexTable(padapter, 0x55555555, 0xffff, 0x3);
+               btdm_2AntIgnoreWlanAct(padapter, false);
+               btdm_2AntFwDacSwingLvl(padapter, 0x20);
+
+               bCommon = false;
+       }
+       return bCommon;
+}
+
+static void
+btdm_2AntTdmaDurationAdjust(struct rtw_adapter *padapter, u8 bScoHid,
+                           u8 bTxPause, u8 maxInterval)
+{
+       struct hal_data_8723a *pHalData = GET_HAL_DATA(padapter);
+       struct btdm_8723a_2ant *pBtdm8723 = &pHalData->bt_coexist.halCoex8723.btdm2Ant;
+       static s32              up, dn, m, n, WaitCount;
+       s32                     result;   /* 0: no change, +1: increase WiFi duration, -1: decrease WiFi duration */
+       u8 retryCount = 0;
+
+       RTPRINT(FBT, BT_TRACE, ("[BTCoex], TdmaDurationAdjust()\n"));
+
+       if (pBtdm8723->bResetTdmaAdjust) {
+               pBtdm8723->bResetTdmaAdjust = false;
+               RTPRINT(FBT, BT_TRACE, ("[BTCoex], first run TdmaDurationAdjust()!!\n"));
+               if (bScoHid) {
+                       if (bTxPause) {
+                               btdm_2AntPsTdma(padapter, true, 15);
+                               pBtdm8723->psTdmaDuAdjType = 15;
+                       } else {
+                               btdm_2AntPsTdma(padapter, true, 11);
+                               pBtdm8723->psTdmaDuAdjType = 11;
+                       }
+               } else {
+                       if (bTxPause) {
+                               btdm_2AntPsTdma(padapter, true, 7);
+                               pBtdm8723->psTdmaDuAdjType = 7;
+                       } else {
+                               btdm_2AntPsTdma(padapter, true, 3);
+                               pBtdm8723->psTdmaDuAdjType = 3;
+                       }
+               }
+               up = 0;
+               dn = 0;
+               m = 1;
+               n = 3;
+               result = 0;
+               WaitCount = 0;
+       } else {
+               /* accquire the BT TRx retry count from BT_Info byte2 */
+               retryCount = pHalData->bt_coexist.halCoex8723.btRetryCnt;
+               RTPRINT(FBT, BT_TRACE, ("[BTCoex], retryCount = %d\n", retryCount));
+               result = 0;
+               WaitCount++;
+
+               if (retryCount == 0) {  /*  no retry in the last 2-second duration */
+                       up++;
+                       dn--;
+
+                       if (dn <= 0)
+                               dn = 0;
+
+                       if (up >= n) {  /*  if ³sÄò n ­Ó2¬í retry count¬°0, «h½Õ¼eWiFi duration */
+                               WaitCount = 0;
+                               n = 3;
+                               up = 0;
+                               dn = 0;
+                               result = 1;
+                               RTPRINT(FBT, BT_TRACE, ("[BTCoex], Increase wifi duration!!\n"));
+                       }
+               } else if (retryCount <= 3) {   /*  <= 3 retry in the last 2-second duration */
+                       up--;
+                       dn++;
+
+                       if (up <= 0)
+                               up = 0;
+
+                       if (dn == 2) {  /*  if ³sÄò 2 ­Ó2¬í retry count< 3, «h½Õ¯¶WiFi duration */
+                               if (WaitCount <= 2)
+                                       m++; /*  ÁקK¤@ª½¦b¨â­Ólevel¤¤¨Ó¦^ */
+                               else
+                                       m = 1;
+
+                               if (m >= 20) /* m ³Ì¤j­È = 20 ' ³Ì¤j120¬í recheck¬O§_½Õ¾ã WiFi duration. */
+                                       m = 20;
+
+                               n = 3*m;
+                               up = 0;
+                               dn = 0;
+                               WaitCount = 0;
+                               result = -1;
+                               RTPRINT(FBT, BT_TRACE, ("[BTCoex], Decrease wifi duration for retryCounter<3!!\n"));
+                       }
+               } else {  /* retry count > 3, ¥u­n1¦¸ retry count > 3, «h½Õ¯¶WiFi duration */
+                       if (WaitCount == 1)
+                               m++; /*  ÁקK¤@ª½¦b¨â­Ólevel¤¤¨Ó¦^ */
+                       else
+                               m = 1;
+
+                       if (m >= 20) /* m ³Ì¤j­È = 20 ' ³Ì¤j120¬í recheck¬O§_½Õ¾ã WiFi duration. */
+                               m = 20;
+                       n = 3*m;
+                       up = 0;
+                       dn = 0;
+                       WaitCount = 0;
+                       result = -1;
+                       RTPRINT(FBT, BT_TRACE, ("[BTCoex], Decrease wifi duration for retryCounter>3!!\n"));
+               }
+
+               RTPRINT(FBT, BT_TRACE, ("[BTCoex], max Interval = %d\n", maxInterval));
+               if (maxInterval == 1) {
+                       if (bTxPause) {
+                               RTPRINT(FBT, BT_TRACE, ("[BTCoex], TxPause = 1\n"));
+                               if (pBtdm8723->curPsTdma == 1) {
+                                       btdm_2AntPsTdma(padapter, true, 5);
+                                       pBtdm8723->psTdmaDuAdjType = 5;
+                               } else if (pBtdm8723->curPsTdma == 2) {
+                                       btdm_2AntPsTdma(padapter, true, 6);
+                                       pBtdm8723->psTdmaDuAdjType = 6;
+                               } else if (pBtdm8723->curPsTdma == 3) {
+                                       btdm_2AntPsTdma(padapter, true, 7);
+                                       pBtdm8723->psTdmaDuAdjType = 7;
+                               } else if (pBtdm8723->curPsTdma == 4) {
+                                       btdm_2AntPsTdma(padapter, true, 8);
+                                       pBtdm8723->psTdmaDuAdjType = 8;
+                               }
+                               if (pBtdm8723->curPsTdma == 9) {
+                                       btdm_2AntPsTdma(padapter, true, 13);
+                                       pBtdm8723->psTdmaDuAdjType = 13;
+                               } else if (pBtdm8723->curPsTdma == 10) {
+                                       btdm_2AntPsTdma(padapter, true, 14);
+                                       pBtdm8723->psTdmaDuAdjType = 14;
+                               } else if (pBtdm8723->curPsTdma == 11) {
+                                       btdm_2AntPsTdma(padapter, true, 15);
+                                       pBtdm8723->psTdmaDuAdjType = 15;
+                               } else if (pBtdm8723->curPsTdma == 12) {
+                                       btdm_2AntPsTdma(padapter, true, 16);
+                                       pBtdm8723->psTdmaDuAdjType = 16;
+                               }
+
+                               if (result == -1) {
+                                       if (pBtdm8723->curPsTdma == 5) {
+                                               btdm_2AntPsTdma(padapter, true, 6);
+                                               pBtdm8723->psTdmaDuAdjType = 6;
+                                       } else if (pBtdm8723->curPsTdma == 6) {
+                                               btdm_2AntPsTdma(padapter, true, 7);
+                                               pBtdm8723->psTdmaDuAdjType = 7;
+                                       } else if (pBtdm8723->curPsTdma == 7) {
+                                               btdm_2AntPsTdma(padapter, true, 8);
+                                               pBtdm8723->psTdmaDuAdjType = 8;
+                                       } else if (pBtdm8723->curPsTdma == 13) {
+                                               btdm_2AntPsTdma(padapter, true, 14);
+                                               pBtdm8723->psTdmaDuAdjType = 14;
+                                       } else if (pBtdm8723->curPsTdma == 14) {
+                                               btdm_2AntPsTdma(padapter, true, 15);
+                                               pBtdm8723->psTdmaDuAdjType = 15;
+                                       } else if (pBtdm8723->curPsTdma == 15) {
+                                               btdm_2AntPsTdma(padapter, true, 16);
+                                               pBtdm8723->psTdmaDuAdjType = 16;
+                                       }
+                               } else if (result == 1) {
+                                       if (pBtdm8723->curPsTdma == 8) {
+                                               btdm_2AntPsTdma(padapter, true, 7);
+                                               pBtdm8723->psTdmaDuAdjType = 7;
+                                       } else if (pBtdm8723->curPsTdma == 7) {
+                                               btdm_2AntPsTdma(padapter, true, 6);
+                                               pBtdm8723->psTdmaDuAdjType = 6;
+                                       } else if (pBtdm8723->curPsTdma == 6) {
+                                               btdm_2AntPsTdma(padapter, true, 5);
+                                               pBtdm8723->psTdmaDuAdjType = 5;
+                                       } else if (pBtdm8723->curPsTdma == 16) {
+                                               btdm_2AntPsTdma(padapter, true, 15);
+                                               pBtdm8723->psTdmaDuAdjType = 15;
+                                       } else if (pBtdm8723->curPsTdma == 15) {
+                                               btdm_2AntPsTdma(padapter, true, 14);
+                                               pBtdm8723->psTdmaDuAdjType = 14;
+                                       } else if (pBtdm8723->curPsTdma == 14) {
+                                               btdm_2AntPsTdma(padapter, true, 13);
+                                               pBtdm8723->psTdmaDuAdjType = 13;
+                                       }
+                               }
+                       } else {
+                               RTPRINT(FBT, BT_TRACE, ("[BTCoex], TxPause = 0\n"));
+                               if (pBtdm8723->curPsTdma == 5) {
+                                       btdm_2AntPsTdma(padapter, true, 1);
+                                       pBtdm8723->psTdmaDuAdjType = 1;
+                               } else if (pBtdm8723->curPsTdma == 6) {
+                                       btdm_2AntPsTdma(padapter, true, 2);
+                                       pBtdm8723->psTdmaDuAdjType = 2;
+                               } else if (pBtdm8723->curPsTdma == 7) {
+                                       btdm_2AntPsTdma(padapter, true, 3);
+                                       pBtdm8723->psTdmaDuAdjType = 3;
+                               } else if (pBtdm8723->curPsTdma == 8) {
+                                       btdm_2AntPsTdma(padapter, true, 4);
+                                       pBtdm8723->psTdmaDuAdjType = 4;
+                               }
+                               if (pBtdm8723->curPsTdma == 13) {
+                                       btdm_2AntPsTdma(padapter, true, 9);
+                                       pBtdm8723->psTdmaDuAdjType = 9;
+                               } else if (pBtdm8723->curPsTdma == 14) {
+                                       btdm_2AntPsTdma(padapter, true, 10);
+                                       pBtdm8723->psTdmaDuAdjType = 10;
+                               } else if (pBtdm8723->curPsTdma == 15) {
+                                       btdm_2AntPsTdma(padapter, true, 11);
+                                       pBtdm8723->psTdmaDuAdjType = 11;
+                               } else if (pBtdm8723->curPsTdma == 16) {
+                                       btdm_2AntPsTdma(padapter, true, 12);
+                                       pBtdm8723->psTdmaDuAdjType = 12;
+                               }
+
+                               if (result == -1) {
+                                       if (pBtdm8723->curPsTdma == 1) {
+                                               btdm_2AntPsTdma(padapter, true, 2);
+                                               pBtdm8723->psTdmaDuAdjType = 2;
+                                       } else if (pBtdm8723->curPsTdma == 2) {
+                                               btdm_2AntPsTdma(padapter, true, 3);
+                                               pBtdm8723->psTdmaDuAdjType = 3;
+                                       } else if (pBtdm8723->curPsTdma == 3) {
+                                               btdm_2AntPsTdma(padapter, true, 4);
+                                               pBtdm8723->psTdmaDuAdjType = 4;
+                                       } else if (pBtdm8723->curPsTdma == 9) {
+                                               btdm_2AntPsTdma(padapter, true, 10);
+                                               pBtdm8723->psTdmaDuAdjType = 10;
+                                       } else if (pBtdm8723->curPsTdma == 10) {
+                                               btdm_2AntPsTdma(padapter, true, 11);
+                                               pBtdm8723->psTdmaDuAdjType = 11;
+                                       } else if (pBtdm8723->curPsTdma == 11) {
+                                               btdm_2AntPsTdma(padapter, true, 12);
+                                               pBtdm8723->psTdmaDuAdjType = 12;
+                                       }
+                               } else if (result == 1) {
+                                       if (pBtdm8723->curPsTdma == 4) {
+                                               btdm_2AntPsTdma(padapter, true, 3);
+                                               pBtdm8723->psTdmaDuAdjType = 3;
+                                       } else if (pBtdm8723->curPsTdma == 3) {
+                                               btdm_2AntPsTdma(padapter, true, 2);
+                                               pBtdm8723->psTdmaDuAdjType = 2;
+                                       } else if (pBtdm8723->curPsTdma == 2) {
+                                               btdm_2AntPsTdma(padapter, true, 1);
+                                               pBtdm8723->psTdmaDuAdjType = 1;
+                                       } else if (pBtdm8723->curPsTdma == 12) {
+                                               btdm_2AntPsTdma(padapter, true, 11);
+                                               pBtdm8723->psTdmaDuAdjType = 11;
+                                       } else if (pBtdm8723->curPsTdma == 11) {
+                                               btdm_2AntPsTdma(padapter, true, 10);
+                                               pBtdm8723->psTdmaDuAdjType = 10;
+                                       } else if (pBtdm8723->curPsTdma == 10) {
+                                               btdm_2AntPsTdma(padapter, true, 9);
+                                               pBtdm8723->psTdmaDuAdjType = 9;
+                                       }
+                               }
+                       }
+               } else if (maxInterval == 2) {
+                       if (bTxPause) {
+                               RTPRINT(FBT, BT_TRACE, ("[BTCoex], TxPause = 1\n"));
+                               if (pBtdm8723->curPsTdma == 1) {
+                                       btdm_2AntPsTdma(padapter, true, 6);
+                                       pBtdm8723->psTdmaDuAdjType = 6;
+                               } else if (pBtdm8723->curPsTdma == 2) {
+                                       btdm_2AntPsTdma(padapter, true, 6);
+                                       pBtdm8723->psTdmaDuAdjType = 6;
+                               } else if (pBtdm8723->curPsTdma == 3) {
+                                       btdm_2AntPsTdma(padapter, true, 7);
+                                       pBtdm8723->psTdmaDuAdjType = 7;
+                               } else if (pBtdm8723->curPsTdma == 4) {
+                                       btdm_2AntPsTdma(padapter, true, 8);
+                                       pBtdm8723->psTdmaDuAdjType = 8;
+                               }
+                               if (pBtdm8723->curPsTdma == 9) {
+                                       btdm_2AntPsTdma(padapter, true, 14);
+                                       pBtdm8723->psTdmaDuAdjType = 14;
+                               } else if (pBtdm8723->curPsTdma == 10) {
+                                       btdm_2AntPsTdma(padapter, true, 14);
+                                       pBtdm8723->psTdmaDuAdjType = 14;
+                               } else if (pBtdm8723->curPsTdma == 11) {
+                                       btdm_2AntPsTdma(padapter, true, 15);
+                                       pBtdm8723->psTdmaDuAdjType = 15;
+                               } else if (pBtdm8723->curPsTdma == 12) {
+                                       btdm_2AntPsTdma(padapter, true, 16);
+                                       pBtdm8723->psTdmaDuAdjType = 16;
+                               }
+                               if (result == -1) {
+                                       if (pBtdm8723->curPsTdma == 5) {
+                                               btdm_2AntPsTdma(padapter, true, 6);
+                                               pBtdm8723->psTdmaDuAdjType = 6;
+                                       } else if (pBtdm8723->curPsTdma == 6) {
+                                               btdm_2AntPsTdma(padapter, true, 7);
+                                               pBtdm8723->psTdmaDuAdjType = 7;
+                                       } else if (pBtdm8723->curPsTdma == 7) {
+                                               btdm_2AntPsTdma(padapter, true, 8);
+                                               pBtdm8723->psTdmaDuAdjType = 8;
+                                       } else if (pBtdm8723->curPsTdma == 13) {
+                                               btdm_2AntPsTdma(padapter, true, 14);
+                                               pBtdm8723->psTdmaDuAdjType = 14;
+                                       } else if (pBtdm8723->curPsTdma == 14) {
+                                               btdm_2AntPsTdma(padapter, true, 15);
+                                               pBtdm8723->psTdmaDuAdjType = 15;
+                                       } else if (pBtdm8723->curPsTdma == 15) {
+                                               btdm_2AntPsTdma(padapter, true, 16);
+                                               pBtdm8723->psTdmaDuAdjType = 16;
+                                       }
+                               } else if (result == 1) {
+                                       if (pBtdm8723->curPsTdma == 8) {
+                                               btdm_2AntPsTdma(padapter, true, 7);
+                                               pBtdm8723->psTdmaDuAdjType = 7;
+                                       } else if (pBtdm8723->curPsTdma == 7) {
+                                               btdm_2AntPsTdma(padapter, true, 6);
+                                               pBtdm8723->psTdmaDuAdjType = 6;
+                                       } else if (pBtdm8723->curPsTdma == 6) {
+                                               btdm_2AntPsTdma(padapter, true, 6);
+                                               pBtdm8723->psTdmaDuAdjType = 6;
+                                       } else if (pBtdm8723->curPsTdma == 16) {
+                                               btdm_2AntPsTdma(padapter, true, 15);
+                                               pBtdm8723->psTdmaDuAdjType = 15;
+                                       } else if (pBtdm8723->curPsTdma == 15) {
+                                               btdm_2AntPsTdma(padapter, true, 14);
+                                               pBtdm8723->psTdmaDuAdjType = 14;
+                                       } else if (pBtdm8723->curPsTdma == 14) {
+                                               btdm_2AntPsTdma(padapter, true, 14);
+                                               pBtdm8723->psTdmaDuAdjType = 14;
+                                       }
+                               }
+                       } else {
+                               RTPRINT(FBT, BT_TRACE, ("[BTCoex], TxPause = 0\n"));
+                               if (pBtdm8723->curPsTdma == 5) {
+                                       btdm_2AntPsTdma(padapter, true, 2);
+                                       pBtdm8723->psTdmaDuAdjType = 2;
+                               } else if (pBtdm8723->curPsTdma == 6) {
+                                       btdm_2AntPsTdma(padapter, true, 2);
+                                       pBtdm8723->psTdmaDuAdjType = 2;
+                               } else if (pBtdm8723->curPsTdma == 7) {
+                                       btdm_2AntPsTdma(padapter, true, 3);
+                                       pBtdm8723->psTdmaDuAdjType = 3;
+                               } else if (pBtdm8723->curPsTdma == 8) {
+                                       btdm_2AntPsTdma(padapter, true, 4);
+                                       pBtdm8723->psTdmaDuAdjType = 4;
+                               }
+                               if (pBtdm8723->curPsTdma == 13) {
+                                       btdm_2AntPsTdma(padapter, true, 10);
+                                       pBtdm8723->psTdmaDuAdjType = 10;
+                               } else if (pBtdm8723->curPsTdma == 14) {
+                                       btdm_2AntPsTdma(padapter, true, 10);
+                                       pBtdm8723->psTdmaDuAdjType = 10;
+                               } else if (pBtdm8723->curPsTdma == 15) {
+                                       btdm_2AntPsTdma(padapter, true, 11);
+                                       pBtdm8723->psTdmaDuAdjType = 11;
+                               } else if (pBtdm8723->curPsTdma == 16) {
+                                       btdm_2AntPsTdma(padapter, true, 12);
+                                       pBtdm8723->psTdmaDuAdjType = 12;
+                               }
+                               if (result == -1) {
+                                       if (pBtdm8723->curPsTdma == 1) {
+                                               btdm_2AntPsTdma(padapter, true, 2);
+                                               pBtdm8723->psTdmaDuAdjType = 2;
+                                       } else if (pBtdm8723->curPsTdma == 2) {
+                                               btdm_2AntPsTdma(padapter, true, 3);
+                                               pBtdm8723->psTdmaDuAdjType = 3;
+                                       } else if (pBtdm8723->curPsTdma == 3) {
+                                               btdm_2AntPsTdma(padapter, true, 4);
+                                               pBtdm8723->psTdmaDuAdjType = 4;
+                                       } else if (pBtdm8723->curPsTdma == 9) {
+                                               btdm_2AntPsTdma(padapter, true, 10);
+                                               pBtdm8723->psTdmaDuAdjType = 10;
+                                       } else if (pBtdm8723->curPsTdma == 10) {
+                                               btdm_2AntPsTdma(padapter, true, 11);
+                                               pBtdm8723->psTdmaDuAdjType = 11;
+                                       } else if (pBtdm8723->curPsTdma == 11) {
+                                               btdm_2AntPsTdma(padapter, true, 12);
+                                               pBtdm8723->psTdmaDuAdjType = 12;
+                                       }
+                               } else if (result == 1) {
+                                       if (pBtdm8723->curPsTdma == 4) {
+                                               btdm_2AntPsTdma(padapter, true, 3);
+                                               pBtdm8723->psTdmaDuAdjType = 3;
+                                       } else if (pBtdm8723->curPsTdma == 3) {
+                                               btdm_2AntPsTdma(padapter, true, 2);
+                                               pBtdm8723->psTdmaDuAdjType = 2;
+                                       } else if (pBtdm8723->curPsTdma == 2) {
+                                               btdm_2AntPsTdma(padapter, true, 2);
+                                               pBtdm8723->psTdmaDuAdjType = 2;
+                                       } else if (pBtdm8723->curPsTdma == 12) {
+                                               btdm_2AntPsTdma(padapter, true, 11);
+                                               pBtdm8723->psTdmaDuAdjType = 11;
+                                       } else if (pBtdm8723->curPsTdma == 11) {
+                                               btdm_2AntPsTdma(padapter, true, 10);
+                                               pBtdm8723->psTdmaDuAdjType = 10;
+                                       } else if (pBtdm8723->curPsTdma == 10) {
+                                               btdm_2AntPsTdma(padapter, true, 10);
+                                               pBtdm8723->psTdmaDuAdjType = 10;
+                                       }
+                               }
+                       }
+               } else if (maxInterval == 3) {
+                       if (bTxPause) {
+                               RTPRINT(FBT, BT_TRACE, ("[BTCoex], TxPause = 1\n"));
+                               if (pBtdm8723->curPsTdma == 1) {
+                                       btdm_2AntPsTdma(padapter, true, 7);
+                                       pBtdm8723->psTdmaDuAdjType = 7;
+                               } else if (pBtdm8723->curPsTdma == 2) {
+                                       btdm_2AntPsTdma(padapter, true, 7);
+                                       pBtdm8723->psTdmaDuAdjType = 7;
+                               } else if (pBtdm8723->curPsTdma == 3) {
+                                       btdm_2AntPsTdma(padapter, true, 7);
+                                       pBtdm8723->psTdmaDuAdjType = 7;
+                               } else if (pBtdm8723->curPsTdma == 4) {
+                                       btdm_2AntPsTdma(padapter, true, 8);
+                                       pBtdm8723->psTdmaDuAdjType = 8;
+                               }
+                               if (pBtdm8723->curPsTdma == 9) {
+                                       btdm_2AntPsTdma(padapter, true, 15);
+                                       pBtdm8723->psTdmaDuAdjType = 15;
+                               } else if (pBtdm8723->curPsTdma == 10) {
+                                       btdm_2AntPsTdma(padapter, true, 15);
+                                       pBtdm8723->psTdmaDuAdjType = 15;
+                               } else if (pBtdm8723->curPsTdma == 11) {
+                                       btdm_2AntPsTdma(padapter, true, 15);
+                                       pBtdm8723->psTdmaDuAdjType = 15;
+                               } else if (pBtdm8723->curPsTdma == 12) {
+                                       btdm_2AntPsTdma(padapter, true, 16);
+                                       pBtdm8723->psTdmaDuAdjType = 16;
+                               }
+                               if (result == -1) {
+                                       if (pBtdm8723->curPsTdma == 5) {
+                                               btdm_2AntPsTdma(padapter, true, 7);
+                                               pBtdm8723->psTdmaDuAdjType = 7;
+                                       } else if (pBtdm8723->curPsTdma == 6) {
+                                               btdm_2AntPsTdma(padapter, true, 7);
+                                               pBtdm8723->psTdmaDuAdjType = 7;
+                                       } else if (pBtdm8723->curPsTdma == 7) {
+                                               btdm_2AntPsTdma(padapter, true, 8);
+                                               pBtdm8723->psTdmaDuAdjType = 8;
+                                       } else if (pBtdm8723->curPsTdma == 13) {
+                                               btdm_2AntPsTdma(padapter, true, 15);
+                                               pBtdm8723->psTdmaDuAdjType = 15;
+                                       } else if (pBtdm8723->curPsTdma == 14) {
+                                               btdm_2AntPsTdma(padapter, true, 15);
+                                               pBtdm8723->psTdmaDuAdjType = 15;
+                                       } else if (pBtdm8723->curPsTdma == 15) {
+                                               btdm_2AntPsTdma(padapter, true, 16);
+                                               pBtdm8723->psTdmaDuAdjType = 16;
+                                       }
+                               } else if (result == 1) {
+                                       if (pBtdm8723->curPsTdma == 8) {
+                                               btdm_2AntPsTdma(padapter, true, 7);
+                                               pBtdm8723->psTdmaDuAdjType = 7;
+                                       } else if (pBtdm8723->curPsTdma == 7) {
+                                               btdm_2AntPsTdma(padapter, true, 7);
+                                               pBtdm8723->psTdmaDuAdjType = 7;
+                                       } else if (pBtdm8723->curPsTdma == 6) {
+                                               btdm_2AntPsTdma(padapter, true, 7);
+                                               pBtdm8723->psTdmaDuAdjType = 7;
+                                       } else if (pBtdm8723->curPsTdma == 16) {
+                                               btdm_2AntPsTdma(padapter, true, 15);
+                                               pBtdm8723->psTdmaDuAdjType = 15;
+                                       } else if (pBtdm8723->curPsTdma == 15) {
+                                               btdm_2AntPsTdma(padapter, true, 15);
+                                               pBtdm8723->psTdmaDuAdjType = 15;
+                                       } else if (pBtdm8723->curPsTdma == 14) {
+                                               btdm_2AntPsTdma(padapter, true, 15);
+                                               pBtdm8723->psTdmaDuAdjType = 15;
+                                       }
+                               }
+                       } else {
+                               RTPRINT(FBT, BT_TRACE, ("[BTCoex], TxPause = 0\n"));
+                               if (pBtdm8723->curPsTdma == 5) {
+                                       btdm_2AntPsTdma(padapter, true, 3);
+                                       pBtdm8723->psTdmaDuAdjType = 3;
+                               } else if (pBtdm8723->curPsTdma == 6) {
+                                       btdm_2AntPsTdma(padapter, true, 3);
+                                       pBtdm8723->psTdmaDuAdjType = 3;
+                               } else if (pBtdm8723->curPsTdma == 7) {
+                                       btdm_2AntPsTdma(padapter, true, 3);
+                                       pBtdm8723->psTdmaDuAdjType = 3;
+                               } else if (pBtdm8723->curPsTdma == 8) {
+                                       btdm_2AntPsTdma(padapter, true, 4);
+                                       pBtdm8723->psTdmaDuAdjType = 4;
+                               }
+                               if (pBtdm8723->curPsTdma == 13) {
+                                       btdm_2AntPsTdma(padapter, true, 11);
+                                       pBtdm8723->psTdmaDuAdjType = 11;
+                               } else if (pBtdm8723->curPsTdma == 14) {
+                                       btdm_2AntPsTdma(padapter, true, 11);
+                                       pBtdm8723->psTdmaDuAdjType = 11;
+                               } else if (pBtdm8723->curPsTdma == 15) {
+                                       btdm_2AntPsTdma(padapter, true, 11);
+                                       pBtdm8723->psTdmaDuAdjType = 11;
+                               } else if (pBtdm8723->curPsTdma == 16) {
+                                       btdm_2AntPsTdma(padapter, true, 12);
+                                       pBtdm8723->psTdmaDuAdjType = 12;
+                               }
+                               if (result == -1) {
+                                       if (pBtdm8723->curPsTdma == 1) {
+                                               btdm_2AntPsTdma(padapter, true, 3);
+                                               pBtdm8723->psTdmaDuAdjType = 3;
+                                       } else if (pBtdm8723->curPsTdma == 2) {
+                                               btdm_2AntPsTdma(padapter, true, 3);
+                                               pBtdm8723->psTdmaDuAdjType = 3;
+                                       } else if (pBtdm8723->curPsTdma == 3) {
+                                               btdm_2AntPsTdma(padapter, true, 4);
+                                               pBtdm8723->psTdmaDuAdjType = 4;
+                                       } else if (pBtdm8723->curPsTdma == 9) {
+                                               btdm_2AntPsTdma(padapter, true, 11);
+                                               pBtdm8723->psTdmaDuAdjType = 11;
+                                       } else if (pBtdm8723->curPsTdma == 10) {
+                                               btdm_2AntPsTdma(padapter, true, 11);
+                                               pBtdm8723->psTdmaDuAdjType = 11;
+                                       } else if (pBtdm8723->curPsTdma == 11) {
+                                               btdm_2AntPsTdma(padapter, true, 12);
+                                               pBtdm8723->psTdmaDuAdjType = 12;
+                                       }
+                               } else if (result == 1) {
+                                       if (pBtdm8723->curPsTdma == 4) {
+                                               btdm_2AntPsTdma(padapter, true, 3);
+                                               pBtdm8723->psTdmaDuAdjType = 3;
+                                       } else if (pBtdm8723->curPsTdma == 3) {
+                                               btdm_2AntPsTdma(padapter, true, 3);
+                                               pBtdm8723->psTdmaDuAdjType = 3;
+                                       } else if (pBtdm8723->curPsTdma == 2) {
+                                               btdm_2AntPsTdma(padapter, true, 3);
+                                               pBtdm8723->psTdmaDuAdjType = 3;
+                                       } else if (pBtdm8723->curPsTdma == 12) {
+                                               btdm_2AntPsTdma(padapter, true, 11);
+                                               pBtdm8723->psTdmaDuAdjType = 11;
+                                       } else if (pBtdm8723->curPsTdma == 11) {
+                                               btdm_2AntPsTdma(padapter, true, 11);
+                                               pBtdm8723->psTdmaDuAdjType = 11;
+                                       } else if (pBtdm8723->curPsTdma == 10) {
+                                               btdm_2AntPsTdma(padapter, true, 11);
+                                               pBtdm8723->psTdmaDuAdjType = 11;
+                                       }
+                               }
+                       }
+               }
+       }
+       RTPRINT(FBT, BT_TRACE, ("[BTCoex], PsTdma type : recordPsTdma =%d\n", pBtdm8723->psTdmaDuAdjType));
+       /*  if current PsTdma not match with the recorded one (when scan, dhcp...), */
+       /*  then we have to adjust it back to the previous record one. */
+       if (pBtdm8723->curPsTdma != pBtdm8723->psTdmaDuAdjType) {
+               RTPRINT(FBT, BT_TRACE, ("[BTCoex], PsTdma type dismatch!!!, curPsTdma =%d, recordPsTdma =%d\n",
+                       pBtdm8723->curPsTdma, pBtdm8723->psTdmaDuAdjType));
+
+               if (!check_fwstate(&padapter->mlmepriv, _FW_UNDER_SURVEY|_FW_UNDER_LINKING))
+                       btdm_2AntPsTdma(padapter, true, pBtdm8723->psTdmaDuAdjType);
+               else
+                       RTPRINT(FBT, BT_TRACE, ("[BTCoex], roaming/link/scan is under progress, will adjust next time!!!\n"));
+       }
+}
+
+/*  default Action */
+/*  SCO only or SCO+PAN(HS) */
+static void btdm_2Ant8723ASCOAction(struct rtw_adapter *padapter)
+{
+       u8 btRssiState, btRssiState1;
+
+       if (btdm_NeedToDecBtPwr(padapter))
+               btdm_2AntDecBtPwr(padapter, true);
+       else
+               btdm_2AntDecBtPwr(padapter, false);
+
+       if (BTDM_IsHT40(padapter)) {
+               RTPRINT(FBT, BT_TRACE, ("HT40\n"));
+               btRssiState = BTDM_CheckCoexRSSIState(padapter, 2, 37, 0);
+               /*  fw mechanism */
+               if ((btRssiState == BT_RSSI_STATE_HIGH) ||
+                   (btRssiState == BT_RSSI_STATE_STAY_HIGH)) {
+                       RTPRINT(FBT, BT_TRACE, ("Wifi rssi-1 high \n"));
+                       PlatformEFIOWrite1Byte(padapter, 0x883, 0x40);
+                       btdm_2AntPsTdma(padapter, true, 11);
+               } else {
+                       RTPRINT(FBT, BT_TRACE, ("Wifi rssi-1 low \n"));
+                       btdm_2AntPsTdma(padapter, true, 15);
+               }
+
+               /*  sw mechanism */
+               btdm_2AntAgcTable(padapter, false);
+               btdm_2AntAdcBackOff(padapter, true);
+               btdm_2AntDacSwing(padapter, false, 0xc0);
+       } else {
+               RTPRINT(FBT, BT_TRACE, ("HT20 or Legacy\n"));
+               btRssiState = BTDM_CheckCoexRSSIState(padapter, 2, 37, 0);
+               btRssiState1 = BTDM_CheckCoexRSSIState1(padapter, 2, 27, 0);
+
+               /*  fw mechanism */
+               if ((btRssiState1 == BT_RSSI_STATE_HIGH) ||
+                   (btRssiState1 == BT_RSSI_STATE_STAY_HIGH)) {
+                       RTPRINT(FBT, BT_TRACE, ("Wifi rssi-1 high \n"));
+                       PlatformEFIOWrite1Byte(padapter, 0x883, 0x40);
+                       btdm_2AntPsTdma(padapter, true, 11);
+               } else {
+                       RTPRINT(FBT, BT_TRACE, ("Wifi rssi-1 low \n"));
+                       btdm_2AntPsTdma(padapter, true, 15);
+               }
+
+               /*  sw mechanism */
+               if ((btRssiState == BT_RSSI_STATE_HIGH) ||
+                   (btRssiState == BT_RSSI_STATE_STAY_HIGH)) {
+                       RTPRINT(FBT, BT_TRACE, ("Wifi rssi high \n"));
+                       btdm_2AntAgcTable(padapter, true);
+                       btdm_2AntAdcBackOff(padapter, true);
+                       btdm_2AntDacSwing(padapter, false, 0xc0);
+               } else {
+                       RTPRINT(FBT, BT_TRACE, ("Wifi rssi low \n"));
+                       btdm_2AntAgcTable(padapter, false);
+                       btdm_2AntAdcBackOff(padapter, false);
+                       btdm_2AntDacSwing(padapter, false, 0xc0);
+               }
+       }
+}
+
+static void btdm_2Ant8723AHIDAction(struct rtw_adapter *padapter)
+{
+       u8 btRssiState, btRssiState1;
+
+       if (btdm_NeedToDecBtPwr(padapter))
+               btdm_2AntDecBtPwr(padapter, true);
+       else
+               btdm_2AntDecBtPwr(padapter, false);
+
+       if (BTDM_IsHT40(padapter)) {
+               RTPRINT(FBT, BT_TRACE, ("HT40\n"));
+               btRssiState = BTDM_CheckCoexRSSIState(padapter, 2, 37, 0);
+                       /*  fw mechanism */
+               if ((btRssiState == BT_RSSI_STATE_HIGH) ||
+                   (btRssiState == BT_RSSI_STATE_STAY_HIGH)) {
+                       RTPRINT(FBT, BT_TRACE, ("Wifi rssi-1 high \n"));
+                       PlatformEFIOWrite1Byte(padapter, 0x883, 0x40);
+                       btdm_2AntPsTdma(padapter, true, 9);
+               } else {
+                       RTPRINT(FBT, BT_TRACE, ("Wifi rssi-1 low \n"));
+                       btdm_2AntPsTdma(padapter, true, 13);
+               }
+
+               /*  sw mechanism */
+               btdm_2AntAgcTable(padapter, false);
+               btdm_2AntAdcBackOff(padapter, false);
+               btdm_2AntDacSwing(padapter, false, 0xc0);
+       } else {
+               RTPRINT(FBT, BT_TRACE, ("HT20 or Legacy\n"));
+               btRssiState = BTDM_CheckCoexRSSIState(padapter, 2, 37, 0);
+               btRssiState1 = BTDM_CheckCoexRSSIState1(padapter, 2, 27, 0);
+
+               /*  fw mechanism */
+               if ((btRssiState1 == BT_RSSI_STATE_HIGH) ||
+                   (btRssiState1 == BT_RSSI_STATE_STAY_HIGH)) {
+                       RTPRINT(FBT, BT_TRACE, ("Wifi rssi-1 high \n"));
+                       PlatformEFIOWrite1Byte(padapter, 0x883, 0x40);
+                       btdm_2AntPsTdma(padapter, true, 9);
+               } else {
+                       RTPRINT(FBT, BT_TRACE, ("Wifi rssi-1 low \n"));
+                       btdm_2AntPsTdma(padapter, true, 13);
+               }
+
+               /*  sw mechanism */
+               if ((btRssiState == BT_RSSI_STATE_HIGH) ||
+                   (btRssiState == BT_RSSI_STATE_STAY_HIGH)) {
+                       RTPRINT(FBT, BT_TRACE, ("Wifi rssi high \n"));
+                       btdm_2AntAgcTable(padapter, true);
+                       btdm_2AntAdcBackOff(padapter, true);
+                       btdm_2AntDacSwing(padapter, false, 0xc0);
+               } else {
+                       RTPRINT(FBT, BT_TRACE, ("Wifi rssi low \n"));
+                       btdm_2AntAgcTable(padapter, false);
+                       btdm_2AntAdcBackOff(padapter, false);
+                       btdm_2AntDacSwing(padapter, false, 0xc0);
+               }
+       }
+}
+
+/* A2DP only / PAN(EDR) only/ A2DP+PAN(HS) */
+static void btdm_2Ant8723AA2DPAction(struct rtw_adapter *padapter)
+{
+       u8 btRssiState, btRssiState1;
+       struct hal_data_8723a *pHalData = GET_HAL_DATA(padapter);
+       u8 btInfoExt = pHalData->bt_coexist.halCoex8723.btInfoExt;
+
+       if (btdm_NeedToDecBtPwr(padapter))
+               btdm_2AntDecBtPwr(padapter, true);
+       else
+               btdm_2AntDecBtPwr(padapter, false);
+
+       if (BTDM_IsHT40(padapter)) {
+               RTPRINT(FBT, BT_TRACE, ("HT40\n"));
+               btRssiState = BTDM_CheckCoexRSSIState(padapter, 2, 37, 0);
+
+               /*  fw mechanism */
+               if ((btRssiState == BT_RSSI_STATE_HIGH) ||
+                   (btRssiState == BT_RSSI_STATE_STAY_HIGH)) {
+                       RTPRINT(FBT, BT_TRACE, ("Wifi rssi high \n"));
+                       PlatformEFIOWrite1Byte(padapter, 0x883, 0x40);
+
+                       if (btInfoExt&BIT(0)) { /* a2dp rate, 1:basic /0:edr */
+                               RTPRINT(FBT, BT_TRACE, ("a2dp basic rate \n"));
+                               btdm_2AntTdmaDurationAdjust(padapter, false, false, 3);
+                       } else {
+                               RTPRINT(FBT, BT_TRACE, ("a2dp edr rate \n"));
+                               btdm_2AntTdmaDurationAdjust(padapter, false, false, 1);
+                       }
+               } else {
+                       RTPRINT(FBT, BT_TRACE, ("Wifi rssi low \n"));
+                       if (btInfoExt&BIT(0)) { /* a2dp rate, 1:basic /0:edr */
+                               RTPRINT(FBT, BT_TRACE, ("a2dp basic rate \n"));
+                               btdm_2AntTdmaDurationAdjust(padapter, false, true, 3);
+                       } else {
+                               RTPRINT(FBT, BT_TRACE, ("a2dp edr rate \n"));
+                       btdm_2AntTdmaDurationAdjust(padapter, false, true, 1);
+                       }
+               }
+
+               /*  sw mechanism */
+               btdm_2AntAgcTable(padapter, false);
+               btdm_2AntAdcBackOff(padapter, true);
+               btdm_2AntDacSwing(padapter, false, 0xc0);
+       } else {
+               RTPRINT(FBT, BT_TRACE, ("HT20 or Legacy\n"));
+               btRssiState = BTDM_CheckCoexRSSIState(padapter, 2, 37, 0);
+               btRssiState1 = BTDM_CheckCoexRSSIState1(padapter, 2, 27, 0);
+
+               /*  fw mechanism */
+               if ((btRssiState1 == BT_RSSI_STATE_HIGH) ||
+                   (btRssiState1 == BT_RSSI_STATE_STAY_HIGH)) {
+                       RTPRINT(FBT, BT_TRACE, ("Wifi rssi-1 high \n"));
+                       PlatformEFIOWrite1Byte(padapter, 0x883, 0x40);
+                       if (btInfoExt&BIT(0)) { /* a2dp rate, 1:basic /0:edr */
+                               RTPRINT(FBT, BT_TRACE, ("a2dp basic rate \n"));
+                               btdm_2AntTdmaDurationAdjust(padapter, false, false, 3);
+                       } else {
+                               RTPRINT(FBT, BT_TRACE, ("a2dp edr rate \n"));
+                               btdm_2AntTdmaDurationAdjust(padapter, false, false, 1);
+                       }
+               } else {
+                       RTPRINT(FBT, BT_TRACE, ("Wifi rssi-1 low \n"));
+                       if (btInfoExt&BIT(0)) { /* a2dp rate, 1:basic /0:edr */
+                               RTPRINT(FBT, BT_TRACE, ("a2dp basic rate \n"));
+                               btdm_2AntTdmaDurationAdjust(padapter, false, true, 3);
+                       } else {
+                               RTPRINT(FBT, BT_TRACE, ("a2dp edr rate \n"));
+                               btdm_2AntTdmaDurationAdjust(padapter, false, true, 1);
+                       }
+               }
+
+               /*  sw mechanism */
+               if ((btRssiState == BT_RSSI_STATE_HIGH) ||
+                   (btRssiState == BT_RSSI_STATE_STAY_HIGH)) {
+                       RTPRINT(FBT, BT_TRACE, ("Wifi rssi high \n"));
+                       btdm_2AntAgcTable(padapter, true);
+                       btdm_2AntAdcBackOff(padapter, true);
+                       btdm_2AntDacSwing(padapter, false, 0xc0);
+               } else {
+                       RTPRINT(FBT, BT_TRACE, ("Wifi rssi low \n"));
+                       btdm_2AntAgcTable(padapter, false);
+                       btdm_2AntAdcBackOff(padapter, false);
+                       btdm_2AntDacSwing(padapter, false, 0xc0);
+               }
+       }
+}
+
+static void btdm_2Ant8723APANEDRAction(struct rtw_adapter *padapter)
+{
+       u8 btRssiState, btRssiState1;
+
+       if (btdm_NeedToDecBtPwr(padapter))
+               btdm_2AntDecBtPwr(padapter, true);
+       else
+               btdm_2AntDecBtPwr(padapter, false);
+
+       if (BTDM_IsHT40(padapter)) {
+               RTPRINT(FBT, BT_TRACE, ("HT40\n"));
+               btRssiState = BTDM_CheckCoexRSSIState(padapter, 2, 37, 0);
+
+               /*  fw mechanism */
+               if ((btRssiState == BT_RSSI_STATE_HIGH) ||
+                   (btRssiState == BT_RSSI_STATE_STAY_HIGH)) {
+                       RTPRINT(FBT, BT_TRACE, ("Wifi rssi high \n"));
+                       PlatformEFIOWrite1Byte(padapter, 0x883, 0x40);
+                       btdm_2AntPsTdma(padapter, true, 2);
+               } else {
+                       RTPRINT(FBT, BT_TRACE, ("Wifi rssi low \n"));
+                       btdm_2AntPsTdma(padapter, true, 6);
+               }
+
+               /*  sw mechanism */
+               btdm_2AntAgcTable(padapter, false);
+               btdm_2AntAdcBackOff(padapter, true);
+               btdm_2AntDacSwing(padapter, false, 0xc0);
+       } else {
+               RTPRINT(FBT, BT_TRACE, ("HT20 or Legacy\n"));
+               btRssiState = BTDM_CheckCoexRSSIState(padapter, 2, 37, 0);
+               btRssiState1 = BTDM_CheckCoexRSSIState1(padapter, 2, 27, 0);
+
+               /*  fw mechanism */
+               if ((btRssiState1 == BT_RSSI_STATE_HIGH) ||
+                   (btRssiState1 == BT_RSSI_STATE_STAY_HIGH)) {
+                       RTPRINT(FBT, BT_TRACE, ("Wifi rssi-1 high \n"));
+                       PlatformEFIOWrite1Byte(padapter, 0x883, 0x40);
+                       btdm_2AntPsTdma(padapter, true, 2);
+               } else {
+                       RTPRINT(FBT, BT_TRACE, ("Wifi rssi-1 low \n"));
+                       btdm_2AntPsTdma(padapter, true, 6);
+               }
+
+               /*  sw mechanism */
+               if ((btRssiState == BT_RSSI_STATE_HIGH) ||
+                   (btRssiState == BT_RSSI_STATE_STAY_HIGH)) {
+                       RTPRINT(FBT, BT_TRACE, ("Wifi rssi high \n"));
+                       btdm_2AntAgcTable(padapter, true);
+                       btdm_2AntAdcBackOff(padapter, true);
+                       btdm_2AntDacSwing(padapter, false, 0xc0);
+               } else {
+                       RTPRINT(FBT, BT_TRACE, ("Wifi rssi low \n"));
+                       btdm_2AntAgcTable(padapter, false);
+                       btdm_2AntAdcBackOff(padapter, false);
+                       btdm_2AntDacSwing(padapter, false, 0xc0);
+               }
+       }
+}
+
+/* PAN(HS) only */
+static void btdm_2Ant8723APANHSAction(struct rtw_adapter *padapter)
+{
+       u8 btRssiState;
+
+       if (BTDM_IsHT40(padapter)) {
+               RTPRINT(FBT, BT_TRACE, ("HT40\n"));
+               btRssiState = BTDM_CheckCoexRSSIState(padapter, 2, 47, 0);
+               /*  fw mechanism */
+               if ((btRssiState == BT_RSSI_STATE_HIGH) ||
+                   (btRssiState == BT_RSSI_STATE_STAY_HIGH)) {
+                       RTPRINT(FBT, BT_TRACE, ("Wifi rssi high \n"));
+                       btdm_2AntDecBtPwr(padapter, true);
+               } else {
+                       RTPRINT(FBT, BT_TRACE, ("Wifi rssi low \n"));
+                       btdm_2AntDecBtPwr(padapter, false);
+               }
+               btdm_2AntPsTdma(padapter, false, 0);
+
+               /*  sw mechanism */
+               btdm_2AntAgcTable(padapter, false);
+               btdm_2AntAdcBackOff(padapter, true);
+               btdm_2AntDacSwing(padapter, false, 0xc0);
+       } else {
+               RTPRINT(FBT, BT_TRACE, ("HT20 or Legacy\n"));
+               btRssiState = BTDM_CheckCoexRSSIState(padapter, 2, 47, 0);
+
+               if ((btRssiState == BT_RSSI_STATE_HIGH) ||
+                   (btRssiState == BT_RSSI_STATE_STAY_HIGH)) {
+                       RTPRINT(FBT, BT_TRACE, ("Wifi rssi high\n"));
+                       /*  fw mechanism */
+                       btdm_2AntDecBtPwr(padapter, true);
+                       btdm_2AntPsTdma(padapter, false, 0);
+
+                       /*  sw mechanism */
+                       btdm_2AntAgcTable(padapter, true);
+                       btdm_2AntAdcBackOff(padapter, true);
+                       btdm_2AntDacSwing(padapter, false, 0xc0);
+               } else {
+                       RTPRINT(FBT, BT_TRACE, ("Wifi rssi low\n"));
+                       /*  fw mechanism */
+                       btdm_2AntDecBtPwr(padapter, false);
+                       btdm_2AntPsTdma(padapter, false, 0);
+
+                       /*  sw mechanism */
+                       btdm_2AntAgcTable(padapter, false);
+                       btdm_2AntAdcBackOff(padapter, false);
+                       btdm_2AntDacSwing(padapter, false, 0xc0);
+               }
+       }
+}
+
+/* PAN(EDR)+A2DP */
+static void btdm_2Ant8723APANEDRA2DPAction(struct rtw_adapter *padapter)
+{
+       u8 btRssiState, btRssiState1, btInfoExt;
+       struct hal_data_8723a *pHalData = GET_HAL_DATA(padapter);
+
+       btInfoExt = pHalData->bt_coexist.halCoex8723.btInfoExt;
+
+       if (btdm_NeedToDecBtPwr(padapter))
+               btdm_2AntDecBtPwr(padapter, true);
+       else
+               btdm_2AntDecBtPwr(padapter, false);
+
+       if (BTDM_IsHT40(padapter)) {
+               RTPRINT(FBT, BT_TRACE, ("HT40\n"));
+               btRssiState = BTDM_CheckCoexRSSIState(padapter, 2, 37, 0);
+
+               if ((btRssiState == BT_RSSI_STATE_HIGH) ||
+                   (btRssiState == BT_RSSI_STATE_STAY_HIGH)) {
+                       RTPRINT(FBT, BT_TRACE, ("Wifi rssi high \n"));
+                       /*  fw mechanism */
+                       PlatformEFIOWrite1Byte(padapter, 0x883, 0x40);
+
+                       if (btInfoExt&BIT(0)) { /* a2dp rate, 1:basic /0:edr */
+                               RTPRINT(FBT, BT_TRACE, ("a2dp basic rate \n"));
+                               btdm_2AntPsTdma(padapter, true, 4);
+                       } else {
+                               RTPRINT(FBT, BT_TRACE, ("a2dp edr rate \n"));
+                               btdm_2AntPsTdma(padapter, true, 2);
+                       }
+               } else {
+                       RTPRINT(FBT, BT_TRACE, ("Wifi rssi low \n"));
+                       /*  fw mechanism */
+                       if (btInfoExt&BIT(0)) { /* a2dp rate, 1:basic /0:edr */
+                               RTPRINT(FBT, BT_TRACE, ("a2dp basic rate \n"));
+                               btdm_2AntPsTdma(padapter, true, 8);
+                       } else {
+                               RTPRINT(FBT, BT_TRACE, ("a2dp edr rate \n"));
+                               btdm_2AntPsTdma(padapter, true, 6);
+                       }
+               }
+
+               /*  sw mechanism */
+               btdm_2AntAgcTable(padapter, false);
+               btdm_2AntAdcBackOff(padapter, true);
+               btdm_2AntDacSwing(padapter, false, 0xc0);
+       } else {
+               RTPRINT(FBT, BT_TRACE, ("HT20 or Legacy\n"));
+               btRssiState = BTDM_CheckCoexRSSIState(padapter, 2, 37, 0);
+               btRssiState1 = BTDM_CheckCoexRSSIState1(padapter, 2, 27, 0);
+
+               if ((btRssiState1 == BT_RSSI_STATE_HIGH) ||
+                   (btRssiState1 == BT_RSSI_STATE_STAY_HIGH)) {
+                       RTPRINT(FBT, BT_TRACE, ("Wifi rssi-1 high \n"));
+                       PlatformEFIOWrite1Byte(padapter, 0x883, 0x40);
+                       /*  fw mechanism */
+                       if (btInfoExt&BIT(0)) { /* a2dp rate, 1:basic /0:edr */
+                               RTPRINT(FBT, BT_TRACE, ("a2dp basic rate \n"));
+                               btdm_2AntPsTdma(padapter, true, 4);
+                       } else {
+                               RTPRINT(FBT, BT_TRACE, ("a2dp edr rate \n"));
+                               btdm_2AntPsTdma(padapter, true, 2);
+                       }
+               } else {
+                       RTPRINT(FBT, BT_TRACE, ("Wifi rssi-1 low \n"));
+                       /*  fw mechanism */
+                       if (btInfoExt&BIT(0)) { /* a2dp rate, 1:basic /0:edr */
+                               RTPRINT(FBT, BT_TRACE, ("a2dp basic rate \n"));
+                               btdm_2AntPsTdma(padapter, true, 8);
+                       } else {
+                               RTPRINT(FBT, BT_TRACE, ("a2dp edr rate \n"));
+                               btdm_2AntPsTdma(padapter, true, 6);
+                       }
+               }
+
+               /*  sw mechanism */
+               if ((btRssiState == BT_RSSI_STATE_HIGH) ||
+                   (btRssiState == BT_RSSI_STATE_STAY_HIGH)) {
+                       RTPRINT(FBT, BT_TRACE, ("Wifi rssi high \n"));
+                       btdm_2AntAgcTable(padapter, true);
+                       btdm_2AntAdcBackOff(padapter, true);
+                       btdm_2AntDacSwing(padapter, false, 0xc0);
+               } else {
+                       RTPRINT(FBT, BT_TRACE, ("Wifi rssi low \n"));
+                       btdm_2AntAgcTable(padapter, false);
+                       btdm_2AntAdcBackOff(padapter, false);
+                       btdm_2AntDacSwing(padapter, false, 0xc0);
+               }
+       }
+}
+
+static void btdm_2Ant8723APANEDRHIDAction(struct rtw_adapter *padapter)
+{
+       u8 btRssiState, btRssiState1;
+
+       if (btdm_NeedToDecBtPwr(padapter))
+               btdm_2AntDecBtPwr(padapter, true);
+       else
+               btdm_2AntDecBtPwr(padapter, false);
+
+       if (BTDM_IsHT40(padapter)) {
+               RTPRINT(FBT, BT_TRACE, ("HT40\n"));
+               btRssiState = BTDM_CheckCoexRSSIState(padapter, 2, 37, 0);
+               /*  fw mechanism */
+               if ((btRssiState == BT_RSSI_STATE_HIGH) ||
+                   (btRssiState == BT_RSSI_STATE_STAY_HIGH)) {
+                       RTPRINT(FBT, BT_TRACE, ("Wifi rssi high \n"));
+                       PlatformEFIOWrite1Byte(padapter, 0x883, 0x40);
+                       btdm_2AntPsTdma(padapter, true, 10);
+               } else {
+                       RTPRINT(FBT, BT_TRACE, ("Wifi rssi low \n"));
+                       btdm_2AntPsTdma(padapter, true, 14);
+               }
+
+               /*  sw mechanism */
+               btdm_2AntAgcTable(padapter, false);
+               btdm_2AntAdcBackOff(padapter, true);
+               btdm_2AntDacSwing(padapter, false, 0xc0);
+       } else {
+               RTPRINT(FBT, BT_TRACE, ("HT20 or Legacy\n"));
+               btRssiState = BTDM_CheckCoexRSSIState(padapter, 2, 37, 0);
+               btRssiState1 = BTDM_CheckCoexRSSIState1(padapter, 2, 27, 0);
+
+               /*  fw mechanism */
+               if ((btRssiState1 == BT_RSSI_STATE_HIGH) ||
+                   (btRssiState1 == BT_RSSI_STATE_STAY_HIGH)) {
+                       RTPRINT(FBT, BT_TRACE, ("Wifi rssi-1 high \n"));
+                       PlatformEFIOWrite1Byte(padapter, 0x883, 0x40);
+                       btdm_2AntPsTdma(padapter, true, 10);
+               } else {
+                       RTPRINT(FBT, BT_TRACE, ("Wifi rssi-1 low \n"));
+                       btdm_2AntPsTdma(padapter, true, 14);
+               }
+
+               /*  sw mechanism */
+               if ((btRssiState == BT_RSSI_STATE_HIGH) ||
+                   (btRssiState == BT_RSSI_STATE_STAY_HIGH)) {
+                       RTPRINT(FBT, BT_TRACE, ("Wifi rssi high \n"));
+                       btdm_2AntAgcTable(padapter, true);
+                       btdm_2AntAdcBackOff(padapter, true);
+                       btdm_2AntDacSwing(padapter, false, 0xc0);
+               } else {
+                       RTPRINT(FBT, BT_TRACE, ("Wifi rssi low \n"));
+                       btdm_2AntAgcTable(padapter, false);
+                       btdm_2AntAdcBackOff(padapter, false);
+                       btdm_2AntDacSwing(padapter, false, 0xc0);
+               }
+       }
+}
+
+/*  HID+A2DP+PAN(EDR) */
+static void btdm_2Ant8723AHIDA2DPPANEDRAction(struct rtw_adapter *padapter)
+{
+       u8 btRssiState, btRssiState1, btInfoExt;
+       struct hal_data_8723a *pHalData = GET_HAL_DATA(padapter);
+
+       btInfoExt = pHalData->bt_coexist.halCoex8723.btInfoExt;
+
+       if (btdm_NeedToDecBtPwr(padapter))
+               btdm_2AntDecBtPwr(padapter, true);
+       else
+               btdm_2AntDecBtPwr(padapter, false);
+
+       if (BTDM_IsHT40(padapter)) {
+               RTPRINT(FBT, BT_TRACE, ("HT40\n"));
+               btRssiState = BTDM_CheckCoexRSSIState(padapter, 2, 37, 0);
+               if ((btRssiState == BT_RSSI_STATE_HIGH) ||
+                   (btRssiState == BT_RSSI_STATE_STAY_HIGH)) {
+                       RTPRINT(FBT, BT_TRACE, ("Wifi rssi high \n"));
+                       PlatformEFIOWrite1Byte(padapter, 0x883, 0x40);
+
+                       if (btInfoExt&BIT(0)) { /* a2dp rate, 1:basic /0:edr */
+                               RTPRINT(FBT, BT_TRACE, ("a2dp basic rate \n"));
+                               btdm_2AntPsTdma(padapter, true, 12);
+                       } else {
+                               RTPRINT(FBT, BT_TRACE, ("a2dp edr rate \n"));
+                               btdm_2AntPsTdma(padapter, true, 10);
+                       }
+               } else {
+                       RTPRINT(FBT, BT_TRACE, ("Wifi rssi low \n"));
+                       if (btInfoExt&BIT(0)) { /* a2dp rate, 1:basic /0:edr */
+                               RTPRINT(FBT, BT_TRACE, ("a2dp basic rate \n"));
+                               btdm_2AntPsTdma(padapter, true, 16);
+                       } else {
+                               RTPRINT(FBT, BT_TRACE, ("a2dp edr rate \n"));
+                               btdm_2AntPsTdma(padapter, true, 14);
+                       }
+               }
+
+               /*  sw mechanism */
+               btdm_2AntAgcTable(padapter, false);
+               btdm_2AntAdcBackOff(padapter, true);
+               btdm_2AntDacSwing(padapter, false, 0xc0);
+       } else {
+               RTPRINT(FBT, BT_TRACE, ("HT20 or Legacy\n"));
+               btRssiState1 = BTDM_CheckCoexRSSIState1(padapter, 2, 37, 0);
+               btRssiState = BTDM_CheckCoexRSSIState(padapter, 2, 27, 0);
+               if ((btRssiState == BT_RSSI_STATE_HIGH) ||
+                   (btRssiState == BT_RSSI_STATE_STAY_HIGH)) {
+                       RTPRINT(FBT, BT_TRACE, ("Wifi rssi high \n"));
+                       PlatformEFIOWrite1Byte(padapter, 0x883, 0x40);
+
+                       if (btInfoExt&BIT(0)) { /* a2dp rate, 1:basic /0:edr */
+                               RTPRINT(FBT, BT_TRACE, ("a2dp basic rate \n"));
+                               btdm_2AntPsTdma(padapter, true, 12);
+                       } else {
+                               RTPRINT(FBT, BT_TRACE, ("a2dp edr rate \n"));
+                               btdm_2AntPsTdma(padapter, true, 10);
+                       }
+               } else {
+                       RTPRINT(FBT, BT_TRACE, ("Wifi rssi low \n"));
+                       if (btInfoExt&BIT(0)) { /* a2dp rate, 1:basic /0:edr */
+                               RTPRINT(FBT, BT_TRACE, ("a2dp basic rate \n"));
+                               btdm_2AntPsTdma(padapter, true, 16);
+                       } else {
+                               RTPRINT(FBT, BT_TRACE, ("a2dp edr rate \n"));
+                               btdm_2AntPsTdma(padapter, true, 14);
+                       }
+               }
+
+               /*  sw mechanism */
+               if ((btRssiState1 == BT_RSSI_STATE_HIGH) ||
+                   (btRssiState1 == BT_RSSI_STATE_STAY_HIGH)) {
+                       RTPRINT(FBT, BT_TRACE, ("Wifi rssi-1 high \n"));
+                       btdm_2AntAgcTable(padapter, true);
+                       btdm_2AntAdcBackOff(padapter, true);
+                       btdm_2AntDacSwing(padapter, false, 0xc0);
+               } else {
+                       RTPRINT(FBT, BT_TRACE, ("Wifi rssi-1 high \n"));
+                       btdm_2AntAgcTable(padapter, false);
+                       btdm_2AntAdcBackOff(padapter, false);
+                       btdm_2AntDacSwing(padapter, false, 0xc0);
+               }
+       }
+}
+
+static void btdm_2Ant8723AHIDA2DPAction(struct rtw_adapter *padapter)
+{
+       struct hal_data_8723a *pHalData = GET_HAL_DATA(padapter);
+       u8 btRssiState, btRssiState1, btInfoExt;
+
+       btInfoExt = pHalData->bt_coexist.halCoex8723.btInfoExt;
+
+       if (btdm_NeedToDecBtPwr(padapter))
+               btdm_2AntDecBtPwr(padapter, true);
+       else
+               btdm_2AntDecBtPwr(padapter, false);
+
+       if (BTDM_IsHT40(padapter)) {
+               RTPRINT(FBT, BT_TRACE, ("HT40\n"));
+               btRssiState = BTDM_CheckCoexRSSIState(padapter, 2, 37, 0);
+               if ((btRssiState == BT_RSSI_STATE_HIGH) ||
+                   (btRssiState == BT_RSSI_STATE_STAY_HIGH)) {
+                       RTPRINT(FBT, BT_TRACE, ("Wifi rssi high \n"));
+                       PlatformEFIOWrite1Byte(padapter, 0x883, 0x40);
+
+                       if (btInfoExt&BIT(0)) { /* a2dp rate, 1:basic /0:edr */
+                               RTPRINT(FBT, BT_TRACE, ("a2dp basic rate \n"));
+                               btdm_2AntTdmaDurationAdjust(padapter, true, false, 3);
+                       } else {
+                               RTPRINT(FBT, BT_TRACE, ("a2dp edr rate \n"));
+                               btdm_2AntTdmaDurationAdjust(padapter, true, false, 1);
+                       }
+               } else {
+                       RTPRINT(FBT, BT_TRACE, ("Wifi rssi low \n"));
+                       if (btInfoExt&BIT(0)) { /* a2dp rate, 1:basic /0:edr */
+                               RTPRINT(FBT, BT_TRACE, ("a2dp basic rate \n"));
+                               btdm_2AntTdmaDurationAdjust(padapter, true, true, 3);
+                       } else {
+                               RTPRINT(FBT, BT_TRACE, ("a2dp edr rate \n"));
+                               btdm_2AntTdmaDurationAdjust(padapter, true, true, 1);
+                       }
+               }
+               /*  sw mechanism */
+               btdm_2AntAgcTable(padapter, false);
+               btdm_2AntAdcBackOff(padapter, true);
+               btdm_2AntDacSwing(padapter, false, 0xc0);
+       } else {
+               RTPRINT(FBT, BT_TRACE, ("HT20 or Legacy\n"));
+               btRssiState = BTDM_CheckCoexRSSIState(padapter, 2, 37, 0);
+               btRssiState1 = BTDM_CheckCoexRSSIState(padapter, 2, 27, 0);
+
+               if ((btRssiState == BT_RSSI_STATE_HIGH) ||
+                   (btRssiState == BT_RSSI_STATE_STAY_HIGH)) {
+                       RTPRINT(FBT, BT_TRACE, ("Wifi rssi high \n"));
+                       PlatformEFIOWrite1Byte(padapter, 0x883, 0x40);
+
+                       if (btInfoExt&BIT(0)) { /* a2dp rate, 1:basic /0:edr */
+                               RTPRINT(FBT, BT_TRACE, ("a2dp basic rate \n"));
+                               btdm_2AntTdmaDurationAdjust(padapter, true, false, 3);
+                       } else {
+                               RTPRINT(FBT, BT_TRACE, ("a2dp edr rate \n"));
+                               btdm_2AntTdmaDurationAdjust(padapter, true, false, 1);
+                       }
+               } else {
+                       RTPRINT(FBT, BT_TRACE, ("Wifi rssi low \n"));
+                       if (btInfoExt&BIT(0)) { /* a2dp rate, 1:basic /0:edr */
+                               RTPRINT(FBT, BT_TRACE, ("a2dp basic rate \n"));
+                               btdm_2AntTdmaDurationAdjust(padapter, true, true, 3);
+                       } else {
+                               RTPRINT(FBT, BT_TRACE, ("a2dp edr rate \n"));
+                               btdm_2AntTdmaDurationAdjust(padapter, true, true, 1);
+                       }
+               }
+               if ((btRssiState1 == BT_RSSI_STATE_HIGH) ||
+                   (btRssiState1 == BT_RSSI_STATE_STAY_HIGH)) {
+                       RTPRINT(FBT, BT_TRACE, ("Wifi rssi-1 high \n"));
+                       /*  sw mechanism */
+                       btdm_2AntAgcTable(padapter, true);
+                       btdm_2AntAdcBackOff(padapter, true);
+                       btdm_2AntDacSwing(padapter, false, 0xc0);
+               } else {
+                       RTPRINT(FBT, BT_TRACE, ("Wifi rssi-1 low \n"));
+                       /*  sw mechanism */
+                       btdm_2AntAgcTable(padapter, false);
+                       btdm_2AntAdcBackOff(padapter, false);
+                       btdm_2AntDacSwing(padapter, false, 0xc0);
+               }
+       }
+}
+
+static void btdm_2Ant8723AA2dp(struct rtw_adapter *padapter)
+{
+       struct hal_data_8723a *pHalData = GET_HAL_DATA(padapter);
+       u8 btRssiState, btRssiState1, btInfoExt;
+
+       btInfoExt = pHalData->bt_coexist.halCoex8723.btInfoExt;
+
+       if (btdm_NeedToDecBtPwr(padapter))
+               btdm_2AntDecBtPwr(padapter, true);
+       else
+               btdm_2AntDecBtPwr(padapter, false);
+       /*  coex table */
+       btdm_2AntCoexTable(padapter, 0x55555555, 0xffff, 0x3);
+       btdm_2AntIgnoreWlanAct(padapter, false);
+
+       if (BTDM_IsHT40(padapter)) {
+               RTPRINT(FBT, BT_TRACE, ("HT40\n"));
+               btRssiState = BTDM_CheckCoexRSSIState(padapter, 2, 37, 0);
+               /*  fw mechanism */
+               if ((btRssiState == BT_RSSI_STATE_HIGH) ||
+                   (btRssiState == BT_RSSI_STATE_STAY_HIGH)) {
+                       RTPRINT(FBT, BT_TRACE, ("Wifi rssi-1 high \n"));
+                       PlatformEFIOWrite1Byte(padapter, 0x883, 0x40);
+                       btdm_2AntTdmaDurationAdjust(padapter, false, false, 1);
+               } else {
+                       RTPRINT(FBT, BT_TRACE, ("Wifi rssi-1 low \n"));
+                       btdm_2AntTdmaDurationAdjust(padapter, false, true, 1);
+               }
+
+               /*  sw mechanism */
+               btdm_2AntAgcTable(padapter, false);
+               btdm_2AntAdcBackOff(padapter, true);
+               btdm_2AntDacSwing(padapter, false, 0xc0);
+       } else {
+               RTPRINT(FBT, BT_TRACE, ("HT20 or Legacy\n"));
+               btRssiState = BTDM_CheckCoexRSSIState(padapter, 2, 47, 0);
+               btRssiState1 = BTDM_CheckCoexRSSIState1(padapter, 2, 27, 0);
+
+               /*  fw mechanism */
+               if ((btRssiState1 == BT_RSSI_STATE_HIGH) ||
+                   (btRssiState1 == BT_RSSI_STATE_STAY_HIGH)) {
+                       RTPRINT(FBT, BT_TRACE, ("Wifi rssi-1 high \n"));
+                       PlatformEFIOWrite1Byte(padapter, 0x883, 0x40);
+                       btdm_2AntTdmaDurationAdjust(padapter, false, false, 1);
+               } else {
+                       RTPRINT(FBT, BT_TRACE, ("Wifi rssi-1 low \n"));
+                       btdm_2AntTdmaDurationAdjust(padapter, false, true, 1);
+               }
+
+               /*  sw mechanism */
+               if ((btRssiState == BT_RSSI_STATE_HIGH) ||
+                   (btRssiState == BT_RSSI_STATE_STAY_HIGH)) {
+                       RTPRINT(FBT, BT_TRACE, ("Wifi rssi high \n"));
+                       btdm_2AntAgcTable(padapter, true);
+                       btdm_2AntAdcBackOff(padapter, true);
+                       btdm_2AntDacSwing(padapter, false, 0xc0);
+               } else {
+                       RTPRINT(FBT, BT_TRACE, ("Wifi rssi low \n"));
+                       btdm_2AntAgcTable(padapter, false);
+                       btdm_2AntAdcBackOff(padapter, false);
+                       btdm_2AntDacSwing(padapter, false, 0xc0);
+               }
+       }
+}
+
+/*  extern function start with BTDM_ */
+static void BTDM_2AntParaInit(struct rtw_adapter *padapter)
+{
+
+       struct hal_data_8723a *pHalData = GET_HAL_DATA(padapter);
+       struct btdm_8723a_2ant *pBtdm8723 = &pHalData->bt_coexist.halCoex8723.btdm2Ant;
+
+       RTPRINT(FBT, BT_TRACE, ("[BTCoex], 2Ant Parameter Init!!\n"));
+
+       /*  Enable counter statistics */
+       rtl8723au_write8(padapter, 0x76e, 0x4);
+       rtl8723au_write8(padapter, 0x778, 0x3);
+       rtl8723au_write8(padapter, 0x40, 0x20);
+
+       /*  force to reset coex mechanism */
+       pBtdm8723->preVal0x6c0 = 0x0;
+       btdm_2AntCoexTable(padapter, 0x55555555, 0xffff, 0x3);
+
+       pBtdm8723->bPrePsTdmaOn = true;
+       btdm_2AntPsTdma(padapter, false, 0);
+
+       pBtdm8723->preFwDacSwingLvl = 0x10;
+       btdm_2AntFwDacSwingLvl(padapter, 0x20);
+
+       pBtdm8723->bPreDecBtPwr = true;
+       btdm_2AntDecBtPwr(padapter, false);
+
+       pBtdm8723->bPreAgcTableEn = true;
+       btdm_2AntAgcTable(padapter, false);
+
+       pBtdm8723->bPreAdcBackOff = true;
+       btdm_2AntAdcBackOff(padapter, false);
+
+       pBtdm8723->bPreLowPenaltyRa = true;
+       btdm_2AntLowPenaltyRa(padapter, false);
+
+       pBtdm8723->bPreRfRxLpfShrink = true;
+       btdm_2AntRfShrink(padapter, false);
+
+       pBtdm8723->bPreDacSwingOn = true;
+       btdm_2AntDacSwing(padapter, false, 0xc0);
+
+       pBtdm8723->bPreIgnoreWlanAct = true;
+       btdm_2AntIgnoreWlanAct(padapter, false);
+}
+
+static void BTDM_2AntHwCoexAllOff8723A(struct rtw_adapter *padapter)
+{
+       btdm_2AntCoexTable(padapter, 0x55555555, 0xffff, 0x3);
+}
+
+static void BTDM_2AntFwCoexAllOff8723A(struct rtw_adapter *padapter)
+{
+       btdm_2AntIgnoreWlanAct(padapter, false);
+       btdm_2AntPsTdma(padapter, false, 0);
+       btdm_2AntFwDacSwingLvl(padapter, 0x20);
+       btdm_2AntDecBtPwr(padapter, false);
+}
+
+static void BTDM_2AntSwCoexAllOff8723A(struct rtw_adapter *padapter)
+{
+       btdm_2AntAgcTable(padapter, false);
+       btdm_2AntAdcBackOff(padapter, false);
+       btdm_2AntLowPenaltyRa(padapter, false);
+       btdm_2AntRfShrink(padapter, false);
+       btdm_2AntDacSwing(padapter, false, 0xc0);
+}
+
+static void BTDM_2AntFwC2hBtInfo8723A(struct rtw_adapter *padapter)
+{
+       struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
+       struct bt_mgnt *pBtMgnt = &pBTInfo->BtMgnt;
+       struct hal_data_8723a *pHalData = GET_HAL_DATA(padapter);
+       struct btdm_8723a_2ant *pBtdm8723 = &pHalData->bt_coexist.halCoex8723.btdm2Ant;
+       u8 btInfo = 0;
+       u8 algorithm = BT_2ANT_COEX_ALGO_UNDEFINED;
+       u8 bBtLinkExist = false, bBtHsModeExist = false;
+
+       btInfo = pHalData->bt_coexist.halCoex8723.c2hBtInfoOriginal;
+       pBtdm8723->btStatus = BT_2ANT_BT_STATUS_IDLE;
+
+       /*  check BIT2 first ==> check if bt is under inquiry or page scan */
+       if (btInfo & BIT(2)) {
+               if (!pHalData->bt_coexist.halCoex8723.bC2hBtInquiryPage) {
+                       pBtMgnt->ExtConfig.bHoldForBtOperation = true;
+                       pBtMgnt->ExtConfig.bHoldPeriodCnt = 1;
+                       btdm_2AntBtInquiryPage(padapter);
+               } else {
+                       pBtMgnt->ExtConfig.bHoldPeriodCnt++;
+                       btdm_HoldForBtInqPage(padapter);
+               }
+               pHalData->bt_coexist.halCoex8723.bC2hBtInquiryPage = true;
+
+       } else {
+               pHalData->bt_coexist.halCoex8723.bC2hBtInquiryPage = false;
+               pBtMgnt->ExtConfig.bHoldForBtOperation = false;
+               pBtMgnt->ExtConfig.bHoldPeriodCnt = 0;
+
+       }
+       RTPRINT(FBT, BT_TRACE,
+               ("[BTC2H], pHalData->bt_coexist.halCoex8723.bC2hBtInquiryPage =%x pBtMgnt->ExtConfig.bHoldPeriodCnt =%x pBtMgnt->ExtConfig.bHoldForBtOperation =%x\n",
+               pHalData->bt_coexist.halCoex8723.bC2hBtInquiryPage,
+               pBtMgnt->ExtConfig.bHoldPeriodCnt,
+               pBtMgnt->ExtConfig.bHoldForBtOperation));
+
+       RTPRINT(FBT, BT_TRACE,
+               ("[BTC2H],   btInfo =%x   pHalData->bt_coexist.halCoex8723.c2hBtInfoOriginal =%x\n",
+               btInfo, pHalData->bt_coexist.halCoex8723.c2hBtInfoOriginal));
+       if (btInfo&BT_INFO_ACL) {
+               RTPRINT(FBT, BT_TRACE, ("[BTC2H], BTInfo: bConnect = true   btInfo =%x\n", btInfo));
+               bBtLinkExist = true;
+               if (((btInfo&(BT_INFO_FTP|BT_INFO_A2DP|BT_INFO_HID|BT_INFO_SCO_BUSY)) != 0) ||
+                   pHalData->bt_coexist.halCoex8723.btRetryCnt > 0) {
+                       pBtdm8723->btStatus = BT_2ANT_BT_STATUS_NON_IDLE;
+               } else {
+                       pBtdm8723->btStatus = BT_2ANT_BT_STATUS_CONNECTED_IDLE;
+               }
+
+               if (btInfo&BT_INFO_SCO || btInfo&BT_INFO_SCO_BUSY) {
+                       if (btInfo&BT_INFO_FTP || btInfo&BT_INFO_A2DP || btInfo&BT_INFO_HID) {
+                               switch (btInfo&0xe0) {
+                               case BT_INFO_HID:
+                                       RTPRINT(FBT, BT_TRACE, ("[BTCoex], SCO + HID\n"));
+                                       algorithm = BT_2ANT_COEX_ALGO_HID;
+                                       break;
+                               case BT_INFO_A2DP:
+                                       RTPRINT(FBT, BT_TRACE, ("[BTCoex], Error!!! SCO + A2DP\n"));
+                                       break;
+                               case BT_INFO_FTP:
+                                       if (bBtHsModeExist) {
+                                               RTPRINT(FBT, BT_TRACE, ("[BTCoex], SCO + PAN(HS)\n"));
+                                               algorithm = BT_2ANT_COEX_ALGO_SCO;
+                                       } else {
+                                               RTPRINT(FBT, BT_TRACE, ("[BTCoex], SCO + PAN(EDR)\n"));
+                                               algorithm = BT_2ANT_COEX_ALGO_PANEDR_HID;
+                                       }
+                                       break;
+                               case (BT_INFO_HID | BT_INFO_A2DP):
+                                       RTPRINT(FBT, BT_TRACE, ("[BTCoex], HID + A2DP\n"));
+                                       algorithm = BT_2ANT_COEX_ALGO_HID_A2DP;
+                                       break;
+                               case (BT_INFO_HID | BT_INFO_FTP):
+                                       if (bBtHsModeExist) {
+                                               RTPRINT(FBT, BT_TRACE, ("[BTCoex], HID + PAN(HS)\n"));
+                                               algorithm = BT_2ANT_COEX_ALGO_HID_A2DP;
+                                       } else {
+                                               RTPRINT(FBT, BT_TRACE, ("[BTCoex], HID + PAN(EDR)\n"));
+                                               algorithm = BT_2ANT_COEX_ALGO_PANEDR_HID;
+                                       }
+                                       break;
+                               case (BT_INFO_A2DP | BT_INFO_FTP):
+                                       if (bBtHsModeExist) {
+                                               RTPRINT(FBT, BT_TRACE, ("[BTCoex], A2DP + PAN(HS)\n"));
+                                               algorithm = BT_2ANT_COEX_ALGO_A2DP;
+                                       } else {
+                                               RTPRINT(FBT, BT_TRACE, ("[BTCoex], A2DP + PAN(EDR)\n"));
+                                               algorithm = BT_2ANT_COEX_ALGO_PANEDR_A2DP;
+                                       }
+                                       break;
+                               case (BT_INFO_HID | BT_INFO_A2DP | BT_INFO_FTP):
+                                       if (bBtHsModeExist) {
+                                               RTPRINT(FBT, BT_TRACE, ("[BTCoex], HID + A2DP + PAN(HS)\n"));
+                                               algorithm = BT_2ANT_COEX_ALGO_HID_A2DP;
+                                       } else {
+                                               RTPRINT(FBT, BT_TRACE, ("[BTCoex], HID + A2DP + PAN(EDR)\n"));
+                                               algorithm = BT_2ANT_COEX_ALGO_HID_A2DP_PANEDR;
+                                       }
+                                       break;
+                               }
+                       } else {
+                               RTPRINT(FBT, BT_TRACE, ("[BTCoex], SCO only\n"));
+                               algorithm = BT_2ANT_COEX_ALGO_SCO;
+                       }
+               } else {
+                       RTPRINT(FBT, BT_TRACE, ("[BTCoex], non SCO\n"));
+                       switch (btInfo&0xe0) {
+                       case BT_INFO_HID:
+                               RTPRINT(FBT, BT_TRACE, ("[BTCoex], HID\n"));
+                               algorithm = BT_2ANT_COEX_ALGO_HID;
+                               break;
+                       case BT_INFO_A2DP:
+                               RTPRINT(FBT, BT_TRACE, ("[BTCoex],  A2DP\n"));
+                               algorithm = BT_2ANT_COEX_ALGO_A2DP;
+                               break;
+                       case BT_INFO_FTP:
+                               RTPRINT(FBT, BT_TRACE, ("[BTCoex], PAN(EDR)\n"));
+                               algorithm = BT_2ANT_COEX_ALGO_PANEDR_HID;
+                               break;
+                       case (BT_INFO_HID | BT_INFO_A2DP):
+                               RTPRINT(FBT, BT_TRACE, ("[BTCoex], HID + A2DP\n"));
+                               algorithm = BT_2ANT_COEX_ALGO_HID_A2DP;
+                               break;
+                       case (BT_INFO_HID|BT_INFO_FTP):
+                               if (bBtHsModeExist) {
+                                       RTPRINT(FBT, BT_TRACE, ("[BTCoex], HID + PAN(HS)\n"));
+                                       algorithm = BT_2ANT_COEX_ALGO_HID_A2DP;
+                               } else {
+                                       RTPRINT(FBT, BT_TRACE, ("[BTCoex], HID + PAN(EDR)\n"));
+                                       algorithm = BT_2ANT_COEX_ALGO_PANEDR_HID;
+                               }
+                               break;
+                       case (BT_INFO_A2DP|BT_INFO_FTP):
+                               if (bBtHsModeExist) {
+                                       RTPRINT(FBT, BT_TRACE, ("[BTCoex], A2DP + PAN(HS)\n"));
+                                       algorithm = BT_2ANT_COEX_ALGO_A2DP;
+                               } else {
+                                       RTPRINT(FBT, BT_TRACE, ("[BTCoex], A2DP + PAN(EDR)\n"));
+                                       algorithm = BT_2ANT_COEX_ALGO_PANEDR_A2DP;
+                               }
+                               break;
+                       case (BT_INFO_HID|BT_INFO_A2DP|BT_INFO_FTP):
+                               if (bBtHsModeExist) {
+                                       RTPRINT(FBT, BT_TRACE, ("[BTCoex], HID + A2DP + PAN(HS)\n"));
+                                       algorithm = BT_2ANT_COEX_ALGO_HID_A2DP;
+                               } else {
+                                       RTPRINT(FBT, BT_TRACE, ("[BTCoex], HID + A2DP + PAN(EDR)\n"));
+                                       algorithm = BT_2ANT_COEX_ALGO_HID_A2DP_PANEDR;
+                               }
+                               break;
+                       }
+
+               }
+       } else {
+               RTPRINT(FBT, BT_TRACE, ("[BTC2H], BTInfo: bConnect = false\n"));
+               pBtdm8723->btStatus = BT_2ANT_BT_STATUS_IDLE;
+       }
+
+       pBtdm8723->curAlgorithm = algorithm;
+       RTPRINT(FBT, BT_TRACE, ("[BTCoex], Algorithm = %d \n", pBtdm8723->curAlgorithm));
+
+/* From */
+       BTDM_CheckWiFiState(padapter);
+       if (pBtMgnt->ExtConfig.bManualControl) {
+               RTPRINT(FBT, BT_TRACE, ("Action Manual control, won't execute bt coexist mechanism!!\n"));
+               return;
+       }
+}
+
+void BTDM_2AntBtCoexist8723A(struct rtw_adapter *padapter)
+{
+       struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
+       struct bt_mgnt *pBtMgnt = &pBTInfo->BtMgnt;
+       struct bt_dgb *pBtDbg = &pBTInfo->BtDbg;
+       u8 btInfoOriginal = 0;
+       struct hal_data_8723a *pHalData = GET_HAL_DATA(padapter);
+       struct btdm_8723a_2ant *pBtdm8723 = &pHalData->bt_coexist.halCoex8723.btdm2Ant;
+
+       if (BTDM_BtProfileSupport(padapter)) {
+               if (pBtMgnt->ExtConfig.bHoldForBtOperation) {
+                       RTPRINT(FBT, BT_TRACE, ("Action for BT Operation adjust!!\n"));
+                       return;
+               }
+               if (pBtMgnt->ExtConfig.bHoldPeriodCnt) {
+                       RTPRINT(FBT, BT_TRACE, ("Hold BT inquiry/page scan setting (cnt = %d)!!\n",
+                               pBtMgnt->ExtConfig.bHoldPeriodCnt));
+                       if (pBtMgnt->ExtConfig.bHoldPeriodCnt >= 11) {
+                               pBtMgnt->ExtConfig.bHoldPeriodCnt = 0;
+                               /*  next time the coexist parameters should be reset again. */
+                       } else {
+                               pBtMgnt->ExtConfig.bHoldPeriodCnt++;
+                       }
+                       return;
+               }
+
+               if (pBtDbg->dbgCtrl)
+                       RTPRINT(FBT, BT_TRACE, ("[Dbg control], "));
+
+               pBtdm8723->curAlgorithm = btdm_ActionAlgorithm(padapter);
+               RTPRINT(FBT, BT_TRACE, ("[BTCoex], Algorithm = %d \n", pBtdm8723->curAlgorithm));
+
+               if (btdm_Is2Ant8723ACommonAction(padapter)) {
+                       RTPRINT(FBT, BT_TRACE, ("Action 2-Ant common.\n"));
+                       pBtdm8723->bResetTdmaAdjust = true;
+               } else {
+                       if (pBtdm8723->curAlgorithm != pBtdm8723->preAlgorithm) {
+                               RTPRINT(FBT, BT_TRACE, ("[BTCoex], preAlgorithm =%d, curAlgorithm =%d\n",
+                               pBtdm8723->preAlgorithm, pBtdm8723->curAlgorithm));
+                               pBtdm8723->bResetTdmaAdjust = true;
+                       }
+                       switch (pBtdm8723->curAlgorithm) {
+                       case BT_2ANT_COEX_ALGO_SCO:
+                               RTPRINT(FBT, BT_TRACE, ("Action 2-Ant, algorithm = SCO.\n"));
+                               btdm_2Ant8723ASCOAction(padapter);
+                               break;
+                       case BT_2ANT_COEX_ALGO_HID:
+                               RTPRINT(FBT, BT_TRACE, ("Action 2-Ant, algorithm = HID.\n"));
+                               btdm_2Ant8723AHIDAction(padapter);
+                               break;
+                       case BT_2ANT_COEX_ALGO_A2DP:
+                               RTPRINT(FBT, BT_TRACE, ("Action 2-Ant, algorithm = A2DP.\n"));
+                               btdm_2Ant8723AA2DPAction(padapter);
+                               break;
+                       case BT_2ANT_COEX_ALGO_PANEDR:
+                               RTPRINT(FBT, BT_TRACE, ("Action 2-Ant, algorithm = PAN(EDR).\n"));
+                               btdm_2Ant8723APANEDRAction(padapter);
+                               break;
+                       case BT_2ANT_COEX_ALGO_PANHS:
+                               RTPRINT(FBT, BT_TRACE, ("Action 2-Ant, algorithm = HS mode.\n"));
+                               btdm_2Ant8723APANHSAction(padapter);
+                               break;
+                       case BT_2ANT_COEX_ALGO_PANEDR_A2DP:
+                               RTPRINT(FBT, BT_TRACE, ("Action 2-Ant, algorithm = PAN+A2DP.\n"));
+                               btdm_2Ant8723APANEDRA2DPAction(padapter);
+                               break;
+                       case BT_2ANT_COEX_ALGO_PANEDR_HID:
+                               RTPRINT(FBT, BT_TRACE, ("Action 2-Ant, algorithm = PAN(EDR)+HID.\n"));
+                               btdm_2Ant8723APANEDRHIDAction(padapter);
+                               break;
+                       case BT_2ANT_COEX_ALGO_HID_A2DP_PANEDR:
+                               RTPRINT(FBT, BT_TRACE, ("Action 2-Ant, algorithm = HID+A2DP+PAN.\n"));
+                               btdm_2Ant8723AHIDA2DPPANEDRAction(padapter);
+                               break;
+                       case BT_2ANT_COEX_ALGO_HID_A2DP:
+                               RTPRINT(FBT, BT_TRACE, ("Action 2-Ant, algorithm = HID+A2DP.\n"));
+                               btdm_2Ant8723AHIDA2DPAction(padapter);
+                               break;
+                       default:
+                               RTPRINT(FBT, BT_TRACE, ("Action 2-Ant, algorithm = 0.\n"));
+                               btdm_2Ant8723AA2DPAction(padapter);
+                               break;
+                       }
+                       pBtdm8723->preAlgorithm = pBtdm8723->curAlgorithm;
+               }
+       } else {
+               RTPRINT(FBT, BT_TRACE, ("[BTCoex] Get bt info by fw!!\n"));
+               /* msg shows c2h rsp for bt_info is received or not. */
+               if (pHalData->bt_coexist.halCoex8723.bC2hBtInfoReqSent)
+                       RTPRINT(FBT, BT_TRACE, ("[BTCoex] c2h for btInfo not rcvd yet!!\n"));
+
+               btInfoOriginal = pHalData->bt_coexist.halCoex8723.c2hBtInfoOriginal;
+
+               if (pBtMgnt->ExtConfig.bHoldForBtOperation) {
+                       RTPRINT(FBT, BT_TRACE, ("Action for BT Operation adjust!!\n"));
+                       return;
+               }
+               if (pBtMgnt->ExtConfig.bHoldPeriodCnt) {
+                       RTPRINT(FBT, BT_TRACE,
+                               ("Hold BT inquiry/page scan setting (cnt = %d)!!\n",
+                               pBtMgnt->ExtConfig.bHoldPeriodCnt));
+                       if (pBtMgnt->ExtConfig.bHoldPeriodCnt >= 11) {
+                               pBtMgnt->ExtConfig.bHoldPeriodCnt = 0;
+                               /*  next time the coexist parameters should be reset again. */
+                       } else {
+                                pBtMgnt->ExtConfig.bHoldPeriodCnt++;
+                       }
+                       return;
+               }
+
+               if (pBtDbg->dbgCtrl)
+                       RTPRINT(FBT, BT_TRACE, ("[Dbg control], "));
+               if (btdm_Is2Ant8723ACommonAction(padapter)) {
+                       RTPRINT(FBT, BT_TRACE, ("Action 2-Ant common.\n"));
+                       pBtdm8723->bResetTdmaAdjust = true;
+               } else {
+                       if (pBtdm8723->curAlgorithm != pBtdm8723->preAlgorithm) {
+                               RTPRINT(FBT, BT_TRACE,
+                                       ("[BTCoex], preAlgorithm =%d, curAlgorithm =%d\n",
+                                       pBtdm8723->preAlgorithm,
+                                       pBtdm8723->curAlgorithm));
+                               pBtdm8723->bResetTdmaAdjust = true;
+                       }
+                       switch (pBtdm8723->curAlgorithm) {
+                       case BT_2ANT_COEX_ALGO_SCO:
+                               RTPRINT(FBT, BT_TRACE, ("Action 2-Ant, algorithm = SCO.\n"));
+                               btdm_2Ant8723ASCOAction(padapter);
+                               break;
+                       case BT_2ANT_COEX_ALGO_HID:
+                               RTPRINT(FBT, BT_TRACE, ("Action 2-Ant, algorithm = HID.\n"));
+                               btdm_2Ant8723AHIDAction(padapter);
+                               break;
+                       case BT_2ANT_COEX_ALGO_A2DP:
+                               RTPRINT(FBT, BT_TRACE, ("Action 2-Ant, algorithm = A2DP.\n"));
+                               btdm_2Ant8723AA2dp(padapter);
+                               break;
+                       case BT_2ANT_COEX_ALGO_PANEDR:
+                               RTPRINT(FBT, BT_TRACE, ("Action 2-Ant, algorithm = PAN(EDR).\n"));
+                               btdm_2Ant8723APANEDRAction(padapter);
+                               break;
+                       case BT_2ANT_COEX_ALGO_PANHS:
+                               RTPRINT(FBT, BT_TRACE, ("Action 2-Ant, algorithm = HS mode.\n"));
+                               btdm_2Ant8723APANHSAction(padapter);
+                               break;
+                       case BT_2ANT_COEX_ALGO_PANEDR_A2DP:
+                               RTPRINT(FBT, BT_TRACE, ("Action 2-Ant, algorithm = PAN+A2DP.\n"));
+                               btdm_2Ant8723APANEDRA2DPAction(padapter);
+                               break;
+                       case BT_2ANT_COEX_ALGO_PANEDR_HID:
+                               RTPRINT(FBT, BT_TRACE, ("Action 2-Ant, algorithm = PAN(EDR)+HID.\n"));
+                               btdm_2Ant8723APANEDRHIDAction(padapter);
+                               break;
+                       case BT_2ANT_COEX_ALGO_HID_A2DP_PANEDR:
+                               RTPRINT(FBT, BT_TRACE, ("Action 2-Ant, algorithm = HID+A2DP+PAN.\n"));
+                               btdm_2Ant8723AHIDA2DPPANEDRAction(padapter);
+                               break;
+                       case BT_2ANT_COEX_ALGO_HID_A2DP:
+                               RTPRINT(FBT, BT_TRACE, ("Action 2-Ant, algorithm = HID+A2DP.\n"));
+                               btdm_2Ant8723AHIDA2DPAction(padapter);
+                               break;
+                       default:
+                               RTPRINT(FBT, BT_TRACE, ("Action 2-Ant, algorithm = 0.\n"));
+                               btdm_2Ant8723AA2DPAction(padapter);
+                               break;
+                       }
+                       pBtdm8723->preAlgorithm = pBtdm8723->curAlgorithm;
+               }
+       }
+}
+
+/*  ===== End of sync from SD7 driver HAL/BTCoexist/HalBtc87232Ant.c ===== */
+
+/*  ===== Below this line is sync from SD7 driver HAL/BTCoexist/HalBtc8723.c ===== */
+
+static u8 btCoexDbgBuf[BT_TMP_BUF_SIZE];
+
+static const char *const BtProfileString[] = {
+       "NONE",
+       "A2DP",
+       "PAN",
+       "HID",
+       "SCO",
+};
+
+static const char *const BtSpecString[] = {
+       "1.0b",
+       "1.1",
+       "1.2",
+       "2.0+EDR",
+       "2.1+EDR",
+       "3.0+HS",
+       "4.0",
+};
+
+static const char *const BtLinkRoleString[] = {
+       "Master",
+       "Slave",
+};
+
+static u8 btdm_BtWifiAntNum(struct rtw_adapter *padapter)
+{
+       struct hal_data_8723a *pHalData = GET_HAL_DATA(padapter);
+       struct bt_coexist_8723a *pBtCoex = &pHalData->bt_coexist.halCoex8723;
+
+       if (Ant_x2 == pHalData->bt_coexist.BT_Ant_Num) {
+               if (Ant_x2 == pBtCoex->TotalAntNum)
+                       return Ant_x2;
+               else
+                       return Ant_x1;
+       } else {
+               return Ant_x1;
+       }
+       return Ant_x2;
+}
+
+static void btdm_BtHwCountersMonitor(struct rtw_adapter *padapter)
+{
+       struct hal_data_8723a *pHalData = GET_HAL_DATA(padapter);
+       u32     regHPTxRx, regLPTxRx, u4Tmp;
+       u32     regHPTx = 0, regHPRx = 0, regLPTx = 0, regLPRx = 0;
+
+       regHPTxRx = REG_HIGH_PRIORITY_TXRX;
+       regLPTxRx = REG_LOW_PRIORITY_TXRX;
+
+       u4Tmp = rtl8723au_read32(padapter, regHPTxRx);
+       regHPTx = u4Tmp & bMaskLWord;
+       regHPRx = (u4Tmp & bMaskHWord)>>16;
+
+       u4Tmp = rtl8723au_read32(padapter, regLPTxRx);
+       regLPTx = u4Tmp & bMaskLWord;
+       regLPRx = (u4Tmp & bMaskHWord)>>16;
+
+       pHalData->bt_coexist.halCoex8723.highPriorityTx = regHPTx;
+       pHalData->bt_coexist.halCoex8723.highPriorityRx = regHPRx;
+       pHalData->bt_coexist.halCoex8723.lowPriorityTx = regLPTx;
+       pHalData->bt_coexist.halCoex8723.lowPriorityRx = regLPRx;
+
+       RTPRINT(FBT, BT_TRACE, ("High Priority Tx/Rx = %d / %d\n", regHPTx, regHPRx));
+       RTPRINT(FBT, BT_TRACE, ("Low Priority Tx/Rx = %d / %d\n", regLPTx, regLPRx));
+
+       /*  reset counter */
+       rtl8723au_write8(padapter, 0x76e, 0xc);
+}
+
+/*  This function check if 8723 bt is disabled */
+static void btdm_BtEnableDisableCheck8723A(struct rtw_adapter *padapter)
+{
+       u8 btAlife = true;
+       struct hal_data_8723a *pHalData = GET_HAL_DATA(padapter);
+
+#ifdef CHECK_BT_EXIST_FROM_REG
+       u8 val8;
+
+       /*  ox68[28]= 1 => BT enable; otherwise disable */
+       val8 = rtl8723au_read8(padapter, 0x6B);
+       if (!(val8 & BIT(4)))
+               btAlife = false;
+
+       if (btAlife)
+               pHalData->bt_coexist.bCurBtDisabled = false;
+       else
+               pHalData->bt_coexist.bCurBtDisabled = true;
+#else
+       if (pHalData->bt_coexist.halCoex8723.highPriorityTx == 0 &&
+           pHalData->bt_coexist.halCoex8723.highPriorityRx == 0 &&
+           pHalData->bt_coexist.halCoex8723.lowPriorityTx == 0 &&
+           pHalData->bt_coexist.halCoex8723.lowPriorityRx == 0)
+               btAlife = false;
+       if (pHalData->bt_coexist.halCoex8723.highPriorityTx == 0xeaea &&
+           pHalData->bt_coexist.halCoex8723.highPriorityRx == 0xeaea &&
+           pHalData->bt_coexist.halCoex8723.lowPriorityTx == 0xeaea &&
+           pHalData->bt_coexist.halCoex8723.lowPriorityRx == 0xeaea)
+               btAlife = false;
+       if (pHalData->bt_coexist.halCoex8723.highPriorityTx == 0xffff &&
+           pHalData->bt_coexist.halCoex8723.highPriorityRx == 0xffff &&
+           pHalData->bt_coexist.halCoex8723.lowPriorityTx == 0xffff &&
+           pHalData->bt_coexist.halCoex8723.lowPriorityRx == 0xffff)
+               btAlife = false;
+       if (btAlife) {
+               pHalData->bt_coexist.btActiveZeroCnt = 0;
+               pHalData->bt_coexist.bCurBtDisabled = false;
+               RTPRINT(FBT, BT_TRACE, ("8723A BT is enabled !!\n"));
+       } else {
+               pHalData->bt_coexist.btActiveZeroCnt++;
+               RTPRINT(FBT, BT_TRACE, ("8723A bt all counters = 0, %d times!!\n",
+                               pHalData->bt_coexist.btActiveZeroCnt));
+               if (pHalData->bt_coexist.btActiveZeroCnt >= 2) {
+                       pHalData->bt_coexist.bCurBtDisabled = true;
+                       RTPRINT(FBT, BT_TRACE, ("8723A BT is disabled !!\n"));
+               }
+       }
+#endif
+
+       if (!pHalData->bt_coexist.bCurBtDisabled) {
+               if (BTDM_IsWifiConnectionExist(padapter))
+                       BTDM_SetFwChnlInfo(padapter, RT_MEDIA_CONNECT);
+               else
+                       BTDM_SetFwChnlInfo(padapter, RT_MEDIA_DISCONNECT);
+       }
+
+       if (pHalData->bt_coexist.bPreBtDisabled !=
+           pHalData->bt_coexist.bCurBtDisabled) {
+               RTPRINT(FBT, BT_TRACE, ("8723A BT is from %s to %s!!\n",
+                       (pHalData->bt_coexist.bPreBtDisabled ? "disabled":"enabled"),
+                       (pHalData->bt_coexist.bCurBtDisabled ? "disabled":"enabled")));
+               pHalData->bt_coexist.bPreBtDisabled = pHalData->bt_coexist.bCurBtDisabled;
+       }
+}
+
+static void btdm_BTCoexist8723AHandler(struct rtw_adapter *padapter)
+{
+       struct hal_data_8723a *pHalData;
+
+       pHalData = GET_HAL_DATA(padapter);
+
+       if (btdm_BtWifiAntNum(padapter) == Ant_x2) {
+               RTPRINT(FBT, BT_TRACE, ("[BTCoex], 2 Ant mechanism\n"));
+               BTDM_2AntBtCoexist8723A(padapter);
+       } else {
+               RTPRINT(FBT, BT_TRACE, ("[BTCoex], 1 Ant mechanism\n"));
+               BTDM_1AntBtCoexist8723A(padapter);
+       }
+
+       if (!BTDM_IsSameCoexistState(padapter)) {
+               RTPRINT(FBT, BT_TRACE, ("[BTCoex], Coexist State[bitMap] change from 0x%"i64fmt"x to 0x%"i64fmt"x\n",
+                       pHalData->bt_coexist.PreviousState,
+                       pHalData->bt_coexist.CurrentState));
+               pHalData->bt_coexist.PreviousState = pHalData->bt_coexist.CurrentState;
+
+               RTPRINT(FBT, BT_TRACE, ("["));
+               if (pHalData->bt_coexist.CurrentState & BT_COEX_STATE_BT30)
+                       RTPRINT(FBT, BT_TRACE, ("BT 3.0, "));
+               if (pHalData->bt_coexist.CurrentState & BT_COEX_STATE_WIFI_HT20)
+                       RTPRINT(FBT, BT_TRACE, ("HT20, "));
+               if (pHalData->bt_coexist.CurrentState & BT_COEX_STATE_WIFI_HT40)
+                       RTPRINT(FBT, BT_TRACE, ("HT40, "));
+               if (pHalData->bt_coexist.CurrentState & BT_COEX_STATE_WIFI_LEGACY)
+                       RTPRINT(FBT, BT_TRACE, ("Legacy, "));
+               if (pHalData->bt_coexist.CurrentState & BT_COEX_STATE_WIFI_RSSI_LOW)
+                       RTPRINT(FBT, BT_TRACE, ("Rssi_Low, "));
+               if (pHalData->bt_coexist.CurrentState & BT_COEX_STATE_WIFI_RSSI_MEDIUM)
+                       RTPRINT(FBT, BT_TRACE, ("Rssi_Mid, "));
+               if (pHalData->bt_coexist.CurrentState & BT_COEX_STATE_WIFI_RSSI_HIGH)
+                       RTPRINT(FBT, BT_TRACE, ("Rssi_High, "));
+               if (pHalData->bt_coexist.CurrentState & BT_COEX_STATE_WIFI_IDLE)
+                       RTPRINT(FBT, BT_TRACE, ("Wifi_Idle, "));
+               if (pHalData->bt_coexist.CurrentState & BT_COEX_STATE_WIFI_UPLINK)
+                       RTPRINT(FBT, BT_TRACE, ("Wifi_Uplink, "));
+               if (pHalData->bt_coexist.CurrentState & BT_COEX_STATE_WIFI_DOWNLINK)
+                       RTPRINT(FBT, BT_TRACE, ("Wifi_Downlink, "));
+               if (pHalData->bt_coexist.CurrentState & BT_COEX_STATE_BT_IDLE)
+                       RTPRINT(FBT, BT_TRACE, ("BT_idle, "));
+               if (pHalData->bt_coexist.CurrentState & BT_COEX_STATE_PROFILE_HID)
+                       RTPRINT(FBT, BT_TRACE, ("PRO_HID, "));
+               if (pHalData->bt_coexist.CurrentState & BT_COEX_STATE_PROFILE_A2DP)
+                       RTPRINT(FBT, BT_TRACE, ("PRO_A2DP, "));
+               if (pHalData->bt_coexist.CurrentState & BT_COEX_STATE_PROFILE_PAN)
+                       RTPRINT(FBT, BT_TRACE, ("PRO_PAN, "));
+               if (pHalData->bt_coexist.CurrentState & BT_COEX_STATE_PROFILE_SCO)
+                       RTPRINT(FBT, BT_TRACE, ("PRO_SCO, "));
+               RTPRINT(FBT, BT_TRACE, ("]\n"));
+       }
+}
+
+/*  extern function start with BTDM_ */
+u32 BTDM_BtTxRxCounterH(struct rtw_adapter *padapter)
+{
+       struct hal_data_8723a *pHalData = GET_HAL_DATA(padapter);
+       u32     counters = 0;
+
+       counters = pHalData->bt_coexist.halCoex8723.highPriorityTx+
+               pHalData->bt_coexist.halCoex8723.highPriorityRx;
+       return counters;
+}
+
+u32 BTDM_BtTxRxCounterL(struct rtw_adapter *padapter)
+{
+       struct hal_data_8723a *pHalData = GET_HAL_DATA(padapter);
+       u32     counters = 0;
+
+       counters = pHalData->bt_coexist.halCoex8723.lowPriorityTx+
+               pHalData->bt_coexist.halCoex8723.lowPriorityRx;
+       return counters;
+}
+
+void BTDM_SetFwChnlInfo(struct rtw_adapter *padapter, enum rt_media_status mstatus)
+{
+       struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
+       struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
+       struct bt_mgnt *pBtMgnt = &pBTInfo->BtMgnt;
+       u8 H2C_Parameter[3] = {0};
+       u8 chnl;
+
+       /*  opMode */
+       if (RT_MEDIA_CONNECT == mstatus)
+               H2C_Parameter[0] = 0x1; /*  0: disconnected, 1:connected */
+
+       if (check_fwstate(&padapter->mlmepriv, WIFI_ASOC_STATE)) {
+               /*  channel */
+               chnl = pmlmeext->cur_channel;
+               if (BTDM_IsHT40(padapter)) {
+                       if (pmlmeext->cur_ch_offset == HAL_PRIME_CHNL_OFFSET_UPPER)
+                               chnl -= 2;
+                       else if (pmlmeext->cur_ch_offset == HAL_PRIME_CHNL_OFFSET_LOWER)
+                               chnl += 2;
+               }
+               H2C_Parameter[1] = chnl;
+       } else {        /*  check if HS link is exists */
+               /*  channel */
+               if (BT_Operation(padapter))
+                       H2C_Parameter[1] = pBtMgnt->BTChannel;
+               else
+                       H2C_Parameter[1] = pmlmeext->cur_channel;
+       }
+
+       if (BTDM_IsHT40(padapter))
+               H2C_Parameter[2] = 0x30;
+       else
+               H2C_Parameter[2] = 0x20;
+
+       FillH2CCmd(padapter, 0x19, 3, H2C_Parameter);
+}
+
+u8 BTDM_IsWifiConnectionExist(struct rtw_adapter *padapter)
+{
+       u8 bRet = false;
+
+       if (BTHCI_HsConnectionEstablished(padapter))
+               bRet = true;
+
+       if (check_fwstate(&padapter->mlmepriv, WIFI_ASOC_STATE) == true)
+               bRet = true;
+
+       return bRet;
+}
+
+void BTDM_SetFw3a(
+       struct rtw_adapter *padapter,
+       u8 byte1,
+       u8 byte2,
+       u8 byte3,
+       u8 byte4,
+       u8 byte5
+       )
+{
+       u8 H2C_Parameter[5] = {0};
+
+       if (rtl8723a_BT_using_antenna_1(padapter)) {
+               if ((!check_fwstate(&padapter->mlmepriv, WIFI_STATION_STATE)) &&
+                   (get_fwstate(&padapter->mlmepriv) != WIFI_NULL_STATE)) {
+                       /*  for softap mode */
+                       struct hal_data_8723a *pHalData = GET_HAL_DATA(padapter);
+                       struct bt_coexist_8723a *pBtCoex = &pHalData->bt_coexist.halCoex8723;
+                       u8 BtState = pBtCoex->c2hBtInfo;
+
+                       if ((BtState != BT_INFO_STATE_NO_CONNECTION) &&
+                           (BtState != BT_INFO_STATE_CONNECT_IDLE)) {
+                               if (byte1 & BIT(4)) {
+                                       byte1 &= ~BIT(4);
+                                       byte1 |= BIT(5);
+                               }
+
+                               byte5 |= BIT(5);
+                               if (byte5 & BIT(6))
+                                       byte5 &= ~BIT(6);
+                       }
+               }
+       }
+
+       H2C_Parameter[0] = byte1;
+       H2C_Parameter[1] = byte2;
+       H2C_Parameter[2] = byte3;
+       H2C_Parameter[3] = byte4;
+       H2C_Parameter[4] = byte5;
+
+       RTPRINT(FBT, BT_TRACE, ("[BTCoex], FW write 0x3a(5bytes) = 0x%02x%08x\n",
+               H2C_Parameter[0],
+               H2C_Parameter[1]<<24|H2C_Parameter[2]<<16|H2C_Parameter[3]<<8|H2C_Parameter[4]));
+
+       FillH2CCmd(padapter, 0x3a, 5, H2C_Parameter);
+}
+
+void BTDM_QueryBtInformation(struct rtw_adapter *padapter)
+{
+       u8 H2C_Parameter[1] = {0};
+       struct hal_data_8723a *pHalData;
+       struct bt_coexist_8723a *pBtCoex;
+
+       pHalData = GET_HAL_DATA(padapter);
+       pBtCoex = &pHalData->bt_coexist.halCoex8723;
+
+       if (!rtl8723a_BT_enabled(padapter)) {
+               pBtCoex->c2hBtInfo = BT_INFO_STATE_DISABLED;
+               pBtCoex->bC2hBtInfoReqSent = false;
+               return;
+       }
+
+       if (pBtCoex->c2hBtInfo == BT_INFO_STATE_DISABLED)
+               pBtCoex->c2hBtInfo = BT_INFO_STATE_NO_CONNECTION;
+
+       if (pBtCoex->bC2hBtInfoReqSent == true)
+               RTPRINT(FBT, BT_TRACE, ("[BTCoex], didn't recv previous BtInfo report!\n"));
+       else
+               pBtCoex->bC2hBtInfoReqSent = true;
+
+       H2C_Parameter[0] |= BIT(0);     /*  trigger */
+
+/*RTPRINT(FBT, BT_TRACE, ("[BTCoex], Query Bt information, write 0x38 = 0x%x\n", */
+/*H2C_Parameter[0])); */
+
+       FillH2CCmd(padapter, 0x38, 1, H2C_Parameter);
+}
+
+void BTDM_SetSwRfRxLpfCorner(struct rtw_adapter *padapter, u8 type)
+{
+       struct hal_data_8723a *pHalData = GET_HAL_DATA(padapter);
+
+       if (BT_RF_RX_LPF_CORNER_SHRINK == type) {
+               /* Shrink RF Rx LPF corner */
+               RTPRINT(FBT, BT_TRACE, ("Shrink RF Rx LPF corner!!\n"));
+               PHY_SetRFReg(padapter, PathA, 0x1e, bRFRegOffsetMask, 0xf0ff7);
+               pHalData->bt_coexist.bSWCoexistAllOff = false;
+       } else if (BT_RF_RX_LPF_CORNER_RESUME == type) {
+               /* Resume RF Rx LPF corner */
+               RTPRINT(FBT, BT_TRACE, ("Resume RF Rx LPF corner!!\n"));
+               PHY_SetRFReg(padapter, PathA, 0x1e, bRFRegOffsetMask, pHalData->bt_coexist.BtRfRegOrigin1E);
+       }
+}
+
+void
+BTDM_SetSwPenaltyTxRateAdaptive(
+       struct rtw_adapter *padapter,
+       u8 raType
+       )
+{
+       struct hal_data_8723a *pHalData = GET_HAL_DATA(padapter);
+       u8 tmpU1;
+
+       tmpU1 = rtl8723au_read8(padapter, 0x4fd);
+       tmpU1 |= BIT(0);
+       if (BT_TX_RATE_ADAPTIVE_LOW_PENALTY == raType) {
+               tmpU1 &= ~BIT(2);
+               pHalData->bt_coexist.bSWCoexistAllOff = false;
+       } else if (BT_TX_RATE_ADAPTIVE_NORMAL == raType) {
+               tmpU1 |= BIT(2);
+       }
+
+       rtl8723au_write8(padapter, 0x4fd, tmpU1);
+}
+
+void BTDM_SetFwDecBtPwr(struct rtw_adapter *padapter, u8 bDecBtPwr)
+{
+       struct hal_data_8723a *pHalData = GET_HAL_DATA(padapter);
+       u8 H2C_Parameter[1] = {0};
+
+       H2C_Parameter[0] = 0;
+
+       if (bDecBtPwr) {
+               H2C_Parameter[0] |= BIT(1);
+               pHalData->bt_coexist.bFWCoexistAllOff = false;
+       }
+
+       RTPRINT(FBT, BT_TRACE, ("[BTCoex], decrease Bt Power : %s, write 0x21 = 0x%x\n",
+               (bDecBtPwr ? "Yes!!" : "No!!"), H2C_Parameter[0]));
+
+       FillH2CCmd(padapter, 0x21, 1, H2C_Parameter);
+}
+
+u8 BTDM_BtProfileSupport(struct rtw_adapter *padapter)
+{
+       u8 bRet = false;
+       struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
+       struct bt_mgnt *pBtMgnt = &pBTInfo->BtMgnt;
+       struct hal_data_8723a *pHalData = GET_HAL_DATA(padapter);
+
+       if (pBtMgnt->bSupportProfile &&
+           !pHalData->bt_coexist.halCoex8723.bForceFwBtInfo)
+               bRet = true;
+
+       return bRet;
+}
+
+static void BTDM_AdjustForBtOperation8723A(struct rtw_adapter *padapter)
+{
+       /* BTDM_2AntAdjustForBtOperation8723(padapter); */
+}
+
+static void BTDM_FwC2hBtRssi8723A(struct rtw_adapter *padapter, u8 *tmpBuf)
+{
+       struct hal_data_8723a *pHalData = GET_HAL_DATA(padapter);
+       u8 percent = 0, u1tmp = 0;
+
+       u1tmp = tmpBuf[0];
+       percent = u1tmp*2+10;
+
+       pHalData->bt_coexist.halCoex8723.btRssi = percent;
+/*RTPRINT(FBT, BT_TRACE, ("[BTC2H], BT RSSI =%d\n", percent)); */
+}
+
+void
+rtl8723a_fw_c2h_BT_info(struct rtw_adapter *padapter, u8 *tmpBuf, u8 length)
+{
+       struct hal_data_8723a *pHalData;
+       struct bt_30info *pBTInfo;
+       struct bt_mgnt *pBtMgnt;
+       struct bt_coexist_8723a *pBtCoex;
+       u8 i;
+
+       pHalData = GET_HAL_DATA(padapter);
+       pBTInfo = GET_BT_INFO(padapter);
+       pBtMgnt = &pBTInfo->BtMgnt;
+       pBtCoex = &pHalData->bt_coexist.halCoex8723;
+
+       pBtCoex->bC2hBtInfoReqSent = false;
+
+       RTPRINT(FBT, BT_TRACE, ("[BTC2H], BT info[%d]=[", length));
+
+       pBtCoex->btRetryCnt = 0;
+       for (i = 0; i < length; i++) {
+               switch (i) {
+               case 0:
+                       pBtCoex->c2hBtInfoOriginal = tmpBuf[i];
+                       break;
+               case 1:
+                       pBtCoex->btRetryCnt = tmpBuf[i];
+                       break;
+               case 2:
+                       BTDM_FwC2hBtRssi8723A(padapter, &tmpBuf[i]);
+                       break;
+               case 3:
+                       pBtCoex->btInfoExt = tmpBuf[i]&BIT(0);
+                       break;
+               }
+
+               if (i == length-1)
+                       RTPRINT(FBT, BT_TRACE, ("0x%02x]\n", tmpBuf[i]));
+               else
+                       RTPRINT(FBT, BT_TRACE, ("0x%02x, ", tmpBuf[i]));
+       }
+       RTPRINT(FBT, BT_TRACE, ("[BTC2H], BT RSSI =%d\n", pBtCoex->btRssi));
+       if (pBtCoex->btInfoExt)
+               RTPRINT(FBT, BT_TRACE, ("[BTC2H], pBtCoex->btInfoExt =%x\n", pBtCoex->btInfoExt));
+
+       if (btdm_BtWifiAntNum(padapter) == Ant_x1)
+               BTDM_1AntFwC2hBtInfo8723A(padapter);
+       else
+               BTDM_2AntFwC2hBtInfo8723A(padapter);
+
+       if (pBtMgnt->ExtConfig.bManualControl) {
+               RTPRINT(FBT, BT_TRACE, ("%s: Action Manual control!!\n", __func__));
+               return;
+       }
+
+       btdm_BTCoexist8723AHandler(padapter);
+}
+
+static void BTDM_Display8723ABtCoexInfo(struct rtw_adapter *padapter)
+{
+       struct hal_data_8723a *pHalData = GET_HAL_DATA(padapter);
+       struct bt_coexist_8723a *pBtCoex = &pHalData->bt_coexist.halCoex8723;
+       struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
+       struct bt_mgnt *pBtMgnt = &pBTInfo->BtMgnt;
+       u8 u1Tmp, u1Tmp1, u1Tmp2, i, btInfoExt, psTdmaCase = 0;
+       u32 u4Tmp[4];
+       u8 antNum = Ant_x2;
+
+       rsprintf(btCoexDbgBuf, BT_TMP_BUF_SIZE, "\r\n ============[BT Coexist info]============");
+       DCMD_Printf(btCoexDbgBuf);
+
+       if (!rtl8723a_BT_coexist(padapter)) {
+               rsprintf(btCoexDbgBuf, BT_TMP_BUF_SIZE, "\r\n BT not exists !!!");
+               DCMD_Printf(btCoexDbgBuf);
+               return;
+       }
+
+       antNum = btdm_BtWifiAntNum(padapter);
+       rsprintf(btCoexDbgBuf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d/%d ", "Ant mechanism PG/Now run :", \
+               ((pHalData->bt_coexist.BT_Ant_Num == Ant_x2) ? 2 : 1), ((antNum == Ant_x2) ? 2 : 1));
+       DCMD_Printf(btCoexDbgBuf);
+
+       if (pBtMgnt->ExtConfig.bManualControl) {
+               rsprintf(btCoexDbgBuf, BT_TMP_BUF_SIZE, "\r\n %-35s", "[Action Manual control]!!");
+               DCMD_Printf(btCoexDbgBuf);
+       } else {
+               rsprintf(btCoexDbgBuf, BT_TMP_BUF_SIZE, "\r\n %-35s = %s / %d", "BT stack/ hci ext ver", \
+                       ((pBtMgnt->bSupportProfile) ? "Yes" : "No"), pBtMgnt->ExtConfig.HCIExtensionVer);
+               DCMD_Printf(btCoexDbgBuf);
+       }
+
+       rsprintf(btCoexDbgBuf, BT_TMP_BUF_SIZE, "\n %-35s = / %d", "Dot11 channel / BT channel", \
+               pBtMgnt->BTChannel);
+               DCMD_Printf(btCoexDbgBuf);
+
+       rsprintf(btCoexDbgBuf, BT_TMP_BUF_SIZE, "\n %-35s = %d / %d / %d", "Wifi/BT/HS rssi", \
+               BTDM_GetRxSS(padapter),
+               pHalData->bt_coexist.halCoex8723.btRssi,
+               pHalData->dmpriv.EntryMinUndecoratedSmoothedPWDB);
+                       DCMD_Printf(btCoexDbgBuf);
+
+       if (!pBtMgnt->ExtConfig.bManualControl) {
+               rsprintf(btCoexDbgBuf, BT_TMP_BUF_SIZE, "\n %-35s = %s / %s ", "WIfi status",
+                       ((BTDM_Legacy(padapter)) ? "Legacy" : (((BTDM_IsHT40(padapter)) ? "HT40" : "HT20"))),
+                       ((!BTDM_IsWifiBusy(padapter)) ? "idle" : ((BTDM_IsWifiUplink(padapter)) ? "uplink" : "downlink")));
+               DCMD_Printf(btCoexDbgBuf);
+
+               if (pBtMgnt->bSupportProfile) {
+                       rsprintf(btCoexDbgBuf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d / %d / %d / %d", "SCO/HID/PAN/A2DP",
+                               ((BTHCI_CheckProfileExist(padapter, BT_PROFILE_SCO)) ? 1 : 0),
+                               ((BTHCI_CheckProfileExist(padapter, BT_PROFILE_HID)) ? 1 : 0),
+                               ((BTHCI_CheckProfileExist(padapter, BT_PROFILE_PAN)) ? 1 : 0),
+                               ((BTHCI_CheckProfileExist(padapter, BT_PROFILE_A2DP)) ? 1 : 0));
+               DCMD_Printf(btCoexDbgBuf);
+
+                       for (i = 0; i < pBtMgnt->ExtConfig.NumberOfHandle; i++) {
+                               if (pBtMgnt->ExtConfig.HCIExtensionVer >= 1) {
+                                       rsprintf(btCoexDbgBuf, BT_TMP_BUF_SIZE, "\r\n %-35s = %s/ %s/ %s", "Bt link type/spec/role",
+                                               BtProfileString[pBtMgnt->ExtConfig.linkInfo[i].BTProfile],
+                                               BtSpecString[pBtMgnt->ExtConfig.linkInfo[i].BTCoreSpec],
+                                               BtLinkRoleString[pBtMgnt->ExtConfig.linkInfo[i].linkRole]);
+                                       DCMD_Printf(btCoexDbgBuf);
+
+                                       btInfoExt = pHalData->bt_coexist.halCoex8723.btInfoExt;
+                                       rsprintf(btCoexDbgBuf, BT_TMP_BUF_SIZE, "\r\n %-35s = %s", "A2DP rate", \
+                                                (btInfoExt & BIT(0)) ?
+                                                "Basic rate" : "EDR rate");
+                                       DCMD_Printf(btCoexDbgBuf);
+                               } else {
+                                       rsprintf(btCoexDbgBuf, BT_TMP_BUF_SIZE, "\r\n %-35s = %s/ %s", "Bt link type/spec", \
+                                               BtProfileString[pBtMgnt->ExtConfig.linkInfo[i].BTProfile],
+                                               BtSpecString[pBtMgnt->ExtConfig.linkInfo[i].BTCoreSpec]);
+                                       DCMD_Printf(btCoexDbgBuf);
+                               }
+                       }
+               }
+       }
+
+       /*  Sw mechanism */
+       if (!pBtMgnt->ExtConfig.bManualControl) {
+               rsprintf(btCoexDbgBuf, BT_TMP_BUF_SIZE, "\r\n %-35s", "============[Sw BT Coex mechanism]============");
+               DCMD_Printf(btCoexDbgBuf);
+               rsprintf(btCoexDbgBuf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d ", "AGC Table", \
+                       pBtCoex->btdm2Ant.bCurAgcTableEn);
+               DCMD_Printf(btCoexDbgBuf);
+               rsprintf(btCoexDbgBuf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d ", "ADC Backoff", \
+                       pBtCoex->btdm2Ant.bCurAdcBackOff);
+               DCMD_Printf(btCoexDbgBuf);
+               rsprintf(btCoexDbgBuf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d ", "Low penalty RA", \
+                       pBtCoex->btdm2Ant.bCurLowPenaltyRa);
+               DCMD_Printf(btCoexDbgBuf);
+               rsprintf(btCoexDbgBuf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d ", "RF Rx LPF Shrink", \
+                       pBtCoex->btdm2Ant.bCurRfRxLpfShrink);
+               DCMD_Printf(btCoexDbgBuf);
+       }
+       u4Tmp[0] = PHY_QueryRFReg(padapter, PathA, 0x1e, 0xff0);
+       rsprintf(btCoexDbgBuf, BT_TMP_BUF_SIZE, "\r\n %-35s = 0x%x/ 0x%x", "RF-A, 0x1e[11:4]/original val", \
+               u4Tmp[0], pHalData->bt_coexist.BtRfRegOrigin1E);
+       DCMD_Printf(btCoexDbgBuf);
+
+       /*  Fw mechanism */
+       if (!pBtMgnt->ExtConfig.bManualControl) {
+               rsprintf(btCoexDbgBuf, BT_TMP_BUF_SIZE, "\r\n %-35s", "============[Fw BT Coex mechanism]============");
+               DCMD_Printf(btCoexDbgBuf);
+       }
+       if (!pBtMgnt->ExtConfig.bManualControl) {
+               if (btdm_BtWifiAntNum(padapter) == Ant_x1)
+                       psTdmaCase = pHalData->bt_coexist.halCoex8723.btdm1Ant.curPsTdma;
+               else
+                       psTdmaCase = pHalData->bt_coexist.halCoex8723.btdm2Ant.curPsTdma;
+               rsprintf(btCoexDbgBuf, BT_TMP_BUF_SIZE, "\r\n %-35s = %02x %02x %02x %02x %02x case-%d", "PS TDMA(0x3a)", \
+                       pHalData->bt_coexist.fw3aVal[0], pHalData->bt_coexist.fw3aVal[1],
+                       pHalData->bt_coexist.fw3aVal[2], pHalData->bt_coexist.fw3aVal[3],
+                       pHalData->bt_coexist.fw3aVal[4], psTdmaCase);
+               DCMD_Printf(btCoexDbgBuf);
+
+               rsprintf(btCoexDbgBuf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d ", "Decrease Bt Power", \
+                       pBtCoex->btdm2Ant.bCurDecBtPwr);
+               DCMD_Printf(btCoexDbgBuf);
+       }
+       u1Tmp = rtl8723au_read8(padapter, 0x778);
+       u1Tmp1 = rtl8723au_read8(padapter, 0x783);
+       u1Tmp2 = rtl8723au_read8(padapter, 0x796);
+       rsprintf(btCoexDbgBuf, BT_TMP_BUF_SIZE, "\r\n %-35s = 0x%x/ 0x%x/ 0x%x", "0x778/ 0x783/ 0x796", \
+               u1Tmp, u1Tmp1, u1Tmp2);
+       DCMD_Printf(btCoexDbgBuf);
+
+       if (!pBtMgnt->ExtConfig.bManualControl) {
+               rsprintf(btCoexDbgBuf, BT_TMP_BUF_SIZE, "\r\n %-35s = 0x%x / 0x%x", "Sw DacSwing Ctrl/Val", \
+                       pBtCoex->btdm2Ant.bCurDacSwingOn, pBtCoex->btdm2Ant.curDacSwingLvl);
+               DCMD_Printf(btCoexDbgBuf);
+       }
+       u4Tmp[0] =  rtl8723au_read32(padapter, 0x880);
+       rsprintf(btCoexDbgBuf, BT_TMP_BUF_SIZE, "\r\n %-35s = 0x%x", "0x880", \
+               u4Tmp[0]);
+       DCMD_Printf(btCoexDbgBuf);
+
+       /*  Hw mechanism */
+       if (!pBtMgnt->ExtConfig.bManualControl) {
+               rsprintf(btCoexDbgBuf, BT_TMP_BUF_SIZE, "\r\n %-35s", "============[Hw BT Coex mechanism]============");
+               DCMD_Printf(btCoexDbgBuf);
+       }
+
+       u1Tmp = rtl8723au_read8(padapter, 0x40);
+       rsprintf(btCoexDbgBuf, BT_TMP_BUF_SIZE, "\r\n %-35s = 0x%x", "0x40", \
+               u1Tmp);
+       DCMD_Printf(btCoexDbgBuf);
+
+       u4Tmp[0] = rtl8723au_read32(padapter, 0x550);
+       u1Tmp = rtl8723au_read8(padapter, 0x522);
+       rsprintf(btCoexDbgBuf, BT_TMP_BUF_SIZE, "\r\n %-35s = 0x%x/0x%x", "0x550(bcn contrl)/0x522", \
+               u4Tmp[0], u1Tmp);
+       DCMD_Printf(btCoexDbgBuf);
+
+       u4Tmp[0] = rtl8723au_read32(padapter, 0x484);
+       rsprintf(btCoexDbgBuf, BT_TMP_BUF_SIZE, "\r\n %-35s = 0x%x", "0x484(rate adaptive)", \
+               u4Tmp[0]);
+       DCMD_Printf(btCoexDbgBuf);
+
+       u4Tmp[0] = rtl8723au_read32(padapter, 0x50);
+       rsprintf(btCoexDbgBuf, BT_TMP_BUF_SIZE, "\r\n %-35s = 0x%x", "0xc50(dig)", \
+               u4Tmp[0]);
+       DCMD_Printf(btCoexDbgBuf);
+
+       u4Tmp[0] = rtl8723au_read32(padapter, 0xda0);
+       u4Tmp[1] = rtl8723au_read32(padapter, 0xda4);
+       u4Tmp[2] = rtl8723au_read32(padapter, 0xda8);
+       u4Tmp[3] = rtl8723au_read32(padapter, 0xdac);
+       rsprintf(btCoexDbgBuf, BT_TMP_BUF_SIZE, "\r\n %-35s = 0x%x/ 0x%x/ 0x%x/ 0x%x", "0xda0/0xda4/0xda8/0xdac(FA cnt)", \
+               u4Tmp[0], u4Tmp[1], u4Tmp[2], u4Tmp[3]);
+       DCMD_Printf(btCoexDbgBuf);
+
+       u4Tmp[0] = rtl8723au_read32(padapter, 0x6c0);
+       u4Tmp[1] = rtl8723au_read32(padapter, 0x6c4);
+       u4Tmp[2] = rtl8723au_read32(padapter, 0x6c8);
+       u1Tmp = rtl8723au_read8(padapter, 0x6cc);
+       rsprintf(btCoexDbgBuf, BT_TMP_BUF_SIZE, "\r\n %-35s = 0x%x/ 0x%x/ 0x%x/ 0x%x", "0x6c0/0x6c4/0x6c8/0x6cc(coexTable)", \
+               u4Tmp[0], u4Tmp[1], u4Tmp[2], u1Tmp);
+       DCMD_Printf(btCoexDbgBuf);
+
+       /* u4Tmp = rtl8723au_read32(padapter, 0x770); */
+       rsprintf(btCoexDbgBuf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d / %d", "0x770(Hi pri Rx[31:16]/Tx[15:0])", \
+               pHalData->bt_coexist.halCoex8723.highPriorityRx,
+               pHalData->bt_coexist.halCoex8723.highPriorityTx);
+       DCMD_Printf(btCoexDbgBuf);
+       /* u4Tmp = rtl8723au_read32(padapter, 0x774); */
+       rsprintf(btCoexDbgBuf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d / %d", "0x774(Lo pri Rx[31:16]/Tx[15:0])", \
+               pHalData->bt_coexist.halCoex8723.lowPriorityRx,
+               pHalData->bt_coexist.halCoex8723.lowPriorityTx);
+       DCMD_Printf(btCoexDbgBuf);
+
+       /*  Tx mgnt queue hang or not, 0x41b should = 0xf, ex: 0xd ==>hang */
+       u1Tmp = rtl8723au_read8(padapter, 0x41b);
+       rsprintf(btCoexDbgBuf, BT_TMP_BUF_SIZE, "\r\n %-35s = 0x%x", "0x41b (hang chk == 0xf)", \
+               u1Tmp);
+       DCMD_Printf(btCoexDbgBuf);
+       rsprintf(btCoexDbgBuf, BT_TMP_BUF_SIZE, "\r\n %-35s = 0x%x", "lastHMEBoxNum", \
+               pHalData->LastHMEBoxNum);
+       DCMD_Printf(btCoexDbgBuf);
+}
+
+static void
+BTDM_8723ASignalCompensation(struct rtw_adapter *padapter,
+                            u8 *rssi_wifi, u8 *rssi_bt)
+{
+       if (btdm_BtWifiAntNum(padapter) == Ant_x1)
+               BTDM_1AntSignalCompensation(padapter, rssi_wifi, rssi_bt);
+}
+
+static void BTDM_8723AInit(struct rtw_adapter *padapter)
+{
+       if (btdm_BtWifiAntNum(padapter) == Ant_x2)
+               BTDM_2AntParaInit(padapter);
+       else
+               BTDM_1AntParaInit(padapter);
+}
+
+static void BTDM_HWCoexAllOff8723A(struct rtw_adapter *padapter)
+{
+       struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
+       struct bt_mgnt *pBtMgnt = &pBTInfo->BtMgnt;
+
+       if (pBtMgnt->ExtConfig.bManualControl)
+               return;
+
+       if (btdm_BtWifiAntNum(padapter) == Ant_x2)
+               BTDM_2AntHwCoexAllOff8723A(padapter);
+}
+
+static void BTDM_FWCoexAllOff8723A(struct rtw_adapter *padapter)
+{
+       struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
+       struct bt_mgnt *pBtMgnt = &pBTInfo->BtMgnt;
+
+       if (pBtMgnt->ExtConfig.bManualControl)
+               return;
+
+       if (btdm_BtWifiAntNum(padapter) == Ant_x2)
+               BTDM_2AntFwCoexAllOff8723A(padapter);
+}
+
+static void BTDM_SWCoexAllOff8723A(struct rtw_adapter *padapter)
+{
+       struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
+       struct bt_mgnt *pBtMgnt = &pBTInfo->BtMgnt;
+
+       if (pBtMgnt->ExtConfig.bManualControl)
+               return;
+
+       if (btdm_BtWifiAntNum(padapter) == Ant_x2)
+               BTDM_2AntSwCoexAllOff8723A(padapter);
+}
+
+static void
+BTDM_Set8723ABtCoexCurrAntNum(struct rtw_adapter *padapter, u8 antNum)
+{
+       struct hal_data_8723a *pHalData = GET_HAL_DATA(padapter);
+       struct bt_coexist_8723a *pBtCoex = &pHalData->bt_coexist.halCoex8723;
+
+       if (antNum == 1)
+               pBtCoex->TotalAntNum = Ant_x1;
+       else if (antNum == 2)
+               pBtCoex->TotalAntNum = Ant_x2;
+}
+
+void rtl8723a_BT_lps_leave(struct rtw_adapter *padapter)
+{
+       struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
+       struct bt_mgnt *pBtMgnt = &pBTInfo->BtMgnt;
+
+       if (pBtMgnt->ExtConfig.bManualControl)
+               return;
+
+       if (btdm_BtWifiAntNum(padapter) == Ant_x1)
+               BTDM_1AntLpsLeave(padapter);
+}
+
+static void BTDM_ForHalt8723A(struct rtw_adapter *padapter)
+{
+       struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
+       struct bt_mgnt *pBtMgnt = &pBTInfo->BtMgnt;
+
+       if (pBtMgnt->ExtConfig.bManualControl)
+               return;
+
+       if (btdm_BtWifiAntNum(padapter) == Ant_x1)
+               BTDM_1AntForHalt(padapter);
+}
+
+static void BTDM_WifiScanNotify8723A(struct rtw_adapter *padapter, u8 scanType)
+{
+       struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
+       struct bt_mgnt *pBtMgnt = &pBTInfo->BtMgnt;
+
+       if (pBtMgnt->ExtConfig.bManualControl)
+               return;
+
+       if (btdm_BtWifiAntNum(padapter) == Ant_x1)
+               BTDM_1AntWifiScanNotify(padapter, scanType);
+}
+
+static void
+BTDM_WifiAssociateNotify8723A(struct rtw_adapter *padapter, u8 action)
+{
+       struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
+       struct bt_mgnt *pBtMgnt = &pBTInfo->BtMgnt;
+
+       if (pBtMgnt->ExtConfig.bManualControl)
+               return;
+
+       if (btdm_BtWifiAntNum(padapter) == Ant_x1)
+               BTDM_1AntWifiAssociateNotify(padapter, action);
+}
+
+static void
+BTDM_MediaStatusNotify8723A(struct rtw_adapter *padapter,
+                           enum rt_media_status mstatus)
+{
+       struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
+       struct bt_mgnt *pBtMgnt = &pBTInfo->BtMgnt;
+
+       RTPRINT(FBT, BT_TRACE, ("[BTCoex], MediaStatusNotify, %s\n",
+               mstatus?"connect":"disconnect"));
+
+       BTDM_SetFwChnlInfo(padapter, mstatus);
+
+       if (pBtMgnt->ExtConfig.bManualControl)
+               return;
+
+       if (btdm_BtWifiAntNum(padapter) == Ant_x1)
+               BTDM_1AntMediaStatusNotify(padapter, mstatus);
+}
+
+static void BTDM_ForDhcp8723A(struct rtw_adapter *padapter)
+{
+       struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
+       struct bt_mgnt *pBtMgnt = &pBTInfo->BtMgnt;
+
+       if (pBtMgnt->ExtConfig.bManualControl)
+               return;
+
+       if (btdm_BtWifiAntNum(padapter) == Ant_x1)
+               BTDM_1AntForDhcp(padapter);
+}
+
+bool rtl8723a_BT_using_antenna_1(struct rtw_adapter *padapter)
+{
+       if (btdm_BtWifiAntNum(padapter) == Ant_x1)
+               return true;
+       else
+               return false;
+}
+
+static void BTDM_BTCoexist8723A(struct rtw_adapter *padapter)
+{
+       struct hal_data_8723a *pHalData;
+       struct bt_30info *pBTInfo;
+       struct bt_mgnt *pBtMgnt;
+       struct bt_coexist_8723a *pBtCoex;
+
+       pHalData = GET_HAL_DATA(padapter);
+       pBTInfo = GET_BT_INFO(padapter);
+       pBtMgnt = &pBTInfo->BtMgnt;
+       pBtCoex = &pHalData->bt_coexist.halCoex8723;
+
+       RTPRINT(FBT, BT_TRACE, ("[BTCoex], beacon RSSI = 0x%x(%d)\n",
+               pHalData->dmpriv.EntryMinUndecoratedSmoothedPWDB,
+               pHalData->dmpriv.EntryMinUndecoratedSmoothedPWDB));
+
+       btdm_BtHwCountersMonitor(padapter);
+       btdm_BtEnableDisableCheck8723A(padapter);
+
+       if (pBtMgnt->ExtConfig.bManualControl) {
+               RTPRINT(FBT, BT_TRACE, ("%s: Action Manual control!!\n", __func__));
+               return;
+       }
+
+       if (pBtCoex->bC2hBtInfoReqSent) {
+               if (!rtl8723a_BT_enabled(padapter)) {
+                       pBtCoex->c2hBtInfo = BT_INFO_STATE_DISABLED;
+               } else {
+                       if (pBtCoex->c2hBtInfo == BT_INFO_STATE_DISABLED)
+                               pBtCoex->c2hBtInfo = BT_INFO_STATE_NO_CONNECTION;
+               }
+
+               btdm_BTCoexist8723AHandler(padapter);
+       } else if (!rtl8723a_BT_enabled(padapter)) {
+               pBtCoex->c2hBtInfo = BT_INFO_STATE_DISABLED;
+               btdm_BTCoexist8723AHandler(padapter);
+       }
+
+       BTDM_QueryBtInformation(padapter);
+}
+
+/*  ===== End of sync from SD7 driver HAL/BTCoexist/HalBtc8723.c ===== */
+
+/*  ===== Below this line is sync from SD7 driver HAL/BTCoexist/HalBtcCsr1Ant.c ===== */
+
+/*  local function start with btdm_ */
+/*  extern function start with BTDM_ */
+
+static void BTDM_SetAntenna(struct rtw_adapter *padapter, u8 who)
+{
+}
+
+void
+BTDM_SingleAnt(
+       struct rtw_adapter *padapter,
+       u8 bSingleAntOn,
+       u8 bInterruptOn,
+       u8 bMultiNAVOn
+       )
+{
+       struct hal_data_8723a *pHalData = GET_HAL_DATA(padapter);
+       u8 H2C_Parameter[3] = {0};
+
+       if (pHalData->bt_coexist.BT_Ant_Num != Ant_x1)
+               return;
+
+       H2C_Parameter[2] = 0;
+       H2C_Parameter[1] = 0;
+       H2C_Parameter[0] = 0;
+
+       if (bInterruptOn) {
+               H2C_Parameter[2] |= 0x02;       /* BIT1 */
+               pHalData->bt_coexist.bFWCoexistAllOff = false;
+       }
+       pHalData->bt_coexist.bInterruptOn = bInterruptOn;
+
+       if (bSingleAntOn) {
+               H2C_Parameter[2] |= 0x10;       /* BIT4 */
+               pHalData->bt_coexist.bFWCoexistAllOff = false;
+       }
+       pHalData->bt_coexist.bSingleAntOn = bSingleAntOn;
+
+       if (bMultiNAVOn) {
+               H2C_Parameter[2] |= 0x20;       /* BIT5 */
+               pHalData->bt_coexist.bFWCoexistAllOff = false;
+       }
+       pHalData->bt_coexist.bMultiNAVOn = bMultiNAVOn;
+
+       RTPRINT(FBT, BT_TRACE, ("[DM][BT], SingleAntenna =[%s:%s:%s], write 0xe = 0x%x\n",
+               bSingleAntOn?"ON":"OFF", bInterruptOn?"ON":"OFF", bMultiNAVOn?"ON":"OFF",
+               H2C_Parameter[0]<<16|H2C_Parameter[1]<<8|H2C_Parameter[2]));
+}
+
+void BTDM_CheckBTIdleChange1Ant(struct rtw_adapter *padapter)
+{
+       struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
+       struct bt_mgnt *pBtMgnt = &pBTInfo->BtMgnt;
+       struct hal_data_8723a *pHalData = GET_HAL_DATA(padapter);
+/*PMGNT_INFO           pMgntInfo = &padapter->MgntInfo; */
+       u8      stateChange = false;
+       u32                     BT_Polling, Ratio_Act, Ratio_STA;
+       u32                             BT_Active, BT_State;
+       u32                             regBTActive = 0, regBTState = 0, regBTPolling = 0;
+
+       if (!rtl8723a_BT_coexist(padapter))
+               return;
+       if (pBtMgnt->ExtConfig.bManualControl)
+               return;
+       if (pHalData->bt_coexist.BT_CoexistType != BT_CSR_BC8)
+               return;
+       if (pHalData->bt_coexist.BT_Ant_Num != Ant_x1)
+               return;
+
+       /*  The following we only consider CSR BC8 and fw version should be >= 62 */
+       RTPRINT(FBT, BT_TRACE, ("[DM][BT], FirmwareVersion = 0x%x(%d)\n",
+       pHalData->FirmwareVersion, pHalData->FirmwareVersion));
+       regBTActive = REG_BT_ACTIVE;
+       regBTState = REG_BT_STATE;
+       if (pHalData->FirmwareVersion >= FW_VER_BT_REG1)
+               regBTPolling = REG_BT_POLLING1;
+       else
+               regBTPolling = REG_BT_POLLING;
+
+       BT_Active = rtl8723au_read32(padapter, regBTActive);
+       RTPRINT(FBT, BT_TRACE, ("[DM][BT], BT_Active(0x%x) =%x\n", regBTActive, BT_Active));
+       BT_Active = BT_Active & 0x00ffffff;
+
+       BT_State = rtl8723au_read32(padapter, regBTState);
+       RTPRINT(FBT, BT_TRACE, ("[DM][BT], BT_State(0x%x) =%x\n", regBTState, BT_State));
+       BT_State = BT_State & 0x00ffffff;
+
+       BT_Polling = rtl8723au_read32(padapter, regBTPolling);
+       RTPRINT(FBT, BT_TRACE, ("[DM][BT], BT_Polling(0x%x) =%x\n", regBTPolling, BT_Polling));
+
+       if (BT_Active == 0xffffffff && BT_State == 0xffffffff && BT_Polling == 0xffffffff)
+               return;
+       if (BT_Polling == 0)
+               return;
+
+       Ratio_Act = BT_Active*1000/BT_Polling;
+       Ratio_STA = BT_State*1000/BT_Polling;
+
+       pHalData->bt_coexist.Ratio_Tx = Ratio_Act;
+       pHalData->bt_coexist.Ratio_PRI = Ratio_STA;
+
+       RTPRINT(FBT, BT_TRACE, ("[DM][BT], Ratio_Act =%d\n", Ratio_Act));
+       RTPRINT(FBT, BT_TRACE, ("[DM][BT], Ratio_STA =%d\n", Ratio_STA));
+
+       if (Ratio_STA < 60 && Ratio_Act < 500) {        /*  BT PAN idle */
+               pHalData->bt_coexist.CurrentState |= BT_COEX_STATE_BT_PAN_IDLE;
+               pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_BT_PAN_DOWNLINK;
+               pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_BT_PAN_UPLINK;
+       } else {
+               pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_BT_PAN_IDLE;
+
+               if (Ratio_STA) {
+                       /*  Check if BT PAN (under BT 2.1) is uplink or downlink */
+                       if ((Ratio_Act/Ratio_STA) < 2) {
+                               /*  BT PAN Uplink */
+                               pHalData->bt_coexist.BT21TrafficStatistics.bTxBusyTraffic = true;
+                               pHalData->bt_coexist.CurrentState |= BT_COEX_STATE_BT_PAN_UPLINK;
+                               pHalData->bt_coexist.BT21TrafficStatistics.bRxBusyTraffic = false;
+                               pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_BT_PAN_DOWNLINK;
+                       } else {
+                               /*  BT PAN downlink */
+                               pHalData->bt_coexist.BT21TrafficStatistics.bTxBusyTraffic = false;
+                               pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_BT_PAN_UPLINK;
+                               pHalData->bt_coexist.BT21TrafficStatistics.bRxBusyTraffic = true;
+                               pHalData->bt_coexist.CurrentState |= BT_COEX_STATE_BT_PAN_DOWNLINK;
+                       }
+               } else {
+                       /*  BT PAN downlink */
+                       pHalData->bt_coexist.BT21TrafficStatistics.bTxBusyTraffic = false;
+                       pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_BT_PAN_UPLINK;
+                       pHalData->bt_coexist.BT21TrafficStatistics.bRxBusyTraffic = true;
+                       pHalData->bt_coexist.CurrentState |= BT_COEX_STATE_BT_PAN_DOWNLINK;
+               }
+       }
+
+       /*  Check BT is idle or not */
+       if (pBtMgnt->ExtConfig.NumberOfHandle == 0 &&
+           pBtMgnt->ExtConfig.NumberOfSCO == 0) {
+               pBtMgnt->ExtConfig.bBTBusy = false;
+               pHalData->bt_coexist.CurrentState |= BT_COEX_STATE_BT_IDLE;
+       } else {
+               if (Ratio_STA < 60) {
+                       pBtMgnt->ExtConfig.bBTBusy = false;
+                       pHalData->bt_coexist.CurrentState |= BT_COEX_STATE_BT_IDLE;
+               } else {
+                       pBtMgnt->ExtConfig.bBTBusy = true;
+                       pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_BT_IDLE;
+               }
+       }
+
+       if (pBtMgnt->ExtConfig.NumberOfHandle == 0 &&
+           pBtMgnt->ExtConfig.NumberOfSCO == 0) {
+               pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_BT_RSSI_LOW;
+               pBtMgnt->ExtConfig.MIN_BT_RSSI = 0;
+               BTDM_SetAntenna(padapter, BTDM_ANT_BT_IDLE);
+       } else {
+               if (pBtMgnt->ExtConfig.MIN_BT_RSSI <= -5) {
+                       pHalData->bt_coexist.CurrentState |= BT_COEX_STATE_BT_RSSI_LOW;
+                       RTPRINT(FBT, BT_TRACE, ("[DM][BT], core stack notify bt rssi Low\n"));
+               } else {
+                       pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_BT_RSSI_LOW;
+                       RTPRINT(FBT, BT_TRACE, ("[DM][BT], core stack notify bt rssi Normal\n"));
+               }
+       }
+
+       if (pHalData->bt_coexist.bBTBusyTraffic != pBtMgnt->ExtConfig.bBTBusy) {
+               /*  BT idle or BT non-idle */
+               pHalData->bt_coexist.bBTBusyTraffic = pBtMgnt->ExtConfig.bBTBusy;
+               stateChange = true;
+       }
+
+       if (stateChange) {
+               if (!pBtMgnt->ExtConfig.bBTBusy)
+                       RTPRINT(FBT, BT_TRACE, ("[DM][BT], BT is idle or disable\n"));
+               else
+                       RTPRINT(FBT, BT_TRACE, ("[DM][BT], BT is non-idle\n"));
+       }
+       if (!pBtMgnt->ExtConfig.bBTBusy) {
+               RTPRINT(FBT, BT_TRACE, ("[DM][BT], BT is idle or disable\n"));
+               if (check_fwstate(&padapter->mlmepriv, WIFI_UNDER_LINKING|WIFI_SITE_MONITOR) == true)
+                       BTDM_SetAntenna(padapter, BTDM_ANT_WIFI);
+       }
+}
+
+/*  ===== End of sync from SD7 driver HAL/BTCoexist/HalBtcCsr1Ant.c ===== */
+
+/*  ===== Below this line is sync from SD7 driver HAL/BTCoexist/HalBtcCsr2Ant.c ===== */
+
+/*  local function start with btdm_ */
+
+/*  Note: */
+/*  In the following, FW should be done before SW mechanism. */
+/*  BTDM_Balance(), BTDM_DiminishWiFi(), BT_NAV() should be done */
+/*  before BTDM_AGCTable(), BTDM_BBBackOffLevel(), btdm_DacSwing(). */
+
+/*  extern function start with BTDM_ */
+
+void
+BTDM_DiminishWiFi(
+       struct rtw_adapter *padapter,
+       u8 bDACOn,
+       u8 bInterruptOn,
+       u8 DACSwingLevel,
+       u8 bNAVOn
+       )
+{
+       struct hal_data_8723a *pHalData = GET_HAL_DATA(padapter);
+       u8 H2C_Parameter[3] = {0};
+
+       if (pHalData->bt_coexist.BT_Ant_Num != Ant_x2)
+               return;
+
+       if ((pHalData->bt_coexist.CurrentState & BT_COEX_STATE_BT_RSSI_LOW) &&
+           (DACSwingLevel == 0x20)) {
+               RTPRINT(FBT, BT_TRACE, ("[BT]DiminishWiFi 0x20 original, but set 0x18 for Low RSSI!\n"));
+               DACSwingLevel = 0x18;
+       }
+
+       H2C_Parameter[2] = 0;
+       H2C_Parameter[1] = DACSwingLevel;
+       H2C_Parameter[0] = 0;
+       if (bDACOn) {
+               H2C_Parameter[2] |= 0x01;       /* BIT0 */
+               if (bInterruptOn)
+                       H2C_Parameter[2] |= 0x02;       /* BIT1 */
+               pHalData->bt_coexist.bFWCoexistAllOff = false;
+       }
+       if (bNAVOn) {
+               H2C_Parameter[2] |= 0x08;       /* BIT3 */
+               pHalData->bt_coexist.bFWCoexistAllOff = false;
+       }
+
+       RTPRINT(FBT, BT_TRACE, ("[DM][BT], bDACOn = %s, bInterruptOn = %s, write 0xe = 0x%x\n",
+               bDACOn?"ON":"OFF", bInterruptOn?"ON":"OFF",
+               H2C_Parameter[0]<<16|H2C_Parameter[1]<<8|H2C_Parameter[2]));
+       RTPRINT(FBT, BT_TRACE, ("[DM][BT], bNAVOn = %s\n",
+               bNAVOn?"ON":"OFF"));
+}
+
+/*  ===== End of sync from SD7 driver HAL/BTCoexist/HalBtcCsr2Ant.c ===== */
+
+/*  ===== Below this line is sync from SD7 driver HAL/BTCoexist/HalBtCoexist.c ===== */
+
+/*  local function */
+static void btdm_ResetFWCoexState(struct rtw_adapter *padapter)
+{
+       struct hal_data_8723a *pHalData = GET_HAL_DATA(padapter);
+
+       pHalData->bt_coexist.CurrentState = 0;
+       pHalData->bt_coexist.PreviousState = 0;
+}
+
+static void btdm_InitBtCoexistDM(struct rtw_adapter *padapter)
+{
+       struct hal_data_8723a *pHalData = GET_HAL_DATA(padapter);
+
+       /*  20100415 Joseph: Restore RF register 0x1E and 0x1F value for further usage. */
+       pHalData->bt_coexist.BtRfRegOrigin1E = PHY_QueryRFReg(padapter, PathA, RF_RCK1, bRFRegOffsetMask);
+       pHalData->bt_coexist.BtRfRegOrigin1F = PHY_QueryRFReg(padapter, PathA, RF_RCK2, 0xf0);
+
+       pHalData->bt_coexist.CurrentState = 0;
+       pHalData->bt_coexist.PreviousState = 0;
+
+       BTDM_8723AInit(padapter);
+       pHalData->bt_coexist.bInitlized = true;
+}
+
+/*  */
+/*  extern function */
+/*  */
+void BTDM_CheckAntSelMode(struct rtw_adapter *padapter)
+{
+}
+
+void BTDM_FwC2hBtRssi(struct rtw_adapter *padapter, u8 *tmpBuf)
+{
+       BTDM_FwC2hBtRssi8723A(padapter, tmpBuf);
+}
+
+void BTDM_DisplayBtCoexInfo(struct rtw_adapter *padapter)
+{
+       BTDM_Display8723ABtCoexInfo(padapter);
+}
+
+void BTDM_RejectAPAggregatedPacket(struct rtw_adapter *padapter, u8 bReject)
+{
+}
+
+u8 BTDM_IsHT40(struct rtw_adapter *padapter)
+{
+       u8 isht40 = true;
+       enum ht_channel_width bw;
+
+       bw = padapter->mlmeextpriv.cur_bwmode;
+
+       if (bw == HT_CHANNEL_WIDTH_20)
+               isht40 = false;
+       else if (bw == HT_CHANNEL_WIDTH_40)
+               isht40 = true;
+
+       return isht40;
+}
+
+u8 BTDM_Legacy(struct rtw_adapter *padapter)
+{
+       struct mlme_ext_priv *pmlmeext;
+       u8 isLegacy = false;
+
+       pmlmeext = &padapter->mlmeextpriv;
+       if ((pmlmeext->cur_wireless_mode == WIRELESS_11B) ||
+               (pmlmeext->cur_wireless_mode == WIRELESS_11G) ||
+               (pmlmeext->cur_wireless_mode == WIRELESS_11BG))
+               isLegacy = true;
+
+       return isLegacy;
+}
+
+void BTDM_CheckWiFiState(struct rtw_adapter *padapter)
+{
+       struct hal_data_8723a *pHalData;
+       struct mlme_priv *pmlmepriv;
+       struct bt_30info *pBTInfo;
+       struct bt_mgnt *pBtMgnt;
+
+       pHalData = GET_HAL_DATA(padapter);
+       pmlmepriv = &padapter->mlmepriv;
+       pBTInfo = GET_BT_INFO(padapter);
+       pBtMgnt = &pBTInfo->BtMgnt;
+
+       if (pmlmepriv->LinkDetectInfo.bBusyTraffic) {
+               pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_WIFI_IDLE;
+
+               if (pmlmepriv->LinkDetectInfo.bTxBusyTraffic)
+                       pHalData->bt_coexist.CurrentState |= BT_COEX_STATE_WIFI_UPLINK;
+               else
+                       pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_WIFI_UPLINK;
+
+               if (pmlmepriv->LinkDetectInfo.bRxBusyTraffic)
+                       pHalData->bt_coexist.CurrentState |= BT_COEX_STATE_WIFI_DOWNLINK;
+               else
+                       pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_WIFI_DOWNLINK;
+       } else {
+               pHalData->bt_coexist.CurrentState |= BT_COEX_STATE_WIFI_IDLE;
+               pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_WIFI_UPLINK;
+               pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_WIFI_DOWNLINK;
+       }
+
+       if (BTDM_Legacy(padapter)) {
+               pHalData->bt_coexist.CurrentState |= BT_COEX_STATE_WIFI_LEGACY;
+               pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_WIFI_HT20;
+               pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_WIFI_HT40;
+       } else {
+               pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_WIFI_LEGACY;
+               if (BTDM_IsHT40(padapter)) {
+                       pHalData->bt_coexist.CurrentState |= BT_COEX_STATE_WIFI_HT40;
+                       pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_WIFI_HT20;
+               } else {
+                       pHalData->bt_coexist.CurrentState |= BT_COEX_STATE_WIFI_HT20;
+                       pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_WIFI_HT40;
+               }
+       }
+
+       if (pBtMgnt->BtOperationOn)
+               pHalData->bt_coexist.CurrentState |= BT_COEX_STATE_BT30;
+       else
+               pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_BT30;
+}
+
+s32 BTDM_GetRxSS(struct rtw_adapter *padapter)
+{
+/*PMGNT_INFO           pMgntInfo = &padapter->MgntInfo; */
+       struct mlme_priv *pmlmepriv;
+       struct hal_data_8723a *pHalData;
+       s32                     UndecoratedSmoothedPWDB = 0;
+
+       pmlmepriv = &padapter->mlmepriv;
+       pHalData = GET_HAL_DATA(padapter);
+
+       if (check_fwstate(pmlmepriv, _FW_LINKED)) {
+               UndecoratedSmoothedPWDB = GET_UNDECORATED_AVERAGE_RSSI(padapter);
+       } else { /*  associated entry pwdb */
+               UndecoratedSmoothedPWDB = pHalData->dmpriv.EntryMinUndecoratedSmoothedPWDB;
+               /* pHalData->BT_EntryMinUndecoratedSmoothedPWDB */
+       }
+       RTPRINT(FBT, BT_TRACE, ("BTDM_GetRxSS() = %d\n", UndecoratedSmoothedPWDB));
+       return UndecoratedSmoothedPWDB;
+}
+
+static s32 BTDM_GetRxBeaconSS(struct rtw_adapter *padapter)
+{
+/*PMGNT_INFO           pMgntInfo = &padapter->MgntInfo; */
+       struct mlme_priv *pmlmepriv;
+       struct hal_data_8723a *pHalData;
+       s32                     pwdbBeacon = 0;
+
+       pmlmepriv = &padapter->mlmepriv;
+       pHalData = GET_HAL_DATA(padapter);
+
+       if (check_fwstate(pmlmepriv, _FW_LINKED)) {
+               /* pwdbBeacon = pHalData->dmpriv.UndecoratedSmoothedBeacon; */
+               pwdbBeacon = pHalData->dmpriv.EntryMinUndecoratedSmoothedPWDB;
+       }
+       RTPRINT(FBT, BT_TRACE, ("BTDM_GetRxBeaconSS() = %d\n", pwdbBeacon));
+       return pwdbBeacon;
+}
+
+/*  Get beacon rssi state */
+u8 BTDM_CheckCoexBcnRssiState(struct rtw_adapter *padapter, u8 levelNum,
+                             u8 RssiThresh, u8 RssiThresh1)
+{
+       struct hal_data_8723a *pHalData = GET_HAL_DATA(padapter);
+       s32 pwdbBeacon = 0;
+       u8 bcnRssiState = 0;
+
+       pwdbBeacon = BTDM_GetRxBeaconSS(padapter);
+
+       if (levelNum == 2) {
+               pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_WIFI_RSSI_BEACON_MEDIUM;
+
+               if ((pHalData->bt_coexist.preRssiStateBeacon == BT_RSSI_STATE_LOW) ||
+                   (pHalData->bt_coexist.preRssiStateBeacon == BT_RSSI_STATE_STAY_LOW)) {
+                       if (pwdbBeacon >= (RssiThresh+BT_FW_COEX_THRESH_TOL)) {
+                               bcnRssiState = BT_RSSI_STATE_HIGH;
+                               pHalData->bt_coexist.CurrentState |= BT_COEX_STATE_WIFI_RSSI_BEACON_HIGH;
+                               pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_WIFI_RSSI_BEACON_LOW;
+                               RTPRINT(FBT, BT_TRACE, ("[DM][BT], RSSI_BEACON state switch to High\n"));
+                       } else {
+                               bcnRssiState = BT_RSSI_STATE_STAY_LOW;
+                               RTPRINT(FBT, BT_TRACE, ("[DM][BT], RSSI_BEACON state stay at Low\n"));
+                       }
+               } else {
+                       if (pwdbBeacon < RssiThresh) {
+                               bcnRssiState = BT_RSSI_STATE_LOW;
+                               pHalData->bt_coexist.CurrentState |= BT_COEX_STATE_WIFI_RSSI_BEACON_LOW;
+                               pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_WIFI_RSSI_BEACON_HIGH;
+                               RTPRINT(FBT, BT_TRACE, ("[DM][BT], RSSI_BEACON state switch to Low\n"));
+                       } else {
+                               bcnRssiState = BT_RSSI_STATE_STAY_HIGH;
+                               RTPRINT(FBT, BT_TRACE, ("[DM][BT], RSSI_BEACON state stay at High\n"));
+                       }
+               }
+       } else if (levelNum == 3) {
+               if (RssiThresh > RssiThresh1) {
+                       RTPRINT(FBT, BT_TRACE, ("[DM][BT], RSSI_BEACON thresh error!!\n"));
+                       return pHalData->bt_coexist.preRssiStateBeacon;
+               }
+
+               if ((pHalData->bt_coexist.preRssiStateBeacon == BT_RSSI_STATE_LOW) ||
+                   (pHalData->bt_coexist.preRssiStateBeacon == BT_RSSI_STATE_STAY_LOW)) {
+                       if (pwdbBeacon >= (RssiThresh+BT_FW_COEX_THRESH_TOL)) {
+                               bcnRssiState = BT_RSSI_STATE_MEDIUM;
+                               pHalData->bt_coexist.CurrentState |= BT_COEX_STATE_WIFI_RSSI_BEACON_MEDIUM;
+                               pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_WIFI_RSSI_BEACON_LOW;
+                               pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_WIFI_RSSI_BEACON_HIGH;
+                               RTPRINT(FBT, BT_TRACE, ("[DM][BT], RSSI_BEACON state switch to Medium\n"));
+                       } else {
+                               bcnRssiState = BT_RSSI_STATE_STAY_LOW;
+                               RTPRINT(FBT, BT_TRACE, ("[DM][BT], RSSI_BEACON state stay at Low\n"));
+                       }
+               } else if ((pHalData->bt_coexist.preRssiStateBeacon == BT_RSSI_STATE_MEDIUM) ||
+                          (pHalData->bt_coexist.preRssiStateBeacon == BT_RSSI_STATE_STAY_MEDIUM)) {
+                       if (pwdbBeacon >= (RssiThresh1+BT_FW_COEX_THRESH_TOL)) {
+                               bcnRssiState = BT_RSSI_STATE_HIGH;
+                               pHalData->bt_coexist.CurrentState |= BT_COEX_STATE_WIFI_RSSI_BEACON_HIGH;
+                               pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_WIFI_RSSI_BEACON_LOW;
+                               pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_WIFI_RSSI_BEACON_MEDIUM;
+                               RTPRINT(FBT, BT_TRACE, ("[DM][BT], RSSI_BEACON state switch to High\n"));
+                       } else if (pwdbBeacon < RssiThresh) {
+                               bcnRssiState = BT_RSSI_STATE_LOW;
+                               pHalData->bt_coexist.CurrentState |= BT_COEX_STATE_WIFI_RSSI_BEACON_LOW;
+                               pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_WIFI_RSSI_BEACON_HIGH;
+                               pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_WIFI_RSSI_BEACON_MEDIUM;
+                               RTPRINT(FBT, BT_TRACE, ("[DM][BT], RSSI_BEACON state switch to Low\n"));
+                       } else {
+                               bcnRssiState = BT_RSSI_STATE_STAY_MEDIUM;
+                               RTPRINT(FBT, BT_TRACE, ("[DM][BT], RSSI_BEACON state stay at Medium\n"));
+                       }
+               } else {
+                       if (pwdbBeacon < RssiThresh1) {
+                               bcnRssiState = BT_RSSI_STATE_MEDIUM;
+                               pHalData->bt_coexist.CurrentState |= BT_COEX_STATE_WIFI_RSSI_BEACON_MEDIUM;
+                               pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_WIFI_RSSI_BEACON_HIGH;
+                               pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_WIFI_RSSI_BEACON_LOW;
+                               RTPRINT(FBT, BT_TRACE, ("[DM][BT], RSSI_BEACON state switch to Medium\n"));
+                       } else {
+                               bcnRssiState = BT_RSSI_STATE_STAY_HIGH;
+                               RTPRINT(FBT, BT_TRACE, ("[DM][BT], RSSI_BEACON state stay at High\n"));
+                       }
+               }
+       }
+
+       pHalData->bt_coexist.preRssiStateBeacon = bcnRssiState;
+
+       return bcnRssiState;
+}
+
+u8 BTDM_CheckCoexRSSIState1(struct rtw_adapter *padapter, u8 levelNum,
+                           u8 RssiThresh, u8 RssiThresh1)
+{
+       struct hal_data_8723a *pHalData = GET_HAL_DATA(padapter);
+       s32 UndecoratedSmoothedPWDB = 0;
+       u8 btRssiState = 0;
+
+       UndecoratedSmoothedPWDB = BTDM_GetRxSS(padapter);
+
+       if (levelNum == 2) {
+               pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_WIFI_RSSI_1_MEDIUM;
+
+               if ((pHalData->bt_coexist.preRssiState1 == BT_RSSI_STATE_LOW) ||
+                   (pHalData->bt_coexist.preRssiState1 == BT_RSSI_STATE_STAY_LOW)) {
+                       if (UndecoratedSmoothedPWDB >= (RssiThresh+BT_FW_COEX_THRESH_TOL)) {
+                               btRssiState = BT_RSSI_STATE_HIGH;
+                               pHalData->bt_coexist.CurrentState |= BT_COEX_STATE_WIFI_RSSI_1_HIGH;
+                               pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_WIFI_RSSI_1_LOW;
+                               RTPRINT(FBT, BT_TRACE, ("[DM][BT], RSSI_1 state switch to High\n"));
+                       } else {
+                               btRssiState = BT_RSSI_STATE_STAY_LOW;
+                               RTPRINT(FBT, BT_TRACE, ("[DM][BT], RSSI_1 state stay at Low\n"));
+                       }
+               } else {
+                       if (UndecoratedSmoothedPWDB < RssiThresh) {
+                               btRssiState = BT_RSSI_STATE_LOW;
+                               pHalData->bt_coexist.CurrentState |= BT_COEX_STATE_WIFI_RSSI_1_LOW;
+                               pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_WIFI_RSSI_1_HIGH;
+                               RTPRINT(FBT, BT_TRACE, ("[DM][BT], RSSI_1 state switch to Low\n"));
+                       } else {
+                               btRssiState = BT_RSSI_STATE_STAY_HIGH;
+                               RTPRINT(FBT, BT_TRACE, ("[DM][BT], RSSI_1 state stay at High\n"));
+                       }
+               }
+       } else if (levelNum == 3) {
+               if (RssiThresh > RssiThresh1) {
+                       RTPRINT(FBT, BT_TRACE, ("[DM][BT], RSSI_1 thresh error!!\n"));
+                       return pHalData->bt_coexist.preRssiState1;
+               }
+
+               if ((pHalData->bt_coexist.preRssiState1 == BT_RSSI_STATE_LOW) ||
+                   (pHalData->bt_coexist.preRssiState1 == BT_RSSI_STATE_STAY_LOW)) {
+                       if (UndecoratedSmoothedPWDB >= (RssiThresh+BT_FW_COEX_THRESH_TOL)) {
+                               btRssiState = BT_RSSI_STATE_MEDIUM;
+                               pHalData->bt_coexist.CurrentState |= BT_COEX_STATE_WIFI_RSSI_1_MEDIUM;
+                               pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_WIFI_RSSI_1_LOW;
+                               pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_WIFI_RSSI_1_HIGH;
+                               RTPRINT(FBT, BT_TRACE, ("[DM][BT], RSSI_1 state switch to Medium\n"));
+                       } else {
+                               btRssiState = BT_RSSI_STATE_STAY_LOW;
+                               RTPRINT(FBT, BT_TRACE, ("[DM][BT], RSSI_1 state stay at Low\n"));
+                       }
+               } else if ((pHalData->bt_coexist.preRssiState1 == BT_RSSI_STATE_MEDIUM) ||
+                          (pHalData->bt_coexist.preRssiState1 == BT_RSSI_STATE_STAY_MEDIUM)) {
+                       if (UndecoratedSmoothedPWDB >= (RssiThresh1+BT_FW_COEX_THRESH_TOL)) {
+                               btRssiState = BT_RSSI_STATE_HIGH;
+                               pHalData->bt_coexist.CurrentState |= BT_COEX_STATE_WIFI_RSSI_1_HIGH;
+                               pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_WIFI_RSSI_1_LOW;
+                               pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_WIFI_RSSI_1_MEDIUM;
+                               RTPRINT(FBT, BT_TRACE, ("[DM][BT], RSSI_1 state switch to High\n"));
+                       } else if (UndecoratedSmoothedPWDB < RssiThresh) {
+                               btRssiState = BT_RSSI_STATE_LOW;
+                               pHalData->bt_coexist.CurrentState |= BT_COEX_STATE_WIFI_RSSI_1_LOW;
+                               pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_WIFI_RSSI_1_HIGH;
+                               pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_WIFI_RSSI_1_MEDIUM;
+                               RTPRINT(FBT, BT_TRACE, ("[DM][BT], RSSI_1 state switch to Low\n"));
+                       } else {
+                               btRssiState = BT_RSSI_STATE_STAY_MEDIUM;
+                               RTPRINT(FBT, BT_TRACE, ("[DM][BT], RSSI_1 state stay at Medium\n"));
+                       }
+               } else {
+                       if (UndecoratedSmoothedPWDB < RssiThresh1) {
+                               btRssiState = BT_RSSI_STATE_MEDIUM;
+                               pHalData->bt_coexist.CurrentState |= BT_COEX_STATE_WIFI_RSSI_1_MEDIUM;
+                               pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_WIFI_RSSI_1_HIGH;
+                               pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_WIFI_RSSI_1_LOW;
+                               RTPRINT(FBT, BT_TRACE, ("[DM][BT], RSSI_1 state switch to Medium\n"));
+                       } else {
+                               btRssiState = BT_RSSI_STATE_STAY_HIGH;
+                               RTPRINT(FBT, BT_TRACE, ("[DM][BT], RSSI_1 state stay at High\n"));
+                       }
+               }
+       }
+
+       pHalData->bt_coexist.preRssiState1 = btRssiState;
+
+       return btRssiState;
+}
+
+u8 BTDM_CheckCoexRSSIState(struct rtw_adapter *padapter, u8 levelNum,
+                          u8 RssiThresh, u8 RssiThresh1)
+{
+       struct hal_data_8723a *pHalData = GET_HAL_DATA(padapter);
+       s32 UndecoratedSmoothedPWDB = 0;
+       u8 btRssiState = 0;
+
+       UndecoratedSmoothedPWDB = BTDM_GetRxSS(padapter);
+
+       if (levelNum == 2) {
+               pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_WIFI_RSSI_MEDIUM;
+
+               if ((pHalData->bt_coexist.preRssiState == BT_RSSI_STATE_LOW) ||
+                   (pHalData->bt_coexist.preRssiState == BT_RSSI_STATE_STAY_LOW)) {
+                       if (UndecoratedSmoothedPWDB >= (RssiThresh+BT_FW_COEX_THRESH_TOL)) {
+                               btRssiState = BT_RSSI_STATE_HIGH;
+                               pHalData->bt_coexist.CurrentState |= BT_COEX_STATE_WIFI_RSSI_HIGH;
+                               pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_WIFI_RSSI_LOW;
+                               RTPRINT(FBT, BT_TRACE, ("[DM][BT], RSSI state switch to High\n"));
+                       } else {
+                               btRssiState = BT_RSSI_STATE_STAY_LOW;
+                               RTPRINT(FBT, BT_TRACE, ("[DM][BT], RSSI state stay at Low\n"));
+                       }
+               } else {
+                       if (UndecoratedSmoothedPWDB < RssiThresh) {
+                               btRssiState = BT_RSSI_STATE_LOW;
+                               pHalData->bt_coexist.CurrentState |= BT_COEX_STATE_WIFI_RSSI_LOW;
+                               pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_WIFI_RSSI_HIGH;
+                               RTPRINT(FBT, BT_TRACE, ("[DM][BT], RSSI state switch to Low\n"));
+                       } else {
+                               btRssiState = BT_RSSI_STATE_STAY_HIGH;
+                               RTPRINT(FBT, BT_TRACE, ("[DM][BT], RSSI state stay at High\n"));
+                       }
+               }
+       } else if (levelNum == 3) {
+               if (RssiThresh > RssiThresh1) {
+                       RTPRINT(FBT, BT_TRACE, ("[DM][BT], RSSI thresh error!!\n"));
+                       return pHalData->bt_coexist.preRssiState;
+               }
+
+               if ((pHalData->bt_coexist.preRssiState == BT_RSSI_STATE_LOW) ||
+                   (pHalData->bt_coexist.preRssiState == BT_RSSI_STATE_STAY_LOW)) {
+                       if (UndecoratedSmoothedPWDB >= (RssiThresh+BT_FW_COEX_THRESH_TOL)) {
+                               btRssiState = BT_RSSI_STATE_MEDIUM;
+                               pHalData->bt_coexist.CurrentState |= BT_COEX_STATE_WIFI_RSSI_MEDIUM;
+                               pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_WIFI_RSSI_LOW;
+                               pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_WIFI_RSSI_HIGH;
+                               RTPRINT(FBT, BT_TRACE, ("[DM][BT], RSSI state switch to Medium\n"));
+                       } else {
+                               btRssiState = BT_RSSI_STATE_STAY_LOW;
+                               RTPRINT(FBT, BT_TRACE, ("[DM][BT], RSSI state stay at Low\n"));
+                       }
+               } else if ((pHalData->bt_coexist.preRssiState == BT_RSSI_STATE_MEDIUM) ||
+                          (pHalData->bt_coexist.preRssiState == BT_RSSI_STATE_STAY_MEDIUM)) {
+                       if (UndecoratedSmoothedPWDB >= (RssiThresh1+BT_FW_COEX_THRESH_TOL)) {
+                               btRssiState = BT_RSSI_STATE_HIGH;
+                               pHalData->bt_coexist.CurrentState |= BT_COEX_STATE_WIFI_RSSI_HIGH;
+                               pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_WIFI_RSSI_LOW;
+                               pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_WIFI_RSSI_MEDIUM;
+                               RTPRINT(FBT, BT_TRACE, ("[DM][BT], RSSI state switch to High\n"));
+                       } else if (UndecoratedSmoothedPWDB < RssiThresh) {
+                               btRssiState = BT_RSSI_STATE_LOW;
+                               pHalData->bt_coexist.CurrentState |= BT_COEX_STATE_WIFI_RSSI_LOW;
+                               pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_WIFI_RSSI_HIGH;
+                               pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_WIFI_RSSI_MEDIUM;
+                               RTPRINT(FBT, BT_TRACE, ("[DM][BT], RSSI state switch to Low\n"));
+                       } else {
+                               btRssiState = BT_RSSI_STATE_STAY_MEDIUM;
+                               RTPRINT(FBT, BT_TRACE, ("[DM][BT], RSSI state stay at Medium\n"));
+                       }
+               } else {
+                       if (UndecoratedSmoothedPWDB < RssiThresh1) {
+                               btRssiState = BT_RSSI_STATE_MEDIUM;
+                               pHalData->bt_coexist.CurrentState |= BT_COEX_STATE_WIFI_RSSI_MEDIUM;
+                               pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_WIFI_RSSI_HIGH;
+                               pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_WIFI_RSSI_LOW;
+                               RTPRINT(FBT, BT_TRACE, ("[DM][BT], RSSI state switch to Medium\n"));
+                       } else {
+                               btRssiState = BT_RSSI_STATE_STAY_HIGH;
+                               RTPRINT(FBT, BT_TRACE, ("[DM][BT], RSSI state stay at High\n"));
+                       }
+               }
+       }
+
+       pHalData->bt_coexist.preRssiState = btRssiState;
+
+       return btRssiState;
+}
+
+bool rtl8723a_BT_disable_EDCA_turbo(struct rtw_adapter *padapter)
+{
+       struct bt_mgnt *pBtMgnt;
+       struct hal_data_8723a *pHalData;
+       u8 bBtChangeEDCA = false;
+       u32 EDCA_BT_BE = 0x5ea42b, cur_EDCA_reg;
+       bool bRet = false;
+
+       pHalData = GET_HAL_DATA(padapter);
+       pBtMgnt = &pHalData->BtInfo.BtMgnt;
+
+       if (!rtl8723a_BT_coexist(padapter)) {
+               bRet = false;
+               pHalData->bt_coexist.lastBtEdca = 0;
+               return bRet;
+       }
+       if (!((pBtMgnt->bSupportProfile) ||
+           (pHalData->bt_coexist.BT_CoexistType == BT_CSR_BC8))) {
+               bRet = false;
+               pHalData->bt_coexist.lastBtEdca = 0;
+               return bRet;
+       }
+
+       if (rtl8723a_BT_using_antenna_1(padapter)) {
+               bRet = false;
+               pHalData->bt_coexist.lastBtEdca = 0;
+               return bRet;
+       }
+
+       if (pHalData->bt_coexist.exec_cnt < 3)
+               pHalData->bt_coexist.exec_cnt++;
+       else
+               pHalData->bt_coexist.bEDCAInitialized = true;
+
+       /*  When BT is non idle */
+       if (!(pHalData->bt_coexist.CurrentState & BT_COEX_STATE_BT_IDLE)) {
+               RTPRINT(FBT, BT_TRACE, ("BT state non idle, set bt EDCA\n"));
+
+               /* aggr_num = 0x0909; */
+               if (pHalData->odmpriv.DM_EDCA_Table.bCurrentTurboEDCA) {
+                       bBtChangeEDCA = true;
+                       pHalData->odmpriv.DM_EDCA_Table.bCurrentTurboEDCA = false;
+                       pHalData->dmpriv.prv_traffic_idx = 3;
+               }
+               cur_EDCA_reg = rtl8723au_read32(padapter, REG_EDCA_BE_PARAM);
+
+               if (cur_EDCA_reg != EDCA_BT_BE)
+                       bBtChangeEDCA = true;
+               if (bBtChangeEDCA || !pHalData->bt_coexist.bEDCAInitialized) {
+                       rtl8723au_write32(padapter, REG_EDCA_BE_PARAM,
+                                         EDCA_BT_BE);
+                       pHalData->bt_coexist.lastBtEdca = EDCA_BT_BE;
+               }
+               bRet = true;
+       } else {
+               RTPRINT(FBT, BT_TRACE, ("BT state idle, set original EDCA\n"));
+               pHalData->bt_coexist.lastBtEdca = 0;
+               bRet = false;
+       }
+       return bRet;
+}
+
+void
+BTDM_Balance(
+       struct rtw_adapter *padapter,
+       u8 bBalanceOn,
+       u8 ms0,
+       u8 ms1
+       )
+{
+       struct hal_data_8723a *pHalData = GET_HAL_DATA(padapter);
+       u8 H2C_Parameter[3] = {0};
+
+       if (bBalanceOn) {
+               H2C_Parameter[2] = 1;
+               H2C_Parameter[1] = ms1;
+               H2C_Parameter[0] = ms0;
+               pHalData->bt_coexist.bFWCoexistAllOff = false;
+       } else {
+               H2C_Parameter[2] = 0;
+               H2C_Parameter[1] = 0;
+               H2C_Parameter[0] = 0;
+       }
+       pHalData->bt_coexist.bBalanceOn = bBalanceOn;
+
+       RTPRINT(FBT, BT_TRACE, ("[DM][BT], Balance =[%s:%dms:%dms], write 0xc = 0x%x\n",
+               bBalanceOn?"ON":"OFF", ms0, ms1,
+               H2C_Parameter[0]<<16|H2C_Parameter[1]<<8|H2C_Parameter[2]));
+
+       FillH2CCmd(padapter, 0xc, 3, H2C_Parameter);
+}
+
+void BTDM_AGCTable(struct rtw_adapter *padapter, u8 type)
+{
+       struct hal_data_8723a *pHalData = GET_HAL_DATA(padapter);
+       if (type == BT_AGCTABLE_OFF) {
+               RTPRINT(FBT, BT_TRACE, ("[BT]AGCTable Off!\n"));
+               rtl8723au_write32(padapter, 0xc78, 0x641c0001);
+               rtl8723au_write32(padapter, 0xc78, 0x631d0001);
+               rtl8723au_write32(padapter, 0xc78, 0x621e0001);
+               rtl8723au_write32(padapter, 0xc78, 0x611f0001);
+               rtl8723au_write32(padapter, 0xc78, 0x60200001);
+
+               PHY_SetRFReg(padapter, PathA, RF_RX_AGC_HP, bRFRegOffsetMask, 0x32000);
+               PHY_SetRFReg(padapter, PathA, RF_RX_AGC_HP, bRFRegOffsetMask, 0x71000);
+               PHY_SetRFReg(padapter, PathA, RF_RX_AGC_HP, bRFRegOffsetMask, 0xb0000);
+               PHY_SetRFReg(padapter, PathA, RF_RX_AGC_HP, bRFRegOffsetMask, 0xfc000);
+               PHY_SetRFReg(padapter, PathA, RF_RX_G1, bRFRegOffsetMask, 0x30355);
+
+               pHalData->bt_coexist.b8723aAgcTableOn = false;
+       } else if (type == BT_AGCTABLE_ON) {
+               RTPRINT(FBT, BT_TRACE, ("[BT]AGCTable On!\n"));
+               rtl8723au_write32(padapter, 0xc78, 0x4e1c0001);
+               rtl8723au_write32(padapter, 0xc78, 0x4d1d0001);
+               rtl8723au_write32(padapter, 0xc78, 0x4c1e0001);
+               rtl8723au_write32(padapter, 0xc78, 0x4b1f0001);
+               rtl8723au_write32(padapter, 0xc78, 0x4a200001);
+
+               PHY_SetRFReg(padapter, PathA, RF_RX_AGC_HP, bRFRegOffsetMask, 0xdc000);
+               PHY_SetRFReg(padapter, PathA, RF_RX_AGC_HP, bRFRegOffsetMask, 0x90000);
+               PHY_SetRFReg(padapter, PathA, RF_RX_AGC_HP, bRFRegOffsetMask, 0x51000);
+               PHY_SetRFReg(padapter, PathA, RF_RX_AGC_HP, bRFRegOffsetMask, 0x12000);
+               PHY_SetRFReg(padapter, PathA, RF_RX_G1, bRFRegOffsetMask, 0x00355);
+
+               pHalData->bt_coexist.b8723aAgcTableOn = true;
+
+               pHalData->bt_coexist.bSWCoexistAllOff = false;
+       }
+}
+
+void BTDM_BBBackOffLevel(struct rtw_adapter *padapter, u8 type)
+{
+       struct hal_data_8723a *pHalData = GET_HAL_DATA(padapter);
+
+       if (type == BT_BB_BACKOFF_OFF) {
+               RTPRINT(FBT, BT_TRACE, ("[BT]BBBackOffLevel Off!\n"));
+               rtl8723au_write32(padapter, 0xc04, 0x3a05611);
+       } else if (type == BT_BB_BACKOFF_ON) {
+               RTPRINT(FBT, BT_TRACE, ("[BT]BBBackOffLevel On!\n"));
+               rtl8723au_write32(padapter, 0xc04, 0x3a07611);
+               pHalData->bt_coexist.bSWCoexistAllOff = false;
+       }
+}
+
+void BTDM_FWCoexAllOff(struct rtw_adapter *padapter)
+{
+       struct hal_data_8723a *pHalData = GET_HAL_DATA(padapter);
+
+       RTPRINT(FBT, BT_TRACE, ("BTDM_FWCoexAllOff()\n"));
+       if (pHalData->bt_coexist.bFWCoexistAllOff)
+               return;
+       RTPRINT(FBT, BT_TRACE, ("BTDM_FWCoexAllOff(), real Do\n"));
+
+       BTDM_FWCoexAllOff8723A(padapter);
+
+       pHalData->bt_coexist.bFWCoexistAllOff = true;
+}
+
+void BTDM_SWCoexAllOff(struct rtw_adapter *padapter)
+{
+       struct hal_data_8723a *pHalData = GET_HAL_DATA(padapter);
+
+       RTPRINT(FBT, BT_TRACE, ("BTDM_SWCoexAllOff()\n"));
+       if (pHalData->bt_coexist.bSWCoexistAllOff)
+               return;
+       RTPRINT(FBT, BT_TRACE, ("BTDM_SWCoexAllOff(), real Do\n"));
+       BTDM_SWCoexAllOff8723A(padapter);
+
+       pHalData->bt_coexist.bSWCoexistAllOff = true;
+}
+
+void BTDM_HWCoexAllOff(struct rtw_adapter *padapter)
+{
+       struct hal_data_8723a *pHalData = GET_HAL_DATA(padapter);
+
+       RTPRINT(FBT, BT_TRACE, ("BTDM_HWCoexAllOff()\n"));
+       if (pHalData->bt_coexist.bHWCoexistAllOff)
+               return;
+       RTPRINT(FBT, BT_TRACE, ("BTDM_HWCoexAllOff(), real Do\n"));
+
+       BTDM_HWCoexAllOff8723A(padapter);
+
+       pHalData->bt_coexist.bHWCoexistAllOff = true;
+}
+
+void BTDM_CoexAllOff(struct rtw_adapter *padapter)
+{
+       BTDM_FWCoexAllOff(padapter);
+       BTDM_SWCoexAllOff(padapter);
+       BTDM_HWCoexAllOff(padapter);
+}
+
+void rtl8723a_BT_disable_coexist(struct rtw_adapter *padapter)
+{
+       struct pwrctrl_priv *ppwrctrl = &padapter->pwrctrlpriv;
+
+       if (!rtl8723a_BT_coexist(padapter))
+               return;
+
+       /*  8723 1Ant doesn't need to turn off bt coexist mechanism. */
+       if (rtl8723a_BT_using_antenna_1(padapter))
+               return;
+
+       /*  Before enter IPS, turn off FW BT Co-exist mechanism */
+       if (ppwrctrl->reg_rfoff == rf_on) {
+               RTPRINT(FBT, BT_TRACE, ("[BT][DM], Before enter IPS, turn off all Coexist DM\n"));
+               btdm_ResetFWCoexState(padapter);
+               BTDM_CoexAllOff(padapter);
+               BTDM_SetAntenna(padapter, BTDM_ANT_BT);
+       }
+}
+
+void BTDM_SignalCompensation(struct rtw_adapter *padapter, u8 *rssi_wifi, u8 *rssi_bt)
+{
+       BTDM_8723ASignalCompensation(padapter, rssi_wifi, rssi_bt);
+}
+
+void rtl8723a_BT_do_coexist(struct rtw_adapter *padapter)
+{
+       struct hal_data_8723a *pHalData = GET_HAL_DATA(padapter);
+
+       if (!rtl8723a_BT_coexist(padapter)) {
+               RTPRINT(FBT, BT_TRACE, ("[DM][BT], BT not exists!!\n"));
+               return;
+       }
+
+       if (!pHalData->bt_coexist.bInitlized) {
+               RTPRINT(FBT, BT_TRACE, ("[DM][BT], btdm_InitBtCoexistDM()\n"));
+               btdm_InitBtCoexistDM(padapter);
+       }
+
+       RTPRINT(FBT, BT_TRACE, ("\n\n[DM][BT], BTDM start!!\n"));
+
+       BTDM_PWDBMonitor(padapter);
+
+       RTPRINT(FBT, BT_TRACE, ("[DM][BT], HW type is 8723\n"));
+       BTDM_BTCoexist8723A(padapter);
+       RTPRINT(FBT, BT_TRACE, ("[DM][BT], BTDM end!!\n\n"));
+}
+
+void BTDM_UpdateCoexState(struct rtw_adapter *padapter)
+{
+       struct hal_data_8723a *pHalData = GET_HAL_DATA(padapter);
+
+       if (!BTDM_IsSameCoexistState(padapter)) {
+               RTPRINT(FBT, BT_TRACE, ("[BTCoex], Coexist State[bitMap] change from 0x%"i64fmt"x to 0x%"i64fmt"x,  changeBits = 0x%"i64fmt"x\n",
+                       pHalData->bt_coexist.PreviousState,
+                       pHalData->bt_coexist.CurrentState,
+                       (pHalData->bt_coexist.PreviousState^pHalData->bt_coexist.CurrentState)));
+               pHalData->bt_coexist.PreviousState = pHalData->bt_coexist.CurrentState;
+       }
+}
+
+u8 BTDM_IsSameCoexistState(struct rtw_adapter *padapter)
+{
+       struct hal_data_8723a *pHalData = GET_HAL_DATA(padapter);
+
+       if (pHalData->bt_coexist.PreviousState == pHalData->bt_coexist.CurrentState) {
+               return true;
+       } else {
+               RTPRINT(FBT, BT_TRACE, ("[DM][BT], Coexist state changed!!\n"));
+               return false;
+       }
+}
+
+void BTDM_PWDBMonitor(struct rtw_adapter *padapter)
+{
+       struct bt_30info *pBTInfo = GET_BT_INFO(GetDefaultAdapter(padapter));
+       struct bt_mgnt *pBtMgnt = &pBTInfo->BtMgnt;
+       struct hal_data_8723a *pHalData = GET_HAL_DATA(padapter);
+       u8 H2C_Parameter[3] = {0};
+       s32 tmpBTEntryMaxPWDB = 0, tmpBTEntryMinPWDB = 0xff;
+       u8 i;
+
+       if (pBtMgnt->BtOperationOn) {
+               for (i = 0; i < MAX_BT_ASOC_ENTRY_NUM; i++) {
+                       if (pBTInfo->BtAsocEntry[i].bUsed) {
+                               if (pBTInfo->BtAsocEntry[i].UndecoratedSmoothedPWDB < tmpBTEntryMinPWDB)
+                                       tmpBTEntryMinPWDB = pBTInfo->BtAsocEntry[i].UndecoratedSmoothedPWDB;
+                               if (pBTInfo->BtAsocEntry[i].UndecoratedSmoothedPWDB > tmpBTEntryMaxPWDB)
+                                       tmpBTEntryMaxPWDB = pBTInfo->BtAsocEntry[i].UndecoratedSmoothedPWDB;
+                               /*  Report every BT connection (HS mode) RSSI to FW */
+                               H2C_Parameter[2] = (u8)(pBTInfo->BtAsocEntry[i].UndecoratedSmoothedPWDB & 0xFF);
+                               H2C_Parameter[0] = (MAX_FW_SUPPORT_MACID_NUM-1-i);
+                               RTPRINT(FDM, DM_BT30, ("RSSI report for BT[%d], H2C_Par = 0x%x\n", i, H2C_Parameter[0]));
+                               FillH2CCmd(padapter, RSSI_SETTING_EID, 3, H2C_Parameter);
+                               RTPRINT_ADDR(FDM, (DM_PWDB|DM_BT30), ("BT_Entry Mac :"),
+                                            pBTInfo->BtAsocEntry[i].BTRemoteMACAddr)
+                               RTPRINT(FDM, (DM_PWDB|DM_BT30),
+                                       ("BT rx pwdb[%d] = 0x%x(%d)\n", i,
+                                       pBTInfo->BtAsocEntry[i].UndecoratedSmoothedPWDB,
+                                       pBTInfo->BtAsocEntry[i].UndecoratedSmoothedPWDB));
+                       }
+               }
+               if (tmpBTEntryMaxPWDB != 0) {   /*  If associated entry is found */
+                       pHalData->dmpriv.BT_EntryMaxUndecoratedSmoothedPWDB = tmpBTEntryMaxPWDB;
+                       RTPRINT(FDM, (DM_PWDB|DM_BT30), ("BT_EntryMaxPWDB = 0x%x(%d)\n",
+                               tmpBTEntryMaxPWDB, tmpBTEntryMaxPWDB));
+               } else {
+                       pHalData->dmpriv.BT_EntryMaxUndecoratedSmoothedPWDB = 0;
+               }
+               if (tmpBTEntryMinPWDB != 0xff) { /*  If associated entry is found */
+                       pHalData->dmpriv.BT_EntryMinUndecoratedSmoothedPWDB = tmpBTEntryMinPWDB;
+                       RTPRINT(FDM, (DM_PWDB|DM_BT30), ("BT_EntryMinPWDB = 0x%x(%d)\n",
+                               tmpBTEntryMinPWDB, tmpBTEntryMinPWDB));
+               } else {
+                       pHalData->dmpriv.BT_EntryMinUndecoratedSmoothedPWDB = 0;
+               }
+       }
+}
+
+u8 BTDM_IsBTBusy(struct rtw_adapter *padapter)
+{
+       struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
+       struct bt_mgnt *pBtMgnt = &pBTInfo->BtMgnt;
+
+       if (pBtMgnt->ExtConfig.bBTBusy)
+               return true;
+       else
+               return false;
+}
+
+u8 BTDM_IsWifiBusy(struct rtw_adapter *padapter)
+{
+/*PMGNT_INFO           pMgntInfo = &GetDefaultAdapter(padapter)->MgntInfo; */
+       struct mlme_priv *pmlmepriv = &GetDefaultAdapter(padapter)->mlmepriv;
+       struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
+       struct bt_traffic *pBtTraffic = &pBTInfo->BtTraffic;
+
+       if (pmlmepriv->LinkDetectInfo.bBusyTraffic ||
+               pBtTraffic->Bt30TrafficStatistics.bTxBusyTraffic ||
+               pBtTraffic->Bt30TrafficStatistics.bRxBusyTraffic)
+               return true;
+       else
+               return false;
+}
+
+u8 BTDM_IsCoexistStateChanged(struct rtw_adapter *padapter)
+{
+       struct hal_data_8723a *pHalData = GET_HAL_DATA(padapter);
+
+       if (pHalData->bt_coexist.PreviousState == pHalData->bt_coexist.CurrentState)
+               return false;
+       else
+               return true;
+}
+
+u8 BTDM_IsWifiUplink(struct rtw_adapter *padapter)
+{
+/*PMGNT_INFO           pMgntInfo = &GetDefaultAdapter(padapter)->MgntInfo; */
+       struct mlme_priv *pmlmepriv;
+       struct bt_30info *pBTInfo;
+       struct bt_traffic *pBtTraffic;
+
+       pmlmepriv = &padapter->mlmepriv;
+       pBTInfo = GET_BT_INFO(padapter);
+       pBtTraffic = &pBTInfo->BtTraffic;
+
+       if ((pmlmepriv->LinkDetectInfo.bTxBusyTraffic) ||
+               (pBtTraffic->Bt30TrafficStatistics.bTxBusyTraffic))
+               return true;
+       else
+               return false;
+}
+
+u8 BTDM_IsWifiDownlink(struct rtw_adapter *padapter)
+{
+/*PMGNT_INFO           pMgntInfo = &GetDefaultAdapter(padapter)->MgntInfo; */
+       struct mlme_priv *pmlmepriv;
+       struct bt_30info *pBTInfo;
+       struct bt_traffic *pBtTraffic;
+
+       pmlmepriv = &padapter->mlmepriv;
+       pBTInfo = GET_BT_INFO(padapter);
+       pBtTraffic = &pBTInfo->BtTraffic;
+
+       if ((pmlmepriv->LinkDetectInfo.bRxBusyTraffic) ||
+               (pBtTraffic->Bt30TrafficStatistics.bRxBusyTraffic))
+               return true;
+       else
+               return false;
+}
+
+u8 BTDM_IsBTHSMode(struct rtw_adapter *padapter)
+{
+/*PMGNT_INFO           pMgntInfo = &GetDefaultAdapter(padapter)->MgntInfo; */
+       struct hal_data_8723a *pHalData;
+       struct bt_mgnt *pBtMgnt;
+
+       pHalData = GET_HAL_DATA(padapter);
+       pBtMgnt = &pHalData->BtInfo.BtMgnt;
+
+       if (pBtMgnt->BtOperationOn)
+               return true;
+       else
+               return false;
+}
+
+u8 BTDM_IsBTUplink(struct rtw_adapter *padapter)
+{
+       struct hal_data_8723a *pHalData = GET_HAL_DATA(padapter);
+
+       if (pHalData->bt_coexist.BT21TrafficStatistics.bTxBusyTraffic)
+               return true;
+       else
+               return false;
+}
+
+u8 BTDM_IsBTDownlink(struct rtw_adapter *padapter)
+{
+       struct hal_data_8723a *pHalData = GET_HAL_DATA(padapter);
+
+       if (pHalData->bt_coexist.BT21TrafficStatistics.bRxBusyTraffic)
+               return true;
+       else
+               return false;
+}
+
+void BTDM_AdjustForBtOperation(struct rtw_adapter *padapter)
+{
+       RTPRINT(FBT, BT_TRACE, ("[BT][DM], BTDM_AdjustForBtOperation()\n"));
+       BTDM_AdjustForBtOperation8723A(padapter);
+}
+
+void BTDM_SetBtCoexCurrAntNum(struct rtw_adapter *padapter, u8 antNum)
+{
+       BTDM_Set8723ABtCoexCurrAntNum(padapter, antNum);
+}
+
+void BTDM_ForHalt(struct rtw_adapter *padapter)
+{
+       if (!rtl8723a_BT_coexist(padapter))
+               return;
+
+       BTDM_ForHalt8723A(padapter);
+       GET_HAL_DATA(padapter)->bt_coexist.bInitlized = false;
+}
+
+void BTDM_WifiScanNotify(struct rtw_adapter *padapter, u8 scanType)
+{
+       if (!rtl8723a_BT_coexist(padapter))
+               return;
+
+       BTDM_WifiScanNotify8723A(padapter, scanType);
+}
+
+void BTDM_WifiAssociateNotify(struct rtw_adapter *padapter, u8 action)
+{
+       if (!rtl8723a_BT_coexist(padapter))
+               return;
+
+       BTDM_WifiAssociateNotify8723A(padapter, action);
+}
+
+void rtl8723a_BT_mediastatus_notify(struct rtw_adapter *padapter,
+                                   enum rt_media_status mstatus)
+{
+       if (!rtl8723a_BT_coexist(padapter))
+               return;
+
+       BTDM_MediaStatusNotify8723A(padapter, mstatus);
+}
+
+void rtl8723a_BT_specialpacket_notify(struct rtw_adapter *padapter)
+{
+       if (!rtl8723a_BT_coexist(padapter))
+               return;
+
+       BTDM_ForDhcp8723A(padapter);
+}
+
+void BTDM_ResetActionProfileState(struct rtw_adapter *padapter)
+{
+       struct hal_data_8723a *pHalData = GET_HAL_DATA(padapter);
+
+       pHalData->bt_coexist.CurrentState &= ~\
+               (BT_COEX_STATE_PROFILE_HID|BT_COEX_STATE_PROFILE_A2DP|
+               BT_COEX_STATE_PROFILE_PAN|BT_COEX_STATE_PROFILE_SCO);
+}
+
+u8 BTDM_IsActionSCO(struct rtw_adapter *padapter)
+{
+       struct hal_data_8723a *pHalData;
+       struct bt_30info *pBTInfo;
+       struct bt_mgnt *pBtMgnt;
+       struct bt_dgb *pBtDbg;
+       u8 bRet;
+
+       pHalData = GET_HAL_DATA(padapter);
+       pBTInfo = GET_BT_INFO(padapter);
+       pBtMgnt = &pBTInfo->BtMgnt;
+       pBtDbg = &pBTInfo->BtDbg;
+       bRet = false;
+
+       if (pBtDbg->dbgCtrl) {
+               if (pBtDbg->dbgProfile == BT_DBG_PROFILE_SCO) {
+                       pHalData->bt_coexist.CurrentState |= BT_COEX_STATE_PROFILE_SCO;
+                       bRet = true;
+               }
+       } else {
+               if (pBtMgnt->ExtConfig.NumberOfSCO > 0) {
+                       pHalData->bt_coexist.CurrentState |= BT_COEX_STATE_PROFILE_SCO;
+                       bRet = true;
+               }
+       }
+       return bRet;
+}
+
+u8 BTDM_IsActionHID(struct rtw_adapter *padapter)
+{
+       struct bt_30info *pBTInfo;
+       struct hal_data_8723a *pHalData;
+       struct bt_mgnt *pBtMgnt;
+       struct bt_dgb *pBtDbg;
+       u8 bRet;
+
+       pHalData = GET_HAL_DATA(padapter);
+       pBTInfo = GET_BT_INFO(padapter);
+       pBtMgnt = &pBTInfo->BtMgnt;
+       pBtDbg = &pBTInfo->BtDbg;
+       bRet = false;
+
+       if (pBtDbg->dbgCtrl) {
+               if (pBtDbg->dbgProfile == BT_DBG_PROFILE_HID) {
+                       pHalData->bt_coexist.CurrentState |= BT_COEX_STATE_PROFILE_HID;
+                       bRet = true;
+               }
+       } else {
+               if (BTHCI_CheckProfileExist(padapter, BT_PROFILE_HID) &&
+                   pBtMgnt->ExtConfig.NumberOfHandle == 1) {
+                       pHalData->bt_coexist.CurrentState |= BT_COEX_STATE_PROFILE_HID;
+                       bRet = true;
+               }
+       }
+       return bRet;
+}
+
+u8 BTDM_IsActionA2DP(struct rtw_adapter *padapter)
+{
+       struct hal_data_8723a *pHalData;
+       struct bt_30info *pBTInfo;
+       struct bt_mgnt *pBtMgnt;
+       struct bt_dgb *pBtDbg;
+       u8 bRet;
+
+       pHalData = GET_HAL_DATA(padapter);
+       pBTInfo = GET_BT_INFO(padapter);
+       pBtMgnt = &pBTInfo->BtMgnt;
+       pBtDbg = &pBTInfo->BtDbg;
+       bRet = false;
+
+       if (pBtDbg->dbgCtrl) {
+               if (pBtDbg->dbgProfile == BT_DBG_PROFILE_A2DP) {
+                       pHalData->bt_coexist.CurrentState |= BT_COEX_STATE_PROFILE_A2DP;
+                       bRet = true;
+               }
+       } else {
+               if (BTHCI_CheckProfileExist(padapter, BT_PROFILE_A2DP) &&
+                   pBtMgnt->ExtConfig.NumberOfHandle == 1) {
+                       pHalData->bt_coexist.CurrentState |= BT_COEX_STATE_PROFILE_A2DP;
+                       bRet = true;
+               }
+       }
+       return bRet;
+}
+
+u8 BTDM_IsActionPAN(struct rtw_adapter *padapter)
+{
+       struct hal_data_8723a *pHalData;
+       struct bt_30info *pBTInfo;
+       struct bt_mgnt *pBtMgnt;
+       struct bt_dgb *pBtDbg;
+       u8 bRet;
+
+       pHalData = GET_HAL_DATA(padapter);
+       pBTInfo = GET_BT_INFO(padapter);
+       pBtMgnt = &pBTInfo->BtMgnt;
+       pBtDbg = &pBTInfo->BtDbg;
+       bRet = false;
+
+       if (pBtDbg->dbgCtrl) {
+               if (pBtDbg->dbgProfile == BT_DBG_PROFILE_PAN) {
+                       pHalData->bt_coexist.CurrentState |= BT_COEX_STATE_PROFILE_PAN;
+                       bRet = true;
+               }
+       } else {
+               if (BTHCI_CheckProfileExist(padapter, BT_PROFILE_PAN) &&
+                   pBtMgnt->ExtConfig.NumberOfHandle == 1) {
+                       pHalData->bt_coexist.CurrentState |= BT_COEX_STATE_PROFILE_PAN;
+                       bRet = true;
+               }
+       }
+       return bRet;
+}
+
+u8 BTDM_IsActionHIDA2DP(struct rtw_adapter *padapter)
+{
+       struct hal_data_8723a *pHalData;
+       struct bt_30info *pBTInfo;
+       struct bt_mgnt *pBtMgnt;
+       struct bt_dgb *pBtDbg;
+       u8 bRet;
+
+       pHalData = GET_HAL_DATA(padapter);
+       pBTInfo = GET_BT_INFO(padapter);
+       pBtMgnt = &pBTInfo->BtMgnt;
+       pBtDbg = &pBTInfo->BtDbg;
+       bRet = false;
+
+       if (pBtDbg->dbgCtrl) {
+               if (pBtDbg->dbgProfile == BT_DBG_PROFILE_HID_A2DP) {
+                       pHalData->bt_coexist.CurrentState |= (BT_COEX_STATE_PROFILE_HID|BT_COEX_STATE_PROFILE_A2DP);
+                       bRet = true;
+               }
+       } else {
+               if (BTHCI_CheckProfileExist(padapter, BT_PROFILE_HID) &&
+                   BTHCI_CheckProfileExist(padapter, BT_PROFILE_A2DP)) {
+                       pHalData->bt_coexist.CurrentState |= (BT_COEX_STATE_PROFILE_HID|BT_COEX_STATE_PROFILE_A2DP);
+                       bRet = true;
+               }
+       }
+       return bRet;
+}
+
+u8 BTDM_IsActionHIDPAN(struct rtw_adapter *padapter)
+{
+       struct hal_data_8723a *pHalData;
+       struct bt_30info *pBTInfo;
+       struct bt_dgb *pBtDbg;
+       u8 bRet;
+
+       pHalData = GET_HAL_DATA(padapter);
+       pBTInfo = GET_BT_INFO(padapter);
+       pBtDbg = &pBTInfo->BtDbg;
+       bRet = false;
+
+       if (pBtDbg->dbgCtrl) {
+               if (pBtDbg->dbgProfile == BT_DBG_PROFILE_HID_PAN) {
+                       pHalData->bt_coexist.CurrentState |= (BT_COEX_STATE_PROFILE_HID|BT_COEX_STATE_PROFILE_PAN);
+                       bRet = true;
+               }
+       } else {
+               if (BTHCI_CheckProfileExist(padapter, BT_PROFILE_HID) &&
+                   BTHCI_CheckProfileExist(padapter, BT_PROFILE_PAN)) {
+                       pHalData->bt_coexist.CurrentState |= (BT_COEX_STATE_PROFILE_HID|BT_COEX_STATE_PROFILE_PAN);
+                       bRet = true;
+               }
+       }
+       return bRet;
+}
+
+u8 BTDM_IsActionPANA2DP(struct rtw_adapter *padapter)
+{
+       struct hal_data_8723a *pHalData;
+       struct bt_30info *pBTInfo;
+       struct bt_dgb *pBtDbg;
+       u8 bRet;
+
+       pHalData = GET_HAL_DATA(padapter);
+       pBTInfo = GET_BT_INFO(padapter);
+       pBtDbg = &pBTInfo->BtDbg;
+       bRet = false;
+
+       if (pBtDbg->dbgCtrl) {
+               if (pBtDbg->dbgProfile == BT_DBG_PROFILE_PAN_A2DP) {
+                       pHalData->bt_coexist.CurrentState |= (BT_COEX_STATE_PROFILE_PAN|BT_COEX_STATE_PROFILE_A2DP);
+                       bRet = true;
+               }
+       } else {
+               if (BTHCI_CheckProfileExist(padapter, BT_PROFILE_PAN) && BTHCI_CheckProfileExist(padapter, BT_PROFILE_A2DP)) {
+                       pHalData->bt_coexist.CurrentState |= (BT_COEX_STATE_PROFILE_PAN|BT_COEX_STATE_PROFILE_A2DP);
+                       bRet = true;
+               }
+       }
+       return bRet;
+}
+
+bool rtl8723a_BT_enabled(struct rtw_adapter *padapter)
+{
+       struct hal_data_8723a *pHalData = GET_HAL_DATA(padapter);
+
+       if (pHalData->bt_coexist.bCurBtDisabled)
+               return false;
+       else
+               return true;
+}
+
+/*  ===== End of sync from SD7 driver HAL/BTCoexist/HalBtCoexist.c ===== */
+
+/*  ===== Below this line is sync from SD7 driver HAL/HalBT.c ===== */
+
+/*  */
+/*local function */
+/*  */
+
+static void halbt_InitHwConfig8723A(struct rtw_adapter *padapter)
+{
+}
+
+/*  */
+/*extern function */
+/*  */
+u8 HALBT_GetPGAntNum(struct rtw_adapter *padapter)
+{
+       struct hal_data_8723a *pHalData = GET_HAL_DATA(padapter);
+
+       return pHalData->bt_coexist.BT_Ant_Num;
+}
+
+void HALBT_SetKey(struct rtw_adapter *padapter, u8 EntryNum)
+{
+       struct bt_30info *pBTinfo;
+       struct bt_asoc_entry *pBtAssocEntry;
+       u16                             usConfig = 0;
+
+       pBTinfo = GET_BT_INFO(padapter);
+       pBtAssocEntry = &pBTinfo->BtAsocEntry[EntryNum];
+
+       pBtAssocEntry->HwCAMIndex = BT_HWCAM_STAR + EntryNum;
+
+       usConfig = CAM_VALID | (CAM_AES << 2);
+       rtl8723a_cam_write(padapter, pBtAssocEntry->HwCAMIndex, usConfig,
+                          pBtAssocEntry->BTRemoteMACAddr,
+                          pBtAssocEntry->PTK + TKIP_ENC_KEY_POS);
+}
+
+void HALBT_RemoveKey(struct rtw_adapter *padapter, u8 EntryNum)
+{
+       struct bt_30info *pBTinfo;
+       struct bt_asoc_entry *pBtAssocEntry;
+
+       pBTinfo = GET_BT_INFO(padapter);
+       pBtAssocEntry = &pBTinfo->BtAsocEntry[EntryNum];
+
+       if (pBTinfo->BtAsocEntry[EntryNum].HwCAMIndex != 0) {
+               /*  ToDo : add New HALBT_RemoveKey function !! */
+               if (pBtAssocEntry->HwCAMIndex >= BT_HWCAM_STAR &&
+                   pBtAssocEntry->HwCAMIndex < HALF_CAM_ENTRY)
+                       rtl8723a_cam_empty_entry(padapter,
+                                                pBtAssocEntry->HwCAMIndex);
+               pBTinfo->BtAsocEntry[EntryNum].HwCAMIndex = 0;
+       }
+}
+
+void rtl8723a_BT_init_hal_vars(struct rtw_adapter *padapter)
+{
+       struct hal_data_8723a *pHalData;
+
+       pHalData = GET_HAL_DATA(padapter);
+
+       pHalData->bt_coexist.BluetoothCoexist = pHalData->EEPROMBluetoothCoexist;
+       pHalData->bt_coexist.BT_Ant_Num = pHalData->EEPROMBluetoothAntNum;
+       pHalData->bt_coexist.BT_CoexistType = pHalData->EEPROMBluetoothType;
+       pHalData->bt_coexist.BT_Ant_isolation = pHalData->EEPROMBluetoothAntIsolation;
+       pHalData->bt_coexist.bt_radiosharedtype = pHalData->EEPROMBluetoothRadioShared;
+
+       RT_TRACE(_module_hal_init_c_, _drv_info_,
+                "BT Coexistance = 0x%x\n", rtl8723a_BT_coexist(padapter));
+
+       if (rtl8723a_BT_coexist(padapter)) {
+               if (pHalData->bt_coexist.BT_Ant_Num == Ant_x2) {
+                       BTDM_SetBtCoexCurrAntNum(padapter, 2);
+                       RT_TRACE(_module_hal_init_c_, _drv_info_,
+                                "BlueTooth BT_Ant_Num = Antx2\n");
+               } else if (pHalData->bt_coexist.BT_Ant_Num == Ant_x1) {
+                       BTDM_SetBtCoexCurrAntNum(padapter, 1);
+                       RT_TRACE(_module_hal_init_c_, _drv_info_,
+                                "BlueTooth BT_Ant_Num = Antx1\n");
+               }
+               pHalData->bt_coexist.bBTBusyTraffic = false;
+               pHalData->bt_coexist.bBTTrafficModeSet = false;
+               pHalData->bt_coexist.bBTNonTrafficModeSet = false;
+               pHalData->bt_coexist.CurrentState = 0;
+               pHalData->bt_coexist.PreviousState = 0;
+
+               RT_TRACE(_module_hal_init_c_, _drv_info_,
+                        "bt_radiosharedType = 0x%x\n",
+                        pHalData->bt_coexist.bt_radiosharedtype);
+       }
+}
+
+bool rtl8723a_BT_coexist(struct rtw_adapter *padapter)
+{
+       struct hal_data_8723a *pHalData = GET_HAL_DATA(padapter);
+
+       if (pHalData->bt_coexist.BluetoothCoexist)
+               return true;
+       else
+               return false;
+}
+
+u8 HALBT_BTChipType(struct rtw_adapter *padapter)
+{
+       struct hal_data_8723a *pHalData = GET_HAL_DATA(padapter);
+
+       return pHalData->bt_coexist.BT_CoexistType;
+}
+
+void rtl8723a_BT_init_hwconfig(struct rtw_adapter *padapter)
+{
+       halbt_InitHwConfig8723A(padapter);
+       rtl8723a_BT_do_coexist(padapter);
+}
+
+void HALBT_SetRtsCtsNoLenLimit(struct rtw_adapter *padapter)
+{
+}
+
+/*  ===== End of sync from SD7 driver HAL/HalBT.c ===== */
+
+void rtl8723a_dual_antenna_detection(struct rtw_adapter *padapter)
+{
+       struct hal_data_8723a *pHalData;
+       struct dm_odm_t *pDM_Odm;
+       struct sw_ant_sw *pDM_SWAT_Table;
+       u8 i;
+
+       pHalData = GET_HAL_DATA(padapter);
+       pDM_Odm = &pHalData->odmpriv;
+       pDM_SWAT_Table = &pDM_Odm->DM_SWAT_Table;
+
+       /*  */
+       /*  <Roger_Notes> RTL8723A Single and Dual antenna dynamic detection
+           mechanism when RF power state is on. */
+       /*  We should take power tracking, IQK, LCK, RCK RF read/write
+           operation into consideration. */
+       /*  2011.12.15. */
+       /*  */
+       if (!pHalData->bAntennaDetected) {
+               u8 btAntNum = BT_GetPGAntNum(padapter);
+
+               /*  Set default antenna B status */
+               if (btAntNum == Ant_x2)
+                       pDM_SWAT_Table->ANTB_ON = true;
+               else if (btAntNum == Ant_x1)
+                       pDM_SWAT_Table->ANTB_ON = false;
+               else
+                       pDM_SWAT_Table->ANTB_ON = true;
+
+               if (pHalData->CustomerID != RT_CID_TOSHIBA) {
+                       for (i = 0; i < MAX_ANTENNA_DETECTION_CNT; i++) {
+                               if (ODM_SingleDualAntennaDetection
+                                   (&pHalData->odmpriv, ANTTESTALL) == true)
+                                       break;
+                       }
+
+                       /*  Set default antenna number for BT coexistence */
+                       if (btAntNum == Ant_x2)
+                               BT_SetBtCoexCurrAntNum(padapter,
+                                                      pDM_SWAT_Table->
+                                                      ANTB_ON ? 2 : 1);
+               }
+               pHalData->bAntennaDetected = true;
+       }
+}