hal/rtl8723a_bt-coexist.c

   1 /******************************************************************************
   2  *
   3  * Copyright(c) 2007 - 2012 Realtek Corporation. All rights reserved.
   4  *
   5  * This program is free software; you can redistribute it and/or modify it
   6  * under the terms of version 2 of the GNU General Public License as
   7  * published by the Free Software Foundation.
   8  *
   9  * This program is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
  12  * more details.
  13  *
  14  * You should have received a copy of the GNU General Public License along with
  15  * this program; if not, write to the Free Software Foundation, Inc.,
  16  * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
  17  *
  18  *
  19  ******************************************************************************/
  20 #include <drv_types.h>
  21 #include <rtl8723a_hal.h>
  22
  23
  24 #ifdef bEnable
  25 #undef bEnable
  26 #endif
  27
  28 //#define BT_DEBUG
  29
  30 #define CHECK_BT_EXIST_FROM_REG
  31 #define DIS_PS_RX_BCN
  32 //#define BTCOEX_DECREASE_WIFI_POWER
  33 //#define BTCOEX_CMCC_TEST
  34
  35 #ifdef CONFIG_BT_COEXIST
  36 #ifdef PLATFORM_LINUX
  37
  38 u32 BTCoexDbgLevel = _bt_dbg_off_;
  39
  40 #define RTPRINT(_Comp, _Level, Fmt)\
  41 do {\
  42         if((BTCoexDbgLevel ==_bt_dbg_on_)) {\
  43 /*              printk("%s", DRIVER_PREFIX);*/\
  44                 printk Fmt;\
  45         }\
  46 }while(0)
  47
  48 #define RTPRINT_ADDR(dbgtype, dbgflag, printstr, _Ptr)\
  49 if((BTCoexDbgLevel ==_bt_dbg_on_) ){\
  50         u32 __i;                                                \
  51         u8 *ptr = (u8*)_Ptr;    \
  52         printk printstr;                                \
  53         printk(" ");                                    \
  54         for( __i=0; __i<6; __i++ )              \
  55                 printk("%02X%s", ptr[__i], (__i==5)?"":"-");            \
  56         printk("\n");                                                   \
  57 }
  58 #define RTPRINT_DATA(dbgtype, dbgflag, _TitleString, _HexData, _HexDataLen)\
  59 if((BTCoexDbgLevel ==_bt_dbg_on_) ){\
  60         u32 __i;                                                                        \
  61         u8 *ptr = (u8*)_HexData;                        \
  62         printk(_TitleString);                                   \
  63         for( __i=0; __i<(u32)_HexDataLen; __i++ )       \
  64         {                                                                               \
  65                 printk("%02X%s", ptr[__i], (((__i + 1) % 4) == 0)?"  ":" ");\
  66                 if (((__i + 1) % 16) == 0)      printk("\n");\
  67         }                                                                               \
  68         printk("\n");                                                   \
  69 }
  70 // Added by Annie, 2005-11-22.
  71 #define MAX_STR_LEN     64
  72 #define PRINTABLE(_ch)  (_ch>=' ' &&_ch<='~')   // I want to see ASCII 33 to 126 only. Otherwise, I print '?'. Annie, 2005-11-22.
  73 #define RT_PRINT_STR(_Comp, _Level, _TitleString, _Ptr, _Len)                                   \
  74 {\
  75 /*      if (((_Comp) & GlobalDebugComponents) && (_Level <= GlobalDebugLevel))  */\
  76         {                                                                       \
  77                 u32 __i;                                                \
  78                 u8 buffer[MAX_STR_LEN];                                 \
  79                 u32     length = (_Len<MAX_STR_LEN)? _Len : (MAX_STR_LEN-1) ;   \
  80                 _rtw_memset(buffer, 0, MAX_STR_LEN);                    \
  81                 _rtw_memcpy(buffer, (u8*)_Ptr, length);         \
  82                 for (__i=0; __i<length; __i++)                                  \
  83                 {                                                               \
  84                         if (!PRINTABLE(buffer[__i]))    buffer[__i] = '?';      \
  85                 }                                                               \
  86                 buffer[length] = '\0';                                          \
  87 /*              printk("Rtl819x: ");*/                                          \
  88                 printk(_TitleString);                                           \
  89                 printk(": %d, <%s>\n", _Len, buffer);                           \
  90         }\
  91 }
  92 #endif // PLATFORM_LINUX
  93
  94 #else // !BT_DEBUG
  95
  96 #define RTPRINT(...)
  97 #define RTPRINT_ADDR(...)
  98 #define RTPRINT_DATA(...)
  99 #define RT_PRINT_STR(...)
 100
 101 #endif // !BT_DEBUG
 102
 103 #define DCMD_Printf(...)
 104 #define RT_ASSERT(...)
 105
 106 #ifdef PLATFORM_LINUX
 107 #define rsprintf snprintf
 108 #elif defined(PLATFORM_WINDOWS)
 109 #define rsprintf sprintf_s
 110 #endif
 111
 112
 113
 114 #define GetDefaultAdapter(padapter)     padapter
 115
 116 #define PlatformZeroMemory(ptr, sz)     _rtw_memset(ptr, 0, sz)
 117
 118 #ifdef PLATFORM_LINUX
 119 #define PlatformProcessHCICommands(...)
 120 #define PlatformTxBTQueuedPackets(...)
 121 #define PlatformIndicateBTACLData(...)  (RT_STATUS_SUCCESS)
 122 #endif
 123 #define PlatformAcquireSpinLock(padapter, type)
 124 #define PlatformReleaseSpinLock(padapter, type)
 125
 126 // timer
 127 #define PlatformInitializeTimer(padapter, ptimer, pfunc, cntx, szID) \
 128         _init_timer(ptimer, padapter->pnetdev, pfunc, padapter)
 129 #define PlatformSetTimer(a, ptimer, delay)      _set_timer(ptimer, delay)
 130 static u8 PlatformCancelTimer(PADAPTER a, _timer *ptimer)
 131 {
 132         u8 bcancelled;
 133         _cancel_timer(ptimer, &bcancelled);
 134         return bcancelled;
 135 }
 136 #define PlatformReleaseTimer(...)
 137
 138 // workitem
 139 // already define in hal/OUTSRC/odm_interface.h
 140 #define PlatformInitializeWorkItem(padapter, pwi, pfunc, cntx, szID) \
 141         _init_workitem(pwi, pfunc, padapter)
 142 #define PlatformFreeWorkItem(...)
 143 #define PlatformScheduleWorkItem(pwork) _set_workitem(pwork)
 144 #define GET_UNDECORATED_AVERAGE_RSSI(padapter)  \
 145                         (GET_HAL_DATA(padapter)->dmpriv.EntryMinUndecoratedSmoothedPWDB)
 146 #define RT_RF_CHANGE_SOURCE u32
 147
 148 typedef enum _RT_JOIN_ACTION{
 149         RT_JOIN_INFRA   = 1,
 150         RT_JOIN_IBSS  = 2,
 151         RT_START_IBSS = 3,
 152         RT_NO_ACTION  = 4,
 153 } RT_JOIN_ACTION;
 154
 155 // power saving
 156 #ifdef CONFIG_IPS
 157 #define IPSReturn(padapter, b)          ips_enter(padapter)
 158 #define IPSDisable(padapter, b, c)      ips_leave(padapter)
 159 #else
 160 #define IPSReturn(...)
 161 #define IPSDisable(...)
 162 #endif
 163 #ifdef CONFIG_LPS
 164 #define LeisurePSLeave(padapter, b)     LPS_Leave(padapter)
 165 #else
 166 #define LeisurePSLeave(...)
 167 #endif
 168
 169 #ifdef __BT_C__ // COMMOM/BT.c
 170 // ===== Below this line is sync from SD7 driver COMMOM/BT.c =====
 171
 172 u8 BT_Operation(PADAPTER padapter)
 173 {
 174         PBT30Info       pBTInfo = GET_BT_INFO(padapter);
 175         PBT_MGNT        pBtMgnt = &pBTInfo->BtMgnt;
 176
 177         if (pBtMgnt->BtOperationOn)
 178                 return _TRUE;
 179         else
 180                 return _FALSE;
 181 }
 182
 183 u8 BT_IsLegalChannel(PADAPTER padapter, u8 channel)
 184 {
 185         PRT_CHANNEL_INFO pChanneList = NULL;
 186         u8 channelLen, i;
 187
 188
 189         pChanneList = padapter->mlmeextpriv.channel_set;
 190         channelLen = padapter->mlmeextpriv.max_chan_nums;
 191
 192         for (i = 0; i < channelLen; i++)
 193         {
 194                 RTPRINT(FIOCTL, IOCTL_STATE, ("Check if chnl(%d) in channel plan contains bt target chnl(%d) for BT connection\n", pChanneList[i].ChannelNum, channel));
 195                 if ((channel == pChanneList[i].ChannelNum) ||
 196                         (channel == pChanneList[i].ChannelNum + 2))
 197                 {
 198                         return channel;
 199                 }
 200         }
 201         return 0;
 202 }
 203
 204 void BT_SignalCompensation(PADAPTER padapter, u8 *rssi_wifi, u8 *rssi_bt)
 205 {
 206         BTDM_SignalCompensation(padapter, rssi_wifi, rssi_bt);
 207 }
 208
 209 void BT_WifiScanNotify(PADAPTER padapter, u8 scanType)
 210 {
 211         BTHCI_WifiScanNotify(padapter, scanType);
 212         BTDM_CheckAntSelMode(padapter);
 213         BTDM_WifiScanNotify(padapter, scanType);
 214 }
 215
 216 void BT_WifiAssociateNotify(PADAPTER padapter, u8 action)
 217 {
 218         // action :
 219         // TRUE = associate start
 220         // FALSE = associate finished
 221         if (action)
 222                 BTDM_CheckAntSelMode(padapter);
 223
 224         BTDM_WifiAssociateNotify(padapter, action);
 225 }
 226
 227 void BT_WifiMediaStatusNotify(PADAPTER padapter, RT_MEDIA_STATUS mstatus)
 228 {
 229         BTDM_MediaStatusNotify(padapter, mstatus);
 230 }
 231
 232 void BT_SpecialPacketNotify(PADAPTER padapter)
 233 {
 234         BTDM_ForDhcp(padapter);
 235 }
 236
 237 void BT_HaltProcess(PADAPTER padapter)
 238 {
 239         BTDM_ForHalt(padapter);
 240 }
 241
 242 void BT_LpsLeave(PADAPTER padapter)
 243 {
 244         BTDM_LpsLeave(padapter);
 245 }
 246
 247 // ===== End of sync from SD7 driver COMMOM/BT.c =====
 248 #endif
 249
 250 #ifdef __BT_HANDLEPACKET_C__ // COMMOM/bt_handlepacket.c
 251 // ===== Below this line is sync from SD7 driver COMMOM/bt_handlepacket.c =====
 252
 253 void btpkt_SendBeacon(PADAPTER padapter)
 254 {
 255 }
 256
 257 void BTPKT_WPAAuthINITIALIZE(PADAPTER padapter, u8 EntryNum)
 258 {
 259 }
 260
 261 void BTPKT_TimerCallbackWPAAuth(PRT_TIMER pTimer)
 262 {
 263 }
 264
 265 void BTPKT_TimerCallbackBeacon(PRT_TIMER pTimer)
 266 {
 267         PADAPTER        padapter = (PADAPTER)pTimer;
 268         PBT30Info               pBTinfo = GET_BT_INFO(padapter);
 269         PBT_MGNT                pBtMgnt = &pBTinfo->BtMgnt;
 270
 271         RTPRINT(FIOCTL, IOCTL_CALLBACK_FUN, ("=====> BTPKT_TimerCallbackBeacon\n"));
 272
 273         if (!pBTinfo->BTBeaconTmrOn)
 274                 return;
 275
 276         if (pBtMgnt->BtOperationOn)
 277         {
 278                 RTPRINT(FIOCTL, IOCTL_CALLBACK_FUN, ("btpkt_SendBeacon\n"));
 279                 btpkt_SendBeacon(GetDefaultAdapter(padapter));
 280                 PlatformSetTimer(padapter, &pBTinfo->BTBeaconTimer, 100);
 281         }
 282         else
 283         {
 284                 RTPRINT(FIOCTL, IOCTL_CALLBACK_FUN, ("<===== BTPKT_TimerCallbackBeacon\n"));
 285         }
 286 }
 287
 288
 289 // ===== End of sync from SD7 driver COMMOM/bt_handlepacket.c =====
 290 #endif
 291
 292 #ifdef __BT_HCI_C__ // COMMOM/bt_hci.c
 293
 294 #define i64fmt          "ll"
 295 #define UINT64_C(v)  (v)
 296
 297 #define FillOctetString(_os,_octet,_len)                \
 298         (_os).Octet=(u8*)(_octet);                      \
 299         (_os).Length=(_len);
 300
 301 static RT_STATUS PlatformIndicateBTEvent(
 302         PADAPTER                                        padapter,
 303         void                                            *pEvntData,
 304         u32                                             dataLen
 305         )
 306 {
 307         RT_STATUS       rt_status = RT_STATUS_FAILURE;
 308 #ifdef PLATFORM_WINDOWS
 309         NTSTATUS        nt_status = STATUS_SUCCESS;
 310         PIRP            pIrp = NULL;
 311         u32                     BytesTransferred = 0;
 312 #endif
 313
 314         RTPRINT(FIOCTL, IOCTL_BT_EVENT_DETAIL, ("BT event start, %d bytes data to Transferred!!\n", dataLen));
 315         RTPRINT_DATA(FIOCTL, IOCTL_BT_EVENT_DETAIL, "To transfer Hex Data :\n",
 316                 pEvntData, dataLen);
 317
 318 //      if (pGBTDeviceExtension==NULL || pGBTDeviceExtension->padapter!=padapter)
 319 //              return rt_status;
 320
 321         BT_EventParse(padapter, pEvntData, dataLen);
 322
 323 #ifdef PLATFORM_LINUX
 324
 325         printk(KERN_WARNING "%s: Linux has no way to report BT event!!\n", __FUNCTION__);
 326
 327 #elif defined(PLATFORM_WINDOWS)
 328
 329         pIrp = IOCTL_BtIrpDequeue(pGBTDeviceExtension, IRP_HCI_EVENT_Q);
 330
 331         if(pIrp)
 332         {
 333                 PVOID   outbuf;
 334                 ULONG   outlen;
 335                 ULONG   offset;
 336
 337                 outbuf = MmGetSystemAddressForMdlSafe(pIrp->MdlAddress, HighPagePriority);
 338                 if(outbuf == NULL)
 339                 {
 340                         RTPRINT(FIOCTL, IOCTL_IRP, ("PlatformIndicateBTEvent(), error!! MdlAddress = NULL!!\n"));
 341                         BytesTransferred = 0;
 342                         nt_status = STATUS_UNSUCCESSFUL;
 343                 }
 344                 else
 345                 {
 346                         outlen = MmGetMdlByteCount(pIrp->MdlAddress);
 347                         offset = MmGetMdlByteOffset(pIrp->MdlAddress);
 348
 349                         if(dataLen <= outlen)
 350                                 BytesTransferred = dataLen;
 351                         else
 352                                 BytesTransferred = outlen;
 353                         _rtw_memcpy(outbuf, pEvntData, BytesTransferred);
 354                         nt_status = STATUS_SUCCESS;
 355                 }
 356                 RTPRINT(FIOCTL, IOCTL_BT_EVENT_DETAIL, ("BT event, %d bytes data Transferred!!\n", BytesTransferred));
 357                 RTPRINT_DATA(FIOCTL, (IOCTL_BT_EVENT_DETAIL|IOCTL_BT_LOGO), "BT EVENT Hex Data :\n",
 358                         outbuf, BytesTransferred);
 359
 360                 IOCTL_CompleteSingleIRP(pIrp, nt_status, BytesTransferred);
 361                 if (nt_status == STATUS_SUCCESS)
 362                         rt_status = RT_STATUS_SUCCESS;
 363         }
 364
 365 #endif // PLATFORM_WINDOWS
 366
 367         RTPRINT(FIOCTL, IOCTL_BT_EVENT_DETAIL, ("BT event end, %s\n",
 368                 (rt_status == RT_STATUS_SUCCESS)? "SUCCESS":"FAIL"));
 369
 370         return rt_status;
 371 }
 372
 373 // ===== Below this line is sync from SD7 driver COMMOM/bt_hci.c =====
 374
 375 u8      testPMK[PMK_LEN] = {2,2,3,3,4,4,5,5,6,6,
 376                                                         7,7,8,8,9,9,2,2,3,3,
 377                                                         4,4,2,2,8,8,9,9,2,2,
 378                                                         5,5};
 379
 380 static u8 bthci_GetLocalChannel(PADAPTER padapter)
 381 {
 382         return padapter->mlmeextpriv.cur_channel;
 383 }
 384
 385 static u8 bthci_GetCurrentEntryNum(PADAPTER padapter, u8 PhyHandle)
 386 {
 387         PBT30Info pBTInfo = GET_BT_INFO(padapter);
 388         u8 i;
 389
 390         for (i = 0; i < MAX_BT_ASOC_ENTRY_NUM; i++)
 391         {
 392                 if ((pBTInfo->BtAsocEntry[i].bUsed == _TRUE) && (pBTInfo->BtAsocEntry[i].PhyLinkCmdData.BtPhyLinkhandle == PhyHandle))
 393                 {
 394                         return i;
 395                 }
 396         }
 397
 398         return 0xFF;
 399 }
 400
 401 static void bthci_DecideBTChannel(PADAPTER padapter, u8 EntryNum)
 402 {
 403 //      PMGNT_INFO pMgntInfo = &padapter->MgntInfo;
 404         struct mlme_priv *pmlmepriv;
 405         PBT30Info pBTInfo;
 406         PBT_MGNT pBtMgnt;
 407         PBT_HCI_INFO pBtHciInfo;
 408         PCHNL_TXPOWER_TRIPLE pTriple_subband = NULL;
 409         PCOMMON_TRIPLE pTriple;
 410         u8 i, j, localchnl, firstRemoteLegalChnlInTriplet=0, regulatory_skipLen=0;
 411         u8 subbandTripletCnt = 0;
 412
 413
 414         pmlmepriv = &padapter->mlmepriv;
 415         pBTInfo = GET_BT_INFO(padapter);
 416         pBtMgnt = &pBTInfo->BtMgnt;
 417         pBtHciInfo = &pBTInfo->BtHciInfo;
 418
 419         pBtMgnt->CheckChnlIsSuit = _TRUE;
 420         localchnl = bthci_GetLocalChannel(padapter);
 421
 422         {
 423                 pTriple = (PCOMMON_TRIPLE)&(pBtHciInfo->BTPreChnllist[COUNTRY_STR_LEN]);
 424
 425                 // contains country string, len is 3
 426                 for (i = 0; i < (pBtHciInfo->BtPreChnlListLen-COUNTRY_STR_LEN); i+=3, pTriple++)
 427                 {
 428                         //
 429                         // check every triplet, an triplet may be
 430                         // regulatory extension identifier or sub-band triplet
 431                         //
 432                         if (pTriple->byte_1st == 0xc9)  // Regulatory Extension Identifier, skip it
 433                         {
 434                                 RTPRINT(FIOCTL, (IOCTL_BT_HCICMD|IOCTL_BT_LOGO), ("Find Regulatory ID, regulatory class = %d\n", pTriple->byte_2nd));
 435                                 regulatory_skipLen += 3;
 436                                 pTriple_subband = NULL;
 437                                 continue;
 438                         }
 439                         else                                                    // Sub-band triplet
 440                         {
 441                                 RTPRINT(FIOCTL, (IOCTL_BT_HCICMD|IOCTL_BT_LOGO), ("Find Sub-band triplet \n"));
 442                                 subbandTripletCnt++;
 443                                 pTriple_subband = (PCHNL_TXPOWER_TRIPLE)pTriple;
 444                                 //
 445                                 // if remote first legal channel not found, then find first remote channel
 446                                 // and it's legal for our channel plan.
 447                                 //
 448
 449                                 // search the sub-band triplet and find if remote channel is legal to our channel plan.
 450                                 for (j = pTriple_subband->FirstChnl; j < (pTriple_subband->FirstChnl+pTriple_subband->NumChnls); j++)
 451                                 {
 452                                         RTPRINT(FIOCTL, (IOCTL_BT_HCICMD|IOCTL_BT_LOGO), (" Check if chnl(%d) is legal\n", j));
 453                                         if (BT_IsLegalChannel(padapter, j))     // remote channel is legal for our channel plan.
 454                                         {
 455                                                 firstRemoteLegalChnlInTriplet = j;
 456                                                 RTPRINT(FIOCTL, (IOCTL_BT_HCICMD|IOCTL_BT_LOGO), ("Find first remote legal channel : %d\n", firstRemoteLegalChnlInTriplet));
 457
 458                                                 //
 459                                                 // If we find a remote legal channel in the sub-band triplet
 460                                                 // and only BT connection is established(local not connect to any AP or IBSS),
 461                                                 // then we just switch channel to remote channel.
 462                                                 //
 463                                                 {
 464                                                         if (!(check_fwstate(pmlmepriv, WIFI_ASOC_STATE|WIFI_ADHOC_STATE|WIFI_AP_STATE) == _TRUE ||
 465                                                                 BTHCI_HsConnectionEstablished(padapter)))
 466                                                         {
 467                                                                 pBtMgnt->BTChannel = firstRemoteLegalChnlInTriplet;
 468                                                                 RTPRINT(FIOCTL, (IOCTL_BT_HCICMD|IOCTL_BT_LOGO), ("Remote legal channel (%d) is selected, Local not connect to any!!\n", pBtMgnt->BTChannel));
 469                                                                 return;
 470                                                         }
 471                                                         else
 472                                                         {
 473                                                                 if ((localchnl >= firstRemoteLegalChnlInTriplet) &&
 474                                                                         (localchnl < (pTriple_subband->FirstChnl+pTriple_subband->NumChnls)))
 475                                                                 {
 476                                                                         pBtMgnt->BTChannel = localchnl;
 477                                                                         RTPRINT(FIOCTL, (IOCTL_BT_HCICMD|IOCTL_BT_LOGO), ("Local channel (%d) is selected, wifi or BT connection exists\n", pBtMgnt->BTChannel));
 478                                                                         return;
 479                                                                 }
 480                                                         }
 481                                                 }
 482                                                 break;
 483                                         }
 484                                 }
 485                         }
 486                 }
 487
 488                 if (subbandTripletCnt)
 489                 {
 490                         //if any preferred channel triplet exists
 491                         RTPRINT(FIOCTL, (IOCTL_BT_HCICMD|IOCTL_BT_LOGO), ("There are %d sub band triplet exists, ", subbandTripletCnt));
 492                         if (firstRemoteLegalChnlInTriplet == 0)
 493                         {
 494                                 //no legal channel is found, reject the connection.
 495                                 RTPRINT(FIOCTL, (IOCTL_BT_HCICMD|IOCTL_BT_LOGO), ("no legal channel is found!!\n"));
 496                         }
 497                         else
 498                         {
 499                                 // Remote Legal channel is found but not match to local
 500                                 //(wifi connection exists), so reject the connection.
 501                                 RTPRINT(FIOCTL, (IOCTL_BT_HCICMD|IOCTL_BT_LOGO), ("Remote Legal channel is found but not match to local(wifi connection exists)!!\n"));
 502                         }
 503                         pBtMgnt->CheckChnlIsSuit = _FALSE;
 504                 }
 505                 else
 506                 {
 507                         // There are not any preferred channel triplet exists
 508                         // Use current legal channel as the bt channel.
 509                         RTPRINT(FIOCTL, (IOCTL_BT_HCICMD|IOCTL_BT_LOGO), ("No sub band triplet exists!!\n"));
 510                 }
 511                 pBtMgnt->BTChannel = localchnl;
 512                 RTPRINT(FIOCTL, (IOCTL_BT_HCICMD|IOCTL_BT_LOGO), ("Local channel (%d) is selected!!\n", pBtMgnt->BTChannel));
 513         }
 514 }
 515
 516
 517 //Success:return _TRUE
 518 //Fail:return _FALSE
 519 static u8 bthci_GetAssocInfo(PADAPTER padapter, u8 EntryNum)
 520 {
 521 //      PMGNT_INFO pMgntInfo = &padapter->MgntInfo;
 522         PBT30Info               pBTInfo;
 523         PBT_HCI_INFO    pBtHciInfo;
 524         u8      tempBuf[256];
 525         u8      i = 0;
 526         u8      BaseMemoryShift = 0;
 527         u16     TotalLen = 0;
 528
 529         PAMP_ASSOC_STRUCTURE    pAmpAsoc;
 530
 531
 532         RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("GetAssocInfo start\n"));
 533
 534         pBTInfo = GET_BT_INFO(padapter);
 535         pBtHciInfo = &pBTInfo->BtHciInfo;
 536
 537         if (pBTInfo->BtAsocEntry[EntryNum].AmpAsocCmdData.LenSoFar == 0)
 538         {
 539
 540                 if (pBTInfo->BtAsocEntry[EntryNum].AmpAsocCmdData.AMPAssocRemLen < (MAX_AMP_ASSOC_FRAG_LEN))
 541                         TotalLen = pBTInfo->BtAsocEntry[EntryNum].AmpAsocCmdData.AMPAssocRemLen;
 542                 else if (pBTInfo->BtAsocEntry[EntryNum].AmpAsocCmdData.AMPAssocRemLen == (MAX_AMP_ASSOC_FRAG_LEN))
 543                         TotalLen = MAX_AMP_ASSOC_FRAG_LEN;
 544         }
 545         else if (pBTInfo->BtAsocEntry[EntryNum].AmpAsocCmdData.LenSoFar > 0)
 546                 TotalLen = pBTInfo->BtAsocEntry[EntryNum].AmpAsocCmdData.LenSoFar;
 547
 548         while ((pBTInfo->BtAsocEntry[EntryNum].AmpAsocCmdData.LenSoFar >= BaseMemoryShift) || TotalLen > BaseMemoryShift)
 549         {
 550                 RTPRINT(FIOCTL, IOCTL_BT_HCICMD_DETAIL, ("GetAssocInfo, TotalLen=%d, BaseMemoryShift=%d\n",TotalLen,BaseMemoryShift));
 551                 _rtw_memcpy(tempBuf,
 552                         (u8*)pBTInfo->BtAsocEntry[EntryNum].AmpAsocCmdData.AMPAssocfragment+BaseMemoryShift,
 553                         TotalLen-BaseMemoryShift);
 554                 RTPRINT_DATA(FIOCTL, IOCTL_BT_HCICMD_DETAIL, "GetAssocInfo :\n",
 555                         tempBuf, TotalLen-BaseMemoryShift);
 556
 557                 pAmpAsoc = (PAMP_ASSOC_STRUCTURE)tempBuf;
 558                 pAmpAsoc->Length = EF2Byte(pAmpAsoc->Length);
 559                 BaseMemoryShift += 3 + pAmpAsoc->Length;
 560
 561                 RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("TypeID = 0x%x, ", pAmpAsoc->TypeID));
 562                 RTPRINT_DATA(FIOCTL, IOCTL_BT_HCICMD, "Hex Data: \n", pAmpAsoc->Data, pAmpAsoc->Length);
 563                 switch (pAmpAsoc->TypeID)
 564                 {
 565                         case AMP_MAC_ADDR:
 566                                 {
 567                                         RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("==> AMP_MAC_ADDR\n"));
 568                                         if (pAmpAsoc->Length > 6)
 569                                         {
 570                                                 return _FALSE;
 571                                         }
 572
 573                                         _rtw_memcpy(pBTInfo->BtAsocEntry[EntryNum].BTRemoteMACAddr, pAmpAsoc->Data,6);
 574                                         RTPRINT_ADDR(FIOCTL, IOCTL_BT_HCICMD, ("Remote Mac address \n"), pBTInfo->BtAsocEntry[EntryNum].BTRemoteMACAddr);
 575                                         break;
 576                                 }
 577
 578                         case AMP_PREFERRED_CHANNEL_LIST:
 579                                 {
 580                                         RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("==> AMP_PREFERRED_CHANNEL_LIST\n"));
 581                                         pBtHciInfo->BtPreChnlListLen=pAmpAsoc->Length;
 582                                         _rtw_memcpy(pBtHciInfo->BTPreChnllist,
 583                                                 pAmpAsoc->Data,
 584                                                 pBtHciInfo->BtPreChnlListLen);
 585                                         RTPRINT_DATA(FIOCTL, IOCTL_BT_HCICMD, "Preferred channel list : \n", pBtHciInfo->BTPreChnllist, pBtHciInfo->BtPreChnlListLen);
 586                                         bthci_DecideBTChannel(padapter,EntryNum);
 587                                         break;
 588                                 }
 589
 590                         case AMP_CONNECTED_CHANNEL:
 591                                 {
 592                                         RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("==> AMP_CONNECTED_CHANNEL\n"));
 593                                         pBtHciInfo->BTConnectChnlListLen=pAmpAsoc->Length;
 594                                         _rtw_memcpy(pBtHciInfo->BTConnectChnllist,
 595                                                 pAmpAsoc->Data,
 596                                                 pBtHciInfo->BTConnectChnlListLen);
 597                                         break;
 598
 599                                 }
 600
 601                         case AMP_80211_PAL_CAP_LIST:
 602                                 {
 603
 604                                         RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("==> AMP_80211_PAL_CAP_LIST\n"));
 605                                         pBTInfo->BtAsocEntry[EntryNum].BTCapability=*(u32 *)(pAmpAsoc->Data);
 606                                         if (pBTInfo->BtAsocEntry[EntryNum].BTCapability && 0x00000001)
 607                                         {
 608                                                 // TODO:
 609
 610                                                 //Signifies PAL capable of utilizing received activity reports.
 611                                         }
 612                                         if (pBTInfo->BtAsocEntry[EntryNum].BTCapability && 0x00000002)
 613                                         {
 614                                                 // TODO:
 615                                                 //Signifies PAL is capable of utilizing scheduling information received in an activity reports.
 616                                         }
 617                                         break;
 618                                 }
 619
 620                         case AMP_80211_PAL_VISION:
 621                                 {
 622                                         pBtHciInfo->BTPalVersion=*(u8 *)(pAmpAsoc->Data);
 623                                         pBtHciInfo->BTPalCompanyID=*(u16 *)(((u8 *)(pAmpAsoc->Data))+1);
 624                                         pBtHciInfo->BTPalsubversion=*(u16 *)(((u8 *)(pAmpAsoc->Data))+3);
 625                                         RTPRINT(FIOCTL, (IOCTL_BT_HCICMD|IOCTL_BT_LOGO), ("==> AMP_80211_PAL_VISION PalVersion  0x%x, PalCompanyID  0x%x, Palsubversion 0x%x\n",
 626                                         pBtHciInfo->BTPalVersion,
 627                                         pBtHciInfo->BTPalCompanyID,
 628                                         pBtHciInfo->BTPalsubversion));
 629                                         break;
 630                                 }
 631
 632                         default:
 633                                         RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("==> Unsupport TypeID !!\n"));
 634                                 break;
 635                 }
 636                 i++;
 637         }
 638         RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("GetAssocInfo end\n"));
 639
 640         return _TRUE;
 641 }
 642
 643 static u8 bthci_AddEntry(PADAPTER padapter)
 644 {
 645         PBT30Info               pBTInfo;
 646         PBT_MGNT                pBtMgnt;
 647         u8                      i;
 648
 649
 650         pBTInfo = GET_BT_INFO(padapter);
 651         pBtMgnt = &pBTInfo->BtMgnt;
 652
 653         for (i = 0; i < MAX_BT_ASOC_ENTRY_NUM; i++)
 654         {
 655                 if (pBTInfo->BtAsocEntry[i].bUsed == _FALSE)
 656                 {
 657                         pBTInfo->BtAsocEntry[i].bUsed = _TRUE;
 658                         pBtMgnt->CurrentConnectEntryNum = i;
 659                         break;
 660                 }
 661         }
 662
 663         if (i == MAX_BT_ASOC_ENTRY_NUM)
 664         {
 665                 RTPRINT(FIOCTL, IOCTL_STATE, ("bthci_AddEntry(), Add entry fail!!\n"));
 666                 return _FALSE;
 667         }
 668         return _TRUE;
 669 }
 670
 671 static u8 bthci_DiscardTxPackets(PADAPTER padapter, u16 LLH)
 672 {
 673         return _FALSE;
 674 }
 675
 676 static u8
 677 bthci_CheckLogLinkBehavior(
 678         PADAPTER                                        padapter,
 679         HCI_FLOW_SPEC                   TxFlowSpec
 680         )
 681 {
 682         u8      ID = TxFlowSpec.Identifier;
 683         u8      ServiceType = TxFlowSpec.ServiceType;
 684         u16     MaxSDUSize = TxFlowSpec.MaximumSDUSize;
 685         u32     SDUInterArrivatime = TxFlowSpec.SDUInterArrivalTime;
 686         u8      match = _FALSE;
 687
 688         switch (ID)
 689         {
 690                 case 1:
 691                 {
 692                         if (ServiceType == BT_LL_BE)
 693                         {
 694                                 match = _TRUE;
 695                                 RTPRINT(FIOCTL, (IOCTL_BT_EVENT|IOCTL_BT_LOGO), ("Logical Link Type =  TX best effort flowspec\n"));
 696                         }
 697                         else if ((ServiceType == BT_LL_GU) && (MaxSDUSize == 0xffff))
 698                         {
 699                                 match = _TRUE;
 700                                 RTPRINT(FIOCTL, (IOCTL_BT_EVENT|IOCTL_BT_LOGO), ("Logical Link Type =  RX guaranteed latency flowspec\n"));
 701                         }
 702                         else if ((ServiceType == BT_LL_GU) && (MaxSDUSize == 2500))
 703                         {
 704                                 RTPRINT(FIOCTL, (IOCTL_BT_EVENT|IOCTL_BT_LOGO), ("Logical Link Type =  RX guaranteed Large latency flowspec\n"));
 705                         }
 706                         break;
 707                 }
 708                 case 2:
 709                 {
 710                         if (ServiceType == BT_LL_BE)
 711                         {
 712                                 match = _TRUE;
 713                                 RTPRINT(FIOCTL, (IOCTL_BT_EVENT|IOCTL_BT_LOGO), ("Logical Link Type =  RX best effort flowspec\n"));
 714
 715                         }
 716                         break;
 717                 }
 718                 case 3:
 719                 {
 720                          if ((ServiceType == BT_LL_GU) && (MaxSDUSize == 1492))
 721                         {
 722                                 match=_TRUE;
 723                                 RTPRINT(FIOCTL, (IOCTL_BT_EVENT|IOCTL_BT_LOGO), ("Logical Link Type =  TX guaranteed latency flowspec\n"));
 724                         }
 725                         else if ((ServiceType==BT_LL_GU) && (MaxSDUSize==2500))
 726                         {
 727                                 RTPRINT(FIOCTL, (IOCTL_BT_EVENT|IOCTL_BT_LOGO), ("Logical Link Type =  TX guaranteed Large latency flowspec\n"));
 728                         }
 729                         break;
 730                 }
 731                 case 4:
 732                 {
 733                         if (ServiceType == BT_LL_BE)
 734                         {
 735                                 if ((SDUInterArrivatime == 0xffffffff) && (ServiceType == BT_LL_BE) && (MaxSDUSize == 1492))
 736                                 {
 737                                         match = _TRUE;
 738                                         RTPRINT(FIOCTL, (IOCTL_BT_EVENT|IOCTL_BT_LOGO), ("Logical Link Type =  TX/RX aggregated best effort flowspec\n"));
 739                                 }
 740                         }
 741                         else if (ServiceType == BT_LL_GU)
 742                         {
 743                                 if ((SDUInterArrivatime == 100) && 10000)
 744                                 {
 745                                         match = _TRUE;
 746                                         RTPRINT(FIOCTL, (IOCTL_BT_EVENT|IOCTL_BT_LOGO), ("Logical Link Type =  TX/RX guaranteed bandwidth flowspec\n"));
 747                                 }
 748                         }
 749                         break;
 750                 }
 751                 default:
 752                 {
 753                         RTPRINT(FIOCTL, (IOCTL_BT_EVENT|IOCTL_BT_LOGO), ("Logical Link Type =  Unknow Type !!!!!!!!\n"));
 754                         break;
 755                 }
 756         }
 757
 758         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",
 759         TxFlowSpec.Identifier, TxFlowSpec.ServiceType, MaxSDUSize, SDUInterArrivatime, TxFlowSpec.AccessLatency, TxFlowSpec.FlushTimeout));
 760         return match;
 761 }
 762
 763 static void
 764 bthci_SelectFlowType(
 765         PADAPTER                                        padapter,
 766         BT_LL_FLOWSPEC                  TxLLFlowSpec,
 767         BT_LL_FLOWSPEC                  RxLLFlowSpec,
 768         PHCI_FLOW_SPEC          TxFlowSpec,
 769         PHCI_FLOW_SPEC          RxFlowSpec
 770         )
 771 {
 772         switch (TxLLFlowSpec)
 773         {
 774                 case BT_TX_BE_FS:
 775                 {
 776                         TxFlowSpec->Identifier = 0x1;
 777                         TxFlowSpec->ServiceType = BT_LL_BE;
 778                         TxFlowSpec->MaximumSDUSize = 0xffff;
 779                         TxFlowSpec->SDUInterArrivalTime = 0xffffffff;
 780                         TxFlowSpec->AccessLatency = 0xffffffff;
 781                         TxFlowSpec->FlushTimeout = 0xffffffff;
 782                         break;
 783                 }
 784                 case BT_RX_BE_FS:
 785                 {
 786                         RxFlowSpec->Identifier = 0x2;
 787                         RxFlowSpec->ServiceType = BT_LL_BE;
 788                         RxFlowSpec->MaximumSDUSize = 0xffff;
 789                         RxFlowSpec->SDUInterArrivalTime = 0xffffffff;
 790                         RxFlowSpec->AccessLatency = 0xffffffff;
 791                         RxFlowSpec->FlushTimeout = 0xffffffff;
 792                         break;
 793                 }
 794                 case BT_TX_GU_FS:
 795                 {
 796                         TxFlowSpec->Identifier = 0x3;
 797                         TxFlowSpec->ServiceType = BT_LL_GU;
 798                         TxFlowSpec->MaximumSDUSize = 1492;
 799                         TxFlowSpec->SDUInterArrivalTime = 0xffffffff;
 800                         TxFlowSpec->AccessLatency = 10000;
 801                         TxFlowSpec->FlushTimeout = 10000;
 802                         break;
 803                 }
 804                 case BT_RX_GU_FS:
 805                 {
 806                         RxFlowSpec->Identifier = 0x1;
 807                         RxFlowSpec->ServiceType = BT_LL_GU;
 808                         RxFlowSpec->MaximumSDUSize = 0xffff;
 809                         RxFlowSpec->SDUInterArrivalTime = 0xffffffff;
 810                         RxFlowSpec->AccessLatency = 10000;
 811                         RxFlowSpec->FlushTimeout = 10000;
 812                         break;
 813                 }
 814                 case BT_TX_BE_AGG_FS:
 815                 {
 816                         TxFlowSpec->Identifier = 0x4;
 817                         TxFlowSpec->ServiceType = BT_LL_BE;
 818                         TxFlowSpec->MaximumSDUSize = 1492;
 819                         TxFlowSpec->SDUInterArrivalTime = 0xffffffff;
 820                         TxFlowSpec->AccessLatency = 0xffffffff;
 821                         TxFlowSpec->FlushTimeout = 0xffffffff;
 822                         break;
 823                 }
 824                 case BT_RX_BE_AGG_FS:
 825                 {
 826                         RxFlowSpec->Identifier = 0x4;
 827                         RxFlowSpec->ServiceType = BT_LL_BE;
 828                         RxFlowSpec->MaximumSDUSize = 1492;
 829                         RxFlowSpec->SDUInterArrivalTime = 0xffffffff;
 830                         RxFlowSpec->AccessLatency = 0xffffffff;
 831                         RxFlowSpec->FlushTimeout = 0xffffffff;
 832                         break;
 833                 }
 834                 case BT_TX_GU_BW_FS:
 835                 {
 836                         TxFlowSpec->Identifier = 0x4;
 837                         TxFlowSpec->ServiceType = BT_LL_GU;
 838                         TxFlowSpec->MaximumSDUSize = 1492;
 839                         TxFlowSpec->SDUInterArrivalTime = 100;
 840                         TxFlowSpec->AccessLatency = 0xffffffff;
 841                         TxFlowSpec->FlushTimeout = 0xffffffff;
 842                         break;
 843                 }
 844                 case BT_RX_GU_BW_FS:
 845                 {
 846                         RxFlowSpec->Identifier = 0x4;
 847                         RxFlowSpec->ServiceType = BT_LL_GU;
 848                         RxFlowSpec->MaximumSDUSize = 1492;
 849                         RxFlowSpec->SDUInterArrivalTime = 100;
 850                         RxFlowSpec->AccessLatency = 0xffffffff;
 851                         RxFlowSpec->FlushTimeout = 0xffffffff;
 852                         break;
 853                 }
 854                 case BT_TX_GU_LARGE_FS:
 855                 {
 856                         TxFlowSpec->Identifier = 0x3;
 857                         TxFlowSpec->ServiceType = BT_LL_GU;
 858                         TxFlowSpec->MaximumSDUSize = 2500;
 859                         TxFlowSpec->SDUInterArrivalTime = 0x1;
 860                         TxFlowSpec->AccessLatency = 10000;
 861                         TxFlowSpec->FlushTimeout = 10000;
 862                         break;
 863                 }
 864                 case BT_RX_GU_LARGE_FS:
 865                 {
 866                         RxFlowSpec->Identifier = 0x1;
 867                         RxFlowSpec->ServiceType = BT_LL_GU;
 868                         RxFlowSpec->MaximumSDUSize = 2500;
 869                         RxFlowSpec->SDUInterArrivalTime = 0x1;
 870                         RxFlowSpec->AccessLatency = 10000;
 871                         RxFlowSpec->FlushTimeout = 10000;
 872                         break;
 873                 }
 874                 default:
 875                         break;
 876         }
 877
 878         switch (RxLLFlowSpec)
 879         {
 880                 case BT_TX_BE_FS:
 881                 {
 882                         TxFlowSpec->Identifier = 0x1;
 883                         TxFlowSpec->ServiceType = BT_LL_BE;
 884                         TxFlowSpec->MaximumSDUSize = 0xffff;
 885                         TxFlowSpec->SDUInterArrivalTime = 0xffffffff;
 886                         TxFlowSpec->AccessLatency = 0xffffffff;
 887                         TxFlowSpec->FlushTimeout = 0xffffffff;
 888                         break;
 889                 }
 890                 case BT_RX_BE_FS:
 891                 {
 892                         RxFlowSpec->Identifier = 0x2;
 893                         RxFlowSpec->ServiceType = BT_LL_BE;
 894                         RxFlowSpec->MaximumSDUSize = 0xffff;
 895                         RxFlowSpec->SDUInterArrivalTime = 0xffffffff;
 896                         RxFlowSpec->AccessLatency = 0xffffffff;
 897                         RxFlowSpec->FlushTimeout = 0xffffffff;
 898                         break;
 899                 }
 900                 case BT_TX_GU_FS:
 901                 {
 902                         TxFlowSpec->Identifier = 0x3;
 903                         TxFlowSpec->ServiceType = BT_LL_GU;
 904                         TxFlowSpec->MaximumSDUSize = 1492;
 905                         TxFlowSpec->SDUInterArrivalTime = 0xffffffff;
 906                         TxFlowSpec->AccessLatency = 10000;
 907                         TxFlowSpec->FlushTimeout = 10000;
 908                         break;
 909                 }
 910                 case BT_RX_GU_FS:
 911                 {
 912                         RxFlowSpec->Identifier = 0x1;
 913                         RxFlowSpec->ServiceType = BT_LL_GU;
 914                         RxFlowSpec->MaximumSDUSize = 0xffff;
 915                         RxFlowSpec->SDUInterArrivalTime = 0xffffffff;
 916                         RxFlowSpec->AccessLatency = 10000;
 917                         RxFlowSpec->FlushTimeout = 10000;
 918                         break;
 919                 }
 920                 case BT_TX_BE_AGG_FS:
 921                 {
 922                         TxFlowSpec->Identifier = 0x4;
 923                         TxFlowSpec->ServiceType = BT_LL_BE;
 924                         TxFlowSpec->MaximumSDUSize = 1492;
 925                         TxFlowSpec->SDUInterArrivalTime = 0xffffffff;
 926                         TxFlowSpec->AccessLatency = 0xffffffff;
 927                         TxFlowSpec->FlushTimeout = 0xffffffff;
 928                         break;
 929                 }
 930                 case BT_RX_BE_AGG_FS:
 931                 {
 932                         RxFlowSpec->Identifier = 0x4;
 933                         RxFlowSpec->ServiceType = BT_LL_BE;
 934                         RxFlowSpec->MaximumSDUSize = 1492;
 935                         RxFlowSpec->SDUInterArrivalTime = 0xffffffff;
 936                         RxFlowSpec->AccessLatency = 0xffffffff;
 937                         RxFlowSpec->FlushTimeout = 0xffffffff;
 938                         break;
 939                 }
 940                 case BT_TX_GU_BW_FS:
 941                 {
 942                         TxFlowSpec->Identifier = 0x4;
 943                         TxFlowSpec->ServiceType = BT_LL_GU;
 944                         TxFlowSpec->MaximumSDUSize = 1492;
 945                         TxFlowSpec->SDUInterArrivalTime = 100;
 946                         TxFlowSpec->AccessLatency = 0xffffffff;
 947                         TxFlowSpec->FlushTimeout = 0xffffffff;
 948                         break;
 949                 }
 950                 case BT_RX_GU_BW_FS:
 951                 {
 952                         RxFlowSpec->Identifier = 0x4;
 953                         RxFlowSpec->ServiceType = BT_LL_GU;
 954                         RxFlowSpec->MaximumSDUSize = 1492;
 955                         RxFlowSpec->SDUInterArrivalTime = 100;
 956                         RxFlowSpec->AccessLatency = 0xffffffff;
 957                         RxFlowSpec->FlushTimeout = 0xffffffff;
 958                         break;
 959                 }
 960                 case BT_TX_GU_LARGE_FS:
 961                 {
 962                         TxFlowSpec->Identifier = 0x3;
 963                         TxFlowSpec->ServiceType = BT_LL_GU;
 964                         TxFlowSpec->MaximumSDUSize = 2500;
 965                         TxFlowSpec->SDUInterArrivalTime = 0x1;
 966                         TxFlowSpec->AccessLatency = 10000;
 967                         TxFlowSpec->FlushTimeout = 10000;
 968                         break;
 969                 }
 970                 case BT_RX_GU_LARGE_FS:
 971                 {
 972                         RxFlowSpec->Identifier = 0x1;
 973                         RxFlowSpec->ServiceType = BT_LL_GU;
 974                         RxFlowSpec->MaximumSDUSize = 2500;
 975                         RxFlowSpec->SDUInterArrivalTime = 0x1;
 976                         RxFlowSpec->AccessLatency = 10000;
 977                         RxFlowSpec->FlushTimeout = 10000;
 978                         break;
 979                 }
 980                 default:
 981                         break;
 982         }
 983 }
 984
 985 static u16
 986 bthci_AssocMACAddr(
 987         PADAPTER        padapter,
 988         void    *pbuf
 989         )
 990 {
 991         PAMP_ASSOC_STRUCTURE pAssoStrc = (PAMP_ASSOC_STRUCTURE)pbuf;
 992 /*
 993         u8      FakeAddress[6],i;
 994
 995         for (i=0;i<6;i++)
 996         {
 997                 FakeAddress[i]=i;
 998         }
 999 */
1000         pAssoStrc->TypeID = AMP_MAC_ADDR;
1001         pAssoStrc->Length = 0x06;
1002         //      _rtw_memcpy(&pAssoStrc->Data[0], Adapter->CurrentAddress, 6);
1003         _rtw_memcpy(&pAssoStrc->Data[0], padapter->eeprompriv.mac_addr, 6);
1004         //_rtw_memcpy(&pAssoStrc->Data[0], FakeAddress, 6);
1005         RTPRINT_DATA(FIOCTL, (IOCTL_BT_HCICMD|IOCTL_BT_HCICMD_DETAIL|IOCTL_BT_LOGO), ("AssocMACAddr : \n"), pAssoStrc, pAssoStrc->Length+3);
1006
1007         return (pAssoStrc->Length+3);
1008 }
1009
1010 static u16
1011 bthci_PALCapabilities(
1012         PADAPTER        padapter,
1013         void    *pbuf
1014         )
1015 {
1016         PAMP_ASSOC_STRUCTURE pAssoStrc = (PAMP_ASSOC_STRUCTURE)pbuf;
1017
1018         pAssoStrc->TypeID = AMP_80211_PAL_CAP_LIST;
1019         pAssoStrc->Length = 0x04;
1020
1021         pAssoStrc->Data[0] = 0x00;
1022         pAssoStrc->Data[1] = 0x00;
1023
1024         RTPRINT_DATA(FIOCTL, IOCTL_BT_HCICMD_DETAIL, ("PALCapabilities : \n"), pAssoStrc, pAssoStrc->Length+3);
1025         RTPRINT(FIOCTL, IOCTL_BT_LOGO, ("PALCapabilities \n"));
1026
1027         RTPRINT(FIOCTL, IOCTL_BT_LOGO, (" TypeID = 0x%x,\n Length = 0x%x,\n Content =0x0000\n",
1028                 pAssoStrc->TypeID,
1029                 pAssoStrc->Length));
1030
1031         return (pAssoStrc->Length+3);
1032 }
1033
1034 static u16
1035 bthci_AssocPreferredChannelList(
1036         PADAPTER                padapter,
1037         void    *pbuf,
1038         u8              EntryNum
1039         )
1040 {
1041         PBT30Info                               pBTInfo;
1042         PAMP_ASSOC_STRUCTURE    pAssoStrc;
1043         PAMP_PREF_CHNL_REGULATORY pReg;
1044         PCHNL_TXPOWER_TRIPLE pTripleIE, pTriple;
1045         char    ctrString[3] = {'X', 'X', 'X'};
1046         u32     len = 0;
1047         u8      i=0, NumTriples=0, preferredChnl;
1048
1049
1050         pBTInfo = GET_BT_INFO(padapter);
1051 //      pDot11dInfo = GET_DOT11D_INFO(pMgntInfo);
1052         pAssoStrc = (PAMP_ASSOC_STRUCTURE)pbuf;
1053         pReg = (PAMP_PREF_CHNL_REGULATORY)&pAssoStrc->Data[3];
1054
1055         preferredChnl = bthci_GetLocalChannel(padapter);
1056         pAssoStrc->TypeID = AMP_PREFERRED_CHANNEL_LIST;
1057         {
1058                 // locale unknown
1059                 _rtw_memcpy(&pAssoStrc->Data[0], &ctrString[0], 3);
1060                 pReg->reXId = 201;
1061                 pReg->regulatoryClass = 254;
1062                 pReg->coverageClass = 0;
1063                 len += 6;
1064                 RTPRINT(FIOCTL, (IOCTL_BT_HCICMD | IOCTL_BT_LOGO), ("PREFERRED_CHNL_LIST\n"));
1065                 RTPRINT(FIOCTL, (IOCTL_BT_HCICMD | IOCTL_BT_LOGO), ("XXX, 201,254,0\n"));
1066                 // at the following, chnl 1~11 should be contained
1067                 pTriple = (PCHNL_TXPOWER_TRIPLE)&pAssoStrc->Data[len];
1068
1069                 // (1) if any wifi or bt HS connection exists
1070                 if ((pBTInfo->BtAsocEntry[EntryNum].AMPRole == AMP_BTAP_CREATOR) ||
1071 #if 0
1072                         pMgntInfo->mAssoc ||
1073                         pMgntInfo->mIbss ||
1074                         IsExtAPModeExist(padapter)) ||
1075 #else
1076                         (check_fwstate(&padapter->mlmepriv, WIFI_ASOC_STATE|WIFI_ADHOC_STATE|WIFI_ADHOC_MASTER_STATE|WIFI_AP_STATE) == _TRUE) ||
1077 #endif
1078                         BTHCI_HsConnectionEstablished(padapter))
1079                 {
1080                         pTriple->FirstChnl = preferredChnl;
1081                         pTriple->NumChnls = 1;
1082                         pTriple->MaxTxPowerInDbm = 20;
1083                         len += 3;
1084                         RTPRINT(FIOCTL, (IOCTL_BT_HCICMD | IOCTL_BT_LOGO), ("First Channel = %d, Channel Num = %d, MaxDbm = %d\n",
1085                                 pTriple->FirstChnl,
1086                                 pTriple->NumChnls,
1087                                 pTriple->MaxTxPowerInDbm));
1088
1089                         //pTriple = (PCHNL_TXPOWER_TRIPLE)((u8*)pTriple + 3);
1090                 }
1091         }
1092         pAssoStrc->Length = (u16)len;
1093         RTPRINT_DATA(FIOCTL, IOCTL_BT_HCICMD, ("AssocPreferredChannelList : \n"), pAssoStrc, pAssoStrc->Length+3);
1094
1095         return (pAssoStrc->Length+3);
1096 }
1097
1098 static u16 bthci_AssocPALVer(PADAPTER padapter, void *pbuf)
1099 {
1100         PAMP_ASSOC_STRUCTURE pAssoStrc = (PAMP_ASSOC_STRUCTURE)pbuf;
1101         u8 *pu1Tmp;
1102         u16     *pu2Tmp;
1103
1104         pAssoStrc->TypeID = AMP_80211_PAL_VISION;
1105         pAssoStrc->Length = 0x5;
1106         pu1Tmp = &pAssoStrc->Data[0];
1107         *pu1Tmp = 0x1;  // PAL Version
1108         pu2Tmp = (u16*)&pAssoStrc->Data[1];
1109         *pu2Tmp = 0x5D; // SIG Company identifier of 802.11 PAL vendor
1110         pu2Tmp = (u16*)&pAssoStrc->Data[3];
1111         *pu2Tmp = 0x1;  // PAL Sub-version specifier
1112
1113         RTPRINT_DATA(FIOCTL, IOCTL_BT_HCICMD_DETAIL, ("AssocPALVer : \n"), pAssoStrc, pAssoStrc->Length+3);
1114         RTPRINT(FIOCTL, IOCTL_BT_LOGO, ("AssocPALVer \n"));
1115
1116         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",
1117                 pAssoStrc->TypeID,
1118                 pAssoStrc->Length));
1119         return (pAssoStrc->Length+3);
1120 }
1121
1122 static u16
1123 bthci_ReservedForTestingPLV(
1124         PADAPTER        padapter,
1125         void    *pbuf
1126         )
1127 {
1128         PAMP_ASSOC_STRUCTURE pAssoStrc = (PAMP_ASSOC_STRUCTURE)pbuf;
1129
1130         pAssoStrc->TypeID = AMP_RESERVED_FOR_TESTING;
1131         pAssoStrc->Length = 0x10;
1132
1133         pAssoStrc->Data[0] = 0x00;
1134         pAssoStrc->Data[1] = 0x01;
1135         pAssoStrc->Data[2] = 0x02;
1136         pAssoStrc->Data[3] = 0x03;
1137         pAssoStrc->Data[4] = 0x04;
1138         pAssoStrc->Data[5] = 0x05;
1139         pAssoStrc->Data[6] = 0x06;
1140         pAssoStrc->Data[7] = 0x07;
1141         pAssoStrc->Data[8] = 0x08;
1142         pAssoStrc->Data[9] = 0x09;
1143         pAssoStrc->Data[10] = 0x0a;
1144         pAssoStrc->Data[11] = 0x0b;
1145         pAssoStrc->Data[12] = 0x0c;
1146         pAssoStrc->Data[13] = 0x0d;
1147         pAssoStrc->Data[14] = 0x0e;
1148         pAssoStrc->Data[15] = 0x0f;
1149
1150         return (pAssoStrc->Length+3);
1151 }
1152
1153 static u8 bthci_CheckRfStateBeforeConnect(PADAPTER padapter)
1154 {
1155         PBT30Info                               pBTInfo;
1156         rt_rf_power_state               RfState;
1157
1158
1159         pBTInfo = GET_BT_INFO(padapter);
1160
1161 //      rtw_hal_get_hwreg(padapter, HW_VAR_RF_STATE, (u8*)(&RfState));
1162         RfState = padapter->pwrctrlpriv.rf_pwrstate;
1163
1164         if (RfState != rf_on)
1165         {
1166                 PlatformSetTimer(padapter, &pBTInfo->BTPsDisableTimer, 50);
1167                 return _FALSE;
1168         }
1169
1170         return _TRUE;
1171 }
1172
1173 static u8
1174 bthci_ConstructScanList(
1175         PBT30Info               pBTInfo,
1176         u8                      *pChannels,
1177         u8                      *pNChannels,
1178         PRT_SCAN_TYPE   pScanType,
1179         u16                     *pDuration
1180         )
1181 {
1182         PADAPTER                                padapter;
1183         PBT_HCI_INFO                            pBtHciInfo;
1184         PCHNL_TXPOWER_TRIPLE    pTriple_subband;
1185         PCOMMON_TRIPLE                  pTriple;
1186         u8                                      chnl, i, j, tripleLetsCnt=0;
1187
1188
1189         padapter = pBTInfo->padapter;
1190         pBtHciInfo = &pBTInfo->BtHciInfo;
1191         *pNChannels = 0;
1192         *pScanType = SCAN_ACTIVE;
1193         *pDuration = 200;
1194
1195         pTriple = (PCOMMON_TRIPLE)&(pBtHciInfo->BTPreChnllist[COUNTRY_STR_LEN]);
1196
1197         // contains country string, len is 3
1198         for (i = 0; i < (pBtHciInfo->BtPreChnlListLen-COUNTRY_STR_LEN); i+=3, pTriple++)
1199         {
1200                 if (pTriple->byte_1st == 0xc9)  // Regulatory Extension Identifier, skip it
1201                         continue;
1202                 else                                                    // Sub-band triplet
1203                 {
1204                         tripleLetsCnt++;
1205                         pTriple_subband = (PCHNL_TXPOWER_TRIPLE)pTriple;
1206
1207                         // search the sub-band triplet and find if remote channel is legal to our channel plan.
1208                         for (chnl = pTriple_subband->FirstChnl; chnl < (pTriple_subband->FirstChnl+pTriple_subband->NumChnls); chnl++)
1209                         {
1210                                 if (BT_IsLegalChannel(padapter, chnl))  // remote channel is legal for our channel plan.
1211                                 {
1212                                         //DbgPrint("cosa insert chnl(%d) into scan list\n", chnl);
1213                                         pChannels[*pNChannels] = chnl;
1214                                         (*pNChannels)++;
1215                                 }
1216                         }
1217                 }
1218         }
1219
1220         if (tripleLetsCnt == 0)
1221         {
1222                 // Fill chnl 1~ chnl 11
1223                 for (chnl=1; chnl<12; chnl++)
1224                 {
1225                         //DbgPrint("cosa insert chnl(%d) into scan list\n", chnl);
1226                         pChannels[*pNChannels] = chnl;
1227                         (*pNChannels)++;
1228                 }
1229         }
1230
1231         if (*pNChannels == 0)
1232                 return _FALSE;
1233         else
1234                 return _TRUE;
1235 }
1236
1237 static void bthci_ResponderStartToScan(PADAPTER padapter)
1238 {
1239 }
1240
1241 static u8
1242 bthci_PhyLinkConnectionInProgress(
1243         PADAPTER        padapter,
1244         u8              PhyLinkHandle
1245         )
1246 {
1247         PBT30Info       pBTInfo;
1248         PBT_MGNT        pBtMgnt;
1249
1250
1251         pBTInfo = GET_BT_INFO(padapter);
1252         pBtMgnt = &pBTInfo->BtMgnt;
1253
1254         if (pBtMgnt->bPhyLinkInProgress &&
1255                 (pBtMgnt->BtCurrentPhyLinkhandle == PhyLinkHandle))
1256         {
1257                 return _TRUE;
1258         }
1259         return _FALSE;
1260 }
1261
1262 static void
1263 bthci_ResetFlowSpec(
1264         PADAPTER        padapter,
1265         u8      EntryNum,
1266         u8      index
1267         )
1268 {
1269         PBT30Info       pBTinfo;
1270
1271
1272         pBTinfo = GET_BT_INFO(padapter);
1273
1274         pBTinfo->BtAsocEntry[EntryNum].LogLinkCmdData[index].BtLogLinkhandle = 0;
1275         pBTinfo->BtAsocEntry[EntryNum].LogLinkCmdData[index].BtPhyLinkhandle = 0;
1276         pBTinfo->BtAsocEntry[EntryNum].LogLinkCmdData[index].bLLCompleteEventIsSet = _FALSE;
1277         pBTinfo->BtAsocEntry[EntryNum].LogLinkCmdData[index].bLLCancelCMDIsSetandComplete = _FALSE;
1278         pBTinfo->BtAsocEntry[EntryNum].LogLinkCmdData[index].BtTxFlowSpecID = 0;
1279         pBTinfo->BtAsocEntry[EntryNum].LogLinkCmdData[index].TxPacketCount = 0;
1280
1281         pBTinfo->BtAsocEntry[EntryNum].LogLinkCmdData[index].Tx_Flow_Spec.Identifier = 0x01;
1282         pBTinfo->BtAsocEntry[EntryNum].LogLinkCmdData[index].Tx_Flow_Spec.ServiceType = SERVICE_BEST_EFFORT;
1283         pBTinfo->BtAsocEntry[EntryNum].LogLinkCmdData[index].Tx_Flow_Spec.MaximumSDUSize = 0xffff;
1284         pBTinfo->BtAsocEntry[EntryNum].LogLinkCmdData[index].Tx_Flow_Spec.SDUInterArrivalTime = 0xffffffff;
1285         pBTinfo->BtAsocEntry[EntryNum].LogLinkCmdData[index].Tx_Flow_Spec.AccessLatency = 0xffffffff;
1286         pBTinfo->BtAsocEntry[EntryNum].LogLinkCmdData[index].Tx_Flow_Spec.FlushTimeout = 0xffffffff;
1287
1288         pBTinfo->BtAsocEntry[EntryNum].LogLinkCmdData[index].Rx_Flow_Spec.Identifier = 0x01;
1289         pBTinfo->BtAsocEntry[EntryNum].LogLinkCmdData[index].Rx_Flow_Spec.ServiceType = SERVICE_BEST_EFFORT;
1290         pBTinfo->BtAsocEntry[EntryNum].LogLinkCmdData[index].Rx_Flow_Spec.MaximumSDUSize = 0xffff;
1291         pBTinfo->BtAsocEntry[EntryNum].LogLinkCmdData[index].Rx_Flow_Spec.SDUInterArrivalTime = 0xffffffff;
1292         pBTinfo->BtAsocEntry[EntryNum].LogLinkCmdData[index].Rx_Flow_Spec.AccessLatency = 0xffffffff;
1293         pBTinfo->BtAsocEntry[EntryNum].LogLinkCmdData[index].Rx_Flow_Spec.FlushTimeout = 0xffffffff;
1294 }
1295
1296 static void bthci_ResetEntry(PADAPTER padapter, u8 EntryNum)
1297 {
1298         PBT30Info               pBTinfo;
1299         PBT_MGNT                pBtMgnt;
1300         u8      j;
1301
1302
1303         pBTinfo = GET_BT_INFO(padapter);
1304         pBtMgnt = &pBTinfo->BtMgnt;
1305
1306         pBTinfo->BtAsocEntry[EntryNum].bUsed=_FALSE;
1307         pBTinfo->BtAsocEntry[EntryNum].BtCurrentState=HCI_STATE_DISCONNECTED;
1308         pBTinfo->BtAsocEntry[EntryNum].BtNextState=HCI_STATE_DISCONNECTED;
1309
1310         pBTinfo->BtAsocEntry[EntryNum].AmpAsocCmdData.AMPAssocRemLen=0;
1311         pBTinfo->BtAsocEntry[EntryNum].AmpAsocCmdData.BtPhyLinkhandle = 0;
1312         if (pBTinfo->BtAsocEntry[EntryNum].AmpAsocCmdData.AMPAssocfragment != NULL)
1313         {
1314                 _rtw_memset(pBTinfo->BtAsocEntry[EntryNum].AmpAsocCmdData.AMPAssocfragment, 0, TOTAL_ALLOCIATE_ASSOC_LEN);
1315         }
1316         pBTinfo->BtAsocEntry[EntryNum].AmpAsocCmdData.LenSoFar=0;
1317
1318         pBTinfo->BtAsocEntry[EntryNum].PhyLinkCmdData.BtAMPKeyType = 0;
1319         pBTinfo->BtAsocEntry[EntryNum].PhyLinkCmdData.BtPhyLinkhandle = 0;
1320         _rtw_memset(pBTinfo->BtAsocEntry[EntryNum].PhyLinkCmdData.BtAMPKey, 0, pBTinfo->BtAsocEntry[EntryNum].PhyLinkCmdData.BtAMPKeyLen);
1321         pBTinfo->BtAsocEntry[EntryNum].PhyLinkCmdData.BtAMPKeyLen=0;
1322
1323         pBTinfo->BtAsocEntry[EntryNum].PhyLinkCmdData.LinkSuperversionTimeout=0x3e80;//0x640; //0.625ms*1600=1000ms, 0.625ms*16000=10000ms
1324
1325         pBTinfo->BtAsocEntry[EntryNum].AMPRole = AMP_BTAP_NONE;
1326
1327         pBTinfo->BtAsocEntry[EntryNum].mAssoc=_FALSE;
1328         pBTinfo->BtAsocEntry[EntryNum].b4waySuccess = _FALSE;
1329
1330         // Reset BT WPA
1331         pBTinfo->BtAsocEntry[EntryNum].KeyReplayCounter = 0;
1332         pBTinfo->BtAsocEntry[EntryNum].BTWPAAuthState = STATE_WPA_AUTH_UNINITIALIZED;
1333
1334         pBTinfo->BtAsocEntry[EntryNum].bSendSupervisionPacket=_FALSE;
1335         pBTinfo->BtAsocEntry[EntryNum].NoRxPktCnt=0;
1336         pBTinfo->BtAsocEntry[EntryNum].ShortRangeMode = 0;
1337         pBTinfo->BtAsocEntry[EntryNum].rxSuvpPktCnt = 0;
1338
1339         for (j=0; j<MAX_LOGICAL_LINK_NUM; j++)
1340         {
1341                 bthci_ResetFlowSpec(padapter, EntryNum, j);
1342         }
1343
1344         pBtMgnt->BTAuthCount = 0;
1345         pBtMgnt->BTAsocCount = 0;
1346         pBtMgnt->BTCurrentConnectType = BT_DISCONNECT;
1347         pBtMgnt->BTReceiveConnectPkt = BT_DISCONNECT;
1348
1349         HALBT_RemoveKey(padapter, EntryNum);
1350 }
1351
1352 static void
1353 bthci_RemoveEntryByEntryNum(
1354         PADAPTER        padapter,
1355         u8              EntryNum
1356         )
1357 {
1358         PBT30Info               pBTInfo = GET_BT_INFO(padapter);
1359         PBT_MGNT                pBtMgnt = &pBTInfo->BtMgnt;
1360
1361         bthci_ResetEntry(padapter, EntryNum);
1362
1363         if (pBtMgnt->CurrentBTConnectionCnt>0)
1364                 pBtMgnt->CurrentBTConnectionCnt--;
1365
1366         RTPRINT(FIOCTL, IOCTL_STATE, ("[BT Flag], CurrentBTConnectionCnt = %d!!\n",
1367                 pBtMgnt->CurrentBTConnectionCnt));
1368
1369         if (pBtMgnt->CurrentBTConnectionCnt > 0)
1370                 pBtMgnt->BtOperationOn = _TRUE;
1371         else
1372         {
1373                 pBtMgnt->BtOperationOn = _FALSE;
1374                 RTPRINT(FIOCTL, IOCTL_STATE, ("[BT Flag], Bt Operation OFF!!\n"));
1375         }
1376
1377         if (pBtMgnt->BtOperationOn == _FALSE)
1378         {
1379                 PlatformCancelTimer(padapter, &pBTInfo->BTSupervisionPktTimer);
1380 #if (SENDTXMEHTOD == 0)
1381                 PlatformCancelTimer(padapter, &pBTInfo->BTHCISendAclDataTimer);
1382 #endif
1383                 PlatformCancelTimer(padapter, &pBTInfo->BTHCIDiscardAclDataTimer);
1384                 PlatformCancelTimer(padapter, &pBTInfo->BTBeaconTimer);
1385                 pBtMgnt->bStartSendSupervisionPkt = _FALSE;
1386 #if (RTS_CTS_NO_LEN_LIMIT == 1)
1387                 rtw_write32(padapter, 0x4c8, 0xc140402);
1388 #endif
1389         }
1390 }
1391
1392 static u8
1393 bthci_CommandCompleteHeader(
1394         u8              *pbuf,
1395         u16             OGF,
1396         u16             OCF,
1397         HCI_STATUS      status
1398         )
1399 {
1400         PPACKET_IRP_HCIEVENT_DATA PPacketIrpEvent = (PPACKET_IRP_HCIEVENT_DATA)pbuf;
1401         u8      NumHCI_Comm = 0x1;
1402
1403
1404         PPacketIrpEvent->EventCode = HCI_EVENT_COMMAND_COMPLETE;
1405         PPacketIrpEvent->Data[0] = NumHCI_Comm; //packet #
1406         PPacketIrpEvent->Data[1] = HCIOPCODELOW(OCF, OGF);
1407         PPacketIrpEvent->Data[2] = HCIOPCODEHIGHT(OCF, OGF);
1408
1409         if (OGF == OGF_EXTENSION)
1410         {
1411                 if (OCF == HCI_SET_RSSI_VALUE)
1412                 {
1413                         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",
1414                                 NumHCI_Comm,(HCIOPCODEHIGHT(OCF, OGF)), (HCIOPCODELOW(OCF, OGF)), status, OGF, OCF));
1415                 }
1416                 else
1417                 {
1418                         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",
1419                                 NumHCI_Comm,(HCIOPCODEHIGHT(OCF, OGF)), (HCIOPCODELOW(OCF, OGF)), status, OGF, OCF));
1420                 }
1421         }
1422         else
1423         {
1424                 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",
1425                         NumHCI_Comm,(HCIOPCODEHIGHT(OCF, OGF)), (HCIOPCODELOW(OCF, OGF)), status, OGF, OCF));
1426         }
1427         return 3;
1428 }
1429
1430 static u8 bthci_ExtensionEventHeader(u8 *pbuf, u8 extensionEvent)
1431 {
1432         PPACKET_IRP_HCIEVENT_DATA PPacketIrpEvent = (PPACKET_IRP_HCIEVENT_DATA)pbuf;
1433         PPacketIrpEvent->EventCode = HCI_EVENT_EXTENSION_MOTO;
1434         PPacketIrpEvent->Data[0] = extensionEvent;      //extension event code
1435
1436         return 1;
1437 }
1438
1439 static u8 bthci_ExtensionEventHeaderRtk(u8 *pbuf, u8 extensionEvent)
1440 {
1441         PPACKET_IRP_HCIEVENT_DATA PPacketIrpEvent = (PPACKET_IRP_HCIEVENT_DATA)pbuf;
1442         PPacketIrpEvent->EventCode = HCI_EVENT_EXTENSION_RTK;
1443         PPacketIrpEvent->Data[0] = extensionEvent;      //extension event code
1444
1445         return 1;
1446 }
1447
1448 static RT_STATUS
1449 bthci_IndicateEvent(
1450         PADAPTER        padapter,
1451         void            *pEvntData,
1452         u32             dataLen
1453         )
1454 {
1455         RT_STATUS       rt_status;
1456
1457         rt_status = PlatformIndicateBTEvent(padapter, pEvntData, dataLen);
1458
1459         return rt_status;
1460 }
1461
1462 static void
1463 bthci_EventWriteRemoteAmpAssoc(
1464         PADAPTER        padapter,
1465         HCI_STATUS      status,
1466         u8              PLHandle
1467         )
1468 {
1469         u8 localBuf[TmpLocalBufSize] = "";
1470         u8 *pRetPar;
1471         u8 len = 0;
1472         PPACKET_IRP_HCIEVENT_DATA PPacketIrpEvent;
1473
1474         PlatformZeroMemory(&localBuf[0], TmpLocalBufSize);
1475         PPacketIrpEvent = (PPACKET_IRP_HCIEVENT_DATA)(&localBuf[0]);
1476
1477         len += bthci_CommandCompleteHeader(&localBuf[0],
1478                 OGF_STATUS_PARAMETERS,
1479                 HCI_WRITE_REMOTE_AMP_ASSOC,
1480                 status);
1481         RTPRINT(FIOCTL, (IOCTL_BT_HCICMD|IOCTL_BT_LOGO), ("PhyLinkHandle = 0x%x, status = %d\n", PLHandle, status));
1482         // Return parameters starts from here
1483         pRetPar = &PPacketIrpEvent->Data[len];
1484         pRetPar[0] = status;            //status
1485         pRetPar[1] = PLHandle;
1486         len += 2;
1487         PPacketIrpEvent->Length = len;
1488
1489         bthci_IndicateEvent(padapter, PPacketIrpEvent, len+2);
1490 }
1491
1492 static void
1493 bthci_EventEnhancedFlushComplete(
1494         PADAPTER                                        padapter,
1495         u16                                     LLH
1496         )
1497 {
1498         u8      localBuf[4] = "";
1499         PPACKET_IRP_HCIEVENT_DATA PPacketIrpEvent;
1500         RTPRINT(FIOCTL, IOCTL_BT_EVENT, ("EventEnhancedFlushComplete, LLH = 0x%x\n", LLH));
1501
1502         PPacketIrpEvent = (PPACKET_IRP_HCIEVENT_DATA)(&localBuf[0]);
1503         PPacketIrpEvent->EventCode=HCI_EVENT_ENHANCED_FLUSH_COMPLETE;
1504         PPacketIrpEvent->Length=2;
1505         //Logical link handle
1506         PPacketIrpEvent->Data[0] = TWOBYTE_LOWBYTE(LLH);
1507         PPacketIrpEvent->Data[1] = TWOBYTE_HIGHTBYTE(LLH);
1508
1509         bthci_IndicateEvent(padapter, PPacketIrpEvent, 4);
1510 }
1511
1512 static void
1513 bthci_EventShortRangeModeChangeComplete(
1514         PADAPTER                                        padapter,
1515         HCI_STATUS                              HciStatus,
1516         u8                                      ShortRangeState,
1517         u8                                      EntryNum
1518         )
1519 {
1520         PBT30Info               pBTInfo = GET_BT_INFO(padapter);
1521         PBT_HCI_INFO            pBtHciInfo = &pBTInfo->BtHciInfo;
1522         u8      localBuf[5] = "";
1523         PPACKET_IRP_HCIEVENT_DATA PPacketIrpEvent;
1524
1525         if (!(pBtHciInfo->BTEventMaskPage2 & EMP2_HCI_EVENT_SHORT_RANGE_MODE_CHANGE_COMPLETE))
1526         {
1527                 RTPRINT(FIOCTL, IOCTL_BT_EVENT, ("[BT event], Short Range Mode Change Complete, Ignore to send this event due to event mask page 2\n"));
1528                 return;
1529         }
1530         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",
1531                 HciStatus, pBTInfo->BtAsocEntry[EntryNum].PhyLinkCmdData.BtPhyLinkhandle, ShortRangeState));
1532
1533         PPacketIrpEvent = (PPACKET_IRP_HCIEVENT_DATA)(&localBuf[0]);
1534         PPacketIrpEvent->EventCode=HCI_EVENT_SHORT_RANGE_MODE_CHANGE_COMPLETE;
1535         PPacketIrpEvent->Length=3;
1536         PPacketIrpEvent->Data[0] = HciStatus;
1537         PPacketIrpEvent->Data[1] = pBTInfo->BtAsocEntry[EntryNum].PhyLinkCmdData.BtPhyLinkhandle;
1538         PPacketIrpEvent->Data[2] = ShortRangeState;
1539         bthci_IndicateEvent(padapter, PPacketIrpEvent, 5);
1540 }
1541
1542 static void
1543 bthci_EventSendFlowSpecModifyComplete(
1544         PADAPTER                                        padapter,
1545         HCI_STATUS                              HciStatus,
1546         u16                                     logicHandle
1547         )
1548 {
1549         u8      localBuf[5] = "";
1550         PPACKET_IRP_HCIEVENT_DATA PPacketIrpEvent;
1551         PBT30Info               pBTInfo = GET_BT_INFO(padapter);
1552         PBT_HCI_INFO            pBtHciInfo = &pBTInfo->BtHciInfo;
1553
1554         if (!(pBtHciInfo->BTEventMaskPage2 & EMP2_HCI_EVENT_FLOW_SPEC_MODIFY_COMPLETE))
1555         {
1556                 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"));
1557                 return;
1558         }
1559         RTPRINT(FIOCTL, (IOCTL_BT_EVENT|IOCTL_BT_LOGO), ("[BT event], Flow Spec Modify Complete, status = 0x%x, LLH = 0x%x\n",HciStatus,logicHandle));
1560         PPacketIrpEvent = (PPACKET_IRP_HCIEVENT_DATA)(&localBuf[0]);
1561         PPacketIrpEvent->EventCode=HCI_EVENT_FLOW_SPEC_MODIFY_COMPLETE;
1562         PPacketIrpEvent->Length=3;
1563
1564         PPacketIrpEvent->Data[0] = HciStatus;
1565         //Logical link handle
1566         PPacketIrpEvent->Data[1] = TWOBYTE_LOWBYTE(logicHandle);
1567         PPacketIrpEvent->Data[2] = TWOBYTE_HIGHTBYTE(logicHandle);
1568
1569         bthci_IndicateEvent(padapter, PPacketIrpEvent, 5);
1570 }
1571
1572 static void
1573 bthci_EventExtGetBTRSSI(
1574         PADAPTER                                        padapter,
1575         u16                                             ConnectionHandle
1576         )
1577 {
1578         u8 len = 0;
1579         u8      localBuf[7] = "";
1580         u8 *pRetPar;
1581         u16     *pu2Temp;
1582         PPACKET_IRP_HCIEVENT_DATA PPacketIrpEvent;
1583
1584         PPacketIrpEvent = (PPACKET_IRP_HCIEVENT_DATA)(&localBuf[0]);
1585
1586         len += bthci_ExtensionEventHeader(&localBuf[0],
1587                         HCI_EVENT_GET_BT_RSSI);
1588
1589         // Return parameters starts from here
1590         pRetPar = &PPacketIrpEvent->Data[len];
1591         pu2Temp = (u16*)&pRetPar[0];
1592         *pu2Temp = ConnectionHandle;
1593         len += 2;
1594
1595         PPacketIrpEvent->Length = len;
1596         if (bthci_IndicateEvent(padapter, PPacketIrpEvent, len+2) == RT_STATUS_SUCCESS)
1597         {
1598                 RTPRINT(FIOCTL, IOCTL_BT_EVENT_PERIODICAL, ("[BT event], Get BT RSSI, Connection Handle = 0x%x, Extension event code = 0x%x\n",
1599                         ConnectionHandle, HCI_EVENT_GET_BT_RSSI));
1600         }
1601 }
1602
1603 static void
1604 bthci_EventExtWifiScanNotify(
1605         PADAPTER                                        padapter,
1606         u8                                              scanType
1607         )
1608 {
1609         PBT30Info               pBTInfo = GET_BT_INFO(padapter);
1610         PBT_MGNT                pBtMgnt = &pBTInfo->BtMgnt;
1611         u8 len = 0;
1612         u8 localBuf[7] = "";
1613         u8 *pRetPar;
1614         u8 *pu1Temp;
1615         PPACKET_IRP_HCIEVENT_DATA PPacketIrpEvent;
1616
1617         if (!pBtMgnt->BtOperationOn)
1618                 return;
1619
1620         PPacketIrpEvent = (PPACKET_IRP_HCIEVENT_DATA)(&localBuf[0]);
1621
1622         len += bthci_ExtensionEventHeaderRtk(&localBuf[0], HCI_EVENT_EXT_WIFI_SCAN_NOTIFY);
1623
1624         // Return parameters starts from here
1625         pRetPar = &PPacketIrpEvent->Data[len];
1626         pu1Temp = (u8*)&pRetPar[0];
1627         *pu1Temp = scanType;
1628         len += 1;
1629
1630         PPacketIrpEvent->Length = len;
1631
1632         if (bthci_IndicateEvent(padapter, PPacketIrpEvent, len+2) == RT_STATUS_SUCCESS)
1633         {
1634                 RTPRINT(FIOCTL, IOCTL_BT_EVENT, ("[BT event], Wifi scan notify, scan type = %d\n",
1635                         scanType));
1636         }
1637 }
1638
1639
1640 static void
1641 bthci_EventAMPReceiverReport(
1642         PADAPTER        padapter,
1643         u8              Reason
1644         )
1645 {
1646         PBT30Info       pBTInfo = GET_BT_INFO(padapter);
1647         PBT_HCI_INFO    pBtHciInfo = &pBTInfo->BtHciInfo;
1648
1649         if (pBtHciInfo->bTestNeedReport)
1650         {
1651                 u8 localBuf[20] = "";
1652                 u32     *pu4Temp;
1653                 u16     *pu2Temp;
1654                 PPACKET_IRP_HCIEVENT_DATA PPacketIrpEvent;
1655
1656
1657                 RTPRINT(FIOCTL, (IOCTL_BT_EVENT|IOCTL_BT_LOGO), (" HCI_EVENT_AMP_RECEIVER_REPORT \n"));
1658                 PPacketIrpEvent = (PPACKET_IRP_HCIEVENT_DATA)(&localBuf[0]);
1659                 PPacketIrpEvent->EventCode = HCI_EVENT_AMP_RECEIVER_REPORT;
1660                 PPacketIrpEvent->Length = 2;
1661
1662                 PPacketIrpEvent->Data[0] = pBtHciInfo->TestCtrType;
1663
1664                 PPacketIrpEvent->Data[1] =Reason;
1665
1666                 pu4Temp = (u32*)&PPacketIrpEvent->Data[2];
1667                 *pu4Temp = pBtHciInfo->TestEventType;
1668
1669                 pu2Temp = (u16*)&PPacketIrpEvent->Data[6];
1670                 *pu2Temp = pBtHciInfo->TestNumOfFrame;
1671
1672                 pu2Temp = (u16*)&PPacketIrpEvent->Data[8];
1673                 *pu2Temp = pBtHciInfo->TestNumOfErrFrame;
1674
1675                 pu4Temp = (u32*)&PPacketIrpEvent->Data[10];
1676                 *pu4Temp = pBtHciInfo->TestNumOfBits;
1677
1678                 pu4Temp = (u32*)&PPacketIrpEvent->Data[14];
1679                 *pu4Temp = pBtHciInfo->TestNumOfErrBits;
1680
1681                 bthci_IndicateEvent(padapter, PPacketIrpEvent, 20);
1682
1683                 //Return to Idel state with RX and TX off.
1684
1685         }
1686
1687         pBtHciInfo->TestNumOfFrame = 0x00;
1688 }
1689
1690 static void
1691 bthci_EventChannelSelected(
1692         PADAPTER                                padapter,
1693         u8                              EntryNum
1694         )
1695 {
1696         PBT30Info               pBTInfo = GET_BT_INFO(padapter);
1697         PBT_HCI_INFO            pBtHciInfo = &pBTInfo->BtHciInfo;
1698         u8      localBuf[3] = "";
1699         PPACKET_IRP_HCIEVENT_DATA PPacketIrpEvent;
1700
1701         if (!(pBtHciInfo->BTEventMaskPage2 & EMP2_HCI_EVENT_CHANNEL_SELECT))
1702         {
1703                 RTPRINT(FIOCTL, IOCTL_BT_EVENT, ("[BT event], Channel Selected, Ignore to send this event due to event mask page 2\n"));
1704                 return;
1705         }
1706
1707         RTPRINT(FIOCTL, IOCTL_BT_EVENT|IOCTL_STATE, ("[BT event], Channel Selected, PhyLinkHandle %d\n",
1708                 pBTInfo->BtAsocEntry[EntryNum].PhyLinkCmdData.BtPhyLinkhandle));
1709
1710         PPacketIrpEvent = (PPACKET_IRP_HCIEVENT_DATA)(&localBuf[0]);
1711         PPacketIrpEvent->EventCode=HCI_EVENT_CHANNEL_SELECT;
1712         PPacketIrpEvent->Length=1;
1713         PPacketIrpEvent->Data[0] = pBTInfo->BtAsocEntry[EntryNum].PhyLinkCmdData.BtPhyLinkhandle;
1714         bthci_IndicateEvent(padapter, PPacketIrpEvent, 3);
1715 }
1716
1717 static void
1718 bthci_EventDisconnectPhyLinkComplete(
1719         PADAPTER                                        padapter,
1720         HCI_STATUS                              HciStatus,
1721         HCI_STATUS                              Reason,
1722         u8                                      EntryNum
1723         )
1724 {
1725         PBT30Info               pBTInfo = GET_BT_INFO(padapter);
1726         PBT_HCI_INFO            pBtHciInfo = &pBTInfo->BtHciInfo;
1727         u8      localBuf[5] = "";
1728         PPACKET_IRP_HCIEVENT_DATA PPacketIrpEvent;
1729
1730         if (!(pBtHciInfo->BTEventMaskPage2 & EMP2_HCI_EVENT_DISCONNECT_PHY_LINK_COMPLETE))
1731         {
1732                 RTPRINT(FIOCTL, IOCTL_BT_EVENT, ("[BT event], Disconnect Physical Link Complete, Ignore to send this event due to event mask page 2\n"));
1733                 return;
1734         }
1735         RTPRINT(FIOCTL, IOCTL_BT_EVENT, ("[BT event], Disconnect Physical Link Complete, Status = 0x%x, PLH = 0x%x Reason =0x%x\n",
1736                 HciStatus,pBTInfo->BtAsocEntry[EntryNum].PhyLinkCmdData.BtPhyLinkhandle,Reason));
1737         PPacketIrpEvent = (PPACKET_IRP_HCIEVENT_DATA)(&localBuf[0]);
1738         PPacketIrpEvent->EventCode=HCI_EVENT_DISCONNECT_PHY_LINK_COMPLETE;
1739         PPacketIrpEvent->Length=3;
1740         PPacketIrpEvent->Data[0] = HciStatus;
1741         PPacketIrpEvent->Data[1] = pBTInfo->BtAsocEntry[EntryNum].PhyLinkCmdData.BtPhyLinkhandle;
1742         PPacketIrpEvent->Data[2] = Reason;
1743         bthci_IndicateEvent(padapter, PPacketIrpEvent, 5);
1744 }
1745
1746 static void
1747 bthci_EventPhysicalLinkComplete(
1748         PADAPTER                                        padapter,
1749         HCI_STATUS                              HciStatus,
1750         u8                                      EntryNum,
1751         u8                                      PLHandle
1752         )
1753 {
1754         PBT30Info               pBTInfo = GET_BT_INFO(padapter);
1755         PBT_MGNT                pBtMgnt = &pBTInfo->BtMgnt;
1756         PBT_HCI_INFO            pBtHciInfo = &pBTInfo->BtHciInfo;
1757         PBT_DBG                 pBtDbg=&pBTInfo->BtDbg;
1758         u8                      localBuf[4] = "";
1759         PPACKET_IRP_HCIEVENT_DATA PPacketIrpEvent;
1760         u8                      PL_handle;
1761
1762         pBtMgnt->bPhyLinkInProgress = _FALSE;
1763         pBtDbg->dbgHciInfo.hciCmdPhyLinkStatus = HciStatus;
1764         if (!(pBtHciInfo->BTEventMaskPage2 & EMP2_HCI_EVENT_PHY_LINK_COMPLETE))
1765         {
1766                 RTPRINT(FIOCTL, IOCTL_BT_EVENT, ("[BT event], Physical Link Complete, Ignore to send this event due to event mask page 2\n"));
1767                 return;
1768         }
1769
1770         if (EntryNum == 0xff)
1771         {
1772                 // connection not started yet, just use the input physical link handle to response.
1773                 PL_handle = PLHandle;
1774         }
1775         else
1776         {
1777                 // connection is under progress, use the phy link handle we recorded.
1778                 PL_handle  = pBTInfo->BtAsocEntry[EntryNum].PhyLinkCmdData.BtPhyLinkhandle;
1779                 pBTInfo->BtAsocEntry[EntryNum].bNeedPhysLinkCompleteEvent=_FALSE;
1780         }
1781
1782         RTPRINT(FIOCTL, IOCTL_BT_EVENT, ("[BT event], Physical Link Complete, Status = 0x%x PhyLinkHandle = 0x%x\n",HciStatus,
1783                 PL_handle));
1784
1785         PPacketIrpEvent = (PPACKET_IRP_HCIEVENT_DATA)(&localBuf[0]);
1786         PPacketIrpEvent->EventCode=HCI_EVENT_PHY_LINK_COMPLETE;
1787         PPacketIrpEvent->Length=2;
1788
1789         PPacketIrpEvent->Data[0] = HciStatus;
1790         PPacketIrpEvent->Data[1] = PL_handle;
1791         bthci_IndicateEvent(padapter, PPacketIrpEvent, 4);
1792
1793 }
1794
1795 static void
1796 bthci_EventCommandStatus(
1797         PADAPTER                                        padapter,
1798         u8                                      OGF,
1799         u16                                     OCF,
1800         HCI_STATUS                              HciStatus
1801         )
1802 {
1803
1804         u8 localBuf[6] = "";
1805         PPACKET_IRP_HCIEVENT_DATA PPacketIrpEvent;
1806         u8      Num_Hci_Comm = 0x1;
1807         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",
1808                 (HCIOPCODEHIGHT(OCF, OGF)), (HCIOPCODELOW(OCF, OGF)), OGF, OCF, HciStatus,Num_Hci_Comm));
1809
1810         PPacketIrpEvent = (PPACKET_IRP_HCIEVENT_DATA)(&localBuf[0]);
1811         PPacketIrpEvent->EventCode=HCI_EVENT_COMMAND_STATUS;
1812         PPacketIrpEvent->Length=4;
1813         PPacketIrpEvent->Data[0] = HciStatus;   //current pending
1814         PPacketIrpEvent->Data[1] = Num_Hci_Comm;        //packet #
1815         PPacketIrpEvent->Data[2] = HCIOPCODELOW(OCF, OGF);
1816         PPacketIrpEvent->Data[3] = HCIOPCODEHIGHT(OCF, OGF);
1817
1818         bthci_IndicateEvent(padapter, PPacketIrpEvent, 6);
1819
1820 }
1821
1822 static void
1823 bthci_EventLogicalLinkComplete(
1824         PADAPTER                                        padapter,
1825         HCI_STATUS                              HciStatus,
1826         u8                                      PhyLinkHandle,
1827         u16                                     LogLinkHandle,
1828         u8                                      LogLinkIndex,
1829         u8                                      EntryNum
1830         )
1831 {
1832 //      PMGNT_INFO pMgntInfo = &padapter->MgntInfo;
1833         PBT30Info       pBTInfo = GET_BT_INFO(padapter);
1834         PBT_HCI_INFO            pBtHciInfo = &pBTInfo->BtHciInfo;
1835         u8      localBuf[7] = "";
1836         PPACKET_IRP_HCIEVENT_DATA PPacketIrpEvent;
1837
1838         if (!(pBtHciInfo->BTEventMaskPage2 & EMP2_HCI_EVENT_LOGICAL_LINK_COMPLETE))
1839         {
1840                 RTPRINT(FIOCTL, IOCTL_BT_EVENT, ("[BT event], Logical Link Complete, Ignore to send this event due to event mask page 2\n"));
1841                 return;
1842         }
1843         RTPRINT(FIOCTL, IOCTL_BT_EVENT, ("[BT event], Logical Link Complete, PhyLinkHandle = 0x%x,  LogLinkHandle = 0x%x, Status= 0x%x\n",
1844                 PhyLinkHandle, LogLinkHandle, HciStatus));
1845
1846
1847         PPacketIrpEvent = (PPACKET_IRP_HCIEVENT_DATA)(&localBuf[0]);
1848         PPacketIrpEvent->EventCode = HCI_EVENT_LOGICAL_LINK_COMPLETE;
1849         PPacketIrpEvent->Length = 5;
1850
1851         PPacketIrpEvent->Data[0] = HciStatus;//status code
1852         //Logical link handle
1853         PPacketIrpEvent->Data[1] = TWOBYTE_LOWBYTE(LogLinkHandle);
1854         PPacketIrpEvent->Data[2] = TWOBYTE_HIGHTBYTE(LogLinkHandle);
1855         //Physical link handle
1856         PPacketIrpEvent->Data[3] = TWOBYTE_LOWBYTE(PhyLinkHandle);
1857         //corresponding Tx flow spec ID
1858         if (HciStatus == HCI_STATUS_SUCCESS)
1859         {
1860                 PPacketIrpEvent->Data[4] =
1861                         pBTInfo->BtAsocEntry[EntryNum].LogLinkCmdData[LogLinkIndex].Tx_Flow_Spec.Identifier;
1862         }
1863         else
1864                 PPacketIrpEvent->Data[4] = 0x0;
1865
1866         bthci_IndicateEvent(padapter, PPacketIrpEvent, 7);
1867 }
1868
1869 static void
1870 bthci_EventDisconnectLogicalLinkComplete(
1871         PADAPTER                                        padapter,
1872         HCI_STATUS                              HciStatus,
1873         u16                                     LogLinkHandle,
1874         HCI_STATUS                              Reason
1875         )
1876 {
1877         u8 localBuf[6] = "";
1878         PBT30Info               pBTInfo = GET_BT_INFO(padapter);
1879         PBT_HCI_INFO            pBtHciInfo = &pBTInfo->BtHciInfo;
1880         PPACKET_IRP_HCIEVENT_DATA PPacketIrpEvent;
1881
1882         if (!(pBtHciInfo->BTEventMaskPage2 & EMP2_HCI_EVENT_DISCONNECT_LOGICAL_LINK_COMPLETE))
1883         {
1884                 RTPRINT(FIOCTL, IOCTL_BT_EVENT, ("[BT event], Disconnect Logical Link Complete, Ignore to send this event due to event mask page 2\n"));
1885                 return;
1886         }
1887         RTPRINT(FIOCTL, IOCTL_BT_EVENT, ("[BT event], Disconnect Logical Link Complete, Status = 0x%x,LLH = 0x%x Reason =0x%x\n",HciStatus,LogLinkHandle,Reason));
1888
1889         PPacketIrpEvent = (PPACKET_IRP_HCIEVENT_DATA)(&localBuf[0]);
1890         PPacketIrpEvent->EventCode=HCI_EVENT_DISCONNECT_LOGICAL_LINK_COMPLETE;
1891         PPacketIrpEvent->Length=4;
1892
1893         PPacketIrpEvent->Data[0] = HciStatus;
1894         //Logical link handle
1895         PPacketIrpEvent->Data[1] = TWOBYTE_LOWBYTE(LogLinkHandle);
1896         PPacketIrpEvent->Data[2] = TWOBYTE_HIGHTBYTE(LogLinkHandle);
1897         //Disconnect reason
1898         PPacketIrpEvent->Data[3] = Reason;
1899
1900         bthci_IndicateEvent(padapter, PPacketIrpEvent, 6);
1901 }
1902
1903 static void
1904 bthci_EventFlushOccurred(
1905         PADAPTER                                        padapter,
1906         u16                                     LogLinkHandle
1907         )
1908 {
1909         u8      localBuf[4] = "";
1910         PPACKET_IRP_HCIEVENT_DATA PPacketIrpEvent;
1911         RTPRINT(FIOCTL, IOCTL_BT_EVENT, ("bthci_EventFlushOccurred(), LLH = 0x%x\n", LogLinkHandle));
1912
1913         PPacketIrpEvent = (PPACKET_IRP_HCIEVENT_DATA)(&localBuf[0]);
1914         PPacketIrpEvent->EventCode = HCI_EVENT_FLUSH_OCCRUED;
1915         PPacketIrpEvent->Length = 2;
1916         //Logical link handle
1917         PPacketIrpEvent->Data[0] = TWOBYTE_LOWBYTE(LogLinkHandle);
1918         PPacketIrpEvent->Data[1] = TWOBYTE_HIGHTBYTE(LogLinkHandle);
1919
1920         bthci_IndicateEvent(padapter, PPacketIrpEvent, 4);
1921 }
1922
1923 static HCI_STATUS
1924 bthci_BuildPhysicalLink(
1925         PADAPTER                                                padapter,
1926         PPACKET_IRP_HCICMD_DATA         pHciCmd,
1927         u16                                                     OCF
1928 )
1929 {
1930         HCI_STATUS              status = HCI_STATUS_SUCCESS;
1931         PBT30Info               pBTInfo = GET_BT_INFO(padapter);
1932         PBT_MGNT                pBtMgnt = &pBTInfo->BtMgnt;
1933         u8                      EntryNum, PLH;
1934
1935         //Send HCI Command status event to AMP.
1936         bthci_EventCommandStatus(padapter,
1937                         OGF_LINK_CONTROL_COMMANDS,
1938                         OCF,
1939                         HCI_STATUS_SUCCESS);
1940
1941         PLH = *((u8*)pHciCmd->Data);
1942
1943         // Check if resource or bt connection is under progress, if yes, reject the link creation.
1944         if (bthci_AddEntry(padapter) == _FALSE)
1945         {
1946                 status = HCI_STATUS_CONNECT_RJT_LIMIT_RESOURCE;
1947                 bthci_EventPhysicalLinkComplete(padapter, status, INVALID_ENTRY_NUM, PLH);
1948                 return status;
1949         }
1950
1951         EntryNum=pBtMgnt->CurrentConnectEntryNum;
1952         pBTInfo->BtAsocEntry[EntryNum].PhyLinkCmdData.BtPhyLinkhandle = PLH;
1953         pBtMgnt->BtCurrentPhyLinkhandle = PLH;
1954
1955         if (pBTInfo->BtAsocEntry[EntryNum].AmpAsocCmdData.AMPAssocfragment == NULL)
1956         {
1957                 RTPRINT(FIOCTL, (IOCTL_BT_HCICMD|IOCTL_BT_LOGO), ("Create/Accept PhysicalLink, AMP controller is busy\n"));
1958                 status = HCI_STATUS_CONTROLLER_BUSY;
1959                 bthci_EventPhysicalLinkComplete(padapter, status, INVALID_ENTRY_NUM, PLH);
1960                 return status;
1961         }
1962
1963         // Record Key and the info
1964         pBTInfo->BtAsocEntry[EntryNum].PhyLinkCmdData.BtAMPKeyLen=(*((u8*)pHciCmd->Data+1));
1965         pBTInfo->BtAsocEntry[EntryNum].PhyLinkCmdData.BtAMPKeyType=(*((u8*)pHciCmd->Data+2));
1966         _rtw_memcpy(pBTInfo->BtAsocEntry[EntryNum].PhyLinkCmdData.BtAMPKey,
1967                 (((u8*)pHciCmd->Data+3)), pBTInfo->BtAsocEntry[EntryNum].PhyLinkCmdData.BtAMPKeyLen);
1968 #if (LOCAL_PMK == 1)
1969         _rtw_memcpy(pBTInfo->BtAsocEntry[EntryNum].PMK, testPMK, PMK_LEN);
1970 #else
1971         _rtw_memcpy(pBTInfo->BtAsocEntry[EntryNum].PMK, pBTInfo->BtAsocEntry[EntryNum].PhyLinkCmdData.BtAMPKey, PMK_LEN);
1972 #endif
1973         RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("BuildPhysicalLink, EntryNum = %d, PLH = 0x%x  KeyLen = 0x%x, KeyType =0x%x\n",
1974                 EntryNum, pBTInfo->BtAsocEntry[EntryNum].PhyLinkCmdData.BtPhyLinkhandle,
1975                 pBTInfo->BtAsocEntry[EntryNum].PhyLinkCmdData.BtAMPKeyLen,
1976                 pBTInfo->BtAsocEntry[EntryNum].PhyLinkCmdData.BtAMPKeyType));
1977         RTPRINT_DATA(FIOCTL, (IOCTL_BT_LOGO|IOCTL_BT_HCICMD), ("BtAMPKey\n"), pBTInfo->BtAsocEntry[EntryNum].PhyLinkCmdData.BtAMPKey,
1978                 pBTInfo->BtAsocEntry[EntryNum].PhyLinkCmdData.BtAMPKeyLen);
1979         RTPRINT_DATA(FIOCTL, (IOCTL_BT_LOGO|IOCTL_BT_HCICMD), ("PMK\n"), pBTInfo->BtAsocEntry[EntryNum].PMK,
1980                 PMK_LEN);
1981
1982         if (OCF == HCI_CREATE_PHYSICAL_LINK)
1983         {
1984                 BTHCI_SM_WITH_INFO(padapter, HCI_STATE_DISCONNECTED, STATE_CMD_CREATE_PHY_LINK, EntryNum);
1985         }
1986         else if (OCF == HCI_ACCEPT_PHYSICAL_LINK)
1987         {
1988                 BTHCI_SM_WITH_INFO(padapter, HCI_STATE_DISCONNECTED, STATE_CMD_ACCEPT_PHY_LINK, EntryNum);
1989         }
1990
1991         return status;
1992 }
1993
1994 static void
1995 bthci_BuildLogicalLink(
1996         PADAPTER                                                padapter,
1997         PPACKET_IRP_HCICMD_DATA         pHciCmd,
1998         u16                                             OCF
1999         )
2000 {
2001         HCI_STATUS status = HCI_STATUS_SUCCESS;
2002 //      PMGNT_INFO pMgntInfo = &padapter->MgntInfo;
2003         PBT30Info       pBTinfo = GET_BT_INFO(padapter);
2004         PBT_MGNT        pBtMgnt = &pBTinfo->BtMgnt;
2005         u8      PhyLinkHandle, EntryNum;
2006         static u16 AssignLogHandle = 1;
2007
2008         HCI_FLOW_SPEC   TxFlowSpec;
2009         HCI_FLOW_SPEC   RxFlowSpec;
2010         u32     MaxSDUSize, ArriveTime, Bandwidth;
2011
2012         PhyLinkHandle = *((u8*)pHciCmd->Data);
2013
2014         EntryNum = bthci_GetCurrentEntryNum(padapter, PhyLinkHandle);
2015
2016         _rtw_memcpy(&TxFlowSpec,
2017                 &pHciCmd->Data[1], sizeof(HCI_FLOW_SPEC));
2018         _rtw_memcpy(&RxFlowSpec,
2019                 &pHciCmd->Data[17], sizeof(HCI_FLOW_SPEC));
2020
2021 #if 0   //for logo special test case only
2022                 if (i==0)
2023                 {
2024                         bthci_SelectFlowType(padapter,BT_TX_BE_FS,BT_RX_BE_FS,&TxFlowSpec,&RxFlowSpec);
2025                         i=1;
2026                 }
2027                 else if (i==1)
2028                 {
2029                         bthci_SelectFlowType(padapter,BT_TX_GU_FS,BT_RX_GU_FS,&TxFlowSpec,&RxFlowSpec);
2030                         i=0;
2031                 }
2032 #endif
2033
2034         MaxSDUSize = TxFlowSpec.MaximumSDUSize;
2035         ArriveTime = TxFlowSpec.SDUInterArrivalTime;
2036
2037         if (bthci_CheckLogLinkBehavior(padapter, TxFlowSpec)&& bthci_CheckLogLinkBehavior(padapter, RxFlowSpec))
2038         {
2039                 Bandwidth = BTTOTALBANDWIDTH;
2040         }
2041         else if (MaxSDUSize==0xffff && ArriveTime==0xffffffff)
2042         {
2043                 Bandwidth = BTTOTALBANDWIDTH;
2044         }
2045         else
2046         {
2047                 Bandwidth = MaxSDUSize*8*1000/(ArriveTime+244);
2048         }
2049
2050 #if 0
2051         RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("BuildLogicalLink, PhyLinkHandle = 0x%x, MaximumSDUSize = 0x%lx, SDUInterArrivalTime = 0x%lx, Bandwidth=0x%lx\n",
2052                 PhyLinkHandle, MaxSDUSize,ArriveTime, Bandwidth));
2053 #else
2054         RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("BuildLogicalLink, PhyLinkHandle=0x%x, MaximumSDUSize=0x%x, SDUInterArrivalTime=0x%x, Bandwidth=0x%x\n",
2055                 PhyLinkHandle, MaxSDUSize, ArriveTime, Bandwidth));
2056 #endif
2057
2058         if (EntryNum == 0xff)
2059         {
2060                 RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("Invalid Physical Link handle = 0x%x, status=HCI_STATUS_UNKNOW_CONNECT_ID, return\n", PhyLinkHandle));
2061                 status = HCI_STATUS_UNKNOW_CONNECT_ID;
2062
2063                 //When we receive Create/Accept logical link command, we should send command status event first.
2064                 bthci_EventCommandStatus(padapter,
2065                         OGF_LINK_CONTROL_COMMANDS,
2066                         OCF,
2067                         status);
2068                 return;
2069         }
2070
2071         if (pBtMgnt->bLogLinkInProgress == _FALSE)
2072         {
2073                 if (bthci_PhyLinkConnectionInProgress(padapter, PhyLinkHandle))
2074                 {
2075                         RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("Physical link connection in progress, status=HCI_STATUS_CMD_DISALLOW, return\n"));
2076                         status = HCI_STATUS_CMD_DISALLOW;
2077
2078                         pBtMgnt->bPhyLinkInProgressStartLL = _TRUE;
2079                         //When we receive Create/Accept logical link command, we should send command status event first.
2080                         bthci_EventCommandStatus(padapter,
2081                                 OGF_LINK_CONTROL_COMMANDS,
2082                                 OCF,
2083                                 status);
2084
2085                         return;
2086                 }
2087
2088                 if (Bandwidth > BTTOTALBANDWIDTH)//BTTOTALBANDWIDTH
2089                 {
2090                         RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("status=HCI_STATUS_QOS_REJECT, Bandwidth=0x%x, return\n", Bandwidth));
2091                         status = HCI_STATUS_QOS_REJECT;
2092
2093                         //When we receive Create/Accept logical link command, we should send command status event first.
2094                         bthci_EventCommandStatus(padapter,
2095                                 OGF_LINK_CONTROL_COMMANDS,
2096                                 OCF,
2097                                 status);
2098                 }
2099                 else
2100                 {
2101                         RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("status=HCI_STATUS_SUCCESS\n"));
2102                         status = HCI_STATUS_SUCCESS;
2103
2104                         //When we receive Create/Accept logical link command, we should send command status event first.
2105                         bthci_EventCommandStatus(padapter,
2106                                 OGF_LINK_CONTROL_COMMANDS,
2107                                 OCF,
2108                                 status);
2109
2110 #if 0// special logo test case only
2111                         bthci_FakeCommand(padapter, OGF_LINK_CONTROL_COMMANDS, HCI_LOGICAL_LINK_CANCEL);
2112 #endif
2113                 }
2114
2115                 if (pBTinfo->BtAsocEntry[EntryNum].BtCurrentState != HCI_STATE_CONNECTED)
2116                 {
2117                         bthci_EventLogicalLinkComplete(padapter,
2118                                 HCI_STATUS_CMD_DISALLOW, 0, 0, 0,EntryNum);
2119                 }
2120                 else
2121                 {
2122                         u8 i, find=0;
2123
2124                         pBtMgnt->bLogLinkInProgress = _TRUE;
2125
2126                         // find an unused logical link index and copy the data
2127                         for (i=0; i<MAX_LOGICAL_LINK_NUM; i++)
2128                         {
2129                                 if (pBTinfo->BtAsocEntry[EntryNum].LogLinkCmdData[i].BtLogLinkhandle == 0)
2130                                 {
2131                                         HCI_STATUS LogCompEventstatus = HCI_STATUS_SUCCESS;
2132
2133                                         pBTinfo->BtAsocEntry[EntryNum].LogLinkCmdData[i].BtPhyLinkhandle = *((u8*)pHciCmd->Data);
2134                                         pBTinfo->BtAsocEntry[EntryNum].LogLinkCmdData[i].BtLogLinkhandle = AssignLogHandle;
2135                                         RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("BuildLogicalLink, EntryNum = %d, physical link handle = 0x%x, logical link handle = 0x%x\n",
2136                                                 EntryNum, pBTinfo->BtAsocEntry[EntryNum].PhyLinkCmdData.BtPhyLinkhandle,
2137                                                                   pBTinfo->BtAsocEntry[EntryNum].LogLinkCmdData[i].BtLogLinkhandle));
2138                                         _rtw_memcpy(&pBTinfo->BtAsocEntry[EntryNum].LogLinkCmdData[i].Tx_Flow_Spec,
2139                                                 &TxFlowSpec, sizeof(HCI_FLOW_SPEC));
2140                                         _rtw_memcpy(&pBTinfo->BtAsocEntry[EntryNum].LogLinkCmdData[i].Rx_Flow_Spec,
2141                                                 &RxFlowSpec, sizeof(HCI_FLOW_SPEC));
2142
2143                                         pBTinfo->BtAsocEntry[EntryNum].LogLinkCmdData[i].bLLCompleteEventIsSet=_FALSE;
2144
2145                                         if (pBTinfo->BtAsocEntry[EntryNum].LogLinkCmdData[i].bLLCancelCMDIsSetandComplete)
2146                                         {
2147                                                 LogCompEventstatus = HCI_STATUS_UNKNOW_CONNECT_ID;
2148                                         }
2149                                         bthci_EventLogicalLinkComplete(padapter,
2150                                                 LogCompEventstatus,
2151                                                 pBTinfo->BtAsocEntry[EntryNum].LogLinkCmdData[i].BtPhyLinkhandle,
2152                                                 pBTinfo->BtAsocEntry[EntryNum].LogLinkCmdData[i].BtLogLinkhandle, i,EntryNum);
2153
2154                                         pBTinfo->BtAsocEntry[EntryNum].LogLinkCmdData[i].bLLCompleteEventIsSet = _TRUE;
2155
2156                                         find = 1;
2157                                         pBtMgnt->BtCurrentLogLinkhandle = AssignLogHandle;
2158                                         AssignLogHandle++;
2159                                         break;
2160                                 }
2161                         }
2162
2163                         if (!find)
2164                         {
2165                                 bthci_EventLogicalLinkComplete(padapter,
2166                                         HCI_STATUS_CONNECT_RJT_LIMIT_RESOURCE, 0, 0, 0,EntryNum);
2167                         }
2168                         pBtMgnt->bLogLinkInProgress = _FALSE;
2169                 }
2170         }
2171         else
2172         {
2173                 bthci_EventLogicalLinkComplete(padapter,
2174                         HCI_STATUS_CONTROLLER_BUSY, 0, 0, 0,EntryNum);
2175         }
2176
2177 #if 0// special logo test case only
2178         bthci_FakeCommand(padapter, OGF_LINK_CONTROL_COMMANDS, HCI_LOGICAL_LINK_CANCEL);
2179 #endif
2180 }
2181
2182 static void
2183 bthci_StartBeaconAndConnect(
2184         PADAPTER        padapter,
2185         PPACKET_IRP_HCICMD_DATA         pHciCmd,
2186         u8              CurrentAssocNum
2187         )
2188 {
2189 //      PMGNT_INFO pMgntInfo = &padapter->MgntInfo;
2190         PBT30Info               pBTInfo = GET_BT_INFO(padapter);
2191         PBT_MGNT                pBtMgnt = &pBTInfo->BtMgnt;
2192
2193         RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("StartBeaconAndConnect, CurrentAssocNum=%d, AMPRole=%d\n",
2194                 CurrentAssocNum,
2195                 pBTInfo->BtAsocEntry[CurrentAssocNum].AMPRole));
2196
2197         if (pBtMgnt->CheckChnlIsSuit == _FALSE)
2198         {
2199                 bthci_EventPhysicalLinkComplete(padapter, HCI_STATUS_CONNECT_REJ_NOT_SUIT_CHNL_FOUND, CurrentAssocNum, INVALID_PL_HANDLE);
2200                 bthci_RemoveEntryByEntryNum(padapter, CurrentAssocNum);
2201                 return;
2202         }
2203
2204         {
2205                 if (pBTInfo->BtAsocEntry[CurrentAssocNum].AMPRole == AMP_BTAP_CREATOR)
2206                 {
2207                         rsprintf((char*)pBTInfo->BtAsocEntry[CurrentAssocNum].BTSsidBuf,32,"AMP-%02x-%02x-%02x-%02x-%02x-%02x",
2208 #if 0
2209                         padapter->PermanentAddress[0],
2210                         padapter->PermanentAddress[1],
2211                         padapter->PermanentAddress[2],
2212                         padapter->PermanentAddress[3],
2213                         padapter->PermanentAddress[4],
2214                         padapter->PermanentAddress[5]);
2215 #else
2216                         padapter->eeprompriv.mac_addr[0],
2217                         padapter->eeprompriv.mac_addr[1],
2218                         padapter->eeprompriv.mac_addr[2],
2219                         padapter->eeprompriv.mac_addr[3],
2220                         padapter->eeprompriv.mac_addr[4],
2221                         padapter->eeprompriv.mac_addr[5]);
2222 #endif
2223                 }
2224                 else if (pBTInfo->BtAsocEntry[CurrentAssocNum].AMPRole == AMP_BTAP_JOINER)
2225                 {
2226                         rsprintf((char*)pBTInfo->BtAsocEntry[CurrentAssocNum].BTSsidBuf,32,"AMP-%02x-%02x-%02x-%02x-%02x-%02x",
2227                         pBTInfo->BtAsocEntry[CurrentAssocNum].BTRemoteMACAddr[0],
2228                         pBTInfo->BtAsocEntry[CurrentAssocNum].BTRemoteMACAddr[1],
2229                         pBTInfo->BtAsocEntry[CurrentAssocNum].BTRemoteMACAddr[2],
2230                         pBTInfo->BtAsocEntry[CurrentAssocNum].BTRemoteMACAddr[3],
2231                         pBTInfo->BtAsocEntry[CurrentAssocNum].BTRemoteMACAddr[4],
2232                         pBTInfo->BtAsocEntry[CurrentAssocNum].BTRemoteMACAddr[5]);
2233                 }
2234
2235                 FillOctetString(pBTInfo->BtAsocEntry[CurrentAssocNum].BTSsid, pBTInfo->BtAsocEntry[CurrentAssocNum].BTSsidBuf, 21);
2236                 pBTInfo->BtAsocEntry[CurrentAssocNum].BTSsid.Length = 21;
2237
2238                 //To avoid set the start ap or connect twice, or the original connection will be disconnected.
2239                 if (!pBtMgnt->bBTConnectInProgress)
2240                 {
2241                         pBtMgnt->bBTConnectInProgress=_TRUE;
2242                         RTPRINT(FIOCTL, IOCTL_STATE, ("[BT Flag], BT Connect in progress ON!!\n"));
2243                         BTHCI_SM_WITH_INFO(padapter,HCI_STATE_STARTING,STATE_CMD_MAC_START_COMPLETE,CurrentAssocNum);
2244
2245 #if 0   //for logo special test case only
2246                         bthci_BuildLogicalLink(padapter, pHciCmd, HCI_CREATE_LOGICAL_LINK);
2247 #endif
2248
2249                         // 20100325 Joseph: Check RF ON/OFF.
2250                         // If RF OFF, it reschedule connecting operation after 50ms.
2251                         if (!bthci_CheckRfStateBeforeConnect(padapter))
2252                                 return;
2253
2254                         if (pBTInfo->BtAsocEntry[CurrentAssocNum].AMPRole == AMP_BTAP_CREATOR)
2255                         {
2256 //                              BTPKT_StartBeacon(padapter, CurrentAssocNum); // not implement yet
2257                                 BTHCI_SM_WITH_INFO(padapter,HCI_STATE_CONNECTING,STATE_CMD_MAC_CONNECT_COMPLETE,CurrentAssocNum);
2258                         }
2259                         else if (pBTInfo->BtAsocEntry[CurrentAssocNum].AMPRole == AMP_BTAP_JOINER)
2260                         {
2261                                 bthci_ResponderStartToScan(padapter);
2262                         }
2263                 }
2264                 RT_PRINT_STR(_module_rtl871x_mlme_c_, _drv_notice_, "StartBeaconAndConnect, SSID:\n", pBTInfo->BtAsocEntry[pBtMgnt->CurrentConnectEntryNum].BTSsid.Octet, pBTInfo->BtAsocEntry[pBtMgnt->CurrentConnectEntryNum].BTSsid.Length);
2265         }
2266 }
2267
2268 static void bthci_ResetBtMgnt(PBT_MGNT pBtMgnt)
2269 {
2270         pBtMgnt->BtOperationOn = _FALSE;
2271         pBtMgnt->bBTConnectInProgress = _FALSE;
2272         pBtMgnt->bLogLinkInProgress = _FALSE;
2273         pBtMgnt->bPhyLinkInProgress = _FALSE;
2274         pBtMgnt->bPhyLinkInProgressStartLL = _FALSE;
2275         pBtMgnt->DisconnectEntryNum = 0xff;
2276         pBtMgnt->bStartSendSupervisionPkt = _FALSE;
2277         pBtMgnt->JoinerNeedSendAuth = _FALSE;
2278         pBtMgnt->CurrentBTConnectionCnt = 0;
2279         pBtMgnt->BTCurrentConnectType = BT_DISCONNECT;
2280         pBtMgnt->BTReceiveConnectPkt = BT_DISCONNECT;
2281         pBtMgnt->BTAuthCount = 0;
2282         pBtMgnt->btLogoTest = 0;
2283 }
2284
2285 static void bthci_ResetBtHciInfo(PBT_HCI_INFO pBtHciInfo)
2286 {
2287         pBtHciInfo->BTEventMask = 0;
2288         pBtHciInfo->BTEventMaskPage2 = 0;
2289         pBtHciInfo->ConnAcceptTimeout =  10000;
2290         pBtHciInfo->PageTimeout  =  0x30;
2291         pBtHciInfo->LocationDomainAware = 0x0;
2292         pBtHciInfo->LocationDomain = 0x5858;
2293         pBtHciInfo->LocationDomainOptions = 0x58;
2294         pBtHciInfo->LocationOptions = 0x0;
2295         pBtHciInfo->FlowControlMode = 0x1;      // 0:Packet based data flow control mode(BR/EDR), 1: Data block based data flow control mode(AMP).
2296
2297         pBtHciInfo->enFlush_LLH = 0;
2298         pBtHciInfo->FLTO_LLH = 0;
2299
2300         //Test command only
2301         pBtHciInfo->bTestIsEnd = _TRUE;
2302         pBtHciInfo->bInTestMode = _FALSE;
2303         pBtHciInfo->bTestNeedReport = _FALSE;
2304         pBtHciInfo->TestScenario = 0xff;
2305         pBtHciInfo->TestReportInterval = 0x01;
2306         pBtHciInfo->TestCtrType = 0x5d;
2307         pBtHciInfo->TestEventType = 0x00;
2308         pBtHciInfo->TestNumOfFrame = 0;
2309         pBtHciInfo->TestNumOfErrFrame = 0;
2310         pBtHciInfo->TestNumOfBits = 0;
2311         pBtHciInfo->TestNumOfErrBits = 0;
2312 }
2313
2314 static void bthci_ResetBtSec(PADAPTER padapter, PBT_SECURITY pBtSec)
2315 {
2316 //      PMGNT_INFO      pMgntInfo = &padapter->MgntInfo;
2317
2318         // Set BT used HW or SW encrypt !!
2319         if (GET_HAL_DATA(padapter)->bBTMode)
2320                 pBtSec->bUsedHwEncrypt = _TRUE;
2321         else
2322                 pBtSec->bUsedHwEncrypt = _FALSE;
2323         RT_TRACE(_module_rtl871x_security_c_, _drv_info_, ("%s: bUsedHwEncrypt=%d\n", __FUNCTION__, pBtSec->bUsedHwEncrypt));
2324
2325         pBtSec->RSNIE.Octet = pBtSec->RSNIEBuf;
2326 }
2327
2328 static void bthci_ResetBtExtInfo(PBT_MGNT pBtMgnt)
2329 {
2330         u8      i;
2331
2332         for (i=0; i<MAX_BT_ASOC_ENTRY_NUM; i++)
2333         {
2334                 pBtMgnt->ExtConfig.linkInfo[i].ConnectHandle = 0;
2335                 pBtMgnt->ExtConfig.linkInfo[i].IncomingTrafficMode = 0;
2336                 pBtMgnt->ExtConfig.linkInfo[i].OutgoingTrafficMode = 0;
2337                 pBtMgnt->ExtConfig.linkInfo[i].BTProfile = BT_PROFILE_NONE;
2338                 pBtMgnt->ExtConfig.linkInfo[i].BTCoreSpec = BT_SPEC_2_1_EDR;
2339                 pBtMgnt->ExtConfig.linkInfo[i].BT_RSSI = 0;
2340                 pBtMgnt->ExtConfig.linkInfo[i].TrafficProfile = BT_PROFILE_NONE;
2341                 pBtMgnt->ExtConfig.linkInfo[i].linkRole = BT_LINK_MASTER;
2342         }
2343
2344         pBtMgnt->ExtConfig.CurrentConnectHandle = 0;
2345         pBtMgnt->ExtConfig.CurrentIncomingTrafficMode = 0;
2346         pBtMgnt->ExtConfig.CurrentOutgoingTrafficMode = 0;
2347         pBtMgnt->ExtConfig.MIN_BT_RSSI = 0;
2348         pBtMgnt->ExtConfig.NumberOfHandle = 0;
2349         pBtMgnt->ExtConfig.NumberOfSCO = 0;
2350         pBtMgnt->ExtConfig.CurrentBTStatus = 0;
2351         pBtMgnt->ExtConfig.HCIExtensionVer = 0;
2352
2353         pBtMgnt->ExtConfig.bManualControl = _FALSE;
2354         pBtMgnt->ExtConfig.bBTBusy = _FALSE;
2355         pBtMgnt->ExtConfig.bBTA2DPBusy = _FALSE;
2356 }
2357
2358 static HCI_STATUS bthci_CmdReset(PADAPTER _padapter, u8 bNeedSendEvent)
2359 {
2360         HCI_STATUS status = HCI_STATUS_SUCCESS;
2361         PADAPTER        padapter;
2362 //      PMGNT_INFO pMgntInfo = &padapter->MgntInfo;
2363         PBT30Info               pBTInfo;
2364         PBT_MGNT                pBtMgnt;
2365         PBT_HCI_INFO            pBtHciInfo;
2366         PBT_SECURITY            pBtSec;
2367         PBT_DBG                 pBtDbg;
2368         u8      i;
2369
2370
2371         RTPRINT(FIOCTL,IOCTL_BT_HCICMD, ("bthci_CmdReset()\n"));
2372
2373         padapter = GetDefaultAdapter(_padapter);
2374         pBTInfo = GET_BT_INFO(padapter);
2375         pBtMgnt = &pBTInfo->BtMgnt;
2376         pBtHciInfo = &pBTInfo->BtHciInfo;
2377         pBtSec = &pBTInfo->BtSec;
2378         pBtDbg = &pBTInfo->BtDbg;
2379
2380         pBTInfo->padapter = padapter;
2381
2382         for (i=0; i<MAX_BT_ASOC_ENTRY_NUM; i++)
2383         {
2384                 bthci_ResetEntry(padapter, i);
2385         }
2386
2387         bthci_ResetBtMgnt(pBtMgnt);
2388         bthci_ResetBtHciInfo(pBtHciInfo);
2389         bthci_ResetBtSec(padapter, pBtSec);
2390
2391         pBtMgnt->BTChannel = BT_Default_Chnl;
2392         pBtMgnt->CheckChnlIsSuit = _TRUE;
2393
2394         pBTInfo->BTBeaconTmrOn = _FALSE;
2395 //      QosInitializeBssDesc(&pBtMgnt->bssDesc.BssQos); // not implement yet
2396
2397         pBtMgnt->bCreateSpportQos=_TRUE;
2398
2399         PlatformCancelTimer(padapter, &pBTInfo->BTSupervisionPktTimer);
2400 #if (SENDTXMEHTOD == 0)
2401         PlatformCancelTimer(padapter, &pBTInfo->BTHCISendAclDataTimer);
2402 #endif
2403         PlatformCancelTimer(padapter, &pBTInfo->BTHCIDiscardAclDataTimer);
2404         PlatformCancelTimer(padapter, &pBTInfo->BTBeaconTimer);
2405
2406         HALBT_SetRtsCtsNoLenLimit(padapter);
2407         //
2408         // Maybe we need to take care Group != AES case !!
2409         // now we Pairwise and Group all used AES !!
2410 //      BTPKT_ConstructRSNIE(padapter); // not implement yet
2411
2412         bthci_ResetBtExtInfo(pBtMgnt);
2413
2414         //send command complete event here when all data are received.
2415         if (bNeedSendEvent)
2416         {
2417                 u8 localBuf[6] = "";
2418                 u8 *pRetPar;
2419                 u8 len = 0;
2420                 PPACKET_IRP_HCIEVENT_DATA PPacketIrpEvent;
2421
2422                 PPacketIrpEvent = (PPACKET_IRP_HCIEVENT_DATA)(&localBuf[0]);
2423
2424                 len += bthci_CommandCompleteHeader(&localBuf[0],
2425                         OGF_SET_EVENT_MASK_COMMAND,
2426                         HCI_RESET,
2427                         status);
2428
2429                 // Return parameters starts from here
2430                 pRetPar = &PPacketIrpEvent->Data[len];
2431                 pRetPar[0] = status;            //status
2432                 len += 1;
2433                 PPacketIrpEvent->Length = len;
2434
2435                 bthci_IndicateEvent(padapter, PPacketIrpEvent, len+2);
2436         }
2437
2438         return status;
2439 }
2440
2441 static HCI_STATUS
2442 bthci_CmdWriteRemoteAMPAssoc(
2443         PADAPTER        padapter,
2444         PPACKET_IRP_HCICMD_DATA         pHciCmd
2445         )
2446 {
2447         HCI_STATUS status = HCI_STATUS_SUCCESS;
2448         PBT30Info               pBTInfo = GET_BT_INFO(padapter);
2449         PBT_DBG                 pBtDbg = &pBTInfo->BtDbg;
2450         u8                      CurrentAssocNum;
2451         u8                      PhyLinkHandle;
2452
2453         pBtDbg->dbgHciInfo.hciCmdCntWriteRemoteAmpAssoc++;
2454         PhyLinkHandle = *((u8*)pHciCmd->Data);
2455         CurrentAssocNum = bthci_GetCurrentEntryNum(padapter, PhyLinkHandle);
2456
2457         if (CurrentAssocNum == 0xff)
2458         {
2459                 RTPRINT(FIOCTL, (IOCTL_BT_HCICMD|IOCTL_BT_LOGO), ("WriteRemoteAMPAssoc, No such Handle in the Entry\n"));
2460                 status = HCI_STATUS_UNKNOW_CONNECT_ID;
2461                 bthci_EventWriteRemoteAmpAssoc(padapter, status, PhyLinkHandle);
2462                 return status;
2463         }
2464
2465         if (pBTInfo->BtAsocEntry[CurrentAssocNum].AmpAsocCmdData.AMPAssocfragment == NULL)
2466         {
2467                 RTPRINT(FIOCTL, (IOCTL_BT_HCICMD|IOCTL_BT_LOGO), ("WriteRemoteAMPAssoc, AMP controller is busy\n"));
2468                 status = HCI_STATUS_CONTROLLER_BUSY;
2469                 bthci_EventWriteRemoteAmpAssoc(padapter, status, PhyLinkHandle);
2470                 return status;
2471         }
2472
2473         pBTInfo->BtAsocEntry[CurrentAssocNum].AmpAsocCmdData.BtPhyLinkhandle = PhyLinkHandle;//*((u8*)pHciCmd->Data);
2474         pBTInfo->BtAsocEntry[CurrentAssocNum].AmpAsocCmdData.LenSoFar = *((u16*)((u8*)pHciCmd->Data+1));
2475         pBTInfo->BtAsocEntry[CurrentAssocNum].AmpAsocCmdData.AMPAssocRemLen = *((u16*)((u8*)pHciCmd->Data+3));
2476
2477         RTPRINT(FIOCTL, (IOCTL_BT_HCICMD_DETAIL|IOCTL_BT_LOGO), ("WriteRemoteAMPAssoc, LenSoFar= 0x%x, AssocRemLen= 0x%x\n",
2478                 pBTInfo->BtAsocEntry[CurrentAssocNum].AmpAsocCmdData.LenSoFar,pBTInfo->BtAsocEntry[CurrentAssocNum].AmpAsocCmdData.AMPAssocRemLen));
2479
2480         RTPRINT_DATA(FIOCTL, (IOCTL_BT_HCICMD_DETAIL|IOCTL_BT_LOGO), ("WriteRemoteAMPAssoc fragment \n"), pHciCmd->Data,pBTInfo->BtAsocEntry[CurrentAssocNum].AmpAsocCmdData.AMPAssocRemLen+5);
2481         if ((pBTInfo->BtAsocEntry[CurrentAssocNum].AmpAsocCmdData.AMPAssocRemLen) > MAX_AMP_ASSOC_FRAG_LEN)
2482         {
2483                 _rtw_memcpy(((u8*)pBTInfo->BtAsocEntry[CurrentAssocNum].AmpAsocCmdData.AMPAssocfragment+(pBTInfo->BtAsocEntry[CurrentAssocNum].AmpAsocCmdData.LenSoFar*(sizeof(u8)))),
2484                         (u8*)pHciCmd->Data+5,
2485                         MAX_AMP_ASSOC_FRAG_LEN);
2486         }
2487         else
2488         {
2489                 _rtw_memcpy((u8*)(pBTInfo->BtAsocEntry[CurrentAssocNum].AmpAsocCmdData.AMPAssocfragment)+(pBTInfo->BtAsocEntry[CurrentAssocNum].AmpAsocCmdData.LenSoFar*(sizeof(u8))),
2490                         ((u8*)pHciCmd->Data+5),
2491                         (pBTInfo->BtAsocEntry[CurrentAssocNum].AmpAsocCmdData.AMPAssocRemLen));
2492
2493                 RTPRINT_DATA(FIOCTL, (IOCTL_BT_HCICMD_DETAIL|IOCTL_BT_LOGO), "WriteRemoteAMPAssoc :\n",
2494                         pHciCmd->Data+5, pBTInfo->BtAsocEntry[CurrentAssocNum].AmpAsocCmdData.AMPAssocRemLen);
2495
2496                 if (!bthci_GetAssocInfo(padapter, CurrentAssocNum))
2497                         status=HCI_STATUS_INVALID_HCI_CMD_PARA_VALUE;
2498
2499                 bthci_EventWriteRemoteAmpAssoc(padapter, status, PhyLinkHandle);
2500
2501                 bthci_StartBeaconAndConnect(padapter,pHciCmd,CurrentAssocNum);
2502         }
2503
2504         return status;
2505 }
2506
2507 //7.3.13
2508 static HCI_STATUS bthci_CmdReadConnectionAcceptTimeout(PADAPTER padapter)
2509 {
2510         HCI_STATUS              status = HCI_STATUS_SUCCESS;
2511 //      PMGNT_INFO              pMgntInfo = &padapter->MgntInfo;
2512         PBT30Info               pBTInfo = GET_BT_INFO(padapter);
2513         PBT_HCI_INFO    pBtHciInfo = &pBTInfo->BtHciInfo;
2514
2515         {
2516                 u8 localBuf[8] = "";
2517                 u8 *pRetPar;
2518                 u8 len = 0;
2519                 PPACKET_IRP_HCIEVENT_DATA PPacketIrpEvent;
2520                 u16 *pu2Temp;
2521
2522                 PPacketIrpEvent = (PPACKET_IRP_HCIEVENT_DATA)(&localBuf[0]);
2523
2524                 len += bthci_CommandCompleteHeader(&localBuf[0],
2525                         OGF_SET_EVENT_MASK_COMMAND,
2526                         HCI_READ_CONNECTION_ACCEPT_TIMEOUT,
2527                         status);
2528
2529                 // Return parameters starts from here
2530                 pRetPar = &PPacketIrpEvent->Data[len];
2531                 pRetPar[0] = status;            //status
2532                 pu2Temp = (u16*)&pRetPar[1];            // Conn_Accept_Timeout
2533                 *pu2Temp = pBtHciInfo->ConnAcceptTimeout;
2534                 len += 3;
2535                 PPacketIrpEvent->Length = len;
2536
2537                 bthci_IndicateEvent(padapter, PPacketIrpEvent, len+2);
2538         }
2539
2540         return status;
2541 }
2542
2543 //7.3.3
2544 static HCI_STATUS
2545 bthci_CmdSetEventFilter(
2546         PADAPTER        padapter,
2547         PPACKET_IRP_HCICMD_DATA         pHciCmd
2548         )
2549 {
2550         HCI_STATUS status = HCI_STATUS_SUCCESS;
2551
2552         return status;
2553 }
2554
2555 //7.3.14
2556 static HCI_STATUS
2557 bthci_CmdWriteConnectionAcceptTimeout(
2558         PADAPTER        padapter,
2559         PPACKET_IRP_HCICMD_DATA         pHciCmd
2560         )
2561 {
2562         HCI_STATUS              status = HCI_STATUS_SUCCESS;
2563 //      PMGNT_INFO              pMgntInfo = &padapter->MgntInfo;
2564         PBT30Info               pBTInfo = GET_BT_INFO(padapter);
2565         PBT_HCI_INFO    pBtHciInfo = &pBTInfo->BtHciInfo;
2566         u16     *pu2Temp;
2567
2568         pu2Temp = (u16*)&pHciCmd->Data[0];
2569         pBtHciInfo->ConnAcceptTimeout = *pu2Temp;
2570         RTPRINT(FIOCTL, IOCTL_BT_HCICMD_DETAIL, ("ConnAcceptTimeout = 0x%x",
2571                 pBtHciInfo->ConnAcceptTimeout));
2572
2573         //send command complete event here when all data are received.
2574         {
2575                 u8 localBuf[6] = "";
2576                 u8 *pRetPar;
2577                 u8 len = 0;
2578                 PPACKET_IRP_HCIEVENT_DATA PPacketIrpEvent;
2579
2580                 PPacketIrpEvent = (PPACKET_IRP_HCIEVENT_DATA)(&localBuf[0]);
2581
2582                 len += bthci_CommandCompleteHeader(&localBuf[0],
2583                         OGF_SET_EVENT_MASK_COMMAND,
2584                         HCI_WRITE_CONNECTION_ACCEPT_TIMEOUT,
2585                         status);
2586
2587                 // Return parameters starts from here
2588                 pRetPar = &PPacketIrpEvent->Data[len];
2589                 pRetPar[0] = status;            //status
2590                 len += 1;
2591                 PPacketIrpEvent->Length = len;
2592
2593                 bthci_IndicateEvent(padapter, PPacketIrpEvent, len+2);
2594         }
2595
2596         return status;
2597 }
2598
2599 static HCI_STATUS
2600 bthci_CmdReadPageTimeout(
2601         PADAPTER        padapter,
2602         PPACKET_IRP_HCICMD_DATA         pHciCmd
2603         )
2604 {
2605         HCI_STATUS              status = HCI_STATUS_SUCCESS;
2606 //      PMGNT_INFO              pMgntInfo = &padapter->MgntInfo;
2607         PBT30Info               pBTInfo = GET_BT_INFO(padapter);
2608         PBT_HCI_INFO    pBtHciInfo = &pBTInfo->BtHciInfo;
2609
2610         {
2611                 u8 localBuf[8] = "";
2612                 u8 *pRetPar;
2613                 u8 len = 0;
2614                 PPACKET_IRP_HCIEVENT_DATA PPacketIrpEvent;
2615                 u16 *pu2Temp;
2616
2617                 PPacketIrpEvent = (PPACKET_IRP_HCIEVENT_DATA)(&localBuf[0]);
2618
2619                 len += bthci_CommandCompleteHeader(&localBuf[0],
2620                         OGF_SET_EVENT_MASK_COMMAND,
2621                         HCI_READ_PAGE_TIMEOUT,
2622                         status);
2623
2624                 RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("Read PageTimeout = 0x%x\n", pBtHciInfo->PageTimeout));
2625                 // Return parameters starts from here
2626                 pRetPar = &PPacketIrpEvent->Data[len];
2627                 pRetPar[0] = status;            //status
2628                 pu2Temp = (u16*)&pRetPar[1];            // Page_Timeout
2629                 *pu2Temp = pBtHciInfo->PageTimeout;
2630                 len+=3;
2631                 PPacketIrpEvent->Length = len;
2632
2633                 bthci_IndicateEvent(padapter, PPacketIrpEvent, len+2);
2634         }
2635
2636         return status;
2637 }
2638
2639 static HCI_STATUS
2640 bthci_CmdWritePageTimeout(
2641         PADAPTER        padapter,
2642         PPACKET_IRP_HCICMD_DATA         pHciCmd
2643         )
2644 {
2645         HCI_STATUS              status = HCI_STATUS_SUCCESS;
2646 //      PMGNT_INFO              pMgntInfo = &padapter->MgntInfo;
2647         PBT30Info               pBTInfo = GET_BT_INFO(padapter);
2648         PBT_HCI_INFO    pBtHciInfo = &pBTInfo->BtHciInfo;
2649         u16     *pu2Temp;
2650
2651         pu2Temp = (u16*)&pHciCmd->Data[0];
2652         pBtHciInfo->PageTimeout = *pu2Temp;
2653         RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("Write PageTimeout = 0x%x\n",
2654                 pBtHciInfo->PageTimeout));
2655
2656         //send command complete event here when all data are received.
2657         {
2658                 u8 localBuf[6] = "";
2659                 u8 *pRetPar;
2660                 u8 len = 0;
2661                 PPACKET_IRP_HCIEVENT_DATA PPacketIrpEvent;
2662
2663                 PPacketIrpEvent = (PPACKET_IRP_HCIEVENT_DATA)(&localBuf[0]);
2664
2665                 len += bthci_CommandCompleteHeader(&localBuf[0],
2666                         OGF_SET_EVENT_MASK_COMMAND,
2667                         HCI_WRITE_PAGE_TIMEOUT,
2668                         status);
2669
2670                 // Return parameters starts from here
2671                 pRetPar = &PPacketIrpEvent->Data[len];
2672                 pRetPar[0] = status;            //status
2673                 len += 1;
2674                 PPacketIrpEvent->Length = len;
2675
2676                 bthci_IndicateEvent(padapter, PPacketIrpEvent, len+2);
2677         }
2678
2679         return status;
2680 }
2681
2682 static HCI_STATUS
2683 bthci_CmdReadLinkSupervisionTimeout(
2684         PADAPTER        padapter,
2685         PPACKET_IRP_HCICMD_DATA         pHciCmd
2686         )
2687 {
2688         HCI_STATUS      status = HCI_STATUS_SUCCESS;
2689         PBT30Info       pBTinfo = GET_BT_INFO(padapter);
2690         u8                      physicalLinkHandle, EntryNum;
2691
2692         physicalLinkHandle = *((u8*)pHciCmd->Data);
2693
2694         EntryNum = bthci_GetCurrentEntryNum(padapter, physicalLinkHandle);
2695
2696         if (EntryNum == 0xff)
2697         {
2698                 RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("ReadLinkSupervisionTimeout, No such Handle in the Entry\n"));
2699                 status = HCI_STATUS_UNKNOW_CONNECT_ID;
2700                 return status;
2701         }
2702
2703         if (pBTinfo->BtAsocEntry[EntryNum].PhyLinkCmdData.BtPhyLinkhandle != physicalLinkHandle)
2704                 status = HCI_STATUS_UNKNOW_CONNECT_ID;
2705
2706         {
2707                 u8 localBuf[10] = "";
2708                 u8 *pRetPar;
2709                 u8 len = 0;
2710                 PPACKET_IRP_HCIEVENT_DATA PPacketIrpEvent;
2711                 u16 *pu2Temp;
2712
2713                 PPacketIrpEvent = (PPACKET_IRP_HCIEVENT_DATA)(&localBuf[0]);
2714
2715                 len += bthci_CommandCompleteHeader(&localBuf[0],
2716                         OGF_SET_EVENT_MASK_COMMAND,
2717                         HCI_READ_LINK_SUPERVISION_TIMEOUT,
2718                         status);
2719
2720                 // Return parameters starts from here
2721                 pRetPar = &PPacketIrpEvent->Data[len];
2722                 pRetPar[0] = status;
2723                 pRetPar[1] = pBTinfo->BtAsocEntry[EntryNum].PhyLinkCmdData.BtPhyLinkhandle;
2724                 pRetPar[2] = 0;
2725                 pu2Temp = (u16*)&pRetPar[3];            // Conn_Accept_Timeout
2726                 *pu2Temp = pBTinfo->BtAsocEntry[EntryNum].PhyLinkCmdData.LinkSuperversionTimeout;
2727                 len += 5;
2728                 PPacketIrpEvent->Length = len;
2729
2730                 bthci_IndicateEvent(padapter, PPacketIrpEvent, len+2);
2731         }
2732
2733         return status;
2734 }
2735
2736 static HCI_STATUS
2737 bthci_CmdWriteLinkSupervisionTimeout(
2738         PADAPTER        padapter,
2739         PPACKET_IRP_HCICMD_DATA         pHciCmd
2740         )
2741 {
2742         HCI_STATUS      status = HCI_STATUS_SUCCESS;
2743         PBT30Info       pBTinfo = GET_BT_INFO(padapter);
2744         u8                      physicalLinkHandle, EntryNum;
2745
2746         physicalLinkHandle = *((u8*)pHciCmd->Data);
2747
2748         EntryNum = bthci_GetCurrentEntryNum(padapter, physicalLinkHandle);
2749
2750         if (EntryNum == 0xff)
2751         {
2752                 RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("WriteLinkSupervisionTimeout, No such Handle in the Entry\n"));
2753                 status=HCI_STATUS_UNKNOW_CONNECT_ID;
2754         }
2755         else
2756         {
2757                 if (pBTinfo->BtAsocEntry[EntryNum].PhyLinkCmdData.BtPhyLinkhandle != physicalLinkHandle)
2758                         status = HCI_STATUS_UNKNOW_CONNECT_ID;
2759                 else
2760                 {
2761                         pBTinfo->BtAsocEntry[EntryNum].PhyLinkCmdData.LinkSuperversionTimeout=*((u16 *)(((u8*)pHciCmd->Data)+2));
2762                         RTPRINT(FIOCTL, IOCTL_STATE, ("BT Write LinkSuperversionTimeout[%d] = 0x%x\n",
2763                                 EntryNum, pBTinfo->BtAsocEntry[EntryNum].PhyLinkCmdData.LinkSuperversionTimeout));
2764                 }
2765         }
2766
2767         {
2768                 u8 localBuf[8] = "";
2769                 u8 *pRetPar;
2770                 u8 len = 0;
2771                 PPACKET_IRP_HCIEVENT_DATA PPacketIrpEvent;
2772
2773                 PPacketIrpEvent = (PPACKET_IRP_HCIEVENT_DATA)(&localBuf[0]);
2774
2775                 len += bthci_CommandCompleteHeader(&localBuf[0],
2776                         OGF_SET_EVENT_MASK_COMMAND,
2777                         HCI_WRITE_LINK_SUPERVISION_TIMEOUT,
2778                         status);
2779
2780                 // Return parameters starts from here
2781                 pRetPar = &PPacketIrpEvent->Data[len];
2782                 pRetPar[0] = status;
2783                 pRetPar[1] = pBTinfo->BtAsocEntry[EntryNum].PhyLinkCmdData.BtPhyLinkhandle;
2784                 pRetPar[2] = 0;
2785                 len += 3;
2786                 PPacketIrpEvent->Length = len;
2787
2788                 bthci_IndicateEvent(padapter, PPacketIrpEvent, len+2);
2789         }
2790
2791         return status;
2792 }
2793
2794 static HCI_STATUS
2795 bthci_CmdEnhancedFlush(
2796         PADAPTER        padapter,
2797         PPACKET_IRP_HCICMD_DATA         pHciCmd
2798         )
2799 {
2800         HCI_STATUS              status = HCI_STATUS_SUCCESS;
2801         PBT30Info               pBTinfo = GET_BT_INFO(padapter);
2802         PBT_HCI_INFO    pBtHciInfo = &pBTinfo->BtHciInfo;
2803         u16             logicHandle;
2804         u8              Packet_Type;
2805
2806         logicHandle = *((u16*)&pHciCmd->Data[0]);
2807         Packet_Type = pHciCmd->Data[2];
2808
2809         if (Packet_Type != 0)
2810         {
2811                 status = HCI_STATUS_INVALID_HCI_CMD_PARA_VALUE;
2812         }
2813         else
2814                 pBtHciInfo->enFlush_LLH = logicHandle;
2815
2816         if (bthci_DiscardTxPackets(padapter, pBtHciInfo->enFlush_LLH))
2817         {
2818                 bthci_EventFlushOccurred(padapter, pBtHciInfo->enFlush_LLH);
2819         }
2820
2821         // should send command status event
2822         bthci_EventCommandStatus(padapter,
2823                         OGF_SET_EVENT_MASK_COMMAND,
2824                         HCI_ENHANCED_FLUSH,
2825                         status);
2826
2827         if (pBtHciInfo->enFlush_LLH)
2828         {
2829                 bthci_EventEnhancedFlushComplete(padapter, pBtHciInfo->enFlush_LLH);
2830                 pBtHciInfo->enFlush_LLH = 0;
2831         }
2832
2833         return status;
2834 }
2835
2836 static HCI_STATUS
2837 bthci_CmdReadLogicalLinkAcceptTimeout(
2838         PADAPTER        padapter,
2839         PPACKET_IRP_HCICMD_DATA         pHciCmd
2840         )
2841 {
2842         HCI_STATUS              status = HCI_STATUS_SUCCESS;
2843 //      PMGNT_INFO              pMgntInfo = &padapter->MgntInfo;
2844         PBT30Info               pBTInfo = GET_BT_INFO(padapter);
2845         PBT_HCI_INFO    pBtHciInfo = &pBTInfo->BtHciInfo;
2846
2847         {
2848                 u8 localBuf[8] = "";
2849                 u8 *pRetPar;
2850                 u8 len = 0;
2851                 PPACKET_IRP_HCIEVENT_DATA PPacketIrpEvent;
2852                 u16 *pu2Temp;
2853
2854                 PPacketIrpEvent = (PPACKET_IRP_HCIEVENT_DATA)(&localBuf[0]);
2855
2856                 len += bthci_CommandCompleteHeader(&localBuf[0],
2857                         OGF_SET_EVENT_MASK_COMMAND,
2858                         HCI_READ_LOGICAL_LINK_ACCEPT_TIMEOUT,
2859                         status);
2860
2861                 // Return parameters starts from here
2862                 pRetPar = &PPacketIrpEvent->Data[len];
2863                 pRetPar[0] = status;
2864
2865                 pu2Temp = (u16*)&pRetPar[1];            // Conn_Accept_Timeout
2866                 *pu2Temp = pBtHciInfo->LogicalAcceptTimeout;
2867                 len += 3;
2868                 PPacketIrpEvent->Length = len;
2869
2870                 bthci_IndicateEvent(padapter, PPacketIrpEvent, len+2);
2871         }
2872
2873         return status;
2874 }
2875
2876 static HCI_STATUS
2877 bthci_CmdWriteLogicalLinkAcceptTimeout(
2878         PADAPTER        padapter,
2879         PPACKET_IRP_HCICMD_DATA         pHciCmd
2880         )
2881 {
2882         HCI_STATUS              status = HCI_STATUS_SUCCESS;
2883 //      PMGNT_INFO              pMgntInfo = &padapter->MgntInfo;
2884         PBT30Info               pBTInfo = GET_BT_INFO(padapter);
2885         PBT_HCI_INFO    pBtHciInfo = &pBTInfo->BtHciInfo;
2886
2887         pBtHciInfo->LogicalAcceptTimeout = *((u16*)pHciCmd->Data);
2888
2889         {
2890                 u8 localBuf[6] = "";
2891                 u8 *pRetPar;
2892                 u8 len = 0;
2893                 PPACKET_IRP_HCIEVENT_DATA PPacketIrpEvent;
2894
2895                 PPacketIrpEvent = (PPACKET_IRP_HCIEVENT_DATA)(&localBuf[0]);
2896
2897                 len += bthci_CommandCompleteHeader(&localBuf[0],
2898                         OGF_SET_EVENT_MASK_COMMAND,
2899                         HCI_WRITE_LOGICAL_LINK_ACCEPT_TIMEOUT,
2900                         status);
2901
2902                 // Return parameters starts from here
2903                 pRetPar = &PPacketIrpEvent->Data[len];
2904                 pRetPar[0] = status;
2905
2906                 len += 1;
2907                 PPacketIrpEvent->Length = len;
2908
2909                 bthci_IndicateEvent(padapter, PPacketIrpEvent, len+2);
2910         }
2911         return status;
2912 }
2913
2914 static HCI_STATUS
2915 bthci_CmdSetEventMask(
2916         PADAPTER        padapter,
2917         PPACKET_IRP_HCICMD_DATA         pHciCmd
2918         )
2919 {
2920         HCI_STATUS              status = HCI_STATUS_SUCCESS;
2921 //      PMGNT_INFO              pMgntInfo = &padapter->MgntInfo;
2922         PBT30Info               pBTInfo = GET_BT_INFO(padapter);
2923         PBT_HCI_INFO    pBtHciInfo = &pBTInfo->BtHciInfo;
2924         u8 *pu8Temp;
2925
2926         pu8Temp = (u8*)&pHciCmd->Data[0];
2927         pBtHciInfo->BTEventMask = *pu8Temp;
2928 #if 0
2929         RTPRINT(FIOCTL, IOCTL_BT_HCICMD_DETAIL, ("BTEventMask = 0x%"i64fmt"x\n",
2930                 ((pBtHciInfo->BTEventMask & UINT64_C(0xffffffff00000000))>>32)));
2931         RTPRINT(FIOCTL, IOCTL_BT_HCICMD_DETAIL, ("%"i64fmt"x\n",
2932                 (pBtHciInfo->BTEventMask & 0xffffffff)));
2933 #else
2934         RTPRINT(FIOCTL, IOCTL_BT_HCICMD_DETAIL, ("BTEventMask = 0x%"i64fmt"x\n",
2935                 pBtHciInfo->BTEventMask));
2936 #endif
2937
2938         //send command complete event here when all data are received.
2939         {
2940                 u8 localBuf[6] = "";
2941                 u8 *pRetPar;
2942                 u8 len = 0;
2943                 PPACKET_IRP_HCIEVENT_DATA PPacketIrpEvent;
2944
2945                 PPacketIrpEvent = (PPACKET_IRP_HCIEVENT_DATA)(&localBuf[0]);
2946
2947                 len += bthci_CommandCompleteHeader(&localBuf[0],
2948                         OGF_SET_EVENT_MASK_COMMAND,
2949                         HCI_SET_EVENT_MASK,
2950                         status);
2951
2952                 // Return parameters starts from here
2953                 pRetPar = &PPacketIrpEvent->Data[len];
2954                 pRetPar[0] = status;            //status
2955                 len += 1;
2956                 PPacketIrpEvent->Length = len;
2957
2958                 bthci_IndicateEvent(padapter, PPacketIrpEvent, len+2);
2959         }
2960
2961         return status;
2962 }
2963
2964 // 7.3.69
2965 static HCI_STATUS
2966 bthci_CmdSetEventMaskPage2(
2967         PADAPTER        padapter,
2968         PPACKET_IRP_HCICMD_DATA         pHciCmd
2969         )
2970 {
2971         HCI_STATUS              status = HCI_STATUS_SUCCESS;
2972         PBT30Info               pBTInfo = GET_BT_INFO(padapter);
2973         PBT_HCI_INFO    pBtHciInfo = &pBTInfo->BtHciInfo;
2974         u8      *pu8Temp;
2975
2976         pu8Temp = (u8*)&pHciCmd->Data[0];
2977         pBtHciInfo->BTEventMaskPage2 = *pu8Temp;
2978         RTPRINT(FIOCTL, (IOCTL_BT_HCICMD_DETAIL|IOCTL_BT_LOGO), ("BTEventMaskPage2 = 0x%"i64fmt"x\n",
2979                 pBtHciInfo->BTEventMaskPage2));
2980
2981         //send command complete event here when all data are received.
2982         {
2983                 u8 localBuf[6] = "";
2984                 u8 *pRetPar;
2985                 u8 len = 0;
2986                 PPACKET_IRP_HCIEVENT_DATA PPacketIrpEvent;
2987
2988                 PPacketIrpEvent = (PPACKET_IRP_HCIEVENT_DATA)(&localBuf[0]);
2989
2990                 len += bthci_CommandCompleteHeader(&localBuf[0],
2991                         OGF_SET_EVENT_MASK_COMMAND,
2992                         HCI_SET_EVENT_MASK_PAGE_2,
2993                         status);
2994
2995                 // Return parameters starts from here
2996                 pRetPar = &PPacketIrpEvent->Data[len];
2997                 pRetPar[0] = status;            //status
2998                 len += 1;
2999                 PPacketIrpEvent->Length = len;
3000
3001                 bthci_IndicateEvent(padapter, PPacketIrpEvent, len+2);
3002         }
3003
3004         return status;
3005 }
3006
3007 static HCI_STATUS
3008 bthci_CmdReadLocationData(
3009         PADAPTER        padapter,
3010         PPACKET_IRP_HCICMD_DATA         pHciCmd
3011         )
3012 {
3013         HCI_STATUS              status = HCI_STATUS_SUCCESS;
3014 //      PMGNT_INFO              pMgntInfo = &padapter->MgntInfo;
3015         PBT30Info               pBTInfo = GET_BT_INFO(padapter);
3016         PBT_HCI_INFO    pBtHciInfo = &pBTInfo->BtHciInfo;
3017
3018         {
3019                 u8 localBuf[12] = "";
3020                 u8 *pRetPar;
3021                 u8 len = 0;
3022                 PPACKET_IRP_HCIEVENT_DATA PPacketIrpEvent;
3023                 u16 *pu2Temp;
3024
3025                 PPacketIrpEvent = (PPACKET_IRP_HCIEVENT_DATA)(&localBuf[0]);
3026
3027                 len += bthci_CommandCompleteHeader(&localBuf[0],
3028                         OGF_SET_EVENT_MASK_COMMAND,
3029                         HCI_READ_LOCATION_DATA,
3030                         status);
3031                 RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("DomainAware = 0x%x\n", pBtHciInfo->LocationDomainAware));
3032                 RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("Domain = 0x%x\n", pBtHciInfo->LocationDomain));
3033                 RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("DomainOptions = 0x%x\n", pBtHciInfo->LocationDomainOptions));
3034                 RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("Options = 0x%x\n", pBtHciInfo->LocationOptions));
3035
3036                 // Return parameters starts from here
3037                 pRetPar = &PPacketIrpEvent->Data[len];
3038                 pRetPar[0] = status;
3039
3040                 pRetPar[1] = pBtHciInfo->LocationDomainAware;   //0x0;  // Location_Domain_Aware
3041                 pu2Temp = (u16*)&pRetPar[2];                                    // Location_Domain
3042                 *pu2Temp = pBtHciInfo->LocationDomain;          //0x5858;
3043                 pRetPar[4] = pBtHciInfo->LocationDomainOptions; //0x58; //Location_Domain_Options
3044                 pRetPar[5] = pBtHciInfo->LocationOptions;               //0x0;  //Location_Options
3045                 len+=6;
3046                 PPacketIrpEvent->Length = len;
3047
3048                 bthci_IndicateEvent(padapter, PPacketIrpEvent, len+2);
3049         }
3050         return status;
3051 }
3052
3053 static HCI_STATUS
3054 bthci_CmdWriteLocationData(
3055         PADAPTER        padapter,
3056         PPACKET_IRP_HCICMD_DATA         pHciCmd
3057         )
3058 {
3059         HCI_STATUS status = HCI_STATUS_SUCCESS;
3060         PBT30Info               pBTInfo = GET_BT_INFO(padapter);
3061         PBT_HCI_INFO    pBtHciInfo = &pBTInfo->BtHciInfo;
3062         u16     *pu2Temp;
3063
3064         pBtHciInfo->LocationDomainAware = pHciCmd->Data[0];
3065         pu2Temp = (u16*)&pHciCmd->Data[1];
3066         pBtHciInfo->LocationDomain = *pu2Temp;
3067         pBtHciInfo->LocationDomainOptions = pHciCmd->Data[3];
3068         pBtHciInfo->LocationOptions = pHciCmd->Data[4];
3069         RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("DomainAware = 0x%x\n", pBtHciInfo->LocationDomainAware));
3070         RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("Domain = 0x%x\n", pBtHciInfo->LocationDomain));
3071         RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("DomainOptions = 0x%x\n", pBtHciInfo->LocationDomainOptions));
3072         RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("Options = 0x%x\n", pBtHciInfo->LocationOptions));
3073
3074         //send command complete event here when all data are received.
3075         {
3076                 u8 localBuf[6] = "";
3077                 u8 *pRetPar;
3078                 u8 len = 0;
3079                 PPACKET_IRP_HCIEVENT_DATA PPacketIrpEvent;
3080
3081                 PPacketIrpEvent = (PPACKET_IRP_HCIEVENT_DATA)(&localBuf[0]);
3082
3083                 len += bthci_CommandCompleteHeader(&localBuf[0],
3084                         OGF_SET_EVENT_MASK_COMMAND,
3085                         HCI_WRITE_LOCATION_DATA,
3086                         status);
3087
3088                 // Return parameters starts from here
3089                 pRetPar = &PPacketIrpEvent->Data[len];
3090                 pRetPar[0] = status;            //status
3091                 len += 1;
3092                 PPacketIrpEvent->Length = len;
3093
3094                 bthci_IndicateEvent(padapter, PPacketIrpEvent, len+2);
3095         }
3096
3097         return status;
3098 }
3099
3100 static HCI_STATUS
3101 bthci_CmdReadFlowControlMode(
3102         PADAPTER        padapter,
3103         PPACKET_IRP_HCICMD_DATA         pHciCmd
3104         )
3105 {
3106         HCI_STATUS status = HCI_STATUS_SUCCESS;
3107         PBT30Info               pBTInfo = GET_BT_INFO(padapter);
3108         PBT_HCI_INFO    pBtHciInfo = &pBTInfo->BtHciInfo;
3109
3110         {
3111                 u8 localBuf[7] = "";
3112                 u8 *pRetPar;
3113                 u8 len = 0;
3114                 PPACKET_IRP_HCIEVENT_DATA PPacketIrpEvent;
3115
3116                 PPacketIrpEvent = (PPACKET_IRP_HCIEVENT_DATA)(&localBuf[0]);
3117
3118                 len += bthci_CommandCompleteHeader(&localBuf[0],
3119                         OGF_SET_EVENT_MASK_COMMAND,
3120                         HCI_READ_FLOW_CONTROL_MODE,
3121                         status);
3122
3123                 // Return parameters starts from here
3124                 pRetPar = &PPacketIrpEvent->Data[len];
3125                 pRetPar[0] = status;
3126                 pRetPar[1] = pBtHciInfo->FlowControlMode;       // Flow Control Mode
3127                 len += 2;
3128                 PPacketIrpEvent->Length = len;
3129
3130                 bthci_IndicateEvent(padapter, PPacketIrpEvent, len+2);
3131         }
3132         return status;
3133 }
3134
3135 static HCI_STATUS
3136 bthci_CmdWriteFlowControlMode(
3137         PADAPTER        padapter,
3138         PPACKET_IRP_HCICMD_DATA         pHciCmd
3139         )
3140 {
3141         HCI_STATUS status = HCI_STATUS_SUCCESS;
3142 //      PMGNT_INFO pMgntInfo = &padapter->MgntInfo;
3143         PBT30Info               pBTInfo = GET_BT_INFO(padapter);
3144         PBT_HCI_INFO    pBtHciInfo = &pBTInfo->BtHciInfo;
3145
3146         pBtHciInfo->FlowControlMode = pHciCmd->Data[0];
3147
3148         //send command complete event here when all data are received.
3149         {
3150                 u8 localBuf[6] = "";
3151                 u8 *pRetPar;
3152                 u8 len = 0;
3153                 PPACKET_IRP_HCIEVENT_DATA PPacketIrpEvent;
3154
3155                 PPacketIrpEvent = (PPACKET_IRP_HCIEVENT_DATA)(&localBuf[0]);
3156
3157                 len += bthci_CommandCompleteHeader(&localBuf[0],
3158                         OGF_SET_EVENT_MASK_COMMAND,
3159                         HCI_WRITE_FLOW_CONTROL_MODE,
3160                         status);
3161
3162                 // Return parameters starts from here
3163                 pRetPar = &PPacketIrpEvent->Data[len];
3164                 pRetPar[0] = status;            //status
3165                 len += 1;
3166                 PPacketIrpEvent->Length = len;
3167
3168                 bthci_IndicateEvent(padapter, PPacketIrpEvent, len+2);
3169         }
3170
3171         return status;
3172 }
3173
3174 static HCI_STATUS
3175 bthci_CmdReadBestEffortFlushTimeout(
3176         PADAPTER        padapter,
3177         PPACKET_IRP_HCICMD_DATA         pHciCmd
3178         )
3179 {
3180         HCI_STATUS status = HCI_STATUS_SUCCESS;
3181         PBT30Info pBTinfo = GET_BT_INFO(padapter);
3182         u16             i, j, logicHandle;
3183         u32             BestEffortFlushTimeout = 0xffffffff;
3184         u8              find = 0;
3185
3186         logicHandle = *((u16*)pHciCmd->Data);
3187         // find an matched logical link index and copy the data
3188         for (j=0; j<MAX_BT_ASOC_ENTRY_NUM; j++)
3189         {
3190                 for (i=0; i<MAX_LOGICAL_LINK_NUM; i++)
3191                 {
3192                         if (pBTinfo->BtAsocEntry[j].LogLinkCmdData[i].BtLogLinkhandle == logicHandle)
3193                         {
3194                                 BestEffortFlushTimeout = pBTinfo->BtAsocEntry[j].LogLinkCmdData[i].BestEffortFlushTimeout;
3195                                 find = 1;
3196                                 break;
3197                         }
3198                 }
3199         }
3200
3201         if (!find)
3202                 status = HCI_STATUS_UNKNOW_CONNECT_ID;
3203
3204         {
3205                 u8 localBuf[10] = "";
3206                 u8 *pRetPar;
3207                 u8 len = 0;
3208                 PPACKET_IRP_HCIEVENT_DATA PPacketIrpEvent;
3209                 u32 *pu4Temp;
3210
3211                 PPacketIrpEvent = (PPACKET_IRP_HCIEVENT_DATA)(&localBuf[0]);
3212
3213                 len += bthci_CommandCompleteHeader(&localBuf[0],
3214                         OGF_SET_EVENT_MASK_COMMAND,
3215                         HCI_READ_BEST_EFFORT_FLUSH_TIMEOUT,
3216                         status);
3217
3218                 // Return parameters starts from here
3219                 pRetPar = &PPacketIrpEvent->Data[len];
3220                 pRetPar[0] = status;
3221                 pu4Temp = (u32*)&pRetPar[1];                            // Best_Effort_Flush_Timeout
3222                 *pu4Temp = BestEffortFlushTimeout;
3223                 len += 5;
3224                 PPacketIrpEvent->Length = len;
3225
3226                 bthci_IndicateEvent(padapter, PPacketIrpEvent, len+2);
3227         }
3228         return status;
3229 }
3230
3231 static HCI_STATUS
3232 bthci_CmdWriteBestEffortFlushTimeout(
3233         PADAPTER        padapter,
3234         PPACKET_IRP_HCICMD_DATA         pHciCmd
3235         )
3236 {
3237         HCI_STATUS status = HCI_STATUS_SUCCESS;
3238         PBT30Info pBTinfo = GET_BT_INFO(padapter);
3239         u16             i, j, logicHandle;
3240         u32             BestEffortFlushTimeout = 0xffffffff;
3241         u8              find = 0;
3242
3243         logicHandle = *((u16*)pHciCmd->Data);
3244         BestEffortFlushTimeout = *((u32 *)(pHciCmd->Data+1));
3245
3246         // find an matched logical link index and copy the data
3247         for (j=0; j<MAX_BT_ASOC_ENTRY_NUM; j++)
3248         {
3249                 for (i=0; i<MAX_LOGICAL_LINK_NUM; i++)
3250                 {
3251                         if (pBTinfo->BtAsocEntry[j].LogLinkCmdData[i].BtLogLinkhandle == logicHandle)
3252                         {
3253                                 pBTinfo->BtAsocEntry[j].LogLinkCmdData[i].BestEffortFlushTimeout = BestEffortFlushTimeout;
3254                                 find = 1;
3255                                 break;
3256                         }
3257                 }
3258         }
3259
3260         if (!find)
3261                 status = HCI_STATUS_UNKNOW_CONNECT_ID;
3262
3263         {
3264                 u8 localBuf[6] = "";
3265                 u8 *pRetPar;
3266                 u8 len = 0;
3267                 PPACKET_IRP_HCIEVENT_DATA PPacketIrpEvent;
3268
3269                 PPacketIrpEvent = (PPACKET_IRP_HCIEVENT_DATA)(&localBuf[0]);
3270
3271                 len += bthci_CommandCompleteHeader(&localBuf[0],
3272                         OGF_SET_EVENT_MASK_COMMAND,
3273                         HCI_WRITE_BEST_EFFORT_FLUSH_TIMEOUT,
3274                         status);
3275
3276                 // Return parameters starts from here
3277                 pRetPar = &PPacketIrpEvent->Data[len];
3278                 pRetPar[0] = status;
3279                 len += 1;
3280                 PPacketIrpEvent->Length = len;
3281
3282                 bthci_IndicateEvent(padapter, PPacketIrpEvent, len+2);
3283         }
3284         return status;
3285 }
3286
3287 static HCI_STATUS
3288 bthci_CmdShortRangeMode(
3289         PADAPTER        padapter,
3290         PPACKET_IRP_HCICMD_DATA         pHciCmd
3291         )
3292 {
3293         HCI_STATUS status = HCI_STATUS_SUCCESS;
3294         PBT30Info       pBTInfo = GET_BT_INFO(padapter);
3295         u8                      PhyLinkHandle, EntryNum, ShortRangeMode;
3296
3297         PhyLinkHandle = pHciCmd->Data[0];
3298         ShortRangeMode = pHciCmd->Data[1];
3299         RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("PLH = 0x%x, Short_Range_Mode = 0x%x\n", PhyLinkHandle, ShortRangeMode));
3300
3301         EntryNum = bthci_GetCurrentEntryNum(padapter, PhyLinkHandle);
3302         if (EntryNum != 0xff)
3303         {
3304                 pBTInfo->BtAsocEntry[EntryNum].ShortRangeMode = ShortRangeMode;
3305         }
3306         else
3307         {
3308                 RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("No such PLH(0x%x)\n", PhyLinkHandle));
3309                 status = HCI_STATUS_UNKNOW_CONNECT_ID;
3310         }
3311
3312         bthci_EventCommandStatus(padapter,
3313                         OGF_SET_EVENT_MASK_COMMAND,
3314                         HCI_SHORT_RANGE_MODE,
3315                         status);
3316
3317         bthci_EventShortRangeModeChangeComplete(padapter, status, ShortRangeMode, EntryNum);
3318
3319         return status;
3320 }
3321
3322 static HCI_STATUS bthci_CmdReadLocalSupportedCommands(PADAPTER padapter)
3323 {
3324         HCI_STATUS status = HCI_STATUS_SUCCESS;
3325
3326         // send command complete event here when all data are received.
3327         {
3328                 //PVOID buffer = padapter->IrpHCILocalbuf.Ptr;
3329                 u8 localBuf[TmpLocalBufSize] = "";
3330                 u8 *pRetPar, *pSupportedCmds;
3331                 u8 len = 0;
3332                 PPACKET_IRP_HCIEVENT_DATA PPacketIrpEvent;
3333
3334                 PlatformZeroMemory(&localBuf[0], TmpLocalBufSize);
3335                 //PPacketIrpEvent = (PPACKET_IRP_HCIEVENT_DATA)(buffer);
3336                 PPacketIrpEvent = (PPACKET_IRP_HCIEVENT_DATA)(&localBuf[0]);
3337
3338                 len += bthci_CommandCompleteHeader(&localBuf[0],
3339                         OGF_INFORMATIONAL_PARAMETERS,
3340                         HCI_READ_LOCAL_SUPPORTED_COMMANDS,
3341                         status);
3342
3343                 // Return parameters starts from here
3344                 pRetPar = &PPacketIrpEvent->Data[len];
3345                 pRetPar[0] = status;            //status
3346                 len += 1;
3347                 pSupportedCmds = &pRetPar[1];
3348                 RTPRINT(FIOCTL, (IOCTL_BT_HCICMD|IOCTL_BT_LOGO), ("Octet[5]=0xc0\nBit [6]=Set Event Mask, [7]=Reset\n"));
3349                 pSupportedCmds[5] = 0xc0;
3350                 RTPRINT(FIOCTL, (IOCTL_BT_HCICMD|IOCTL_BT_LOGO), ("Octet[6]=0x01\nBit [0]=Set Event Filter\n"));
3351                 pSupportedCmds[6] = 0x01;
3352                 RTPRINT(FIOCTL, (IOCTL_BT_HCICMD|IOCTL_BT_LOGO), ("Octet[7]=0x0c\nBit [2]=Read Connection Accept Timeout, [3]=Write Connection Accept Timeout\n"));
3353                 pSupportedCmds[7] = 0x0c;
3354                 RTPRINT(FIOCTL, (IOCTL_BT_HCICMD|IOCTL_BT_LOGO), ("Octet[10]=0x80\nBit [7]=Host Number Of Completed Packets\n"));
3355                 pSupportedCmds[10] = 0x80;
3356                 RTPRINT(FIOCTL, (IOCTL_BT_HCICMD|IOCTL_BT_LOGO), ("Octet[11]=0x03\nBit [0]=Read Link Supervision Timeout, [1]=Write Link Supervision Timeout\n"));
3357                 pSupportedCmds[11] = 0x03;
3358                 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"));
3359                 pSupportedCmds[14] = 0xa8;
3360                 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"));
3361                 pSupportedCmds[15] = 0x1c;
3362                 //pSupportedCmds[16] = 0x04;
3363                 RTPRINT(FIOCTL, (IOCTL_BT_HCICMD|IOCTL_BT_LOGO), ("Octet[19]=0x40\nBit [6]=Enhanced Flush\n"));
3364                 pSupportedCmds[19] = 0x40;
3365                 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"));
3366                 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"));
3367                 pSupportedCmds[21] = 0xff;
3368                 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"));
3369                 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"));
3370                 pSupportedCmds[22] = 0xff;
3371                 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"));
3372                 pSupportedCmds[23] = 0x07;
3373                 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"));
3374                 pSupportedCmds[24] = 0x1c;
3375                 len += 64;
3376                 PPacketIrpEvent->Length = len;
3377
3378                 bthci_IndicateEvent(padapter, PPacketIrpEvent, len+2);
3379         }
3380
3381         return status;
3382 }
3383
3384 static HCI_STATUS bthci_CmdReadLocalSupportedFeatures(PADAPTER padapter)
3385 {
3386         HCI_STATUS status = HCI_STATUS_SUCCESS;
3387
3388         //send command complete event here when all data are received.
3389         {
3390                 //PVOID buffer = padapter->IrpHCILocalbuf.Ptr;
3391                 u8 localBuf[TmpLocalBufSize] = "";
3392                 u8 *pRetPar;
3393                 u8 len = 0;
3394                 PPACKET_IRP_HCIEVENT_DATA PPacketIrpEvent;
3395
3396                 PlatformZeroMemory(&localBuf[0], TmpLocalBufSize);
3397                 //PPacketIrpEvent = (PPACKET_IRP_HCIEVENT_DATA)(buffer);
3398                 PPacketIrpEvent = (PPACKET_IRP_HCIEVENT_DATA)(&localBuf[0]);
3399
3400                 len += bthci_CommandCompleteHeader(&localBuf[0],
3401                         OGF_INFORMATIONAL_PARAMETERS,
3402                         HCI_READ_LOCAL_SUPPORTED_FEATURES,
3403                         status);
3404
3405                 // Return parameters starts from here
3406                 pRetPar = &PPacketIrpEvent->Data[len];
3407                 pRetPar[0] = status;            //status
3408                 len += 9;
3409                 PPacketIrpEvent->Length = len;
3410
3411                 bthci_IndicateEvent(padapter, PPacketIrpEvent, len+2);
3412         }
3413         return status;
3414 }
3415
3416 static HCI_STATUS
3417 bthci_CmdReadLocalAMPAssoc(
3418         PADAPTER        padapter,
3419         PPACKET_IRP_HCICMD_DATA         pHciCmd
3420         )
3421 {
3422         HCI_STATUS status = HCI_STATUS_SUCCESS;
3423         PBT30Info       pBTInfo = GET_BT_INFO(padapter);
3424         PBT_MGNT        pBtMgnt = &pBTInfo->BtMgnt;
3425         PBT_DBG         pBtDbg = &pBTInfo->BtDbg;
3426         u8                      PhyLinkHandle, EntryNum;
3427
3428         pBtDbg->dbgHciInfo.hciCmdCntReadLocalAmpAssoc++;
3429         PhyLinkHandle = *((u8*)pHciCmd->Data);
3430         EntryNum = bthci_GetCurrentEntryNum(padapter, PhyLinkHandle);
3431
3432         if ((EntryNum==0xff) && PhyLinkHandle != 0)
3433         {
3434                 RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("ReadLocalAMPAssoc, EntryNum = %d  !!!!!, physical link handle = 0x%x\n",
3435                 EntryNum, PhyLinkHandle));
3436                 status = HCI_STATUS_UNKNOW_CONNECT_ID;
3437         }
3438         else if (pBtMgnt->bPhyLinkInProgressStartLL)
3439         {
3440                 status = HCI_STATUS_UNKNOW_CONNECT_ID;
3441                 pBtMgnt->bPhyLinkInProgressStartLL = _FALSE;
3442         }
3443         else
3444         {
3445                 pBTInfo->BtAsocEntry[EntryNum].AmpAsocCmdData.BtPhyLinkhandle = *((u8*)pHciCmd->Data);
3446                 pBTInfo->BtAsocEntry[EntryNum].AmpAsocCmdData.LenSoFar = *((u16*)((u8*)pHciCmd->Data+1));
3447                 pBTInfo->BtAsocEntry[EntryNum].AmpAsocCmdData.MaxRemoteASSOCLen = *((u16*)((u8*)pHciCmd->Data+3));
3448                 RTPRINT(FIOCTL, IOCTL_BT_HCICMD_DETAIL, ("ReadLocalAMPAssoc, LenSoFar=%d, MaxRemoteASSOCLen=%d\n",
3449                         pBTInfo->BtAsocEntry[EntryNum].AmpAsocCmdData.LenSoFar,
3450                         pBTInfo->BtAsocEntry[EntryNum].AmpAsocCmdData.MaxRemoteASSOCLen));
3451         }
3452
3453         RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("ReadLocalAMPAssoc, EntryNum = %d  !!!!!, physical link handle = 0x%x, LengthSoFar = %x  \n",
3454                 EntryNum, PhyLinkHandle, pBTInfo->BtAsocEntry[EntryNum].AmpAsocCmdData.LenSoFar));
3455
3456         //send command complete event here when all data are received.
3457         {
3458                 PPACKET_IRP_HCIEVENT_DATA PPacketIrpEvent;
3459
3460                 //PVOID buffer = padapter->IrpHCILocalbuf.Ptr;
3461                 u8 localBuf[TmpLocalBufSize] = "";
3462                 u16     *pRemainLen;
3463                 u32     totalLen = 0;
3464                 u16     typeLen=0, remainLen=0, ret_index=0;
3465                 u8 *pRetPar;
3466
3467                 PlatformZeroMemory(&localBuf[0], TmpLocalBufSize);
3468                 //PPacketIrpEvent = (PPACKET_IRP_HCIEVENT_DATA)(buffer);
3469                 PPacketIrpEvent = (PPACKET_IRP_HCIEVENT_DATA)(&localBuf[0]);
3470
3471                 totalLen += bthci_CommandCompleteHeader(&localBuf[0],
3472                         OGF_STATUS_PARAMETERS,
3473                         HCI_READ_LOCAL_AMP_ASSOC,
3474                         status);
3475                 RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("ReadLocalAMPAssoc, Remaining_Len=%d  \n", remainLen));
3476                 // Return parameters starts from here
3477                 pRetPar = &PPacketIrpEvent->Data[totalLen];
3478                 pRetPar[0] = status;            //status
3479                 pRetPar[1] = *((u8*)pHciCmd->Data);
3480                 pRemainLen = (u16*)&pRetPar[2];         // AMP_ASSOC_Remaining_Length
3481                 totalLen += 4;  //[0]~[3]
3482                 ret_index = 4;
3483
3484                 typeLen = bthci_AssocMACAddr(padapter, &pRetPar[ret_index]);
3485                 totalLen += typeLen;
3486                 remainLen += typeLen;
3487                 ret_index += typeLen;
3488                 typeLen = bthci_AssocPreferredChannelList(padapter, &pRetPar[ret_index], EntryNum);
3489                 totalLen += typeLen;
3490                 remainLen += typeLen;
3491                 ret_index += typeLen;
3492                 typeLen = bthci_PALCapabilities(padapter, &pRetPar[ret_index]);
3493                 totalLen += typeLen;
3494                 remainLen += typeLen;
3495                 ret_index += typeLen;
3496                 typeLen = bthci_AssocPALVer(padapter, &pRetPar[ret_index]);
3497                 totalLen += typeLen;
3498                 remainLen += typeLen;
3499 #if 0//for logo special test case only
3500                 ret_index += typeLen;
3501                 typeLen = bthci_ReservedForTestingPLV(padapter, &pRetPar[ret_index]);
3502                 totalLen += typeLen;
3503                 remainLen += typeLen;
3504 #endif
3505                 PPacketIrpEvent->Length = (UCHAR)totalLen;
3506                 *pRemainLen = remainLen;        // AMP_ASSOC_Remaining_Length
3507                 RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("ReadLocalAMPAssoc, Remaining_Len=%d  \n", remainLen));
3508                 RTPRINT_DATA(FIOCTL, (IOCTL_BT_HCICMD_DETAIL|IOCTL_BT_LOGO), ("AMP_ASSOC_fragment : \n"), PPacketIrpEvent->Data, totalLen);
3509
3510                 bthci_IndicateEvent(padapter, PPacketIrpEvent, totalLen+2);
3511         }
3512
3513         return status;
3514 }
3515
3516 static HCI_STATUS
3517 bthci_CmdReadFailedContactCounter(
3518         PADAPTER        padapter,
3519         PPACKET_IRP_HCICMD_DATA         pHciCmd
3520         )
3521 {
3522
3523         HCI_STATUS              status = HCI_STATUS_SUCCESS;
3524 //      PMGNT_INFO              pMgntInfo = &padapter->MgntInfo;
3525         PBT30Info               pBTInfo = GET_BT_INFO(padapter);
3526         PBT_HCI_INFO    pBtHciInfo = &pBTInfo->BtHciInfo;
3527         u16             handle;
3528
3529         handle=*((u16*)pHciCmd->Data);
3530         //send command complete event here when all data are received.
3531         {
3532                 u8 localBuf[TmpLocalBufSize] = "";
3533                 u8 *pRetPar;
3534                 u8 len = 0;
3535                 PPACKET_IRP_HCIEVENT_DATA PPacketIrpEvent;
3536
3537                 PlatformZeroMemory(&localBuf[0], TmpLocalBufSize);
3538                 PPacketIrpEvent = (PPACKET_IRP_HCIEVENT_DATA)(&localBuf[0]);
3539
3540                 len += bthci_CommandCompleteHeader(&localBuf[0],
3541                         OGF_STATUS_PARAMETERS,
3542                         HCI_READ_FAILED_CONTACT_COUNTER,
3543                         status);
3544
3545                 // Return parameters starts from here
3546                 pRetPar = &PPacketIrpEvent->Data[len];
3547                 pRetPar[0] = status;            //status
3548                 pRetPar[1] = TWOBYTE_LOWBYTE(handle);
3549                 pRetPar[2] = TWOBYTE_HIGHTBYTE(handle);
3550                 pRetPar[3] = TWOBYTE_LOWBYTE(pBtHciInfo->FailContactCount);
3551                 pRetPar[4] = TWOBYTE_HIGHTBYTE(pBtHciInfo->FailContactCount);
3552                 len += 5;
3553                 PPacketIrpEvent->Length = len;
3554
3555                 bthci_IndicateEvent(padapter, PPacketIrpEvent, len+2);
3556         }
3557
3558         return status;
3559 }
3560
3561 static HCI_STATUS
3562 bthci_CmdResetFailedContactCounter(
3563         PADAPTER        padapter,
3564         PPACKET_IRP_HCICMD_DATA         pHciCmd
3565         )
3566 {
3567         HCI_STATUS              status = HCI_STATUS_SUCCESS;
3568 //      PMGNT_INFO              pMgntInfo = &padapter->MgntInfo;
3569         PBT30Info               pBTInfo = GET_BT_INFO(padapter);
3570         PBT_HCI_INFO    pBtHciInfo = &pBTInfo->BtHciInfo;
3571         u16             handle;
3572
3573         handle=*((u16*)pHciCmd->Data);
3574         pBtHciInfo->FailContactCount=0;
3575
3576         //send command complete event here when all data are received.
3577         {
3578                 //PVOID buffer = padapter->IrpHCILocalbuf.Ptr;
3579                 u8 localBuf[TmpLocalBufSize] = "";
3580                 u8 *pRetPar;
3581                 u8 len = 0;
3582                 PPACKET_IRP_HCIEVENT_DATA PPacketIrpEvent;
3583
3584                 PlatformZeroMemory(&localBuf[0], TmpLocalBufSize);
3585                 //PPacketIrpEvent = (PPACKET_IRP_HCIEVENT_DATA)(buffer);
3586                 PPacketIrpEvent = (PPACKET_IRP_HCIEVENT_DATA)(&localBuf[0]);
3587
3588                 len += bthci_CommandCompleteHeader(&localBuf[0],
3589                         OGF_STATUS_PARAMETERS,
3590                         HCI_RESET_FAILED_CONTACT_COUNTER,
3591                         status);
3592
3593                 // Return parameters starts from here
3594                 pRetPar = &PPacketIrpEvent->Data[len];
3595                 pRetPar[0] = status;            //status
3596                 pRetPar[1] = TWOBYTE_LOWBYTE(handle);
3597                 pRetPar[2] = TWOBYTE_HIGHTBYTE(handle);
3598                 len+=3;
3599                 PPacketIrpEvent->Length = len;
3600
3601                 bthci_IndicateEvent(padapter, PPacketIrpEvent, len+2);
3602         }
3603         return status;
3604 }
3605
3606 //
3607 // BT 3.0+HS [Vol 2] 7.4.1
3608 //
3609 static HCI_STATUS
3610 bthci_CmdReadLocalVersionInformation(
3611         PADAPTER        padapter
3612         )
3613 {
3614         HCI_STATUS status = HCI_STATUS_SUCCESS;
3615
3616         //send command complete event here when all data are received.
3617         {
3618                 //PVOID buffer = padapter->IrpHCILocalbuf.Ptr;
3619                 u8 localBuf[TmpLocalBufSize] = "";
3620                 u8 *pRetPar;
3621                 u8 len = 0;
3622                 PPACKET_IRP_HCIEVENT_DATA PPacketIrpEvent;
3623                 u16 *pu2Temp;
3624
3625                 PlatformZeroMemory(&localBuf[0], TmpLocalBufSize);
3626                 //PPacketIrpEvent = (PPACKET_IRP_HCIEVENT_DATA)(buffer);
3627                 PPacketIrpEvent = (PPACKET_IRP_HCIEVENT_DATA)(&localBuf[0]);
3628
3629                 len += bthci_CommandCompleteHeader(&localBuf[0],
3630                         OGF_INFORMATIONAL_PARAMETERS,
3631                         HCI_READ_LOCAL_VERSION_INFORMATION,
3632                         status);
3633
3634                 // Return parameters starts from here
3635                 pRetPar = &PPacketIrpEvent->Data[len];
3636                 pRetPar[0] = status;            //status
3637                 pRetPar[1] = 0x05;                                      // HCI_Version
3638                 pu2Temp = (u16*)&pRetPar[2];            // HCI_Revision
3639                 *pu2Temp = 0x0001;
3640                 pRetPar[4] = 0x05;                                      // LMP/PAL_Version
3641                 pu2Temp = (u16*)&pRetPar[5];            // Manufacturer_Name
3642                 *pu2Temp = 0x005d;
3643                 pu2Temp = (u16*)&pRetPar[7];            // LMP/PAL_Subversion
3644                 *pu2Temp = 0x0001;
3645                 len += 9;
3646                 PPacketIrpEvent->Length = len;
3647
3648                 RTPRINT(FIOCTL, (IOCTL_BT_HCICMD_DETAIL|IOCTL_BT_LOGO), ("LOCAL_VERSION_INFORMATION\n"));
3649                 RTPRINT(FIOCTL, (IOCTL_BT_HCICMD_DETAIL|IOCTL_BT_LOGO), ("Status  %x\n",status));
3650                 RTPRINT(FIOCTL, (IOCTL_BT_HCICMD_DETAIL|IOCTL_BT_LOGO), ("HCI_Version = 0x05\n"));
3651                 RTPRINT(FIOCTL, (IOCTL_BT_HCICMD_DETAIL|IOCTL_BT_LOGO), ("HCI_Revision = 0x0001\n"));
3652                 RTPRINT(FIOCTL, (IOCTL_BT_HCICMD_DETAIL|IOCTL_BT_LOGO), ("LMP/PAL_Version = 0x05\n"));
3653                 RTPRINT(FIOCTL, (IOCTL_BT_HCICMD_DETAIL|IOCTL_BT_LOGO), ("Manufacturer_Name = 0x0001\n"));
3654                 RTPRINT(FIOCTL, (IOCTL_BT_HCICMD_DETAIL|IOCTL_BT_LOGO), ("LMP/PAL_Subversion = 0x0001\n"));
3655
3656                 bthci_IndicateEvent(padapter, PPacketIrpEvent, len+2);
3657         }
3658
3659         return status;
3660 }
3661
3662 //7.4.7
3663 static HCI_STATUS bthci_CmdReadDataBlockSize(PADAPTER padapter)
3664 {
3665         HCI_STATUS                      status = HCI_STATUS_SUCCESS;
3666
3667         {
3668                 //PVOID buffer = padapter->IrpHCILocalbuf.Ptr;
3669                 u8 localBuf[TmpLocalBufSize] = "";
3670                 u8 *pRetPar;
3671                 u8 len = 0;
3672                 PPACKET_IRP_HCIEVENT_DATA PPacketIrpEvent;
3673                 u16 *pu2Temp;
3674
3675                 PlatformZeroMemory(&localBuf[0], TmpLocalBufSize);
3676                 //PPacketIrpEvent = (PPACKET_IRP_HCIEVENT_DATA)(buffer);
3677                 PPacketIrpEvent = (PPACKET_IRP_HCIEVENT_DATA)(&localBuf[0]);
3678
3679                 len += bthci_CommandCompleteHeader(&localBuf[0],
3680                         OGF_INFORMATIONAL_PARAMETERS,
3681                         HCI_READ_DATA_BLOCK_SIZE,
3682                         status);
3683
3684                 // Return parameters starts from here
3685                 pRetPar = &PPacketIrpEvent->Data[len];
3686                 pRetPar[0] = HCI_STATUS_SUCCESS;                //status
3687                 pu2Temp = (u16*)&pRetPar[1];            // Max_ACL_Data_Packet_Length
3688                 *pu2Temp = Max80211PALPDUSize;
3689
3690                 pu2Temp = (u16*)&pRetPar[3];            // Data_Block_Length
3691                 *pu2Temp = Max80211PALPDUSize;
3692                 pu2Temp = (u16*)&pRetPar[5];            // Total_Num_Data_Blocks
3693                 *pu2Temp = BTTotalDataBlockNum;
3694                 len += 7;
3695                 PPacketIrpEvent->Length = len;
3696
3697                 bthci_IndicateEvent(padapter, PPacketIrpEvent, len+2);
3698         }
3699
3700         return status;
3701 }
3702
3703 // 7.4.5
3704 static HCI_STATUS
3705 bthci_CmdReadBufferSize(
3706         PADAPTER                                        padapter
3707         )
3708 {
3709         HCI_STATUS                      status = HCI_STATUS_SUCCESS;
3710
3711         {
3712                 //PVOID buffer = padapter->IrpHCILocalbuf.Ptr;
3713                 u8 localBuf[TmpLocalBufSize] = "";
3714                 u8 *pRetPar;
3715                 u8 len = 0;
3716                 PPACKET_IRP_HCIEVENT_DATA PPacketIrpEvent;
3717                 u16 *pu2Temp;
3718
3719                 PlatformZeroMemory(&localBuf[0], TmpLocalBufSize);
3720                 //PPacketIrpEvent = (PPACKET_IRP_HCIEVENT_DATA)(buffer);
3721                 PPacketIrpEvent = (PPACKET_IRP_HCIEVENT_DATA)(&localBuf[0]);
3722
3723                 len += bthci_CommandCompleteHeader(&localBuf[0],
3724                         OGF_INFORMATIONAL_PARAMETERS,
3725                         HCI_READ_BUFFER_SIZE,
3726                         status);
3727                 RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("Synchronous_Data_Packet_Length = 0x%x\n", BTSynDataPacketLength));
3728                 RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("Total_Num_ACL_Data_Packets = 0x%x\n", BTTotalDataBlockNum));
3729                 RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("Total_Num_Synchronous_Data_Packets = 0x%x\n", BTTotalDataBlockNum));
3730                 // Return parameters starts from here
3731                 pRetPar = &PPacketIrpEvent->Data[len];
3732                 pRetPar[0] = status;            //status
3733                 pu2Temp = (u16*)&pRetPar[1];            // HC_ACL_Data_Packet_Length
3734                 *pu2Temp = Max80211PALPDUSize;
3735
3736                 pRetPar[3] = BTSynDataPacketLength;     // HC_Synchronous_Data_Packet_Length
3737                 pu2Temp = (u16*)&pRetPar[4];            // HC_Total_Num_ACL_Data_Packets
3738                 *pu2Temp = BTTotalDataBlockNum;
3739                 pu2Temp = (u16*)&pRetPar[6];            // HC_Total_Num_Synchronous_Data_Packets
3740                 *pu2Temp = BTTotalDataBlockNum;
3741                 len += 8;
3742                 PPacketIrpEvent->Length = len;
3743
3744                 bthci_IndicateEvent(padapter, PPacketIrpEvent, len+2);
3745         }
3746
3747         return status;
3748 }
3749
3750 static HCI_STATUS
3751 bthci_CmdReadLocalAMPInfo(
3752         PADAPTER                                        padapter
3753         )
3754 {
3755         HCI_STATUS                      status = HCI_STATUS_SUCCESS;
3756
3757         {
3758 //              PMGNT_INFO pMgntInfo = &padapter->MgntInfo;
3759                 struct pwrctrl_priv *ppwrctrl = &padapter->pwrctrlpriv;
3760                 u8 localBuf[TmpLocalBufSize] = "";
3761                 u8 *pRetPar;
3762                 u8 len = 0;
3763                 PPACKET_IRP_HCIEVENT_DATA PPacketIrpEvent;
3764                 u16 *pu2Temp;
3765                 u32 *pu4Temp;
3766                 u32     TotalBandwidth=BTTOTALBANDWIDTH, MaxBandGUBandwidth=BTMAXBANDGUBANDWIDTH;
3767                 u8      ControlType=0x01, AmpStatus=0x01;
3768                 u32     MaxFlushTimeout=10000, BestEffortFlushTimeout=5000;
3769                 u16 MaxPDUSize=Max80211PALPDUSize, PalCap=0x1, AmpAssocLen=Max80211AMPASSOCLen, MinLatency=20;
3770
3771                 if ((ppwrctrl->rfoff_reason & RF_CHANGE_BY_HW) ||
3772                         (ppwrctrl->rfoff_reason & RF_CHANGE_BY_SW))
3773                 {
3774                         AmpStatus = AMP_STATUS_NO_CAPACITY_FOR_BT;
3775                 }
3776
3777                 PlatformZeroMemory(&localBuf[0], TmpLocalBufSize);
3778                 //PPacketIrpEvent = (PPACKET_IRP_HCIEVENT_DATA)(buffer);
3779                 PPacketIrpEvent = (PPACKET_IRP_HCIEVENT_DATA)(&localBuf[0]);
3780
3781                 len += bthci_CommandCompleteHeader(&localBuf[0],
3782                         OGF_STATUS_PARAMETERS,
3783                         HCI_READ_LOCAL_AMP_INFO,
3784                         status);
3785
3786                 // Return parameters starts from here
3787                 pRetPar = &PPacketIrpEvent->Data[len];
3788                 pRetPar[0] = status;            //status
3789                 pRetPar[1] = AmpStatus;                                         // AMP_Status
3790                 pu4Temp = (u32*)&pRetPar[2];            // Total_Bandwidth
3791                 *pu4Temp = TotalBandwidth;//0x19bfcc00;//0x7530;
3792                 pu4Temp = (u32*)&pRetPar[6];            // Max_Guaranteed_Bandwidth
3793                 *pu4Temp = MaxBandGUBandwidth;//0x19bfcc00;//0x4e20;
3794                 pu4Temp = (u32*)&pRetPar[10];           // Min_Latency
3795                 *pu4Temp = MinLatency;//150;
3796                 pu4Temp = (u32*)&pRetPar[14];           // Max_PDU_Size
3797                 *pu4Temp = MaxPDUSize;
3798                 pRetPar[18] = ControlType;                                      // Controller_Type
3799                 pu2Temp = (u16*)&pRetPar[19];           // PAL_Capabilities
3800                 *pu2Temp = PalCap;
3801                 pu2Temp = (u16*)&pRetPar[21];           // AMP_ASSOC_Length
3802                 *pu2Temp = AmpAssocLen;
3803                 pu4Temp = (u32*)&pRetPar[23];           // Max_Flush_Timeout
3804                 *pu4Temp = MaxFlushTimeout;
3805                 pu4Temp = (u32*)&pRetPar[27];           // Best_Effort_Flush_Timeout
3806                 *pu4Temp = BestEffortFlushTimeout;
3807                 len += 31;
3808                 PPacketIrpEvent->Length = len;
3809                 RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("AmpStatus = 0x%x\n",
3810                         AmpStatus));
3811                 RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("TotalBandwidth = 0x%x, MaxBandGUBandwidth = 0x%x, MinLatency = 0x%x, \n MaxPDUSize = 0x%x, ControlType = 0x%x\n",
3812                         TotalBandwidth,MaxBandGUBandwidth,MinLatency,MaxPDUSize,ControlType));
3813                 RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("PalCap = 0x%x, AmpAssocLen = 0x%x, MaxFlushTimeout = 0x%x, BestEffortFlushTimeout = 0x%x\n",
3814                         PalCap,AmpAssocLen,MaxFlushTimeout,BestEffortFlushTimeout));
3815                 bthci_IndicateEvent(padapter, PPacketIrpEvent, len+2);
3816         }
3817
3818         return status;
3819 }
3820
3821 static HCI_STATUS
3822 bthci_CmdCreatePhysicalLink(
3823         PADAPTER        padapter,
3824         PPACKET_IRP_HCICMD_DATA         pHciCmd
3825         )
3826 {
3827         HCI_STATUS      status;
3828         PBT30Info       pBTInfo = GET_BT_INFO(padapter);
3829         PBT_DBG         pBtDbg = &pBTInfo->BtDbg;
3830
3831         pBtDbg->dbgHciInfo.hciCmdCntCreatePhyLink++;
3832
3833         status = bthci_BuildPhysicalLink(padapter,
3834                 pHciCmd, HCI_CREATE_PHYSICAL_LINK);
3835
3836         return status;
3837 }
3838
3839 static HCI_STATUS
3840 bthci_CmdReadLinkQuality(
3841         PADAPTER                                        padapter,
3842         PPACKET_IRP_HCICMD_DATA         pHciCmd
3843         )
3844 {
3845         HCI_STATUS                      status = HCI_STATUS_SUCCESS;
3846         PBT30Info                       pBTInfo = GET_BT_INFO(padapter);
3847         u16                             PLH;
3848         u8                              EntryNum, LinkQuality=0x55;
3849
3850         PLH = *((u16*)&pHciCmd->Data[0]);
3851         RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("PLH = 0x%x\n", PLH));
3852
3853         EntryNum = bthci_GetCurrentEntryNum(padapter, (u8)PLH);
3854         if (EntryNum == 0xff)
3855         {
3856                 RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("No such PLH(0x%x)\n", PLH));
3857                 status=HCI_STATUS_UNKNOW_CONNECT_ID;
3858         }
3859
3860         {
3861                 u8 localBuf[11] = "";
3862                 u8 *pRetPar;
3863                 u8 len = 0;
3864                 PPACKET_IRP_HCIEVENT_DATA PPacketIrpEvent;
3865
3866                 PPacketIrpEvent = (PPACKET_IRP_HCIEVENT_DATA)(&localBuf[0]);
3867
3868                 len += bthci_CommandCompleteHeader(&localBuf[0],
3869                         OGF_STATUS_PARAMETERS,
3870                         HCI_READ_LINK_QUALITY,
3871                         status);
3872
3873                 RTPRINT(FIOCTL, IOCTL_BT_HCICMD, (" PLH = 0x%x\n Link Quality = 0x%x\n", PLH, LinkQuality));
3874
3875                 // Return parameters starts from here
3876                 pRetPar = &PPacketIrpEvent->Data[len];
3877                 pRetPar[0] = status;                    //status
3878                 *((u16*)&(pRetPar[1])) = pBTInfo->BtAsocEntry[EntryNum].PhyLinkCmdData.BtPhyLinkhandle; // Handle
3879                 pRetPar[3] = 0x55;      //Link Quailty
3880                 len += 4;
3881                 PPacketIrpEvent->Length = len;
3882
3883                 bthci_IndicateEvent(padapter, PPacketIrpEvent, len+2);
3884         }
3885
3886         return status;
3887 }
3888
3889 static HCI_STATUS bthci_CmdReadRSSI(PADAPTER padapter)
3890 {
3891         HCI_STATUS status = HCI_STATUS_SUCCESS;
3892         return status;
3893 }
3894
3895 static HCI_STATUS
3896 bthci_CmdCreateLogicalLink(
3897         PADAPTER        padapter,
3898         PPACKET_IRP_HCICMD_DATA         pHciCmd
3899         )
3900 {
3901         HCI_STATUS status = HCI_STATUS_SUCCESS;
3902         PBT30Info       pBTInfo = GET_BT_INFO(padapter);
3903         PBT_DBG         pBtDbg = &pBTInfo->BtDbg;
3904
3905         pBtDbg->dbgHciInfo.hciCmdCntCreateLogLink++;
3906
3907         bthci_BuildLogicalLink(padapter, pHciCmd,
3908                 HCI_CREATE_LOGICAL_LINK);
3909
3910         return status;
3911 }
3912
3913 static HCI_STATUS
3914 bthci_CmdAcceptLogicalLink(
3915         PADAPTER        padapter,
3916         PPACKET_IRP_HCICMD_DATA         pHciCmd
3917         )
3918 {
3919         HCI_STATUS status = HCI_STATUS_SUCCESS;
3920         PBT30Info       pBTInfo = GET_BT_INFO(padapter);
3921         PBT_DBG         pBtDbg = &pBTInfo->BtDbg;
3922
3923         pBtDbg->dbgHciInfo.hciCmdCntAcceptLogLink++;
3924
3925         bthci_BuildLogicalLink(padapter, pHciCmd,
3926                 HCI_ACCEPT_LOGICAL_LINK);
3927
3928         return status;
3929 }
3930
3931 static HCI_STATUS
3932 bthci_CmdDisconnectLogicalLink(
3933         PADAPTER        padapter,
3934         PPACKET_IRP_HCICMD_DATA         pHciCmd
3935         )
3936 {
3937         HCI_STATUS status = HCI_STATUS_SUCCESS;
3938 //      PMGNT_INFO pMgntInfo = &padapter->MgntInfo;
3939         PBT30Info       pBTinfo = GET_BT_INFO(padapter);
3940         PBT_MGNT        pBtMgnt = &pBTinfo->BtMgnt;
3941         PBT_DBG         pBtDbg = &pBTinfo->BtDbg;
3942         u16     logicHandle;
3943         u8 i, j, find=0, LogLinkCount=0;
3944
3945         pBtDbg->dbgHciInfo.hciCmdCntDisconnectLogLink++;
3946
3947         logicHandle = *((u16*)pHciCmd->Data);
3948         RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("DisconnectLogicalLink, logicHandle = 0x%x\n", logicHandle));
3949
3950         // find an created logical link index and clear the data
3951         for (j=0; j<MAX_BT_ASOC_ENTRY_NUM;j++)
3952         {
3953                 for (i=0; i<MAX_LOGICAL_LINK_NUM; i++)
3954                 {
3955                         if (pBTinfo->BtAsocEntry[j].LogLinkCmdData[i].BtLogLinkhandle == logicHandle)
3956                         {
3957                                 RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("DisconnectLogicalLink, logicHandle is matched  0x%x\n", logicHandle));
3958                                 bthci_ResetFlowSpec(padapter, j, i);
3959                                 find = 1;
3960                                 pBtMgnt->DisconnectEntryNum = j;
3961                                 break;
3962                         }
3963                 }
3964         }
3965
3966         if (!find)
3967                 status = HCI_STATUS_UNKNOW_CONNECT_ID;
3968
3969         // To check each
3970         for (i=0; i<MAX_LOGICAL_LINK_NUM; i++)
3971         {
3972                 if (pBTinfo->BtAsocEntry[pBtMgnt->DisconnectEntryNum].LogLinkCmdData[i].BtLogLinkhandle !=0)
3973                 {
3974                         LogLinkCount++;
3975                 }
3976         }
3977
3978         //When we receive Create logical link command, we should send command status event first.
3979         bthci_EventCommandStatus(padapter,
3980                         OGF_LINK_CONTROL_COMMANDS,
3981                         HCI_DISCONNECT_LOGICAL_LINK,
3982                         status);
3983         //
3984         //When we determines the logical link is established, we should send command complete event.
3985         //
3986         if (status == HCI_STATUS_SUCCESS)
3987         {
3988                 bthci_EventDisconnectLogicalLinkComplete(padapter, status,
3989                         logicHandle, HCI_STATUS_CONNECT_TERMINATE_LOCAL_HOST);
3990         }
3991
3992         if (LogLinkCount == 0)
3993                 PlatformSetTimer(padapter, &pBTinfo->BTDisconnectPhyLinkTimer, 100);
3994
3995         return status;
3996 }
3997
3998 HCI_STATUS
3999 bthci_CmdLogicalLinkCancel(
4000         PADAPTER        padapter,
4001         PPACKET_IRP_HCICMD_DATA         pHciCmd
4002         )
4003 {
4004         HCI_STATUS status = HCI_STATUS_SUCCESS;
4005         PBT30Info       pBTinfo = GET_BT_INFO(padapter);
4006         PBT_MGNT        pBtMgnt = &pBTinfo->BtMgnt;
4007         u8      CurrentEntryNum, CurrentLogEntryNum;
4008
4009         u8      physicalLinkHandle, TxFlowSpecID,i;
4010         u16     CurrentLogicalHandle;
4011
4012         physicalLinkHandle = *((u8*)pHciCmd->Data);
4013         TxFlowSpecID = *(((u8*)pHciCmd->Data)+1);
4014
4015         RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("LogicalLinkCancel, physicalLinkHandle = 0x%x, TxFlowSpecID = 0x%x\n",
4016                 physicalLinkHandle, TxFlowSpecID));
4017
4018         CurrentEntryNum=pBtMgnt->CurrentConnectEntryNum;
4019         CurrentLogicalHandle = pBtMgnt->BtCurrentLogLinkhandle;
4020
4021         RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("CurrentEntryNum=0x%x, CurrentLogicalHandle = 0x%x\n",
4022                 CurrentEntryNum, CurrentLogicalHandle));
4023
4024         CurrentLogEntryNum = 0xff;
4025         for (i=0; i<MAX_LOGICAL_LINK_NUM; i++)
4026         {
4027                 if ((CurrentLogicalHandle == pBTinfo->BtAsocEntry[CurrentEntryNum].LogLinkCmdData[i].BtLogLinkhandle) &&
4028                         (physicalLinkHandle == pBTinfo->BtAsocEntry[CurrentEntryNum].LogLinkCmdData[i].BtPhyLinkhandle))
4029                 {
4030                         CurrentLogEntryNum = i;
4031                         break;
4032                 }
4033         }
4034
4035         if (CurrentLogEntryNum == 0xff)
4036         {
4037                 RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("LogicalLinkCancel, CurrentLogEntryNum==0xff !!!!\n"));
4038                 status=HCI_STATUS_UNKNOW_CONNECT_ID;
4039         }
4040         else
4041         {
4042                 if (pBTinfo->BtAsocEntry[CurrentEntryNum].LogLinkCmdData[CurrentLogEntryNum].bLLCompleteEventIsSet)
4043                 {
4044                         RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("LogicalLinkCancel, LLCompleteEventIsSet!!!!\n"));
4045                         status=HCI_STATUS_ACL_CONNECT_EXISTS;
4046                 }
4047         }
4048
4049         {
4050                 u8 localBuf[8] = "";
4051                 u8 *pRetPar;
4052                 u8 len = 0;
4053                 PPACKET_IRP_HCIEVENT_DATA PPacketIrpEvent;
4054
4055                 PPacketIrpEvent = (PPACKET_IRP_HCIEVENT_DATA)(&localBuf[0]);
4056
4057                 len += bthci_CommandCompleteHeader(&localBuf[0],
4058                         OGF_LINK_CONTROL_COMMANDS,
4059                         HCI_LOGICAL_LINK_CANCEL,
4060                         status);
4061
4062                 // Return parameters starts from here
4063                 pRetPar = &PPacketIrpEvent->Data[len];
4064                 pRetPar[0] = status;            //status
4065                 pRetPar[1] = pBTinfo->BtAsocEntry[CurrentEntryNum].LogLinkCmdData[CurrentLogEntryNum].BtPhyLinkhandle;
4066                 pRetPar[2] = pBTinfo->BtAsocEntry[CurrentEntryNum].LogLinkCmdData[CurrentLogEntryNum].BtTxFlowSpecID;
4067                 len += 3;
4068                 PPacketIrpEvent->Length = len;
4069
4070                 bthci_IndicateEvent(padapter, PPacketIrpEvent, len+2);
4071         }
4072
4073         pBTinfo->BtAsocEntry[CurrentEntryNum].LogLinkCmdData[CurrentLogEntryNum].bLLCancelCMDIsSetandComplete=_TRUE;
4074
4075         return status;
4076 }
4077
4078 HCI_STATUS
4079 bthci_CmdFlowSpecModify(
4080         PADAPTER        padapter,
4081         PPACKET_IRP_HCICMD_DATA         pHciCmd
4082         )
4083 {
4084         HCI_STATUS status = HCI_STATUS_SUCCESS;
4085 //      PMGNT_INFO pMgntInfo = &padapter->MgntInfo;
4086         PBT30Info pBTinfo = GET_BT_INFO(padapter);
4087         u8 i, j, find=0;
4088         u16 logicHandle;
4089
4090         logicHandle = *((u16*)pHciCmd->Data);
4091         // find an matched logical link index and copy the data
4092         for (j=0;j<MAX_BT_ASOC_ENTRY_NUM;j++)
4093         {
4094                 for (i=0; i<MAX_LOGICAL_LINK_NUM; i++)
4095                 {
4096                         if (pBTinfo->BtAsocEntry[j].LogLinkCmdData[i].BtLogLinkhandle == logicHandle)
4097                         {
4098                                 _rtw_memcpy(&pBTinfo->BtAsocEntry[j].LogLinkCmdData[i].Tx_Flow_Spec,
4099                                         &pHciCmd->Data[2], sizeof(HCI_FLOW_SPEC));
4100                                 _rtw_memcpy(&pBTinfo->BtAsocEntry[j].LogLinkCmdData[i].Rx_Flow_Spec,
4101                                         &pHciCmd->Data[18], sizeof(HCI_FLOW_SPEC));
4102
4103                                 bthci_CheckLogLinkBehavior(padapter, pBTinfo->BtAsocEntry[j].LogLinkCmdData[i].Tx_Flow_Spec);
4104                                 find = 1;
4105                                 break;
4106                         }
4107                 }
4108         }
4109         RTPRINT(FIOCTL, IOCTL_BT_LOGO, ("FlowSpecModify, LLH = 0x%x, \n",logicHandle));
4110
4111         //When we receive Flow Spec Modify command, we should send command status event first.
4112         bthci_EventCommandStatus(padapter,
4113                 OGF_LINK_CONTROL_COMMANDS,
4114                 HCI_FLOW_SPEC_MODIFY,
4115                 HCI_STATUS_SUCCESS);
4116
4117         if (!find)
4118                 status = HCI_STATUS_UNKNOW_CONNECT_ID;
4119
4120         bthci_EventSendFlowSpecModifyComplete(padapter, status, logicHandle);
4121
4122         return status;
4123 }
4124
4125 HCI_STATUS
4126 bthci_CmdAcceptPhysicalLink(
4127         PADAPTER        padapter,
4128         PPACKET_IRP_HCICMD_DATA         pHciCmd
4129         )
4130 {
4131         HCI_STATUS      status;
4132         PBT30Info       pBTInfo = GET_BT_INFO(padapter);
4133         PBT_DBG         pBtDbg = &pBTInfo->BtDbg;
4134
4135         pBtDbg->dbgHciInfo.hciCmdCntAcceptPhyLink++;
4136
4137         status = bthci_BuildPhysicalLink(padapter,
4138                 pHciCmd, HCI_ACCEPT_PHYSICAL_LINK);
4139
4140         return status;
4141 }
4142
4143 HCI_STATUS
4144 bthci_CmdDisconnectPhysicalLink(
4145         PADAPTER        padapter,
4146         PPACKET_IRP_HCICMD_DATA         pHciCmd
4147         )
4148 {
4149
4150         HCI_STATUS      status = HCI_STATUS_SUCCESS;
4151         PBT30Info       pBTInfo = GET_BT_INFO(padapter);
4152         PBT_DBG         pBtDbg = &pBTInfo->BtDbg;
4153         u8              PLH, CurrentEntryNum, PhysLinkDisconnectReason;
4154
4155         pBtDbg->dbgHciInfo.hciCmdCntDisconnectPhyLink++;
4156
4157         PLH = *((u8*)pHciCmd->Data);
4158         PhysLinkDisconnectReason = (*((u8*)pHciCmd->Data+1));
4159         RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_DISCONNECT_PHYSICAL_LINK  PhyHandle = 0x%x, Reason=0x%x\n",
4160                 PLH, PhysLinkDisconnectReason));
4161
4162         CurrentEntryNum = bthci_GetCurrentEntryNum(padapter, PLH);
4163
4164         if (CurrentEntryNum == 0xff)
4165         {
4166                 RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("DisconnectPhysicalLink, No such Handle in the Entry\n"));
4167                 status=HCI_STATUS_UNKNOW_CONNECT_ID;
4168                 //return status;
4169         }
4170
4171         pBTInfo->BtAsocEntry[CurrentEntryNum].PhyLinkDisconnectReason=(HCI_STATUS)PhysLinkDisconnectReason;
4172         //Send HCI Command status event to AMP.
4173         bthci_EventCommandStatus(padapter,
4174         OGF_LINK_CONTROL_COMMANDS,
4175         HCI_DISCONNECT_PHYSICAL_LINK,
4176         status);
4177
4178         if (status != HCI_STATUS_SUCCESS)
4179                 return status;
4180
4181         if (pBTInfo->BtAsocEntry[CurrentEntryNum].BtCurrentState == HCI_STATE_DISCONNECTED)
4182         {
4183                 BTHCI_SM_WITH_INFO(padapter, HCI_STATE_DISCONNECTED, STATE_CMD_DISCONNECT_PHY_LINK, CurrentEntryNum);
4184         }
4185         else
4186         {
4187                 BTHCI_SM_WITH_INFO(padapter, HCI_STATE_DISCONNECTING, STATE_CMD_DISCONNECT_PHY_LINK, CurrentEntryNum);
4188         }
4189
4190         return status;
4191 }
4192
4193 HCI_STATUS
4194 bthci_CmdSetACLLinkDataFlowMode(
4195         PADAPTER        padapter,
4196         PPACKET_IRP_HCICMD_DATA         pHciCmd
4197         )
4198 {
4199         HCI_STATUS status = HCI_STATUS_SUCCESS;
4200 //      PMGNT_INFO pMgntInfo = &padapter->MgntInfo;
4201         PBT30Info       pBTInfo = GET_BT_INFO(padapter);
4202         PBT_MGNT        pBtMgnt = &pBTInfo->BtMgnt;
4203
4204         pBtMgnt->ExtConfig.CurrentConnectHandle = *((u16*)pHciCmd->Data);
4205         pBtMgnt->ExtConfig.CurrentIncomingTrafficMode = *((u8*)pHciCmd->Data)+2;
4206         pBtMgnt->ExtConfig.CurrentOutgoingTrafficMode = *((u8*)pHciCmd->Data)+3;
4207         RTPRINT(FIOCTL, IOCTL_BT_HCICMD_EXT, ("Connection Handle = 0x%x, Incoming Traffic mode = 0x%x, Outgoing Traffic mode = 0x%x",
4208                 pBtMgnt->ExtConfig.CurrentConnectHandle,
4209                 pBtMgnt->ExtConfig.CurrentIncomingTrafficMode,
4210                 pBtMgnt->ExtConfig.CurrentOutgoingTrafficMode));
4211
4212         {
4213                 u8 localBuf[8] = "";
4214                 u8 *pRetPar;
4215                 u8 len = 0;
4216                 PPACKET_IRP_HCIEVENT_DATA PPacketIrpEvent;
4217                 u16 *pu2Temp;
4218
4219                 PPacketIrpEvent = (PPACKET_IRP_HCIEVENT_DATA)(&localBuf[0]);
4220
4221                 len += bthci_CommandCompleteHeader(&localBuf[0],
4222                         OGF_EXTENSION,
4223                         HCI_SET_ACL_LINK_DATA_FLOW_MODE,
4224                         status);
4225
4226                 // Return parameters starts from here
4227                 pRetPar = &PPacketIrpEvent->Data[len];
4228                 pRetPar[0] = status;            //status
4229
4230                 pu2Temp = (u16*)&pRetPar[1];
4231                 *pu2Temp = pBtMgnt->ExtConfig.CurrentConnectHandle;
4232                 len += 3;
4233                 PPacketIrpEvent->Length = len;
4234
4235                 bthci_IndicateEvent(padapter, PPacketIrpEvent, len+2);
4236         }
4237
4238         return status;
4239 }
4240
4241 HCI_STATUS
4242 bthci_CmdSetACLLinkStatus(
4243         PADAPTER        padapter,
4244         PPACKET_IRP_HCICMD_DATA         pHciCmd
4245         )
4246 {
4247         HCI_STATUS status = HCI_STATUS_SUCCESS;
4248         PBT30Info       pBTInfo = GET_BT_INFO(padapter);
4249         PBT_MGNT        pBtMgnt = &pBTInfo->BtMgnt;
4250         PBT_DBG         pBtDbg = &pBTInfo->BtDbg;
4251         u8              i;
4252         u8              *pTriple;
4253
4254         pBtDbg->dbgHciInfo.hciCmdCntSetAclLinkStatus++;
4255         RTPRINT_DATA(FIOCTL, IOCTL_BT_HCICMD_EXT, "SetACLLinkStatus, Hex Data :\n",
4256                         &pHciCmd->Data[0], pHciCmd->Length);
4257
4258         // Only Core Stack v251 and later version support this command.
4259         pBtMgnt->bSupportProfile = _TRUE;
4260
4261         pBtMgnt->ExtConfig.NumberOfHandle= *((u8*)pHciCmd->Data);
4262         RTPRINT(FIOCTL, IOCTL_BT_HCICMD_EXT, ("NumberOfHandle = 0x%x\n", pBtMgnt->ExtConfig.NumberOfHandle));
4263
4264         pTriple = &pHciCmd->Data[1];
4265         for (i=0; i<pBtMgnt->ExtConfig.NumberOfHandle; i++)
4266         {
4267                 pBtMgnt->ExtConfig.linkInfo[i].ConnectHandle = *((u16*)&pTriple[0]);
4268                 pBtMgnt->ExtConfig.linkInfo[i].IncomingTrafficMode = pTriple[2];
4269                 pBtMgnt->ExtConfig.linkInfo[i].OutgoingTrafficMode = pTriple[3];
4270                 RTPRINT(FIOCTL, IOCTL_BT_HCICMD_EXT,
4271                         ("Connection_Handle = 0x%x, Incoming Traffic mode = 0x%x, Outgoing Traffic Mode = 0x%x\n",
4272                         pBtMgnt->ExtConfig.linkInfo[i].ConnectHandle,
4273                         pBtMgnt->ExtConfig.linkInfo[i].IncomingTrafficMode,
4274                         pBtMgnt->ExtConfig.linkInfo[i].OutgoingTrafficMode));
4275                 pTriple += 4;
4276         }
4277
4278         {
4279                 u8 localBuf[6] = "";
4280                 u8 *pRetPar;
4281                 u8 len = 0;
4282                 PPACKET_IRP_HCIEVENT_DATA PPacketIrpEvent;
4283
4284                 PPacketIrpEvent = (PPACKET_IRP_HCIEVENT_DATA)(&localBuf[0]);
4285
4286                 len += bthci_CommandCompleteHeader(&localBuf[0],
4287                         OGF_EXTENSION,
4288                         HCI_SET_ACL_LINK_STATUS,
4289                         status);
4290
4291                 // Return parameters starts from here
4292                 pRetPar = &PPacketIrpEvent->Data[len];
4293                 pRetPar[0] = status;            //status
4294
4295                 len += 1;
4296                 PPacketIrpEvent->Length = len;
4297
4298                 bthci_IndicateEvent(padapter, PPacketIrpEvent, len+2);
4299         }
4300
4301         return status;
4302 }
4303
4304 static HCI_STATUS
4305 bthci_CmdSetSCOLinkStatus(
4306         PADAPTER        padapter,
4307         PPACKET_IRP_HCICMD_DATA         pHciCmd
4308         )
4309 {
4310         HCI_STATUS status = HCI_STATUS_SUCCESS;
4311         PBT30Info       pBTInfo = GET_BT_INFO(padapter);
4312         PBT_MGNT        pBtMgnt = &pBTInfo->BtMgnt;
4313         PBT_DBG         pBtDbg = &pBTInfo->BtDbg;
4314
4315         pBtDbg->dbgHciInfo.hciCmdCntSetScoLinkStatus++;
4316         pBtMgnt->ExtConfig.NumberOfSCO= *((u8*)pHciCmd->Data);
4317         RTPRINT(FIOCTL, IOCTL_BT_HCICMD_EXT, ("NumberOfSCO = 0x%x\n",
4318                 pBtMgnt->ExtConfig.NumberOfSCO));
4319
4320         {
4321                 u8 localBuf[6] = "";
4322                 u8 *pRetPar;
4323                 u8 len = 0;
4324                 PPACKET_IRP_HCIEVENT_DATA PPacketIrpEvent;
4325
4326                 PPacketIrpEvent = (PPACKET_IRP_HCIEVENT_DATA)(&localBuf[0]);
4327
4328                 len += bthci_CommandCompleteHeader(&localBuf[0],
4329                         OGF_EXTENSION,
4330                         HCI_SET_SCO_LINK_STATUS,
4331                         status);
4332
4333                 // Return parameters starts from here
4334                 pRetPar = &PPacketIrpEvent->Data[len];
4335                 pRetPar[0] = status;            //status
4336
4337                 len += 1;
4338                 PPacketIrpEvent->Length = len;
4339
4340                 bthci_IndicateEvent(padapter, PPacketIrpEvent, len+2);
4341         }
4342
4343         return status;
4344 }
4345
4346 static HCI_STATUS
4347 bthci_CmdSetRSSIValue(
4348         PADAPTER        padapter,
4349         PPACKET_IRP_HCICMD_DATA         pHciCmd
4350         )
4351 {
4352         HCI_STATUS status = HCI_STATUS_SUCCESS;
4353         PBT30Info       pBTInfo = GET_BT_INFO(padapter);
4354         PBT_MGNT        pBtMgnt = &pBTInfo->BtMgnt;
4355         s8              min_bt_rssi = 0;
4356         u8              i;
4357         for (i=0; i<pBtMgnt->ExtConfig.NumberOfHandle; i++)
4358         {
4359                 if (pBtMgnt->ExtConfig.linkInfo[i].ConnectHandle == *((u16*)&pHciCmd->Data[0]))
4360                 {
4361                         pBtMgnt->ExtConfig.linkInfo[i].BT_RSSI = (s8)(pHciCmd->Data[2]);
4362                         RTPRINT(FIOCTL, IOCTL_BT_EVENT_PERIODICAL,
4363                         ("Connection_Handle = 0x%x, RSSI = %d \n",
4364                         pBtMgnt->ExtConfig.linkInfo[i].ConnectHandle,
4365                         pBtMgnt->ExtConfig.linkInfo[i].BT_RSSI));
4366                 }
4367                 // get the minimum bt rssi value
4368                 if (pBtMgnt->ExtConfig.linkInfo[i].BT_RSSI <= min_bt_rssi)
4369                 {
4370                         min_bt_rssi = pBtMgnt->ExtConfig.linkInfo[i].BT_RSSI;
4371                 }
4372         }
4373
4374         {
4375                 pBtMgnt->ExtConfig.MIN_BT_RSSI = min_bt_rssi;
4376                 RTPRINT(FBT, BT_TRACE, ("[bt rssi], the min rssi is %d\n", min_bt_rssi));
4377         }
4378
4379         {
4380                 u8 localBuf[6] = "";
4381                 u8 *pRetPar;
4382                 u8 len = 0;
4383                 PPACKET_IRP_HCIEVENT_DATA PPacketIrpEvent;
4384
4385                 PPacketIrpEvent = (PPACKET_IRP_HCIEVENT_DATA)(&localBuf[0]);
4386
4387                 len += bthci_CommandCompleteHeader(&localBuf[0],
4388                         OGF_EXTENSION,
4389                         HCI_SET_RSSI_VALUE,
4390                         status);
4391
4392                 // Return parameters starts from here
4393                 pRetPar = &PPacketIrpEvent->Data[len];
4394                 pRetPar[0] = status;            //status
4395
4396                 len += 1;
4397                 PPacketIrpEvent->Length = len;
4398
4399                 bthci_IndicateEvent(padapter, PPacketIrpEvent, len+2);
4400         }
4401
4402         return status;
4403 }
4404
4405 static HCI_STATUS
4406 bthci_CmdSetCurrentBluetoothStatus(
4407         PADAPTER        padapter,
4408         PPACKET_IRP_HCICMD_DATA         pHciCmd
4409         )
4410 {
4411         HCI_STATUS      status = HCI_STATUS_SUCCESS;
4412 //      PMGNT_INFO      pMgntInfo = &padapter->MgntInfo;
4413         PBT30Info       pBTInfo = GET_BT_INFO(padapter);
4414         PBT_MGNT        pBtMgnt = &pBTInfo->BtMgnt;
4415
4416         pBtMgnt->ExtConfig.CurrentBTStatus = *((u8*)&pHciCmd->Data[0]);
4417         RTPRINT(FIOCTL, IOCTL_BT_HCICMD_EXT, ("SetCurrentBluetoothStatus, CurrentBTStatus = 0x%x\n",
4418                 pBtMgnt->ExtConfig.CurrentBTStatus));
4419
4420         {
4421                 u8 localBuf[6] = "";
4422                 u8 *pRetPar;
4423                 u8 len = 0;
4424                 PPACKET_IRP_HCIEVENT_DATA PPacketIrpEvent;
4425
4426                 PPacketIrpEvent = (PPACKET_IRP_HCIEVENT_DATA)(&localBuf[0]);
4427
4428                 len += bthci_CommandCompleteHeader(&localBuf[0],
4429                         OGF_EXTENSION,
4430                         HCI_SET_CURRENT_BLUETOOTH_STATUS,
4431                         status);
4432
4433                 // Return parameters starts from here
4434                 pRetPar = &PPacketIrpEvent->Data[len];
4435                 pRetPar[0] = status;            //status
4436                 len += 1;
4437
4438                 PPacketIrpEvent->Length = len;
4439
4440                 bthci_IndicateEvent(padapter, PPacketIrpEvent, len+2);
4441         }
4442
4443         return status;
4444 }
4445
4446 static HCI_STATUS
4447 bthci_CmdExtensionVersionNotify(
4448         PADAPTER                                                padapter,
4449         PPACKET_IRP_HCICMD_DATA         pHciCmd
4450         )
4451 {
4452         HCI_STATUS      status = HCI_STATUS_SUCCESS;
4453         PBT30Info       pBTInfo = GET_BT_INFO(padapter);
4454         PBT_MGNT        pBtMgnt = &pBTInfo->BtMgnt;
4455         PBT_DBG         pBtDbg = &pBTInfo->BtDbg;
4456
4457         pBtDbg->dbgHciInfo.hciCmdCntExtensionVersionNotify++;
4458         RTPRINT_DATA(FIOCTL, IOCTL_BT_HCICMD_EXT, "ExtensionVersionNotify, Hex Data :\n",
4459                         &pHciCmd->Data[0], pHciCmd->Length);
4460
4461         pBtMgnt->ExtConfig.HCIExtensionVer = *((u16*)&pHciCmd->Data[0]);
4462         RTPRINT(FIOCTL, IOCTL_BT_HCICMD_EXT, ("HCIExtensionVer = 0x%x\n", pBtMgnt->ExtConfig.HCIExtensionVer));
4463
4464         {
4465                 u8 localBuf[6] = "";
4466                 u8 *pRetPar;
4467                 u8 len = 0;
4468                 PPACKET_IRP_HCIEVENT_DATA PPacketIrpEvent;
4469
4470                 PPacketIrpEvent = (PPACKET_IRP_HCIEVENT_DATA)(&localBuf[0]);
4471
4472                 len += bthci_CommandCompleteHeader(&localBuf[0],
4473                         OGF_EXTENSION,
4474                         HCI_EXTENSION_VERSION_NOTIFY,
4475                         status);
4476
4477                 // Return parameters starts from here
4478                 pRetPar = &PPacketIrpEvent->Data[len];
4479                 pRetPar[0] = status;            //status
4480
4481                 len += 1;
4482                 PPacketIrpEvent->Length = len;
4483
4484                 bthci_IndicateEvent(padapter, PPacketIrpEvent, len+2);
4485         }
4486
4487         return status;
4488 }
4489
4490 static HCI_STATUS
4491 bthci_CmdLinkStatusNotify(
4492         PADAPTER                                                padapter,
4493         PPACKET_IRP_HCICMD_DATA         pHciCmd
4494         )
4495 {
4496         HCI_STATUS      status = HCI_STATUS_SUCCESS;
4497         PBT30Info       pBTInfo = GET_BT_INFO(padapter);
4498         PBT_MGNT        pBtMgnt = &pBTInfo->BtMgnt;
4499         PBT_DBG         pBtDbg = &pBTInfo->BtDbg;
4500         u8              i;
4501         u8              *pTriple;
4502
4503         pBtDbg->dbgHciInfo.hciCmdCntLinkStatusNotify++;
4504         RTPRINT_DATA(FIOCTL, IOCTL_BT_HCICMD_EXT, "LinkStatusNotify, Hex Data :\n",
4505                         &pHciCmd->Data[0], pHciCmd->Length);
4506
4507         // Current only RTL8723 support this command.
4508         pBtMgnt->bSupportProfile = _TRUE;
4509
4510         pBtMgnt->ExtConfig.NumberOfHandle= *((u8*)pHciCmd->Data);
4511         RTPRINT(FIOCTL, IOCTL_BT_HCICMD_EXT, ("NumberOfHandle = 0x%x\n", pBtMgnt->ExtConfig.NumberOfHandle));
4512         RTPRINT(FIOCTL, IOCTL_BT_HCICMD_EXT, ("HCIExtensionVer = %d\n", pBtMgnt->ExtConfig.HCIExtensionVer));
4513
4514         pTriple = &pHciCmd->Data[1];
4515         for (i=0; i<pBtMgnt->ExtConfig.NumberOfHandle; i++)
4516         {
4517                 if (pBtMgnt->ExtConfig.HCIExtensionVer < 1)
4518                 {
4519                         pBtMgnt->ExtConfig.linkInfo[i].ConnectHandle = *((u16*)&pTriple[0]);
4520                         pBtMgnt->ExtConfig.linkInfo[i].BTProfile = pTriple[2];
4521                         pBtMgnt->ExtConfig.linkInfo[i].BTCoreSpec = pTriple[3];
4522                 RTPRINT(FIOCTL, IOCTL_BT_HCICMD_EXT,
4523                         ("Connection_Handle = 0x%x, BTProfile=%d, BTSpec=%d\n",
4524                                 pBtMgnt->ExtConfig.linkInfo[i].ConnectHandle,
4525                                 pBtMgnt->ExtConfig.linkInfo[i].BTProfile,
4526                                 pBtMgnt->ExtConfig.linkInfo[i].BTCoreSpec));
4527                 pTriple += 4;
4528         }
4529                 else if (pBtMgnt->ExtConfig.HCIExtensionVer >= 1)
4530                 {
4531                         pBtMgnt->ExtConfig.linkInfo[i].ConnectHandle = *((u16*)&pTriple[0]);
4532                         pBtMgnt->ExtConfig.linkInfo[i].BTProfile = pTriple[2];
4533                         pBtMgnt->ExtConfig.linkInfo[i].BTCoreSpec = pTriple[3];
4534                         pBtMgnt->ExtConfig.linkInfo[i].linkRole = pTriple[4];
4535                         RTPRINT(FIOCTL, IOCTL_BT_HCICMD_EXT,
4536                                 ("Connection_Handle = 0x%x, BTProfile=%d, BTSpec=%d, LinkRole=%d\n",
4537                                 pBtMgnt->ExtConfig.linkInfo[i].ConnectHandle,
4538                                 pBtMgnt->ExtConfig.linkInfo[i].BTProfile,
4539                                 pBtMgnt->ExtConfig.linkInfo[i].BTCoreSpec,
4540                                 pBtMgnt->ExtConfig.linkInfo[i].linkRole));
4541                         pTriple += 5;
4542                 }
4543
4544         }
4545         BTHCI_UpdateBTProfileRTKToMoto(padapter);
4546         {
4547                 u8 localBuf[6] = "";
4548                 u8 *pRetPar;
4549                 u8 len = 0;
4550                 PPACKET_IRP_HCIEVENT_DATA PPacketIrpEvent;
4551
4552                 PPacketIrpEvent = (PPACKET_IRP_HCIEVENT_DATA)(&localBuf[0]);
4553
4554                 len += bthci_CommandCompleteHeader(&localBuf[0],
4555                         OGF_EXTENSION,
4556                         HCI_LINK_STATUS_NOTIFY,
4557                         status);
4558
4559                 // Return parameters starts from here
4560                 pRetPar = &PPacketIrpEvent->Data[len];
4561                 pRetPar[0] = status;            //status
4562
4563                 len += 1;
4564                 PPacketIrpEvent->Length = len;
4565
4566                 bthci_IndicateEvent(padapter, PPacketIrpEvent, len+2);
4567         }
4568
4569         return status;
4570 }
4571
4572 static HCI_STATUS
4573 bthci_CmdBtOperationNotify(
4574         PADAPTER        padapter,
4575         PPACKET_IRP_HCICMD_DATA         pHciCmd
4576         )
4577 {
4578         HCI_STATUS      status = HCI_STATUS_SUCCESS;
4579         PBT30Info       pBTInfo = GET_BT_INFO(padapter);
4580         PBT_MGNT        pBtMgnt = &pBTInfo->BtMgnt;
4581
4582         RTPRINT_DATA(FIOCTL, IOCTL_BT_HCICMD_EXT, "Bt Operation notify, Hex Data :\n",
4583                         &pHciCmd->Data[0], pHciCmd->Length);
4584
4585         pBtMgnt->ExtConfig.btOperationCode = *((u8*)pHciCmd->Data);
4586         RTPRINT(FIOCTL, IOCTL_BT_HCICMD_EXT, ("btOperationCode = 0x%x\n", pBtMgnt->ExtConfig.btOperationCode));
4587         switch (pBtMgnt->ExtConfig.btOperationCode)
4588         {
4589                 case HCI_BT_OP_NONE:
4590                         RTPRINT(FIOCTL, IOCTL_BT_HCICMD_EXT, ("[bt operation] : Operation None!!\n"));
4591                         break;
4592                 case HCI_BT_OP_INQUIRY_START:
4593                         RTPRINT(FIOCTL, IOCTL_BT_HCICMD_EXT, ("[bt operation] : Inquire start!!\n"));
4594                         break;
4595                 case HCI_BT_OP_INQUIRY_FINISH:
4596                         RTPRINT(FIOCTL, IOCTL_BT_HCICMD_EXT, ("[bt operation] : Inquire finished!!\n"));
4597                         break;
4598                 case HCI_BT_OP_PAGING_START:
4599                         RTPRINT(FIOCTL, IOCTL_BT_HCICMD_EXT, ("[bt operation] : Paging is started!!\n"));
4600                         break;
4601                 case HCI_BT_OP_PAGING_SUCCESS:
4602                         RTPRINT(FIOCTL, IOCTL_BT_HCICMD_EXT, ("[bt operation] : Paging complete successfully!!\n"));
4603                         break;
4604                 case HCI_BT_OP_PAGING_UNSUCCESS:
4605                         RTPRINT(FIOCTL, IOCTL_BT_HCICMD_EXT, ("[bt operation] : Paging complete unsuccessfully!!\n"));
4606                         break;
4607                 case HCI_BT_OP_PAIRING_START:
4608                         RTPRINT(FIOCTL, IOCTL_BT_HCICMD_EXT, ("[bt operation] : Pairing start!!\n"));
4609                         break;
4610                 case HCI_BT_OP_PAIRING_FINISH:
4611                         RTPRINT(FIOCTL, IOCTL_BT_HCICMD_EXT, ("[bt operation] : Pairing finished!!\n"));
4612                         break;
4613                 case HCI_BT_OP_BT_DEV_ENABLE:
4614                         RTPRINT(FIOCTL, IOCTL_BT_HCICMD_EXT, ("[bt operation] : BT Device is enabled!!\n"));
4615                         break;
4616                 case HCI_BT_OP_BT_DEV_DISABLE:
4617                         RTPRINT(FIOCTL, IOCTL_BT_HCICMD_EXT, ("[bt operation] : BT Device is disabled!!\n"));
4618                         break;
4619                 default:
4620                         RTPRINT(FIOCTL, IOCTL_BT_HCICMD_EXT, ("[bt operation] : Unknown, error!!\n"));
4621                         break;
4622         }
4623         BTDM_AdjustForBtOperation(padapter);
4624         {
4625                 u8 localBuf[6] = "";
4626                 u8 *pRetPar;
4627                 u8 len = 0;
4628                 PPACKET_IRP_HCIEVENT_DATA PPacketIrpEvent;
4629
4630                 PPacketIrpEvent = (PPACKET_IRP_HCIEVENT_DATA)(&localBuf[0]);
4631
4632                 len += bthci_CommandCompleteHeader(&localBuf[0],
4633                         OGF_EXTENSION,
4634                         HCI_BT_OPERATION_NOTIFY,
4635                         status);
4636
4637                 // Return parameters starts from here
4638                 pRetPar = &PPacketIrpEvent->Data[len];
4639                 pRetPar[0] = status;            //status
4640
4641                 len += 1;
4642                 PPacketIrpEvent->Length = len;
4643
4644                 bthci_IndicateEvent(padapter, PPacketIrpEvent, len+2);
4645         }
4646
4647         return status;
4648 }
4649
4650 HCI_STATUS
4651 bthci_CmdEnableWifiScanNotify(
4652         PADAPTER        padapter,
4653         PPACKET_IRP_HCICMD_DATA         pHciCmd
4654         )
4655 {
4656         HCI_STATUS      status = HCI_STATUS_SUCCESS;
4657         PBT30Info       pBTInfo = GET_BT_INFO(padapter);
4658         PBT_MGNT        pBtMgnt = &pBTInfo->BtMgnt;
4659
4660         RTPRINT_DATA(FIOCTL, IOCTL_BT_HCICMD_EXT, "Enable Wifi scan notify, Hex Data :\n",
4661                         &pHciCmd->Data[0], pHciCmd->Length);
4662
4663         pBtMgnt->ExtConfig.bEnableWifiScanNotify = *((u8*)pHciCmd->Data);
4664         RTPRINT(FIOCTL, IOCTL_BT_HCICMD_EXT, ("bEnableWifiScanNotify = %d\n", pBtMgnt->ExtConfig.bEnableWifiScanNotify));
4665
4666         {
4667                 u8 localBuf[6] = "";
4668                 u8 *pRetPar;
4669                 u8 len = 0;
4670                 PPACKET_IRP_HCIEVENT_DATA PPacketIrpEvent;
4671
4672                 PPacketIrpEvent = (PPACKET_IRP_HCIEVENT_DATA)(&localBuf[0]);
4673
4674                 len += bthci_CommandCompleteHeader(&localBuf[0],
4675                         OGF_EXTENSION,
4676                         HCI_ENABLE_WIFI_SCAN_NOTIFY,
4677                         status);
4678
4679                 // Return parameters starts from here
4680                 pRetPar = &PPacketIrpEvent->Data[len];
4681                 pRetPar[0] = status;            //status
4682
4683                 len += 1;
4684                 PPacketIrpEvent->Length = len;
4685
4686                 bthci_IndicateEvent(padapter, PPacketIrpEvent, len+2);
4687         }
4688
4689         return status;
4690 }
4691
4692 HCI_STATUS
4693 bthci_CmdWIFICurrentChannel(
4694         PADAPTER        padapter,
4695         PPACKET_IRP_HCICMD_DATA         pHciCmd
4696         )
4697 {
4698         HCI_STATUS status = HCI_STATUS_SUCCESS;
4699 //      PMGNT_INFO pMgntInfo = &padapter->MgntInfo;
4700         struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
4701 //      u8              chnl = pMgntInfo->dot11CurrentChannelNumber;
4702         u8              chnl = pmlmeext->cur_channel;
4703
4704 //      if (pMgntInfo->pHTInfo->bCurBW40MHz == HT_CHANNEL_WIDTH_20_40)
4705         if (pmlmeext->cur_bwmode == HT_CHANNEL_WIDTH_40)
4706         {
4707 //              if (pMgntInfo->pHTInfo->CurSTAExtChnlOffset == HT_EXTCHNL_OFFSET_UPPER)
4708                 if (pmlmeext->cur_ch_offset == HAL_PRIME_CHNL_OFFSET_UPPER)
4709                 {
4710                         chnl += 2;
4711                 }
4712 //              else if (pMgntInfo->pHTInfo->CurSTAExtChnlOffset == HT_EXTCHNL_OFFSET_LOWER)
4713                 else if (pmlmeext->cur_ch_offset == HAL_PRIME_CHNL_OFFSET_LOWER)
4714                 {
4715                         chnl -= 2;
4716                 }
4717         }
4718
4719         RTPRINT(FIOCTL, IOCTL_BT_HCICMD_EXT, ("Current Channel  = 0x%x\n", chnl));
4720
4721         {
4722                 u8 localBuf[8] = "";
4723                 u8 *pRetPar;
4724                 u8 len = 0;
4725                 PPACKET_IRP_HCIEVENT_DATA PPacketIrpEvent;
4726
4727                 PPacketIrpEvent = (PPACKET_IRP_HCIEVENT_DATA)(&localBuf[0]);
4728
4729                 len += bthci_CommandCompleteHeader(&localBuf[0],
4730                         OGF_EXTENSION,
4731                         HCI_WIFI_CURRENT_CHANNEL,
4732                         status);
4733
4734                 // Return parameters starts from here
4735                 pRetPar = &PPacketIrpEvent->Data[len];
4736                 pRetPar[0] = status;            //status
4737                 pRetPar[1] = chnl;                      //current channel
4738                 len += 2;
4739                 PPacketIrpEvent->Length = len;
4740
4741                 bthci_IndicateEvent(padapter, PPacketIrpEvent, len+2);
4742         }
4743
4744         return status;
4745 }
4746
4747 HCI_STATUS
4748 bthci_CmdWIFICurrentBandwidth(
4749         PADAPTER        padapter,
4750         PPACKET_IRP_HCICMD_DATA         pHciCmd
4751         )
4752 {
4753         HCI_STATUS status = HCI_STATUS_SUCCESS;
4754         HT_CHANNEL_WIDTH bw;
4755         u8      CurrentBW = 0;
4756
4757
4758 //      rtw_hal_get_hwreg(padapter, HW_VAR_BW_MODE, (u8*)(&bw));
4759         bw = padapter->mlmeextpriv.cur_bwmode;
4760
4761         if (bw == HT_CHANNEL_WIDTH_20)
4762         {
4763                 CurrentBW = 0;
4764         }
4765         else if (bw == HT_CHANNEL_WIDTH_40)
4766         {
4767                 CurrentBW = 1;
4768         }
4769
4770         RTPRINT(FIOCTL, IOCTL_BT_HCICMD_EXT, ("Current BW = 0x%x\n",
4771                 CurrentBW));
4772
4773         {
4774                 u8 localBuf[8] = "";
4775                 u8 *pRetPar;
4776                 u8 len = 0;
4777                 PPACKET_IRP_HCIEVENT_DATA PPacketIrpEvent;
4778
4779                 PPacketIrpEvent = (PPACKET_IRP_HCIEVENT_DATA)(&localBuf[0]);
4780
4781                 len += bthci_CommandCompleteHeader(&localBuf[0],
4782                         OGF_EXTENSION,
4783                         HCI_WIFI_CURRENT_BANDWIDTH,
4784                         status);
4785
4786                 // Return parameters starts from here
4787                 pRetPar = &PPacketIrpEvent->Data[len];
4788                 pRetPar[0] = status;            //status
4789                 pRetPar[1] = CurrentBW;         //current BW
4790                 len += 2;
4791                 PPacketIrpEvent->Length = len;
4792
4793                 bthci_IndicateEvent(padapter, PPacketIrpEvent, len+2);
4794         }
4795
4796         return status;
4797 }
4798
4799 static HCI_STATUS
4800 bthci_CmdWIFIConnectionStatus(
4801         PADAPTER        padapter,
4802         PPACKET_IRP_HCICMD_DATA         pHciCmd
4803         )
4804 {
4805         HCI_STATUS status = HCI_STATUS_SUCCESS;
4806         PADAPTER pDefaultAdapter = GetDefaultAdapter(padapter);
4807         u8              connectStatus = HCI_WIFI_NOT_CONNECTED;
4808
4809         if (check_fwstate(&padapter->mlmepriv, WIFI_AP_STATE) == _TRUE) {
4810                 if (padapter->stapriv.asoc_sta_count >= 3)
4811                         connectStatus = HCI_WIFI_CONNECTED;
4812                 else
4813                         connectStatus = HCI_WIFI_NOT_CONNECTED;
4814         }
4815         else if (check_fwstate(&padapter->mlmepriv, WIFI_ADHOC_STATE|WIFI_ADHOC_MASTER_STATE|WIFI_ASOC_STATE) == _TRUE)
4816                 connectStatus = HCI_WIFI_CONNECTED;
4817         else if (check_fwstate(&padapter->mlmepriv, WIFI_UNDER_LINKING) == _TRUE)
4818                 connectStatus = HCI_WIFI_CONNECT_IN_PROGRESS;
4819         else
4820                 connectStatus = HCI_WIFI_NOT_CONNECTED;
4821
4822         {
4823                 u8 localBuf[8] = "";
4824                 u8 *pRetPar;
4825                 u8 len = 0;
4826                 PPACKET_IRP_HCIEVENT_DATA PPacketIrpEvent;
4827
4828                 PPacketIrpEvent = (PPACKET_IRP_HCIEVENT_DATA)(&localBuf[0]);
4829
4830                 len += bthci_CommandCompleteHeader(&localBuf[0],
4831                         OGF_EXTENSION,
4832                         HCI_WIFI_CONNECTION_STATUS,
4833                         status);
4834
4835                 // Return parameters starts from here
4836                 pRetPar = &PPacketIrpEvent->Data[len];
4837                 pRetPar[0] = status;                    //status
4838                 pRetPar[1] = connectStatus;     //connect status
4839                 len += 2;
4840                 PPacketIrpEvent->Length = len;
4841
4842                 bthci_IndicateEvent(padapter, PPacketIrpEvent, len+2);
4843         }
4844
4845         return status;
4846 }
4847
4848 static HCI_STATUS
4849 bthci_CmdEnableDeviceUnderTestMode(
4850         PADAPTER        padapter,
4851         PPACKET_IRP_HCICMD_DATA         pHciCmd
4852         )
4853 {
4854         HCI_STATUS status = HCI_STATUS_SUCCESS;
4855         PBT30Info       pBTInfo = GET_BT_INFO(padapter);
4856         PBT_HCI_INFO            pBtHciInfo = &pBTInfo->BtHciInfo;
4857
4858         pBtHciInfo->bInTestMode = _TRUE;
4859         pBtHciInfo->bTestIsEnd = _FALSE;
4860
4861         //send command complete event here when all data are received.
4862         {
4863                 u8 localBuf[6] = "";
4864                 u8 *pRetPar;
4865                 u8 len = 0;
4866                 PPACKET_IRP_HCIEVENT_DATA PPacketIrpEvent;
4867
4868                 PPacketIrpEvent = (PPACKET_IRP_HCIEVENT_DATA)(&localBuf[0]);
4869
4870                 len += bthci_CommandCompleteHeader(&localBuf[0],
4871                         OGF_TESTING_COMMANDS,
4872                         HCI_ENABLE_DEVICE_UNDER_TEST_MODE,
4873                         status);
4874
4875                 // Return parameters starts from here
4876                 pRetPar = &PPacketIrpEvent->Data[len];
4877                 pRetPar[0] = status;            //status
4878                 len += 1;
4879                 PPacketIrpEvent->Length = len;
4880
4881                 bthci_IndicateEvent(padapter, PPacketIrpEvent, len+2);
4882         }
4883
4884         return status;
4885 }
4886
4887 HCI_STATUS
4888 bthci_CmdAMPTestEnd(
4889         PADAPTER        padapter,
4890         PPACKET_IRP_HCICMD_DATA         pHciCmd
4891         )
4892 {
4893         HCI_STATUS status = HCI_STATUS_SUCCESS;
4894         PBT30Info       pBTInfo = GET_BT_INFO(padapter);
4895         PBT_HCI_INFO            pBtHciInfo = &pBTInfo->BtHciInfo;
4896         u8              bFilterOutNonAssociatedBSSID = _TRUE;
4897
4898         if (!pBtHciInfo->bInTestMode)
4899         {
4900                 RTPRINT(FIOCTL, (IOCTL_BT_EVENT|IOCTL_BT_LOGO), ("Not in Test mode, return status=HCI_STATUS_CMD_DISALLOW\n"));
4901                 status = HCI_STATUS_CMD_DISALLOW;
4902                 return status;
4903         }
4904
4905         pBtHciInfo->bTestIsEnd=_TRUE;
4906
4907         PlatformCancelTimer(padapter,&pBTInfo->BTTestSendPacketTimer);
4908
4909         rtw_hal_set_hwreg(padapter, HW_VAR_CHECK_BSSID, (u8*)(&bFilterOutNonAssociatedBSSID));
4910
4911
4912         //send command complete event here when all data are received.
4913         {
4914                 u8      localBuf[4] = "";
4915                 PPACKET_IRP_HCIEVENT_DATA PPacketIrpEvent;
4916
4917                 RTPRINT(FIOCTL, (IOCTL_BT_EVENT|IOCTL_BT_LOGO), ("AMP Test End Event \n"));
4918                 PPacketIrpEvent = (PPACKET_IRP_HCIEVENT_DATA)(&localBuf[0]);
4919                 PPacketIrpEvent->EventCode=HCI_EVENT_AMP_TEST_END;
4920                 PPacketIrpEvent->Length=2;
4921
4922                 PPacketIrpEvent->Data[0] = status;
4923                 PPacketIrpEvent->Data[1] = pBtHciInfo->TestScenario;
4924
4925                 bthci_IndicateEvent(padapter, PPacketIrpEvent, 4);
4926         }
4927
4928         bthci_EventAMPReceiverReport(padapter,0x01);
4929
4930         return status;
4931 }
4932
4933 HCI_STATUS
4934 bthci_CmdAMPTestCommand(
4935         PADAPTER        padapter,
4936         PPACKET_IRP_HCICMD_DATA         pHciCmd
4937         )
4938 {
4939         HCI_STATUS status = HCI_STATUS_SUCCESS;
4940         PBT30Info       pBTInfo = GET_BT_INFO(padapter);
4941         PBT_HCI_INFO            pBtHciInfo = &pBTInfo->BtHciInfo;
4942
4943         if (!pBtHciInfo->bInTestMode)
4944         {
4945                 RTPRINT(FIOCTL, (IOCTL_BT_EVENT|IOCTL_BT_LOGO), ("Not in Test mode, return status=HCI_STATUS_CMD_DISALLOW\n"));
4946                 status = HCI_STATUS_CMD_DISALLOW;
4947                 return status;
4948         }
4949
4950
4951         pBtHciInfo->TestScenario=*((u8*)pHciCmd->Data);
4952
4953         if (pBtHciInfo->TestScenario == 0x01)
4954         {
4955                 RTPRINT(FIOCTL, (IOCTL_BT_EVENT|IOCTL_BT_LOGO), ("TX Single Test \n"));
4956         }
4957         else if (pBtHciInfo->TestScenario == 0x02)
4958         {
4959                 RTPRINT(FIOCTL, (IOCTL_BT_EVENT|IOCTL_BT_LOGO), ("Receive Frame Test \n"));
4960         }
4961         else
4962         {
4963                 RTPRINT(FIOCTL, (IOCTL_BT_EVENT|IOCTL_BT_LOGO), ("No Such Test !!!!!!!!!!!!!!!!!! \n"));
4964         }
4965
4966
4967         if (pBtHciInfo->bTestIsEnd)
4968         {
4969                 u8      localBuf[5] = "";
4970                 PPACKET_IRP_HCIEVENT_DATA PPacketIrpEvent;
4971
4972
4973                 RTPRINT(FIOCTL, (IOCTL_BT_EVENT|IOCTL_BT_LOGO), ("AMP Test End Event \n"));
4974                 PPacketIrpEvent = (PPACKET_IRP_HCIEVENT_DATA)(&localBuf[0]);
4975                 PPacketIrpEvent->EventCode=HCI_EVENT_AMP_TEST_END;
4976                 PPacketIrpEvent->Length=2;
4977
4978                 PPacketIrpEvent->Data[0] = status;
4979                 PPacketIrpEvent->Data[1] = pBtHciInfo->TestScenario ;
4980
4981                 bthci_IndicateEvent(padapter, PPacketIrpEvent, 4);
4982
4983                 //Return to Idel state with RX and TX off.
4984
4985                 return status;
4986         }
4987
4988         // should send command status event
4989         bthci_EventCommandStatus(padapter,
4990                         OGF_TESTING_COMMANDS,
4991                         HCI_AMP_TEST_COMMAND,
4992                         status);
4993
4994         //The HCI_AMP_Start Test Event shall be generated when the
4995         //HCI_AMP_Test_Command has completed and the first data is ready to be sent
4996         //or received.
4997
4998         {
4999                 u8      localBuf[5] = "";
5000                 PPACKET_IRP_HCIEVENT_DATA PPacketIrpEvent;
5001
5002                 RTPRINT(FIOCTL, (IOCTL_BT_EVENT|IOCTL_BT_LOGO), (" HCI_AMP_Start Test Event \n"));
5003                 PPacketIrpEvent = (PPACKET_IRP_HCIEVENT_DATA)(&localBuf[0]);
5004                 PPacketIrpEvent->EventCode=HCI_EVENT_AMP_START_TEST;
5005                 PPacketIrpEvent->Length=2;
5006
5007                 PPacketIrpEvent->Data[0] = status;
5008                 PPacketIrpEvent->Data[1] = pBtHciInfo->TestScenario ;
5009
5010                 bthci_IndicateEvent(padapter, PPacketIrpEvent, 4);
5011
5012                 //Return to Idel state with RX and TX off.
5013         }
5014
5015         if (pBtHciInfo->TestScenario == 0x01)
5016         {
5017                 /*
5018                         When in a transmitter test scenario and the frames/bursts count have been
5019                         transmitted the HCI_AMP_Test_End event shall be sent.
5020                 */
5021                 PlatformSetTimer(padapter, &pBTInfo->BTTestSendPacketTimer, 50);
5022                 RTPRINT(FIOCTL, (IOCTL_BT_EVENT|IOCTL_BT_LOGO), ("TX Single Test \n"));
5023         }
5024         else if (pBtHciInfo->TestScenario == 0x02)
5025         {
5026                 u8              bFilterOutNonAssociatedBSSID=_FALSE;
5027                 rtw_hal_set_hwreg(padapter, HW_VAR_CHECK_BSSID, (u8*)(&bFilterOutNonAssociatedBSSID));
5028                 RTPRINT(FIOCTL, (IOCTL_BT_EVENT|IOCTL_BT_LOGO), ("Receive Frame Test \n"));
5029         }
5030
5031         return status;
5032 }
5033
5034
5035 HCI_STATUS
5036 bthci_CmdEnableAMPReceiverReports(
5037         PADAPTER        padapter,
5038         PPACKET_IRP_HCICMD_DATA         pHciCmd
5039         )
5040 {
5041         HCI_STATUS status = HCI_STATUS_SUCCESS;
5042         PBT30Info       pBTInfo = GET_BT_INFO(padapter);
5043         PBT_HCI_INFO            pBtHciInfo = &pBTInfo->BtHciInfo;
5044
5045         if (!pBtHciInfo->bInTestMode)
5046         {
5047                 status = HCI_STATUS_CMD_DISALLOW;
5048                 //send command complete event here when all data are received.
5049                 {
5050                         u8 localBuf[6] = "";
5051                         u8 *pRetPar;
5052                         u8 len = 0;
5053                         PPACKET_IRP_HCIEVENT_DATA PPacketIrpEvent;
5054
5055                         PPacketIrpEvent = (PPACKET_IRP_HCIEVENT_DATA)(&localBuf[0]);
5056
5057                         len += bthci_CommandCompleteHeader(&localBuf[0],
5058                                 OGF_TESTING_COMMANDS,
5059                                 HCI_ENABLE_AMP_RECEIVER_REPORTS,
5060                                 status);
5061
5062                         // Return parameters starts from here
5063                         pRetPar = &PPacketIrpEvent->Data[len];
5064                         pRetPar[0] = status;            //status
5065                         len += 1;
5066                         PPacketIrpEvent->Length = len;
5067
5068                         bthci_IndicateEvent(padapter, PPacketIrpEvent, len+2);
5069                 }
5070                 return status;
5071         }
5072
5073         pBtHciInfo->bTestNeedReport= *((u8*)pHciCmd->Data);
5074         pBtHciInfo->TestReportInterval= (*((u8*)pHciCmd->Data+2));
5075
5076         bthci_EventAMPReceiverReport(padapter,0x00);
5077
5078         //send command complete event here when all data are received.
5079         {
5080                 u8 localBuf[6] = "";
5081                 u8 *pRetPar;
5082                 u8 len = 0;
5083                 PPACKET_IRP_HCIEVENT_DATA PPacketIrpEvent;
5084
5085                 PPacketIrpEvent = (PPACKET_IRP_HCIEVENT_DATA)(&localBuf[0]);
5086
5087                 len += bthci_CommandCompleteHeader(&localBuf[0],
5088                         OGF_TESTING_COMMANDS,
5089                         HCI_ENABLE_AMP_RECEIVER_REPORTS,
5090                         status);
5091
5092                 // Return parameters starts from here
5093                 pRetPar = &PPacketIrpEvent->Data[len];
5094                 pRetPar[0] = status;            //status
5095                 len += 1;
5096                 PPacketIrpEvent->Length = len;
5097
5098                 bthci_IndicateEvent(padapter, PPacketIrpEvent, len+2);
5099         }
5100
5101         return status;
5102 }
5103
5104 HCI_STATUS
5105 bthci_CmdHostBufferSize(
5106         PADAPTER        padapter,
5107         PPACKET_IRP_HCICMD_DATA         pHciCmd
5108         )
5109 {
5110         HCI_STATUS status = HCI_STATUS_SUCCESS;
5111         PBT30Info               pBTInfo = GET_BT_INFO(padapter);
5112         PBT_MGNT                pBtMgnt = &pBTInfo->BtMgnt;
5113
5114         pBTInfo->BtAsocEntry[pBtMgnt->CurrentConnectEntryNum].ACLPacketsData.ACLDataPacketLen= *((u16*)pHciCmd->Data);
5115         pBTInfo->BtAsocEntry[pBtMgnt->CurrentConnectEntryNum].SyncDataPacketLen= *((u8 *)(pHciCmd->Data+2));
5116         pBTInfo->BtAsocEntry[pBtMgnt->CurrentConnectEntryNum].TotalNumACLDataPackets= *((u16 *)(pHciCmd->Data+3));
5117         pBTInfo->BtAsocEntry[pBtMgnt->CurrentConnectEntryNum].TotalSyncNumDataPackets= *((u16 *)(pHciCmd->Data+5));
5118
5119         //send command complete event here when all data are received.
5120         {
5121                 u8 localBuf[6] = "";
5122                 u8 *pRetPar;
5123                 u8 len = 0;
5124                 PPACKET_IRP_HCIEVENT_DATA PPacketIrpEvent;
5125
5126                 PPacketIrpEvent = (PPACKET_IRP_HCIEVENT_DATA)(&localBuf[0]);
5127
5128                 len += bthci_CommandCompleteHeader(&localBuf[0],
5129                         OGF_SET_EVENT_MASK_COMMAND,
5130                         HCI_HOST_BUFFER_SIZE,
5131                         status);
5132
5133                 // Return parameters starts from here
5134                 pRetPar = &PPacketIrpEvent->Data[len];
5135                 pRetPar[0] = status;            //status
5136                 len += 1;
5137                 PPacketIrpEvent->Length = len;
5138
5139                 bthci_IndicateEvent(padapter, PPacketIrpEvent, len+2);
5140         }
5141
5142         return status;
5143 }
5144
5145 HCI_STATUS
5146 bthci_CmdHostNumberOfCompletedPackets(
5147         PADAPTER        padapter,
5148         PPACKET_IRP_HCICMD_DATA         pHciCmd
5149         )
5150 {
5151         HCI_STATUS status = HCI_STATUS_SUCCESS;
5152
5153         return status;
5154 }
5155
5156 HCI_STATUS
5157 bthci_UnknownCMD(
5158         PADAPTER        padapter,
5159         PPACKET_IRP_HCICMD_DATA         pHciCmd
5160         )
5161 {
5162         HCI_STATUS status = HCI_STATUS_UNKNOW_HCI_CMD;
5163         PBT30Info       pBTInfo = GET_BT_INFO(padapter);
5164         PBT_DBG         pBtDbg = &pBTInfo->BtDbg;
5165
5166         pBtDbg->dbgHciInfo.hciCmdCntUnknown++;
5167         bthci_EventCommandStatus(padapter,
5168                         (u8)pHciCmd->OGF,
5169                         pHciCmd->OCF,
5170                         status);
5171
5172         return status;
5173 }
5174
5175 HCI_STATUS
5176 bthci_HandleOGFInformationalParameters(
5177         PADAPTER                                        padapter,
5178         PPACKET_IRP_HCICMD_DATA pHciCmd
5179         )
5180 {
5181         HCI_STATUS status = HCI_STATUS_SUCCESS;
5182
5183         switch (pHciCmd->OCF)
5184         {
5185         case HCI_READ_LOCAL_VERSION_INFORMATION:
5186                 RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_READ_LOCAL_VERSION_INFORMATION\n"));
5187                 status = bthci_CmdReadLocalVersionInformation(padapter);
5188                 break;
5189         case HCI_READ_LOCAL_SUPPORTED_COMMANDS:
5190                 RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_READ_LOCAL_SUPPORTED_COMMANDS\n"));
5191                 status = bthci_CmdReadLocalSupportedCommands(padapter);
5192                 break;
5193         case HCI_READ_LOCAL_SUPPORTED_FEATURES:
5194                 RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_READ_LOCAL_SUPPORTED_FEATURES\n"));
5195                 status = bthci_CmdReadLocalSupportedFeatures(padapter);
5196                 break;
5197         case HCI_READ_BUFFER_SIZE:
5198                 RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_READ_BUFFER_SIZE\n"));
5199                 status = bthci_CmdReadBufferSize(padapter);
5200                 break;
5201         case HCI_READ_DATA_BLOCK_SIZE:
5202                 RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_READ_DATA_BLOCK_SIZE\n"));
5203                 status = bthci_CmdReadDataBlockSize(padapter);
5204                 break;
5205         default:
5206                 RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("bthci_HandleOGFInformationalParameters(), Unknown case = 0x%x\n", pHciCmd->OCF));
5207                 RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_UNKNOWN_COMMAND\n"));
5208                 status = bthci_UnknownCMD(padapter, pHciCmd);
5209                 break;
5210         }
5211         return status;
5212 }
5213
5214 HCI_STATUS
5215 bthci_HandleOGFSetEventMaskCMD(
5216         PADAPTER        padapter,
5217         PPACKET_IRP_HCICMD_DATA         pHciCmd
5218         )
5219 {
5220         HCI_STATUS status = HCI_STATUS_SUCCESS;
5221
5222         switch (pHciCmd->OCF)
5223         {
5224         case HCI_SET_EVENT_MASK:
5225                 RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_SET_EVENT_MASK\n"));
5226                 status = bthci_CmdSetEventMask(padapter, pHciCmd);
5227                 break;
5228         case HCI_RESET:
5229                 RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_RESET\n"));
5230                 status = bthci_CmdReset(padapter, _TRUE);
5231                 break;
5232         case HCI_READ_CONNECTION_ACCEPT_TIMEOUT:
5233                 RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_READ_CONNECTION_ACCEPT_TIMEOUT\n"));
5234                 status = bthci_CmdReadConnectionAcceptTimeout(padapter);
5235                 break;
5236         case HCI_SET_EVENT_FILTER:
5237                 RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_SET_EVENT_FILTER\n"));
5238                 status = bthci_CmdSetEventFilter(padapter, pHciCmd);
5239                 break;
5240         case HCI_WRITE_CONNECTION_ACCEPT_TIMEOUT:
5241                 RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_WRITE_CONNECTION_ACCEPT_TIMEOUT\n"));
5242                 status = bthci_CmdWriteConnectionAcceptTimeout(padapter, pHciCmd);
5243                 break;
5244         case HCI_READ_PAGE_TIMEOUT:
5245                 RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_READ_PAGE_TIMEOUT\n"));
5246                 status = bthci_CmdReadPageTimeout(padapter, pHciCmd);
5247                 break;
5248         case HCI_WRITE_PAGE_TIMEOUT:
5249                 RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_WRITE_PAGE_TIMEOUT\n"));
5250                 status = bthci_CmdWritePageTimeout(padapter, pHciCmd);
5251                 break;
5252         case HCI_HOST_NUMBER_OF_COMPLETED_PACKETS:
5253                 RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_HOST_NUMBER_OF_COMPLETED_PACKETS\n"));
5254                 status = bthci_CmdHostNumberOfCompletedPackets(padapter, pHciCmd);
5255                 break;
5256         case HCI_READ_LINK_SUPERVISION_TIMEOUT:
5257                 RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_READ_LINK_SUPERVISION_TIMEOUT\n"));
5258                 status = bthci_CmdReadLinkSupervisionTimeout(padapter, pHciCmd);
5259                 break;
5260         case HCI_WRITE_LINK_SUPERVISION_TIMEOUT:
5261                 RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_WRITE_LINK_SUPERVISION_TIMEOUT\n"));
5262                 status = bthci_CmdWriteLinkSupervisionTimeout(padapter, pHciCmd);
5263                 break;
5264         case HCI_ENHANCED_FLUSH:
5265                 RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_ENHANCED_FLUSH\n"));
5266                 status = bthci_CmdEnhancedFlush(padapter, pHciCmd);
5267                 break;
5268         case HCI_READ_LOGICAL_LINK_ACCEPT_TIMEOUT:
5269                 RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_READ_LOGICAL_LINK_ACCEPT_TIMEOUT\n"));
5270                 status = bthci_CmdReadLogicalLinkAcceptTimeout(padapter, pHciCmd);
5271                 break;
5272         case HCI_WRITE_LOGICAL_LINK_ACCEPT_TIMEOUT:
5273                 RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_WRITE_LOGICAL_LINK_ACCEPT_TIMEOUT\n"));
5274                 status = bthci_CmdWriteLogicalLinkAcceptTimeout(padapter, pHciCmd);
5275                 break;
5276         case HCI_SET_EVENT_MASK_PAGE_2:
5277                 RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_SET_EVENT_MASK_PAGE_2\n"));
5278                 status = bthci_CmdSetEventMaskPage2(padapter, pHciCmd);
5279                 break;
5280         case HCI_READ_LOCATION_DATA:
5281                 RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_READ_LOCATION_DATA\n"));
5282                 status = bthci_CmdReadLocationData(padapter, pHciCmd);
5283                 break;
5284         case HCI_WRITE_LOCATION_DATA:
5285                 RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_WRITE_LOCATION_DATA\n"));
5286                 status = bthci_CmdWriteLocationData(padapter, pHciCmd);
5287                 break;
5288         case HCI_READ_FLOW_CONTROL_MODE:
5289                 RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_READ_FLOW_CONTROL_MODE\n"));
5290                 status = bthci_CmdReadFlowControlMode(padapter, pHciCmd);
5291                 break;
5292         case HCI_WRITE_FLOW_CONTROL_MODE:
5293                 RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_WRITE_FLOW_CONTROL_MODE\n"));
5294                 status = bthci_CmdWriteFlowControlMode(padapter, pHciCmd);
5295                 break;
5296         case HCI_READ_BEST_EFFORT_FLUSH_TIMEOUT:
5297                 RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_READ_BEST_EFFORT_FLUSH_TIMEOUT\n"));
5298                 status = bthci_CmdReadBestEffortFlushTimeout(padapter, pHciCmd);
5299                 break;
5300         case HCI_WRITE_BEST_EFFORT_FLUSH_TIMEOUT:
5301                 RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_WRITE_BEST_EFFORT_FLUSH_TIMEOUT\n"));
5302                 status = bthci_CmdWriteBestEffortFlushTimeout(padapter, pHciCmd);
5303                 break;
5304         case HCI_SHORT_RANGE_MODE:
5305                 RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_SHORT_RANGE_MODE\n"));
5306                 status = bthci_CmdShortRangeMode(padapter, pHciCmd);
5307                 break;
5308         case HCI_HOST_BUFFER_SIZE:
5309                 RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_HOST_BUFFER_SIZE\n"));
5310                 status = bthci_CmdHostBufferSize(padapter,pHciCmd);
5311                 break;
5312         default:
5313                 RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("bthci_HandleOGFSetEventMaskCMD(), Unknown case = 0x%x\n", pHciCmd->OCF));
5314                 RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_UNKNOWN_COMMAND\n"));
5315                 status = bthci_UnknownCMD(padapter, pHciCmd);
5316                 break;
5317         }
5318         return status;
5319 }
5320
5321 HCI_STATUS
5322 bthci_HandleOGFStatusParameters(
5323         PADAPTER                                                padapter,
5324         PPACKET_IRP_HCICMD_DATA pHciCmd
5325         )
5326 {
5327         HCI_STATUS status = HCI_STATUS_SUCCESS;
5328
5329         switch (pHciCmd->OCF)
5330         {
5331         case HCI_READ_FAILED_CONTACT_COUNTER:
5332                 RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_READ_FAILED_CONTACT_COUNTER\n"));
5333                 status = bthci_CmdReadFailedContactCounter(padapter,pHciCmd);
5334                 break;
5335         case HCI_RESET_FAILED_CONTACT_COUNTER:
5336                 RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_RESET_FAILED_CONTACT_COUNTER\n"));
5337                 status = bthci_CmdResetFailedContactCounter(padapter,pHciCmd);
5338                 break;
5339         case HCI_READ_LINK_QUALITY:
5340                 RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_READ_LINK_QUALITY\n"));
5341                 status = bthci_CmdReadLinkQuality(padapter, pHciCmd);
5342                 break;
5343         case HCI_READ_RSSI:
5344                 RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_READ_RSSI\n"));
5345                 status = bthci_CmdReadRSSI(padapter);
5346                 break;
5347         case HCI_READ_LOCAL_AMP_INFO:
5348                 RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_READ_LOCAL_AMP_INFO\n"));
5349                 status = bthci_CmdReadLocalAMPInfo(padapter);
5350                 break;
5351         case HCI_READ_LOCAL_AMP_ASSOC:
5352                 RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_READ_LOCAL_AMP_ASSOC\n"));
5353                 status = bthci_CmdReadLocalAMPAssoc(padapter,pHciCmd);
5354                 break;
5355         case HCI_WRITE_REMOTE_AMP_ASSOC:
5356                 RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_WRITE_REMOTE_AMP_ASSOC\n"));
5357                 status = bthci_CmdWriteRemoteAMPAssoc(padapter,pHciCmd);
5358                 break;
5359         default:
5360                 RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("bthci_HandleOGFStatusParameters(), Unknown case = 0x%x\n", pHciCmd->OCF));
5361                 RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_UNKNOWN_COMMAND\n"));
5362                 status = bthci_UnknownCMD(padapter, pHciCmd);
5363                 break;
5364         }
5365         return status;
5366 }
5367
5368
5369 HCI_STATUS
5370 bthci_HandleOGFLinkControlCMD(
5371         PADAPTER        padapter,
5372         PPACKET_IRP_HCICMD_DATA         pHciCmd
5373         )
5374 {
5375         HCI_STATUS status = HCI_STATUS_SUCCESS;
5376
5377         switch (pHciCmd->OCF)
5378         {
5379                 case HCI_CREATE_PHYSICAL_LINK:
5380                         RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_CREATE_PHYSICAL_LINK\n"));
5381                         status = bthci_CmdCreatePhysicalLink(padapter,pHciCmd);
5382                         break;
5383                 case HCI_ACCEPT_PHYSICAL_LINK:
5384                         RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_ACCEPT_PHYSICAL_LINK\n"));
5385                         status = bthci_CmdAcceptPhysicalLink(padapter,pHciCmd);
5386                         break;
5387                 case HCI_DISCONNECT_PHYSICAL_LINK:
5388                         RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_DISCONNECT_PHYSICAL_LINK\n"));
5389                         status = bthci_CmdDisconnectPhysicalLink(padapter,pHciCmd);
5390                         break;
5391                 case HCI_CREATE_LOGICAL_LINK:
5392                         RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_CREATE_LOGICAL_LINK\n"));
5393                         status = bthci_CmdCreateLogicalLink(padapter,pHciCmd);
5394                         break;
5395                 case HCI_ACCEPT_LOGICAL_LINK:
5396                         RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_ACCEPT_LOGICAL_LINK\n"));
5397                         status = bthci_CmdAcceptLogicalLink(padapter,pHciCmd);
5398                         break;
5399                 case HCI_DISCONNECT_LOGICAL_LINK:
5400                         RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_DISCONNECT_LOGICAL_LINK\n"));
5401                         status = bthci_CmdDisconnectLogicalLink(padapter,pHciCmd);
5402                         break;
5403                 case HCI_LOGICAL_LINK_CANCEL:
5404                         RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_LOGICAL_LINK_CANCEL\n"));
5405                         status = bthci_CmdLogicalLinkCancel(padapter,pHciCmd);
5406                         break;
5407                 case HCI_FLOW_SPEC_MODIFY:
5408                         RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_FLOW_SPEC_MODIFY\n"));
5409                         status = bthci_CmdFlowSpecModify(padapter,pHciCmd);
5410                         break;
5411
5412                 default:
5413                         RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("bthci_HandleOGFLinkControlCMD(), Unknown case = 0x%x\n", pHciCmd->OCF));
5414                         RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_UNKNOWN_COMMAND\n"));
5415                         status = bthci_UnknownCMD(padapter, pHciCmd);
5416                         break;
5417         }
5418         return status;
5419 }
5420
5421 HCI_STATUS
5422 bthci_HandleOGFTestingCMD(
5423         PADAPTER        padapter,
5424         PPACKET_IRP_HCICMD_DATA         pHciCmd
5425         )
5426 {
5427         HCI_STATUS status = HCI_STATUS_SUCCESS;
5428         switch (pHciCmd->OCF)
5429         {
5430                 case HCI_ENABLE_DEVICE_UNDER_TEST_MODE:
5431                         RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_ENABLE_DEVICE_UNDER_TEST_MODE\n"));
5432                         bthci_CmdEnableDeviceUnderTestMode(padapter,pHciCmd);
5433                         break;
5434                 case HCI_AMP_TEST_END:
5435                         RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_AMP_TEST_END\n"));
5436                         bthci_CmdAMPTestEnd(padapter,pHciCmd);
5437                         break;
5438                 case HCI_AMP_TEST_COMMAND:
5439                         RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_AMP_TEST_COMMAND\n"));
5440                         bthci_CmdAMPTestCommand(padapter,pHciCmd);
5441                         break;
5442                 case HCI_ENABLE_AMP_RECEIVER_REPORTS:
5443                         RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_ENABLE_AMP_RECEIVER_REPORTS\n"));
5444                         bthci_CmdEnableAMPReceiverReports(padapter,pHciCmd);
5445                         break;
5446
5447                 default:
5448                         RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_UNKNOWN_COMMAND\n"));
5449                         status = bthci_UnknownCMD(padapter, pHciCmd);
5450                         break;
5451         }
5452         return status;
5453 }
5454
5455 HCI_STATUS
5456 bthci_HandleOGFExtension(
5457         PADAPTER        padapter,
5458         PPACKET_IRP_HCICMD_DATA         pHciCmd
5459         )
5460 {
5461         HCI_STATUS status = HCI_STATUS_SUCCESS;
5462         switch (pHciCmd->OCF)
5463         {
5464                 case HCI_SET_ACL_LINK_DATA_FLOW_MODE:
5465                         RTPRINT(FIOCTL, IOCTL_BT_HCICMD_EXT, ("HCI_SET_ACL_LINK_DATA_FLOW_MODE\n"));
5466                         status = bthci_CmdSetACLLinkDataFlowMode(padapter,pHciCmd);
5467                         break;
5468                 case HCI_SET_ACL_LINK_STATUS:
5469                         RTPRINT(FIOCTL, IOCTL_BT_HCICMD_EXT, ("HCI_SET_ACL_LINK_STATUS\n"));
5470                         status = bthci_CmdSetACLLinkStatus(padapter,pHciCmd);
5471                         break;
5472                 case HCI_SET_SCO_LINK_STATUS:
5473                         RTPRINT(FIOCTL, IOCTL_BT_HCICMD_EXT, ("HCI_SET_SCO_LINK_STATUS\n"));
5474                         status = bthci_CmdSetSCOLinkStatus(padapter,pHciCmd);
5475                         break;
5476                 case HCI_SET_RSSI_VALUE:
5477                         RTPRINT(FIOCTL, IOCTL_BT_EVENT_PERIODICAL, ("HCI_SET_RSSI_VALUE\n"));
5478                         status = bthci_CmdSetRSSIValue(padapter,pHciCmd);
5479                         break;
5480                 case HCI_SET_CURRENT_BLUETOOTH_STATUS:
5481                         RTPRINT(FIOCTL, IOCTL_BT_HCICMD_EXT, ("HCI_SET_CURRENT_BLUETOOTH_STATUS\n"));
5482                         status = bthci_CmdSetCurrentBluetoothStatus(padapter,pHciCmd);
5483                         break;
5484                 //The following is for RTK8723
5485
5486                 case HCI_EXTENSION_VERSION_NOTIFY:
5487                         RTPRINT(FIOCTL, IOCTL_BT_HCICMD_EXT, ("HCI_EXTENSION_VERSION_NOTIFY\n"));
5488                         status = bthci_CmdExtensionVersionNotify(padapter,pHciCmd);
5489                         break;
5490                 case HCI_LINK_STATUS_NOTIFY:
5491                         RTPRINT(FIOCTL, IOCTL_BT_HCICMD_EXT, ("HCI_LINK_STATUS_NOTIFY\n"));
5492                         status = bthci_CmdLinkStatusNotify(padapter,pHciCmd);
5493                         break;
5494                 case HCI_BT_OPERATION_NOTIFY:
5495                         RTPRINT(FIOCTL, IOCTL_BT_HCICMD_EXT, ("HCI_BT_OPERATION_NOTIFY\n"));
5496                         status = bthci_CmdBtOperationNotify(padapter,pHciCmd);
5497                         break;
5498                 case HCI_ENABLE_WIFI_SCAN_NOTIFY:
5499                         RTPRINT(FIOCTL, IOCTL_BT_HCICMD_EXT, ("HCI_ENABLE_WIFI_SCAN_NOTIFY\n"));
5500                         status = bthci_CmdEnableWifiScanNotify(padapter,pHciCmd);
5501                         break;
5502
5503                 //The following is for IVT
5504                 case HCI_WIFI_CURRENT_CHANNEL:
5505                         RTPRINT(FIOCTL, IOCTL_BT_HCICMD_EXT, ("HCI_WIFI_CURRENT_CHANNEL\n"));
5506                         status = bthci_CmdWIFICurrentChannel(padapter,pHciCmd);
5507                         break;
5508                 case HCI_WIFI_CURRENT_BANDWIDTH:
5509                         RTPRINT(FIOCTL, IOCTL_BT_HCICMD_EXT, ("HCI_WIFI_CURRENT_BANDWIDTH\n"));
5510                         status = bthci_CmdWIFICurrentBandwidth(padapter,pHciCmd);
5511                         break;
5512                 case HCI_WIFI_CONNECTION_STATUS:
5513                         RTPRINT(FIOCTL, IOCTL_BT_HCICMD_EXT, ("HCI_WIFI_CONNECTION_STATUS\n"));
5514                         status = bthci_CmdWIFIConnectionStatus(padapter,pHciCmd);
5515                         break;
5516
5517                 default:
5518                         RTPRINT(FIOCTL, IOCTL_BT_HCICMD_EXT, ("HCI_UNKNOWN_COMMAND\n"));
5519                         status = bthci_UnknownCMD(padapter, pHciCmd);
5520                         break;
5521         }
5522         return status;
5523 }
5524
5525 void
5526 bthci_FakeCommand(
5527         PADAPTER        padapter,
5528         u16     OGF,
5529         u16     OCF
5530         )
5531 {
5532 #define MAX_TMP_BUF_SIZE        200
5533         u8      buffer[MAX_TMP_BUF_SIZE];
5534         PPACKET_IRP_HCICMD_DATA pCmd=(PPACKET_IRP_HCICMD_DATA)buffer;
5535
5536         PlatformZeroMemory(buffer, MAX_TMP_BUF_SIZE);
5537
5538         pCmd->OGF = OGF;
5539         pCmd->OCF = OCF;
5540
5541         if (OGF == OGF_LINK_CONTROL_COMMANDS && OCF == HCI_LOGICAL_LINK_CANCEL)
5542         {
5543                 pCmd->Length = 2;
5544                 pCmd->Data[0] = 1;              //physical link handle
5545                 pCmd->Data[1] = 0x16;           //Tx_Flow_Spec_ID
5546                 BTHCI_HandleHCICMD(padapter, (PPACKET_IRP_HCICMD_DATA)buffer);
5547         }
5548 }
5549
5550 void
5551 bthci_StateStarting(
5552         PADAPTER                                        padapter,
5553         HCI_STATE_WITH_CMD              StateCmd,
5554         u8                                      EntryNum
5555         )
5556 {
5557         PBT30Info               pBTInfo = GET_BT_INFO(padapter);
5558         PBT_MGNT                pBtMgnt = &pBTInfo->BtMgnt;
5559
5560         RTPRINT(FIOCTL, IOCTL_STATE, ("[BT state], [Starting], "));
5561         switch (StateCmd)
5562         {
5563                 case STATE_CMD_CONNECT_ACCEPT_TIMEOUT:
5564                 {
5565                         RTPRINT(FIOCTL, IOCTL_STATE, ("STATE_CMD_CONNECT_ACCEPT_TIMEOUT\n"));
5566                         pBTInfo->BtAsocEntry[EntryNum].PhysLinkCompleteStatus=HCI_STATUS_CONNECT_ACCEPT_TIMEOUT;
5567                         pBtMgnt->bNeedNotifyAMPNoCap = _TRUE;
5568                         BTHCI_DisconnectPeer(padapter,EntryNum);
5569                         break;
5570                 }
5571
5572                 case STATE_CMD_DISCONNECT_PHY_LINK:
5573                 {
5574                         RTPRINT(FIOCTL, IOCTL_STATE, ("STATE_CMD_DISCONNECT_PHY_LINK\n"));
5575
5576                         bthci_EventDisconnectPhyLinkComplete(padapter,
5577                         HCI_STATUS_SUCCESS,
5578                         pBTInfo->BtAsocEntry[EntryNum].PhyLinkDisconnectReason,
5579                         EntryNum);
5580
5581                         PlatformCancelTimer(padapter,&pBTInfo->BTHCIJoinTimeoutTimer);
5582
5583                         pBTInfo->BtAsocEntry[EntryNum].PhysLinkCompleteStatus=HCI_STATUS_UNKNOW_CONNECT_ID;
5584
5585                         BTHCI_DisconnectPeer(padapter, EntryNum);
5586                         break;
5587                 }
5588
5589                 case STATE_CMD_MAC_START_COMPLETE:
5590                 {
5591                         RTPRINT(FIOCTL, IOCTL_STATE, ("STATE_CMD_MAC_START_COMPLETE\n"));
5592                         if (pBTInfo->BtAsocEntry[EntryNum].AMPRole == AMP_BTAP_JOINER)
5593                         {
5594                         }
5595                         else if (pBTInfo->BtAsocEntry[EntryNum].AMPRole == AMP_BTAP_CREATOR)
5596                         {
5597                                 bthci_EventChannelSelected(padapter,EntryNum);
5598                         }
5599
5600                         break;
5601                 }
5602
5603                 default:
5604                         RTPRINT(FIOCTL, IOCTL_STATE, ("State command(%d) is Wrong !!!\n", StateCmd));
5605                         break;
5606         }
5607 }
5608
5609 void
5610 bthci_StateConnecting(
5611         PADAPTER                                        padapter,
5612         HCI_STATE_WITH_CMD              StateCmd,
5613         u8                                      EntryNum
5614         )
5615 {
5616         PBT30Info               pBTInfo = GET_BT_INFO(padapter);
5617         PBT_MGNT                pBtMgnt = &pBTInfo->BtMgnt;
5618
5619         RTPRINT(FIOCTL, IOCTL_STATE, ("[BT state], [Connecting], "));
5620         switch (StateCmd)
5621         {
5622                 case STATE_CMD_CONNECT_ACCEPT_TIMEOUT:
5623                 {
5624                         RTPRINT(FIOCTL, IOCTL_STATE, ("STATE_CMD_CONNECT_ACCEPT_TIMEOUT\n"));
5625                         pBTInfo->BtAsocEntry[EntryNum].PhysLinkCompleteStatus=HCI_STATUS_CONNECT_ACCEPT_TIMEOUT;
5626                         pBtMgnt->bNeedNotifyAMPNoCap = _TRUE;
5627                         BTHCI_DisconnectPeer(padapter, EntryNum);
5628                         break;
5629                 }
5630
5631                 case STATE_CMD_MAC_CONNECT_COMPLETE:
5632                 {
5633                         RTPRINT(FIOCTL, IOCTL_STATE, ("STATE_CMD_MAC_CONNECT_COMPLETE\n"));
5634
5635                         if (pBTInfo->BtAsocEntry[EntryNum].AMPRole == AMP_BTAP_JOINER)
5636                         {
5637                                 RT_TRACE(_module_rtl871x_security_c_, _drv_info_ , ("StateConnecting \n"));
5638                         }
5639                         break;
5640                 }
5641
5642                 case STATE_CMD_DISCONNECT_PHY_LINK:
5643                 {
5644                         RTPRINT(FIOCTL, IOCTL_STATE, ("STATE_CMD_DISCONNECT_PHY_LINK\n"));
5645
5646                         bthci_EventDisconnectPhyLinkComplete(padapter,
5647                         HCI_STATUS_SUCCESS,
5648                         pBTInfo->BtAsocEntry[EntryNum].PhyLinkDisconnectReason,
5649                         EntryNum);
5650
5651                         pBTInfo->BtAsocEntry[EntryNum].PhysLinkCompleteStatus=HCI_STATUS_UNKNOW_CONNECT_ID;
5652
5653                         PlatformCancelTimer(padapter,&pBTInfo->BTHCIJoinTimeoutTimer);
5654
5655                         BTHCI_DisconnectPeer(padapter, EntryNum);
5656
5657                         break;
5658                 }
5659
5660                 case STATE_CMD_MAC_CONNECT_CANCEL_INDICATE:
5661                 {
5662                         RTPRINT(FIOCTL, IOCTL_STATE, ("STATE_CMD_MAC_CONNECT_CANCEL_INDICATE\n"));
5663                         pBTInfo->BtAsocEntry[EntryNum].PhysLinkCompleteStatus=HCI_STATUS_CONTROLLER_BUSY;
5664                         // Because this state cmd is caused by the BTHCI_EventAMPStatusChange(),
5665                         // we don't need to send event in the following BTHCI_DisconnectPeer() again.
5666                         pBtMgnt->bNeedNotifyAMPNoCap = _FALSE;
5667                         BTHCI_DisconnectPeer(padapter, EntryNum);
5668                         break;
5669                 }
5670
5671                 default:
5672                         RTPRINT(FIOCTL, IOCTL_STATE, ("State command(%d) is Wrong !!!\n", StateCmd));
5673                         break;
5674         }
5675 }
5676
5677 void
5678 bthci_StateConnected(
5679         PADAPTER                                        padapter,
5680         HCI_STATE_WITH_CMD              StateCmd,
5681         u8                                      EntryNum
5682         )
5683 {
5684 //      PMGNT_INFO pMgntInfo = &padapter->MgntInfo;
5685         PBT30Info               pBTInfo = GET_BT_INFO(padapter);
5686         PBT_MGNT                pBtMgnt = &pBTInfo->BtMgnt;
5687
5688         RTPRINT(FIOCTL, IOCTL_STATE, ("[BT state], [Connected], "));
5689         switch (StateCmd)
5690         {
5691                 case STATE_CMD_DISCONNECT_PHY_LINK:
5692                 {
5693                         RTPRINT(FIOCTL, IOCTL_STATE, ("STATE_CMD_DISCONNECT_PHY_LINK\n"));
5694
5695                         //
5696                         //When we are trying to disconnect the phy link, we should disconnect log link first,
5697                         //
5698                         {
5699                                 u8 i;
5700                                 u16 logicHandle = 0;
5701                                 for (i=0; i<MAX_LOGICAL_LINK_NUM; i++)
5702                                 {
5703                                         if (pBTInfo->BtAsocEntry[EntryNum].LogLinkCmdData->BtLogLinkhandle != 0)
5704                                         {
5705                                                 logicHandle=pBTInfo->BtAsocEntry[EntryNum].LogLinkCmdData->BtLogLinkhandle;
5706
5707                                                 bthci_EventDisconnectLogicalLinkComplete(padapter, HCI_STATUS_SUCCESS,
5708                                                         logicHandle, pBTInfo->BtAsocEntry[EntryNum].PhyLinkDisconnectReason);
5709
5710                                                 pBTInfo->BtAsocEntry[EntryNum].LogLinkCmdData->BtLogLinkhandle = 0;
5711                                         }
5712                                 }
5713                         }
5714
5715                         bthci_EventDisconnectPhyLinkComplete(padapter,
5716                         HCI_STATUS_SUCCESS,
5717                         pBTInfo->BtAsocEntry[EntryNum].PhyLinkDisconnectReason,
5718                         EntryNum);
5719
5720                         PlatformCancelTimer(padapter, &pBTInfo->BTHCIJoinTimeoutTimer);
5721
5722                         BTHCI_DisconnectPeer(padapter, EntryNum);
5723                         break;
5724                 }
5725
5726                 case STATE_CMD_MAC_DISCONNECT_INDICATE:
5727                 {
5728                         RTPRINT(FIOCTL, IOCTL_STATE, ("STATE_CMD_MAC_DISCONNECT_INDICATE\n"));
5729
5730                         bthci_EventDisconnectPhyLinkComplete(padapter,
5731                         HCI_STATUS_SUCCESS,
5732                         // TODO: Remote Host not local host
5733                         HCI_STATUS_CONNECT_TERMINATE_LOCAL_HOST,
5734                         EntryNum);
5735                         BTHCI_DisconnectPeer(padapter, EntryNum);
5736
5737                         break;
5738                 }
5739
5740                 case STATE_CMD_ENTER_STATE:
5741                 {
5742                         RTPRINT(FIOCTL, IOCTL_STATE, ("STATE_CMD_ENTER_STATE\n"));
5743
5744                         if (pBtMgnt->bBTConnectInProgress)
5745                         {
5746                                 pBtMgnt->bBTConnectInProgress = _FALSE;
5747                                 RTPRINT(FIOCTL, IOCTL_STATE, ("[BT Flag], BT Connect in progress OFF!!\n"));
5748                         }
5749                         pBTInfo->BtAsocEntry[EntryNum].BtCurrentState = HCI_STATE_CONNECTED;
5750                         pBTInfo->BtAsocEntry[EntryNum].b4waySuccess = _TRUE;
5751                         pBtMgnt->bStartSendSupervisionPkt = _TRUE;
5752
5753                         PlatformSetTimer(padapter, &pBTInfo->BTSupervisionPktTimer, 10000);
5754                         // for rate adaptive
5755
5756                         if(padapter->HalFunc.UpdateRAMaskHandler)
5757                                 padapter->HalFunc.UpdateRAMaskHandler(padapter, MAX_FW_SUPPORT_MACID_NUM-1-EntryNum, 0);
5758
5759                         rtw_hal_set_hwreg(padapter, HW_VAR_BASIC_RATE, padapter->mlmepriv.cur_network.network.SupportedRates);
5760                         BTDM_SetFwChnlInfo(padapter, RT_MEDIA_CONNECT);
5761
5762                         break;
5763                 }
5764
5765                 default:
5766                         RTPRINT(FIOCTL, IOCTL_STATE, ("State command(%d) is Wrong !!!\n", StateCmd));
5767                         break;
5768         }
5769 }
5770
5771 void
5772 bthci_StateAuth(
5773         PADAPTER                                        padapter,
5774         HCI_STATE_WITH_CMD              StateCmd,
5775         u8                                      EntryNum
5776         )
5777 {
5778         PBT30Info               pBTInfo = GET_BT_INFO(padapter);
5779         PBT_MGNT                pBtMgnt = &pBTInfo->BtMgnt;
5780
5781         RTPRINT(FIOCTL, IOCTL_STATE, ("[BT state], [Authenticating], "));
5782         switch (StateCmd)
5783         {
5784                 case STATE_CMD_CONNECT_ACCEPT_TIMEOUT:
5785                 {
5786                         RTPRINT(FIOCTL, IOCTL_STATE, ("STATE_CMD_CONNECT_ACCEPT_TIMEOUT\n"));
5787                         pBTInfo->BtAsocEntry[EntryNum].PhysLinkCompleteStatus=HCI_STATUS_CONNECT_ACCEPT_TIMEOUT;
5788                         pBtMgnt->bNeedNotifyAMPNoCap = _TRUE;
5789                         BTHCI_DisconnectPeer(padapter, EntryNum);
5790                         break;
5791                 }
5792
5793                 case STATE_CMD_DISCONNECT_PHY_LINK:
5794                 {
5795                         RTPRINT(FIOCTL, IOCTL_STATE, ("STATE_CMD_DISCONNECT_PHY_LINK\n"));
5796                         bthci_EventDisconnectPhyLinkComplete(padapter,
5797                         HCI_STATUS_SUCCESS,
5798                         pBTInfo->BtAsocEntry[EntryNum].PhyLinkDisconnectReason,
5799                         EntryNum);
5800
5801                         pBTInfo->BtAsocEntry[EntryNum].PhysLinkCompleteStatus=HCI_STATUS_UNKNOW_CONNECT_ID;
5802
5803                         PlatformCancelTimer(padapter,&pBTInfo->BTHCIJoinTimeoutTimer);
5804
5805                         BTHCI_DisconnectPeer(padapter,EntryNum);
5806                         break;
5807                 }
5808
5809                 case STATE_CMD_4WAY_FAILED:
5810                 {
5811                         RTPRINT(FIOCTL, IOCTL_STATE, ("STATE_CMD_4WAY_FAILED\n"));
5812
5813                         pBTInfo->BtAsocEntry[EntryNum].PhysLinkCompleteStatus=HCI_STATUS_AUTH_FAIL;
5814                         pBtMgnt->bNeedNotifyAMPNoCap = _TRUE;
5815
5816                         BTHCI_DisconnectPeer(padapter,EntryNum);
5817
5818                         PlatformCancelTimer(padapter,&pBTInfo->BTHCIJoinTimeoutTimer);
5819                         break;
5820                 }
5821
5822                 case STATE_CMD_4WAY_SUCCESSED:
5823                 {
5824                         RTPRINT(FIOCTL, IOCTL_STATE, ("STATE_CMD_4WAY_SUCCESSED\n"));
5825
5826                         bthci_EventPhysicalLinkComplete(padapter, HCI_STATUS_SUCCESS, EntryNum, INVALID_PL_HANDLE);
5827
5828                         PlatformCancelTimer(padapter, &pBTInfo->BTHCIJoinTimeoutTimer);
5829
5830                         BTHCI_SM_WITH_INFO(padapter, HCI_STATE_CONNECTED, STATE_CMD_ENTER_STATE, EntryNum);
5831                         break;
5832                 }
5833
5834                 default:
5835                         RTPRINT(FIOCTL, IOCTL_STATE, ("State command(%d) is Wrong !!!\n", StateCmd));
5836                         break;
5837         }
5838 }
5839
5840 void
5841 bthci_StateDisconnecting(
5842         PADAPTER                                        padapter,
5843         HCI_STATE_WITH_CMD              StateCmd,
5844         u8                                      EntryNum
5845         )
5846 {
5847         PBT30Info               pBTInfo = GET_BT_INFO(padapter);
5848         PBT_MGNT                pBtMgnt = &pBTInfo->BtMgnt;
5849
5850         RTPRINT(FIOCTL, IOCTL_STATE, ("[BT state], [Disconnecting], "));
5851         switch (StateCmd)
5852         {
5853                 case STATE_CMD_MAC_CONNECT_CANCEL_INDICATE:
5854                 {
5855                         RTPRINT(FIOCTL, IOCTL_STATE, ("STATE_CMD_MAC_CONNECT_CANCEL_INDICATE\n"));
5856                         if (pBTInfo->BtAsocEntry[EntryNum].bNeedPhysLinkCompleteEvent)
5857                         {
5858                                 bthci_EventPhysicalLinkComplete(padapter,
5859                                         pBTInfo->BtAsocEntry[EntryNum].PhysLinkCompleteStatus,
5860                                         EntryNum, INVALID_PL_HANDLE);
5861                         }
5862
5863                         if (pBtMgnt->bBTConnectInProgress)
5864                         {
5865                                 pBtMgnt->bBTConnectInProgress = _FALSE;
5866                                 RTPRINT(FIOCTL, IOCTL_STATE, ("[BT Flag], BT Connect in progress OFF!!\n"));
5867                         }
5868
5869                         BTHCI_SM_WITH_INFO(padapter, HCI_STATE_DISCONNECTED, STATE_CMD_ENTER_STATE, EntryNum);
5870                         break;
5871                 }
5872
5873                 case STATE_CMD_DISCONNECT_PHY_LINK:
5874                 {
5875                         RTPRINT(FIOCTL, IOCTL_STATE, ("STATE_CMD_DISCONNECT_PHY_LINK\n"));
5876
5877                         bthci_EventDisconnectPhyLinkComplete(padapter,
5878                         HCI_STATUS_SUCCESS,
5879                         pBTInfo->BtAsocEntry[EntryNum].PhyLinkDisconnectReason,
5880                         EntryNum);
5881
5882                         PlatformCancelTimer(padapter,&pBTInfo->BTHCIJoinTimeoutTimer);
5883
5884                         BTHCI_DisconnectPeer(padapter, EntryNum);
5885                         break;
5886                 }
5887
5888                 default:
5889                         RTPRINT(FIOCTL, IOCTL_STATE, ("State command(%d) is Wrong !!!\n", StateCmd));
5890                         break;
5891         }
5892 }
5893
5894 void
5895 bthci_StateDisconnected(
5896         PADAPTER                                        padapter,
5897         HCI_STATE_WITH_CMD              StateCmd,
5898         u8                                      EntryNum
5899         )
5900 {
5901 //      PMGNT_INFO pMgntInfo = &padapter->MgntInfo;
5902         PBT30Info               pBTInfo = GET_BT_INFO(padapter);
5903         PBT_HCI_INFO            pBtHciInfo = &pBTInfo->BtHciInfo;
5904         PBT_MGNT                pBtMgnt = &pBTInfo->BtMgnt;
5905
5906         RTPRINT(FIOCTL, IOCTL_STATE, ("[BT state], [Disconnected], "));
5907         switch (StateCmd)
5908         {
5909                 case STATE_CMD_CREATE_PHY_LINK:
5910                 case STATE_CMD_ACCEPT_PHY_LINK:
5911                 {
5912                         if (StateCmd == STATE_CMD_CREATE_PHY_LINK)
5913                         {
5914                                 RTPRINT(FIOCTL, IOCTL_STATE, ("STATE_CMD_CREATE_PHY_LINK\n"));
5915                         }
5916                         else
5917                         {
5918                                 RTPRINT(FIOCTL, IOCTL_STATE, ("STATE_CMD_ACCEPT_PHY_LINK\n"));
5919                         }
5920
5921                         RTPRINT(FIOCTL, IOCTL_STATE, ("[BT PS], Disable IPS and LPS\n"));
5922                         IPSDisable(padapter, _FALSE, IPS_DISABLE_BT_ON);
5923                         LeisurePSLeave(padapter, LPS_DISABLE_BT_HS_CONNECTION);
5924
5925                         pBtMgnt->bPhyLinkInProgress =_TRUE;
5926                         pBtMgnt->BTCurrentConnectType=BT_DISCONNECT;
5927                         if (!pBtMgnt->BtOperationOn)
5928                         {
5929 #if (SENDTXMEHTOD == 0)
5930                                 PlatformSetTimer(padapter, &pBTInfo->BTHCISendAclDataTimer, 1);
5931 #endif
5932 #if (RTS_CTS_NO_LEN_LIMIT == 1)
5933                                 rtw_write32(padapter, 0x4c8, 0xc140400);
5934 #endif
5935                         }
5936                         pBtMgnt->CurrentBTConnectionCnt++;
5937                         RTPRINT(FIOCTL, IOCTL_STATE, ("[BT Flag], CurrentBTConnectionCnt = %d\n",
5938                                 pBtMgnt->CurrentBTConnectionCnt));
5939                         pBtMgnt->BtOperationOn = _TRUE;
5940                         RTPRINT(FIOCTL, IOCTL_STATE, ("[BT Flag], Bt Operation ON!! CurrentConnectEntryNum = %d\n",
5941                                 pBtMgnt->CurrentConnectEntryNum));
5942
5943                         if (pBtMgnt->bBTConnectInProgress)
5944                         {
5945                                 bthci_EventPhysicalLinkComplete(padapter, HCI_STATUS_CONTROLLER_BUSY, INVALID_ENTRY_NUM, pBtMgnt->BtCurrentPhyLinkhandle);
5946                                 bthci_RemoveEntryByEntryNum(padapter, EntryNum);
5947                                 return;
5948                         }
5949
5950                         if (StateCmd == STATE_CMD_CREATE_PHY_LINK)
5951                         {
5952                                 pBTInfo->BtAsocEntry[EntryNum].AMPRole = AMP_BTAP_CREATOR;
5953                         }
5954                         else
5955                         {
5956                                 pBTInfo->BtAsocEntry[EntryNum].AMPRole = AMP_BTAP_JOINER;
5957                         }
5958
5959                         // 1. MAC not yet in selected channel
5960                         while (check_fwstate(&padapter->mlmepriv, WIFI_ASOC_STATE|WIFI_SITE_MONITOR) == _TRUE)
5961                         {
5962                                 RTPRINT(FIOCTL, IOCTL_STATE, ("Scan/Roaming/Wifi Link is in Progress, wait 200 ms\n"));
5963                                 rtw_mdelay_os(200);
5964                         }
5965                         // 2. MAC already in selected channel
5966                         {
5967                                 RTPRINT(FIOCTL, IOCTL_STATE, ("Channel is Ready\n"));
5968                                 PlatformSetTimer(padapter, &pBTInfo->BTHCIJoinTimeoutTimer, pBtHciInfo->ConnAcceptTimeout);
5969
5970                                 pBTInfo->BtAsocEntry[EntryNum].bNeedPhysLinkCompleteEvent = _TRUE;
5971                         }
5972                         break;
5973                 }
5974
5975                 case STATE_CMD_DISCONNECT_PHY_LINK:
5976                 {
5977                         RTPRINT(FIOCTL, IOCTL_STATE, ("STATE_CMD_DISCONNECT_PHY_LINK\n"));
5978
5979                         PlatformCancelTimer(padapter,&pBTInfo->BTHCIJoinTimeoutTimer);
5980
5981                         bthci_EventDisconnectPhyLinkComplete(padapter,
5982                         HCI_STATUS_SUCCESS,
5983                         pBTInfo->BtAsocEntry[EntryNum].PhyLinkDisconnectReason,
5984                         EntryNum);
5985
5986                         if (pBTInfo->BtAsocEntry[EntryNum].bNeedPhysLinkCompleteEvent)
5987                         {
5988                                 bthci_EventPhysicalLinkComplete(padapter,
5989                                         HCI_STATUS_UNKNOW_CONNECT_ID,
5990                                         EntryNum, INVALID_PL_HANDLE);
5991                         }
5992
5993                         if (pBtMgnt->bBTConnectInProgress)
5994                         {
5995                                 pBtMgnt->bBTConnectInProgress = _FALSE;
5996                                 RTPRINT(FIOCTL, IOCTL_STATE, ("[BT Flag], BT Connect in progress OFF!!\n"));
5997                         }
5998                         BTHCI_SM_WITH_INFO(padapter, HCI_STATE_DISCONNECTED, STATE_CMD_ENTER_STATE, EntryNum);
5999                         bthci_RemoveEntryByEntryNum(padapter,EntryNum);
6000                         break;
6001                 }
6002
6003                 case STATE_CMD_ENTER_STATE:
6004                 {
6005                         RTPRINT(FIOCTL, IOCTL_STATE, ("STATE_CMD_ENTER_STATE\n"));
6006                         break;
6007                 }
6008
6009                 default:
6010                         RTPRINT(FIOCTL, IOCTL_STATE, ("State command(%d) is Wrong !!!\n", StateCmd));
6011                         break;
6012         }
6013 }
6014
6015 void
6016 bthci_UseFakeData(
6017         PADAPTER        padapter,
6018         PPACKET_IRP_HCICMD_DATA         pHciCmd
6019         )
6020 {
6021         if (pHciCmd->OGF == OGF_LINK_CONTROL_COMMANDS && pHciCmd->OCF == HCI_CREATE_LOGICAL_LINK)
6022         {
6023                 PHCI_FLOW_SPEC  pTxFlowSpec = (PHCI_FLOW_SPEC)&pHciCmd->Data[1];
6024                 PHCI_FLOW_SPEC  pRxFlowSpec = (PHCI_FLOW_SPEC)&pHciCmd->Data[17];
6025                 bthci_SelectFlowType(padapter, BT_TX_BE_FS, BT_RX_BE_FS, pTxFlowSpec, pRxFlowSpec);
6026                 //bthci_SelectFlowType(padapter, BT_TX_be_FS, BT_RX_GU_FS, pTxFlowSpec, pRxFlowSpec);
6027         }
6028         else if (pHciCmd->OGF == OGF_LINK_CONTROL_COMMANDS && pHciCmd->OCF == HCI_FLOW_SPEC_MODIFY)
6029         {
6030                 PHCI_FLOW_SPEC  pTxFlowSpec = (PHCI_FLOW_SPEC)&pHciCmd->Data[2];
6031                 PHCI_FLOW_SPEC  pRxFlowSpec = (PHCI_FLOW_SPEC)&pHciCmd->Data[18];
6032                 //bthci_SelectFlowType(padapter, BT_TX_BE_FS, BT_RX_BE_FS, pTxFlowSpec, pRxFlowSpec);
6033                 bthci_SelectFlowType(padapter, BT_TX_BE_AGG_FS, BT_RX_BE_AGG_FS, pTxFlowSpec, pRxFlowSpec);
6034         }
6035 }
6036
6037 void bthci_TimerCallbackHCICmd(PRT_TIMER pTimer)
6038 {
6039 #if (BT_THREAD == 0)
6040 //      PADAPTER                padapter = (PADAPTER)pTimer->padapter;
6041         PADAPTER                padapter = (PADAPTER)pTimer;
6042         PBT30Info               pBTinfo = GET_BT_INFO(padapter);
6043
6044         RTPRINT(FIOCTL, IOCTL_CALLBACK_FUN, ("bthci_TimerCallbackHCICmd() ==>\n"));
6045
6046         PlatformScheduleWorkItem(&pBTinfo->HCICmdWorkItem);
6047
6048         RTPRINT(FIOCTL, IOCTL_CALLBACK_FUN, ("bthci_TimerCallbackHCICmd() <==\n"));
6049 #endif
6050 }
6051
6052 void bthci_TimerCallbackSendAclData(PRT_TIMER pTimer)
6053 {
6054 #if (SENDTXMEHTOD == 0)
6055 //      PADAPTER                padapter = (PADAPTER)pTimer->padapter;
6056         PADAPTER                padapter = (PADAPTER)pTimer;
6057         PBT30Info               pBTinfo = GET_BT_INFO(padapter);
6058
6059         RTPRINT(FIOCTL, IOCTL_CALLBACK_FUN, ("HCIAclDataTimerCallback() ==>\n"));
6060         if (padapter->bDriverIsGoingToUnload)
6061         {
6062                 return;
6063         }
6064         PlatformScheduleWorkItem(&pBTinfo->HCISendACLDataWorkItem);
6065         RTPRINT(FIOCTL, IOCTL_CALLBACK_FUN, ("HCIAclDataTimerCallback() <==\n"));
6066 #endif
6067 }
6068
6069 void bthci_TimerCallbackDiscardAclData(PRT_TIMER pTimer)
6070 {
6071 //      PADAPTER                padapter = (PADAPTER)pTimer->padapter;
6072         PADAPTER                padapter = (PADAPTER)pTimer;
6073         PBT30Info               pBTInfo = GET_BT_INFO(padapter);
6074         PBT_HCI_INFO            pBtHciInfo = &pBTInfo->BtHciInfo;
6075
6076         RTPRINT(FIOCTL, IOCTL_CALLBACK_FUN, ("bthci_TimerCallbackDiscardAclData() ==>\n"));
6077
6078         RTPRINT(FIOCTL, (IOCTL_CALLBACK_FUN|IOCTL_BT_LOGO), ("Flush Timeout ==>\n"));
6079         if (bthci_DiscardTxPackets(padapter, pBtHciInfo->FLTO_LLH))
6080         {
6081                 bthci_EventFlushOccurred(padapter, pBtHciInfo->FLTO_LLH);
6082         }
6083         RTPRINT(FIOCTL, IOCTL_CALLBACK_FUN, ("bthci_TimerCallbackDiscardAclData() <==\n"));
6084 }
6085
6086 void bthci_TimerCallbackPsDisable(PRT_TIMER pTimer)
6087 {
6088 //      PADAPTER                padapter = (PADAPTER)pTimer->padapter;
6089         PADAPTER                padapter = (PADAPTER)pTimer;
6090         PBT30Info               pBTinfo = GET_BT_INFO(padapter);
6091
6092         RTPRINT(FIOCTL, IOCTL_CALLBACK_FUN, ("bthci_TimerCallbackPsDisable() ==>\n"));
6093
6094         PlatformScheduleWorkItem(&(pBTinfo->BTPsDisableWorkItem));
6095
6096         RTPRINT(FIOCTL, IOCTL_CALLBACK_FUN, ("bthci_TimerCallbackPsDisable() <==\n"));
6097 }
6098
6099 void bthci_TimerCallbackJoinTimeout(PRT_TIMER pTimer)
6100 {
6101 //      PADAPTER                padapter = (PADAPTER)pTimer->padapter;
6102         PADAPTER                padapter = (PADAPTER)pTimer;
6103         PBT30Info               pBTInfo = GET_BT_INFO(padapter);
6104         PBT_MGNT                pBtMgnt = &pBTInfo->BtMgnt;
6105         u8                      CurrentEntry = pBtMgnt->CurrentConnectEntryNum;
6106
6107         RTPRINT(FIOCTL, IOCTL_CALLBACK_FUN, ("bthci_TimerCallbackJoinTimeout() ==> Current State %x\n",pBTInfo->BtAsocEntry[CurrentEntry].BtCurrentState));
6108
6109         if (pBTInfo->BtAsocEntry[CurrentEntry].BtCurrentState == HCI_STATE_STARTING)
6110         {
6111                 bthci_StateStarting(padapter, STATE_CMD_CONNECT_ACCEPT_TIMEOUT,CurrentEntry);
6112         }
6113         else if (pBTInfo->BtAsocEntry[CurrentEntry].BtCurrentState == HCI_STATE_CONNECTING)
6114         {
6115                 bthci_StateConnecting(padapter, STATE_CMD_CONNECT_ACCEPT_TIMEOUT,CurrentEntry);
6116         }
6117         else if (pBTInfo->BtAsocEntry[CurrentEntry].BtCurrentState == HCI_STATE_AUTHENTICATING)
6118         {
6119                 bthci_StateAuth(padapter, STATE_CMD_CONNECT_ACCEPT_TIMEOUT,CurrentEntry);
6120         }
6121         else
6122         {
6123                 RTPRINT(FIOCTL, IOCTL_CALLBACK_FUN, ("bthci_TimerCallbackJoinTimeout() <== No Such state!!!\n"));
6124         }
6125
6126         RTPRINT(FIOCTL, IOCTL_CALLBACK_FUN, ("bthci_TimerCallbackJoinTimeout() <==\n"));
6127 }
6128
6129 void bthci_TimerCallbackSendTestPacket(PRT_TIMER pTimer)
6130 {
6131 //      PADAPTER                padapter = (PADAPTER)pTimer->padapter;
6132         PADAPTER                padapter = (PADAPTER)pTimer;
6133         PBT30Info               pBTInfo = GET_BT_INFO(padapter);
6134         PBT_HCI_INFO            pBtHciInfo = &pBTInfo->BtHciInfo;
6135
6136         RTPRINT(FIOCTL, IOCTL_CALLBACK_FUN, ("bthci_TimerCallbackSendTestPacket() \n"));
6137         if (pBtHciInfo->bTestIsEnd || !pBtHciInfo->bInTestMode)
6138         {
6139                 RTPRINT(FIOCTL, IOCTL_CALLBACK_FUN, ("bthci_TimerCallbackSendTestPacket() <==bTestIsEnd\n"));
6140                 return;
6141         }
6142
6143 //      BTPKT_SendTestPacket(padapter); // not porting yet
6144         PlatformSetTimer(padapter, &pBTInfo->BTTestSendPacketTimer, 50);
6145         RTPRINT(FIOCTL, IOCTL_CALLBACK_FUN, ("bthci_TimerCallbackSendTestPacket() <==\n"));
6146 }
6147
6148 void bthci_TimerCallbackBTSupervisionPacket(PRT_TIMER pTimer)
6149 {
6150 }
6151
6152 void bthci_TimerCallbackBTAuthTimeout(PRT_TIMER pTimer)
6153 {
6154 }
6155
6156 void bthci_TimerCallbackAsocTimeout(PRT_TIMER pTimer)
6157 {
6158 }
6159
6160 void bthci_TimerCallbackDisconnectPhysicalLink(PRT_TIMER pTimer)
6161 {
6162         PADAPTER                padapter = (PADAPTER)pTimer;
6163         PBT30Info               pBTInfo = GET_BT_INFO(padapter);
6164         PBT_MGNT                pBtMgnt = &pBTInfo->BtMgnt;
6165
6166         RT_TRACE(_module_rtl871x_security_c_, _drv_info_, ("===>bthci_TimerCallbackDisconnectPhysicalLink\n"));
6167
6168         if (pBTInfo->BtAsocEntry[pBtMgnt->DisconnectEntryNum].BtCurrentState == HCI_STATE_CONNECTED)
6169         {
6170                 BTHCI_SM_WITH_INFO(padapter,HCI_STATE_CONNECTED,STATE_CMD_DISCONNECT_PHY_LINK, pBtMgnt->DisconnectEntryNum);
6171         }
6172
6173         BTHCI_EventNumOfCompletedDataBlocks(padapter);
6174         pBtMgnt->DisconnectEntryNum = 0xff;
6175         RT_TRACE(_module_rtl871x_security_c_, _drv_info_, ("<===bthci_TimerCallbackDisconnectPhysicalLink\n"));
6176
6177 }
6178
6179 u8 bthci_WaitForRfReady(PADAPTER padapter)
6180 {
6181         u8 bRet = _FALSE;
6182
6183         struct pwrctrl_priv *ppwrctrl = &padapter->pwrctrlpriv;
6184         rt_rf_power_state                       RfState;
6185         u32                                             waitcnt = 0;
6186
6187         while(1)
6188         {
6189                 RfState = ppwrctrl->rf_pwrstate;
6190
6191                 if ((RfState != rf_on) || (ppwrctrl->bips_processing))
6192                 {
6193                         rtw_mdelay_os(10);
6194                         if (waitcnt++ >= 200)
6195                         {
6196                                 bRet = _FALSE;
6197                                 break;
6198                         }
6199                 }
6200                 else
6201                 {
6202                         RTPRINT(FIOCTL, IOCTL_STATE, ("bthci_WaitForRfReady(), Rf is on, wait %d times\n", waitcnt));
6203                         bRet = _TRUE;
6204                         break;
6205                 }
6206         }
6207
6208         return bRet;
6209 }
6210
6211 void bthci_WorkItemCallbackPsDisable(void *pContext)
6212 {
6213         PADAPTER                padapter = (PADAPTER)pContext;
6214         PBT30Info               pBTInfo = GET_BT_INFO(padapter);
6215         u8                      CurrentAssocNum;
6216
6217         for (CurrentAssocNum=0; CurrentAssocNum<MAX_BT_ASOC_ENTRY_NUM; CurrentAssocNum++)
6218         {
6219                 if (pBTInfo->BtAsocEntry[CurrentAssocNum].bUsed == _TRUE)
6220                 {
6221                         RTPRINT(FIOCTL, IOCTL_STATE, ("WorkItemCallbackPsDisable(): Handle Associate Entry %d\n", CurrentAssocNum));
6222
6223                         if (pBTInfo->BtAsocEntry[CurrentAssocNum].AMPRole == AMP_BTAP_CREATOR)
6224                         {
6225 //                              BTPKT_StartBeacon(padapter, CurrentAssocNum); // not porting yet
6226                                 BTHCI_SM_WITH_INFO(padapter, HCI_STATE_CONNECTING, STATE_CMD_MAC_CONNECT_COMPLETE, CurrentAssocNum);
6227                         }
6228                         else if (pBTInfo->BtAsocEntry[CurrentAssocNum].AMPRole == AMP_BTAP_JOINER)
6229                         {
6230                                 bthci_WaitForRfReady(padapter);
6231                                 bthci_ResponderStartToScan(padapter);
6232                         }
6233                 }
6234         }
6235 }
6236
6237 void bthci_WorkItemCallbackHCICmd(void *pContext)
6238 {
6239         PlatformProcessHCICommands(pContext);
6240 }
6241
6242 void bthci_WorkItemCallbackSendACLData(void *pContext)
6243 {
6244 #if (SENDTXMEHTOD == 0)
6245         PADAPTER                padapter = (PADAPTER)pContext;
6246         PlatformTxBTQueuedPackets(padapter);
6247 #endif
6248 }
6249
6250 void bthci_WorkItemCallbackConnect(void *pContext)
6251 {
6252         PADAPTER                padapter = (PADAPTER)pContext;
6253         PBT30Info               pBTInfo = GET_BT_INFO(padapter);
6254         PBT_MGNT                pBtMgnt = &pBTInfo->BtMgnt;
6255
6256 //      BTPKT_JoinerConnectProcess(padapter, pBtMgnt->CurrentConnectEntryNum); // not porting yet
6257 }
6258
6259 u8 BTHCI_GetConnectEntryNum(PADAPTER padapter)
6260 {
6261         PBT30Info               pBTInfo = GET_BT_INFO(padapter);
6262         PBT_MGNT                pBtMgnt = &pBTInfo->BtMgnt;
6263
6264         return bthci_GetCurrentEntryNum(padapter, pBtMgnt->BtCurrentPhyLinkhandle);
6265 }
6266
6267 u8 BTHCI_GetCurrentEntryNumByMAC(PADAPTER padapter, u8 *SA)
6268 {
6269         PBT30Info               pBTInfo = GET_BT_INFO(padapter);
6270         u8      i;
6271
6272         for (i=0; i<MAX_BT_ASOC_ENTRY_NUM; i++)
6273         {
6274                 if (pBTInfo->BtAsocEntry[i].bUsed == _TRUE)
6275                 {
6276                         if (_rtw_memcmp(pBTInfo->BtAsocEntry[i].BTRemoteMACAddr, SA, 6) == _TRUE)
6277                         {
6278                                 return i;
6279                         }
6280                 }
6281         }
6282         return 0xFF;
6283 }
6284
6285 void BTHCI_StatusWatchdog(PADAPTER padapter)
6286 {
6287 //      PMGNT_INFO                      pMgntInfo = &padapter->MgntInfo;
6288         struct pwrctrl_priv *ppwrctrl = &padapter->pwrctrlpriv;
6289         PBT30Info                       pBTInfo = GET_BT_INFO(padapter);
6290         PBT_MGNT                        pBtMgnt = &pBTInfo->BtMgnt;
6291         PBT_TRAFFIC                     pBtTraffic = &pBTInfo->BtTraffic;
6292         u8                              bRfOff=_FALSE, bTxBusy = _FALSE, bRxBusy = _FALSE;
6293
6294
6295         if ((ppwrctrl->rfoff_reason & RF_CHANGE_BY_HW) ||
6296                 (ppwrctrl->rfoff_reason & RF_CHANGE_BY_SW))
6297                 bRfOff = _TRUE;
6298
6299         if ((check_fwstate(&padapter->mlmepriv, WIFI_REASOC_STATE|WIFI_UNDER_LINKING|WIFI_SITE_MONITOR) == _FALSE) &&
6300                 !bRfOff)
6301         {
6302                 static u8 BTwaitcnt=0;
6303                 if (pBtMgnt->BTNeedAMPStatusChg)
6304                 {
6305                         BTwaitcnt++;
6306                         if (BTwaitcnt >= 2)
6307                         {
6308                                 BTHCI_EventAMPStatusChange(padapter, AMP_STATUS_FULL_CAPACITY_FOR_BT);
6309                                 BTwaitcnt = 0;
6310                         }
6311                 }
6312         }
6313
6314         RTPRINT(FIOCTL, IOCTL_BT_TP, ("[BT traffic], TxPktCntInPeriod=%d, TxPktLenInPeriod=%"i64fmt"d\n",
6315                 pBtTraffic->Bt30TrafficStatistics.TxPktCntInPeriod,
6316                 pBtTraffic->Bt30TrafficStatistics.TxPktLenInPeriod));
6317         RTPRINT(FIOCTL, IOCTL_BT_TP, ("[BT traffic], RxPktCntInPeriod=%d, RxPktLenInPeriod=%"i64fmt"d\n",
6318                 pBtTraffic->Bt30TrafficStatistics.RxPktCntInPeriod,
6319                 pBtTraffic->Bt30TrafficStatistics.RxPktLenInPeriod));
6320         if (pBtTraffic->Bt30TrafficStatistics.TxPktCntInPeriod > 100 ||
6321                 pBtTraffic->Bt30TrafficStatistics.RxPktCntInPeriod > 100 )
6322         {
6323                 if (pBtTraffic->Bt30TrafficStatistics.RxPktLenInPeriod > pBtTraffic->Bt30TrafficStatistics.TxPktLenInPeriod)
6324                         bRxBusy = _TRUE;
6325                 else if (pBtTraffic->Bt30TrafficStatistics.TxPktLenInPeriod > pBtTraffic->Bt30TrafficStatistics.RxPktLenInPeriod)
6326                         bTxBusy = _TRUE;
6327         }
6328
6329         pBtTraffic->Bt30TrafficStatistics.TxPktCntInPeriod = 0;
6330         pBtTraffic->Bt30TrafficStatistics.RxPktCntInPeriod = 0;
6331         pBtTraffic->Bt30TrafficStatistics.TxPktLenInPeriod = 0;
6332         pBtTraffic->Bt30TrafficStatistics.RxPktLenInPeriod = 0;
6333         pBtTraffic->Bt30TrafficStatistics.bTxBusyTraffic = bTxBusy;
6334         pBtTraffic->Bt30TrafficStatistics.bRxBusyTraffic = bRxBusy;
6335         RTPRINT(FIOCTL, IOCTL_BT_TP, ("[BT traffic], bTxBusyTraffic=%d, bRxBusyTraffic=%d\n",
6336                 pBtTraffic->Bt30TrafficStatistics.bTxBusyTraffic,
6337                 pBtTraffic->Bt30TrafficStatistics.bRxBusyTraffic));
6338 }
6339
6340 void
6341 BTHCI_NotifyRFState(
6342         PADAPTER                                padapter,
6343         rt_rf_power_state               StateToSet,
6344         RT_RF_CHANGE_SOURCE     ChangeSource
6345         )
6346 {
6347         struct pwrctrl_priv *ppwrctrl = &padapter->pwrctrlpriv;
6348         RT_RF_CHANGE_SOURCE     RfOffReason = ppwrctrl->rfoff_reason;
6349
6350         RTPRINT(FIOCTL, IOCTL_STATE, ("BTHCI_NotifyRFState(), Old RfOffReason = 0x%x, ChangeSource = 0x%x\n", RfOffReason, ChangeSource));
6351         if (ChangeSource < RF_CHANGE_BY_HW)
6352         {
6353                 RTPRINT(FIOCTL, IOCTL_STATE, ("BTHCI_NotifyRFState(), ChangeSource < RF_CHANGE_BY_HW\n"));
6354                 return;
6355         }
6356
6357         //
6358         // When RF is on/off by HW/SW(IPS/LPS not included), we have to notify
6359         // core stack the AMP_Status
6360         //
6361
6362         // We only have to check RF On/Off by HW/SW
6363         RfOffReason &= (RF_CHANGE_BY_HW|RF_CHANGE_BY_SW);
6364
6365         switch (StateToSet)
6366         {
6367                 case rf_on:
6368                         if (RfOffReason)
6369                         {
6370                                 //
6371                                 // Previously, HW or SW Rf state is OFF, check if it is turned on by HW/SW
6372                                 //
6373                                 RfOffReason &= ~ChangeSource;
6374                                 if (!RfOffReason)
6375                                 {
6376                                         // Both HW/SW Rf is turned on
6377                                         RTPRINT(FIOCTL, IOCTL_STATE, ("BTHCI_NotifyRFState(), Rf is turned On!\n"));
6378                                         BTHCI_EventAMPStatusChange(padapter, AMP_STATUS_FULL_CAPACITY_FOR_BT);
6379                                 }
6380                         }
6381                         break;
6382
6383                 case rf_off:
6384                         if (!RfOffReason)
6385                         {
6386                                 //
6387                                 // Previously, both HW/SW Rf state is ON, check if it is turned off by HW/SW
6388                                 //
6389                                 RTPRINT(FIOCTL, IOCTL_STATE, ("BTHCI_NotifyRFState(), Rf is turned Off!\n"));
6390                                 RTPRINT(FIOCTL, IOCTL_STATE, ("[BT AMPStatus], set to invalid in BTHCI_NotifyRFState()\n"));
6391                                 BTHCI_EventAMPStatusChange(padapter, AMP_STATUS_NO_CAPACITY_FOR_BT);
6392                         }
6393                         break;
6394
6395                 default:
6396                         RTPRINT(FIOCTL, IOCTL_STATE, ("Unknown case!! \n"));
6397                         break;
6398         }
6399 }
6400
6401 void
6402 BTHCI_IndicateAMPStatus(
6403         PADAPTER                        padapter,
6404         u8                              JoinAction,
6405         u8                              channel
6406         )
6407 {
6408 //      PMGNT_INFO      pMgntInfo = &(padapter->MgntInfo);
6409         PBT30Info       pBTInfo = GET_BT_INFO(padapter);
6410         PBT_MGNT        pBtMgnt = &pBTInfo->BtMgnt;
6411         u8              bNeedIndicate = _FALSE;
6412
6413         RTPRINT(FIOCTL, IOCTL_STATE, ("JoinAction=%d, bssDesc->bdDsParms.ChannelNumber=%d\n",
6414                 JoinAction, channel));
6415
6416         switch (JoinAction)
6417         {
6418                 case RT_JOIN_INFRA:
6419                 case RT_JOIN_IBSS:
6420                         //
6421                         // When join infra or ibss, check if bt channel is the current channel,
6422                         // if not, we need to indicate AMPStatus=2
6423                         //
6424                         if (channel != pBtMgnt->BTChannel)
6425                                 bNeedIndicate = _TRUE;
6426                         break;
6427                 case RT_START_IBSS:
6428                         //
6429                         // when start IBSS, we need to indicate AMPStatus=2 to
6430                         // reset be hw security
6431                         //
6432                         bNeedIndicate = _TRUE;
6433                         break;
6434                 case RT_NO_ACTION:
6435                         break;
6436                 default:
6437                         break;
6438         }
6439
6440         if (bNeedIndicate)
6441         {
6442                 RTPRINT(FIOCTL, IOCTL_STATE, ("BTHCI_IndicateAMPStatus(), BT channel=%d, bssDesc->bdDsParms.ChannelNumber=%d\n",
6443                         pBtMgnt->BTChannel, channel));
6444
6445                 if (pBtMgnt->BtOperationOn)
6446                 {
6447                         RTPRINT(FIOCTL, IOCTL_STATE, ("[BT AMPStatus], set to invalid in JoinRequest()\n"));
6448                         BTHCI_EventAMPStatusChange(padapter, AMP_STATUS_NO_CAPACITY_FOR_BT);
6449                 }
6450         }
6451 }
6452
6453 void
6454 BTHCI_EventParse(
6455         PADAPTER                                        padapter,
6456         void                                            *pEvntData,
6457         u32                                             dataLen
6458         )
6459 {
6460         PPACKET_IRP_HCIEVENT_DATA PPacketIrpEvent = (PPACKET_IRP_HCIEVENT_DATA)pEvntData;
6461         return;
6462
6463         RTPRINT(FIOCTL, IOCTL_BT_EVENT, ("BT Event Code = 0x%x\n", PPacketIrpEvent->EventCode));
6464         RTPRINT(FIOCTL, IOCTL_BT_EVENT, ("BT Event Length = 0x%x\n", PPacketIrpEvent->Length));
6465
6466         switch (PPacketIrpEvent->EventCode)
6467         {
6468                 case HCI_EVENT_COMMAND_COMPLETE:
6469                         RTPRINT(FIOCTL, (IOCTL_BT_EVENT|IOCTL_BT_LOGO), ("HCI_EVENT_COMMAND_COMPLETE\n"));
6470                         break;
6471                 case HCI_EVENT_COMMAND_STATUS:
6472                         RTPRINT(FIOCTL, (IOCTL_BT_EVENT|IOCTL_BT_LOGO), ("HCI_EVENT_COMMAND_STATUS\n"));
6473                         break;
6474                 default:
6475                         break;
6476         }
6477 }
6478
6479 u16
6480 BTHCI_GetPhysicalLinkHandle(
6481         PADAPTER        padapter,
6482         u8              EntryNum
6483         )
6484 {
6485         PBT30Info               pBTinfo = GET_BT_INFO(padapter);
6486         u16 handle;
6487
6488         handle = pBTinfo->BtAsocEntry[EntryNum].AmpAsocCmdData.BtPhyLinkhandle;
6489
6490         return handle;
6491 }
6492
6493 RT_STATUS
6494 BTHCI_IndicateRxData(
6495         PADAPTER                                        padapter,
6496         void                                            *pData,
6497         u32                                             dataLen,
6498         u8                                              EntryNum
6499         )
6500 {
6501         RT_STATUS       rt_status;
6502
6503         rt_status = PlatformIndicateBTACLData(padapter, pData, dataLen, EntryNum);
6504
6505         return rt_status;
6506 }
6507
6508 void BTHCI_InitializeAllTimer(PADAPTER padapter)
6509 {
6510         PBT30Info               pBTinfo = GET_BT_INFO(padapter);
6511         PBT_SECURITY            pBtSec = &pBTinfo->BtSec;
6512
6513 #if (BT_THREAD == 0)
6514         PlatformInitializeTimer(padapter, &pBTinfo->BTHCICmdTimer, (RT_TIMER_CALL_BACK)bthci_TimerCallbackHCICmd, NULL, "BTHCICmdTimer");
6515 #endif
6516 #if (SENDTXMEHTOD == 0)
6517         PlatformInitializeTimer(padapter, &pBTinfo->BTHCISendAclDataTimer, (RT_TIMER_CALL_BACK)bthci_TimerCallbackSendAclData, NULL, "BTHCISendAclDataTimer");
6518 #endif
6519         PlatformInitializeTimer(padapter, &pBTinfo->BTHCIDiscardAclDataTimer, (RT_TIMER_CALL_BACK)bthci_TimerCallbackDiscardAclData, NULL, "BTHCIDiscardAclDataTimer");
6520         PlatformInitializeTimer(padapter, &pBTinfo->BTHCIJoinTimeoutTimer, (RT_TIMER_CALL_BACK)bthci_TimerCallbackJoinTimeout, NULL, "BTHCIJoinTimeoutTimer");
6521         PlatformInitializeTimer(padapter, &pBTinfo->BTTestSendPacketTimer, (RT_TIMER_CALL_BACK)bthci_TimerCallbackSendTestPacket, NULL, "BTTestSendPacketTimer");
6522
6523         PlatformInitializeTimer(padapter, &pBTinfo->BTBeaconTimer, (RT_TIMER_CALL_BACK)BTPKT_TimerCallbackBeacon, NULL, "BTBeaconTimer");
6524         PlatformInitializeTimer(padapter, &pBtSec->BTWPAAuthTimer, (RT_TIMER_CALL_BACK)BTPKT_TimerCallbackWPAAuth, NULL, "BTWPAAuthTimer");
6525         PlatformInitializeTimer(padapter, &pBTinfo->BTSupervisionPktTimer, (RT_TIMER_CALL_BACK)bthci_TimerCallbackBTSupervisionPacket, NULL, "BTGeneralPurposeTimer");
6526         PlatformInitializeTimer(padapter, &pBTinfo->BTDisconnectPhyLinkTimer, (RT_TIMER_CALL_BACK)bthci_TimerCallbackDisconnectPhysicalLink, NULL, "BTDisconnectPhyLinkTimer");
6527         PlatformInitializeTimer(padapter, &pBTinfo->BTPsDisableTimer, (RT_TIMER_CALL_BACK)bthci_TimerCallbackPsDisable, NULL, "BTPsDisableTimer");
6528         PlatformInitializeTimer(padapter, &pBTinfo->BTAuthTimeoutTimer, (RT_TIMER_CALL_BACK)bthci_TimerCallbackBTAuthTimeout, NULL, "BTAuthTimeoutTimer");
6529         PlatformInitializeTimer(padapter, &pBTinfo->BTAsocTimeoutTimer, (RT_TIMER_CALL_BACK)bthci_TimerCallbackAsocTimeout, NULL, "BTAsocTimeoutTimer");
6530 }
6531
6532 void BTHCI_CancelAllTimer(PADAPTER padapter)
6533 {
6534         PBT30Info               pBTinfo = GET_BT_INFO(padapter);
6535         PBT_SECURITY            pBtSec = &pBTinfo->BtSec;
6536
6537         // Note: don't cancel BTHCICmdTimer, if you cancel this timer, there will
6538         // have posibility to cause irp not completed.
6539 #if (SENDTXMEHTOD == 0)
6540         PlatformCancelTimer(padapter, &pBTinfo->BTHCISendAclDataTimer);
6541 #endif
6542         PlatformCancelTimer(padapter, &pBTinfo->BTHCIDiscardAclDataTimer);
6543         PlatformCancelTimer(padapter, &pBTinfo->BTHCIJoinTimeoutTimer);
6544         PlatformCancelTimer(padapter, &pBTinfo->BTTestSendPacketTimer);
6545
6546         PlatformCancelTimer(padapter, &pBTinfo->BTBeaconTimer);
6547         PlatformCancelTimer(padapter, &pBtSec->BTWPAAuthTimer);
6548         PlatformCancelTimer(padapter, &pBTinfo->BTSupervisionPktTimer);
6549         PlatformCancelTimer(padapter, &pBTinfo->BTDisconnectPhyLinkTimer);
6550         PlatformCancelTimer(padapter, &pBTinfo->BTPsDisableTimer);
6551         PlatformCancelTimer(padapter, &pBTinfo->BTAuthTimeoutTimer);
6552         PlatformCancelTimer(padapter, &pBTinfo->BTAsocTimeoutTimer);
6553 }
6554
6555 void BTHCI_ReleaseAllTimer(PADAPTER padapter)
6556 {
6557         PBT30Info               pBTinfo = GET_BT_INFO(padapter);
6558         PBT_SECURITY            pBtSec = &pBTinfo->BtSec;
6559
6560 #if (BT_THREAD == 0)
6561         PlatformReleaseTimer(padapter, &pBTinfo->BTHCICmdTimer);
6562 #endif
6563 #if (SENDTXMEHTOD == 0)
6564         PlatformReleaseTimer(padapter, &pBTinfo->BTHCISendAclDataTimer);
6565 #endif
6566         PlatformReleaseTimer(padapter, &pBTinfo->BTHCIDiscardAclDataTimer);
6567         PlatformReleaseTimer(padapter, &pBTinfo->BTHCIJoinTimeoutTimer);
6568         PlatformReleaseTimer(padapter, &pBTinfo->BTTestSendPacketTimer);
6569
6570         PlatformReleaseTimer(padapter, &pBTinfo->BTBeaconTimer);
6571         PlatformReleaseTimer(padapter, &pBtSec->BTWPAAuthTimer);
6572         PlatformReleaseTimer(padapter, &pBTinfo->BTSupervisionPktTimer);
6573         PlatformReleaseTimer(padapter, &pBTinfo->BTDisconnectPhyLinkTimer);
6574         PlatformReleaseTimer(padapter, &pBTinfo->BTAuthTimeoutTimer);
6575         PlatformReleaseTimer(padapter, &pBTinfo->BTAsocTimeoutTimer);
6576         PlatformReleaseTimer(padapter, &pBTinfo->BTPsDisableTimer);
6577 }
6578
6579 void BTHCI_InitializeAllWorkItem(PADAPTER padapter)
6580 {
6581         PBT30Info               pBTinfo = GET_BT_INFO(padapter);
6582 #if (BT_THREAD == 0)
6583         PlatformInitializeWorkItem(
6584                 padapter,
6585                 &(pBTinfo->HCICmdWorkItem),
6586                 (RT_WORKITEM_CALL_BACK)bthci_WorkItemCallbackHCICmd,
6587                 (PVOID)padapter,
6588                 "HCICmdWorkItem");
6589 #endif
6590 #if (SENDTXMEHTOD == 0)
6591         PlatformInitializeWorkItem(
6592                 padapter,
6593                 &(pBTinfo->HCISendACLDataWorkItem),
6594                 (RT_WORKITEM_CALL_BACK)bthci_WorkItemCallbackSendACLData,
6595                 (PVOID)padapter,
6596                 "HCISendACLDataWorkItem");
6597 #endif
6598         PlatformInitializeWorkItem(
6599                 padapter,
6600                 &(pBTinfo->BTPsDisableWorkItem),
6601                 (RT_WORKITEM_CALL_BACK)bthci_WorkItemCallbackPsDisable,
6602                 (PVOID)padapter,
6603                 "BTPsDisableWorkItem");
6604
6605         PlatformInitializeWorkItem(
6606                 padapter,
6607                 &(pBTinfo->BTConnectWorkItem),
6608                 (RT_WORKITEM_CALL_BACK)bthci_WorkItemCallbackConnect,
6609                 (PVOID)padapter,
6610                 "BTConnectWorkItem");
6611 }
6612
6613 void BTHCI_FreeAllWorkItem(PADAPTER padapter)
6614 {
6615         PBT30Info               pBTinfo = GET_BT_INFO(padapter);
6616 #if (BT_THREAD == 0)
6617         PlatformFreeWorkItem(&(pBTinfo->HCICmdWorkItem));
6618 #endif
6619 #if (SENDTXMEHTOD == 0)
6620         PlatformFreeWorkItem(&(pBTinfo->HCISendACLDataWorkItem));
6621 #endif
6622         PlatformFreeWorkItem(&(pBTinfo->BTPsDisableWorkItem));
6623         PlatformFreeWorkItem(&(pBTinfo->BTConnectWorkItem));
6624 }
6625
6626 void BTHCI_Reset(PADAPTER padapter)
6627 {
6628         bthci_CmdReset(padapter, _FALSE);
6629 }
6630
6631 u8 BTHCI_HsConnectionEstablished(PADAPTER padapter)
6632 {
6633         u8                      bBtConnectionExist = _FALSE;
6634         PBT30Info       pBtinfo = GET_BT_INFO(padapter);
6635         u8 i;
6636
6637         for (i=0; i<MAX_BT_ASOC_ENTRY_NUM; i++)
6638         {
6639                 if (pBtinfo->BtAsocEntry[i].b4waySuccess == _TRUE)
6640                 {
6641                         bBtConnectionExist = _TRUE;
6642                         break;
6643                 }
6644         }
6645
6646 //      RTPRINT(FIOCTL, IOCTL_STATE, (" BTHCI_HsConnectionEstablished(), connection exist = %d\n", bBtConnectionExist));
6647
6648         return bBtConnectionExist;
6649 }
6650
6651 u8
6652 BTHCI_CheckProfileExist(
6653         PADAPTER        padapter,
6654         BT_TRAFFIC_MODE_PROFILE Profile
6655         )
6656 {
6657         PBT30Info       pBTInfo = GET_BT_INFO(padapter);
6658         PBT_MGNT        pBtMgnt = &pBTInfo->BtMgnt;
6659         u8              IsPRofile = _FALSE;
6660         u8              i=0;
6661
6662         for (i=0; i<pBtMgnt->ExtConfig.NumberOfHandle; i++)
6663         {
6664                 if (pBtMgnt->ExtConfig.linkInfo[i].TrafficProfile == Profile)
6665                 {
6666                         IsPRofile=_TRUE;
6667                         break;
6668                 }
6669         }
6670
6671         return IsPRofile;
6672 }
6673
6674 u8 BTHCI_GetBTCoreSpecByProf(PADAPTER padapter, u8 profile)
6675 {
6676         PBT30Info       pBTInfo = GET_BT_INFO(padapter);
6677         PBT_MGNT        pBtMgnt = &pBTInfo->BtMgnt;
6678         u8              btSpec = BT_SPEC_1_2;
6679         u8              i = 0;
6680
6681         for (i=0; i<pBtMgnt->ExtConfig.NumberOfHandle; i++)
6682         {
6683                 if (pBtMgnt->ExtConfig.linkInfo[i].TrafficProfile == profile)
6684                 {
6685                         btSpec = pBtMgnt->ExtConfig.linkInfo[i].BTCoreSpec;
6686                         break;
6687                 }
6688         }
6689
6690         return btSpec;
6691 }
6692
6693
6694 void BTHCI_GetProfileNameMoto(PADAPTER padapter)
6695 {
6696         PBT30Info       pBTInfo = GET_BT_INFO(padapter);
6697         PBT_MGNT        pBtMgnt = &pBTInfo->BtMgnt;
6698         u8              i = 0;
6699         u8              InCommingMode = 0,OutGoingMode = 0,ScoMode = 0;
6700
6701
6702         ScoMode = pBtMgnt->ExtConfig.NumberOfSCO;
6703
6704         RTPRINT(FBT, BT_TRACE, ("[DM][BT], NumberOfHandle = %d, NumberOfSCO = %d\n",
6705                 pBtMgnt->ExtConfig.NumberOfHandle, pBtMgnt->ExtConfig.NumberOfSCO));
6706
6707         for (i=0; i<pBtMgnt->ExtConfig.NumberOfHandle; i++)
6708         {
6709                 InCommingMode=pBtMgnt->ExtConfig.linkInfo[i].IncomingTrafficMode;
6710                 OutGoingMode=pBtMgnt->ExtConfig.linkInfo[i].OutgoingTrafficMode;
6711
6712                 if (ScoMode)
6713                 {
6714                         pBtMgnt->ExtConfig.linkInfo[i].TrafficProfile = BT_PROFILE_SCO;
6715                 }
6716                 else if ((InCommingMode == BT_MOTOR_EXT_BE) && (OutGoingMode == BT_MOTOR_EXT_BE))
6717                 {
6718                         pBtMgnt->ExtConfig.linkInfo[i].TrafficProfile = BT_PROFILE_PAN;
6719                 }
6720                 else if ((InCommingMode == BT_MOTOR_EXT_GULB) && (OutGoingMode == BT_MOTOR_EXT_GULB))
6721                 {
6722                         pBtMgnt->ExtConfig.linkInfo[i].TrafficProfile = BT_PROFILE_A2DP;
6723                 }
6724                 else if ((InCommingMode == BT_MOTOR_EXT_GUL) && (OutGoingMode == BT_MOTOR_EXT_BE))
6725                 {
6726                         pBtMgnt->ExtConfig.linkInfo[i].TrafficProfile = BT_PROFILE_HID;
6727                 }
6728                 else
6729                 {
6730                         pBtMgnt->ExtConfig.linkInfo[i].TrafficProfile = BT_PROFILE_NONE;
6731                 }
6732         }
6733 }
6734
6735 void BTHCI_UpdateBTProfileRTKToMoto(PADAPTER padapter)
6736 {
6737         PBT30Info       pBTInfo = GET_BT_INFO(padapter);
6738         PBT_MGNT        pBtMgnt = &pBTInfo->BtMgnt;
6739         u8              i = 0;
6740
6741         pBtMgnt->ExtConfig.NumberOfSCO = 0;
6742
6743         for (i=0; i<pBtMgnt->ExtConfig.NumberOfHandle; i++)
6744         {
6745                 pBtMgnt->ExtConfig.linkInfo[i].TrafficProfile = BT_PROFILE_NONE;
6746
6747                 if (pBtMgnt->ExtConfig.linkInfo[i].BTProfile == BT_PROFILE_SCO)
6748                 {
6749                         pBtMgnt->ExtConfig.NumberOfSCO++;
6750                 }
6751
6752                 pBtMgnt->ExtConfig.linkInfo[i].TrafficProfile = pBtMgnt->ExtConfig.linkInfo[i].BTProfile;
6753                 switch (pBtMgnt->ExtConfig.linkInfo[i].TrafficProfile)
6754                 {
6755                         case BT_PROFILE_SCO:
6756                                 break;
6757                         case BT_PROFILE_PAN:
6758                                 pBtMgnt->ExtConfig.linkInfo[i].IncomingTrafficMode = BT_MOTOR_EXT_BE;
6759                                 pBtMgnt->ExtConfig.linkInfo[i].OutgoingTrafficMode = BT_MOTOR_EXT_BE;
6760                                 break;
6761                         case BT_PROFILE_A2DP:
6762                                 pBtMgnt->ExtConfig.linkInfo[i].IncomingTrafficMode = BT_MOTOR_EXT_GULB;
6763                                 pBtMgnt->ExtConfig.linkInfo[i].OutgoingTrafficMode = BT_MOTOR_EXT_GULB;
6764                                 break;
6765                         case BT_PROFILE_HID:
6766                                 pBtMgnt->ExtConfig.linkInfo[i].IncomingTrafficMode = BT_MOTOR_EXT_GUL;
6767                                 pBtMgnt->ExtConfig.linkInfo[i].OutgoingTrafficMode = BT_MOTOR_EXT_BE;
6768                                 break;
6769                         default:
6770                                 break;
6771                 }
6772         }
6773
6774         RTPRINT(FBT, BT_TRACE, ("[DM][BT], RTK, NumberOfHandle = %d, NumberOfSCO = %d\n",
6775                 pBtMgnt->ExtConfig.NumberOfHandle, pBtMgnt->ExtConfig.NumberOfSCO));
6776 }
6777
6778 void BTHCI_GetBTRSSI(PADAPTER padapter)
6779 {
6780         PBT30Info       pBTInfo = GET_BT_INFO(padapter);
6781         PBT_MGNT        pBtMgnt = &pBTInfo->BtMgnt;
6782         u8              i = 0;
6783
6784         //return;
6785
6786         for (i=0; i<pBtMgnt->ExtConfig.NumberOfHandle; i++)
6787         {
6788                 bthci_EventExtGetBTRSSI(padapter, pBtMgnt->ExtConfig.linkInfo[i].ConnectHandle);
6789         }
6790 }
6791
6792 void BTHCI_WifiScanNotify(PADAPTER padapter, u8 scanType)
6793 {
6794         PBT30Info       pBTInfo = GET_BT_INFO(padapter);
6795         PBT_MGNT        pBtMgnt = &pBTInfo->BtMgnt;
6796
6797         if (pBtMgnt->ExtConfig.bEnableWifiScanNotify)
6798                 bthci_EventExtWifiScanNotify(padapter, scanType);
6799 }
6800
6801 void
6802 BTHCI_StateMachine(
6803         PADAPTER                                        padapter,
6804         u8                                      StateToEnter,
6805         HCI_STATE_WITH_CMD              StateCmd,
6806         u8                                      EntryNum
6807         )
6808 {
6809         PBT30Info       pBTInfo = GET_BT_INFO(padapter);
6810         PBT_MGNT        pBtMgnt = &pBTInfo->BtMgnt;
6811
6812         if (EntryNum == 0xff)
6813         {
6814                 RTPRINT(FIOCTL, IOCTL_STATE, (" StateMachine, error EntryNum=0x%x \n",EntryNum));
6815                 return;
6816         }
6817         RTPRINT(FIOCTL, IOCTL_STATE, (" StateMachine, EntryNum = 0x%x, CurrentState = 0x%x, BtNextState = 0x%x,  StateCmd = 0x%x ,StateToEnter = 0x%x\n",
6818                 EntryNum,pBTInfo->BtAsocEntry[EntryNum].BtCurrentState,pBTInfo->BtAsocEntry[EntryNum].BtNextState,StateCmd,StateToEnter));
6819
6820         if (pBTInfo->BtAsocEntry[EntryNum].BtNextState & StateToEnter)
6821         {
6822                 pBTInfo->BtAsocEntry[EntryNum].BtCurrentState = StateToEnter;
6823
6824                 switch (StateToEnter)
6825                 {
6826                         case HCI_STATE_STARTING:
6827                                 {
6828                                         pBTInfo->BtAsocEntry[EntryNum].BtNextState = HCI_STATE_DISCONNECTING | HCI_STATE_CONNECTING;
6829                                         bthci_StateStarting(padapter,StateCmd,EntryNum);
6830                                         break;
6831                                 }
6832                         case HCI_STATE_CONNECTING:
6833                                 {
6834                                         pBTInfo->BtAsocEntry[EntryNum].BtNextState = HCI_STATE_CONNECTING | HCI_STATE_DISCONNECTING | HCI_STATE_AUTHENTICATING;
6835                                         bthci_StateConnecting(padapter,StateCmd,EntryNum);
6836                                         break;
6837                                 }
6838
6839                         case HCI_STATE_AUTHENTICATING:
6840                                 {
6841                                         pBTInfo->BtAsocEntry[EntryNum].BtNextState = HCI_STATE_DISCONNECTING | HCI_STATE_CONNECTED;
6842                                         bthci_StateAuth(padapter,StateCmd,EntryNum);
6843                                         break;
6844                                 }
6845
6846                         case HCI_STATE_CONNECTED:
6847                                 {
6848                                         pBTInfo->BtAsocEntry[EntryNum].BtNextState = HCI_STATE_CONNECTED | HCI_STATE_DISCONNECTING;
6849                                         bthci_StateConnected(padapter,StateCmd,EntryNum);
6850                                         break;
6851                                 }
6852
6853                         case HCI_STATE_DISCONNECTING:
6854                                 {
6855                                         pBTInfo->BtAsocEntry[EntryNum].BtNextState = HCI_STATE_DISCONNECTED | HCI_STATE_DISCONNECTING;
6856                                         bthci_StateDisconnecting(padapter,StateCmd,EntryNum);
6857                                         break;
6858                                 }
6859
6860                         case HCI_STATE_DISCONNECTED:
6861                                 {
6862                                         pBTInfo->BtAsocEntry[EntryNum].BtNextState = HCI_STATE_DISCONNECTED | HCI_STATE_STARTING | HCI_STATE_CONNECTING;
6863                                         bthci_StateDisconnected(padapter,StateCmd,EntryNum);
6864                                         break;
6865                                 }
6866
6867                         default:
6868                                 RTPRINT(FIOCTL, IOCTL_STATE, (" StateMachine, Unknown state to enter!!!\n"));
6869                                 break;
6870                 }
6871         }
6872         else
6873         {
6874                 RTPRINT(FIOCTL, IOCTL_STATE, (" StateMachine, Wrong state to enter\n"));
6875         }
6876
6877         // 20100325 Joseph: Disable/Enable IPS/LPS according to BT status.
6878         if (!pBtMgnt->bBTConnectInProgress && !pBtMgnt->BtOperationOn)
6879         {
6880                 RTPRINT(FIOCTL, IOCTL_STATE, ("[BT PS], IPSReturn()\n"));
6881                 IPSReturn(padapter, IPS_DISABLE_BT_ON);
6882         }
6883 }
6884
6885 void BTHCI_DisconnectPeer(PADAPTER padapter, u8 EntryNum)
6886 {
6887         PBT30Info               pBTInfo = GET_BT_INFO(padapter);
6888         PBT_MGNT                pBtMgnt = &pBTInfo->BtMgnt;
6889
6890         RTPRINT(FIOCTL, IOCTL_BT_HCICMD, (" BTHCI_DisconnectPeer()\n"));
6891
6892         BTHCI_SM_WITH_INFO(padapter,HCI_STATE_DISCONNECTING,STATE_CMD_MAC_CONNECT_CANCEL_INDICATE,EntryNum);
6893
6894         if (pBTInfo->BtAsocEntry[EntryNum].bUsed)
6895         {
6896 //              BTPKT_SendDeauthentication(padapter, pBTInfo->BtAsocEntry[EntryNum].BTRemoteMACAddr, unspec_reason); // not porting yet
6897         }
6898
6899         if (pBtMgnt->bBTConnectInProgress)
6900         {
6901                 pBtMgnt->bBTConnectInProgress = _FALSE;
6902                 RTPRINT(FIOCTL, IOCTL_STATE, ("[BT Flag], BT Connect in progress OFF!!\n"));
6903         }
6904
6905         bthci_RemoveEntryByEntryNum(padapter,EntryNum);
6906
6907         if (pBtMgnt->bNeedNotifyAMPNoCap)
6908         {
6909                 RTPRINT(FIOCTL, IOCTL_STATE, ("[BT AMPStatus], set to invalid in BTHCI_DisconnectPeer()\n"));
6910                 BTHCI_EventAMPStatusChange(padapter, AMP_STATUS_NO_CAPACITY_FOR_BT);
6911         }
6912 }
6913
6914 void BTHCI_EventNumOfCompletedDataBlocks(PADAPTER padapter)
6915 {
6916 //      PMGNT_INFO pMgntInfo = &padapter->MgntInfo;
6917         PBT30Info       pBTInfo = GET_BT_INFO(padapter);
6918         PBT_HCI_INFO            pBtHciInfo = &pBTInfo->BtHciInfo;
6919         u8 localBuf[TmpLocalBufSize] = "";
6920         u8 *pRetPar, *pTriple;
6921         u8 len=0, i, j, handleNum=0;
6922         PPACKET_IRP_HCIEVENT_DATA PPacketIrpEvent;
6923         u16 *pu2Temp, *pPackets, *pHandle, *pDblocks;
6924         u8 sent = 0;
6925
6926         PPacketIrpEvent = (PPACKET_IRP_HCIEVENT_DATA)(&localBuf[0]);
6927
6928         if (!(pBtHciInfo->BTEventMaskPage2 & EMP2_HCI_EVENT_NUM_OF_COMPLETE_DATA_BLOCKS))
6929         {
6930                 RTPRINT(FIOCTL, IOCTL_BT_EVENT, ("[BT event], Num Of Completed DataBlocks, Ignore to send NumOfCompletedDataBlocksEvent due to event mask page 2\n"));
6931                 return;
6932         }
6933
6934         // Return parameters starts from here
6935         pRetPar = &PPacketIrpEvent->Data[0];
6936         pTriple = &pRetPar[3];
6937         for (j=0; j<MAX_BT_ASOC_ENTRY_NUM; j++)
6938         {
6939
6940                 for (i=0; i<MAX_LOGICAL_LINK_NUM; i++)
6941                 {
6942                         if (pBTInfo->BtAsocEntry[j].LogLinkCmdData[i].BtLogLinkhandle)
6943                         {
6944                                 handleNum++;
6945                                 pHandle = (u16*)&pTriple[0];    // Handle[i]
6946                                 pPackets = (u16*)&pTriple[2];   // Num_Of_Completed_Packets[i]
6947                                 pDblocks = (u16*)&pTriple[4];   // Num_Of_Completed_Blocks[i]
6948 #if (SENDTXMEHTOD == 0 || SENDTXMEHTOD == 2)
6949                                 PlatformAcquireSpinLock(padapter, RT_TX_SPINLOCK);
6950 #endif
6951                                 *pHandle = pBTInfo->BtAsocEntry[j].LogLinkCmdData[i].BtLogLinkhandle;
6952                                 *pPackets = (u16)pBTInfo->BtAsocEntry[j].LogLinkCmdData[i].TxPacketCount;
6953                                 *pDblocks = (u16)pBTInfo->BtAsocEntry[j].LogLinkCmdData[i].TxPacketCount;
6954                                 if (pBTInfo->BtAsocEntry[j].LogLinkCmdData[i].TxPacketCount)
6955                                 {
6956                                         sent = 1;
6957                                         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",
6958                                         *pHandle, *pPackets, *pDblocks));
6959                                 }
6960                                 pBTInfo->BtAsocEntry[j].LogLinkCmdData[i].TxPacketCount = 0;
6961 #if (SENDTXMEHTOD == 0 || SENDTXMEHTOD == 2)
6962                                 PlatformReleaseSpinLock(padapter, RT_TX_SPINLOCK);
6963 #endif
6964                                 len += 6;
6965                                 pTriple += len;
6966                         }
6967                 }
6968         }
6969
6970         pRetPar[2] = handleNum;                         // Number_of_Handles
6971         len += 1;
6972         pu2Temp = (u16*)&pRetPar[0];
6973         *pu2Temp = BTTotalDataBlockNum;
6974         len += 2;
6975
6976         PPacketIrpEvent->EventCode = HCI_EVENT_NUM_OF_COMPLETE_DATA_BLOCKS;
6977         PPacketIrpEvent->Length = len;
6978         if (handleNum && sent)
6979         {
6980                 bthci_IndicateEvent(padapter, PPacketIrpEvent, len+2);
6981         }
6982 }
6983
6984 void BTHCI_EventNumOfCompletedPackets(PADAPTER padapter)
6985 {
6986 //      PMGNT_INFO pMgntInfo = &padapter->MgntInfo;
6987         PBT30Info       pBTInfo = GET_BT_INFO(padapter);
6988         u8 localBuf[TmpLocalBufSize] = "";
6989         u8 *pRetPar, *pDouble;
6990         u8 len=0, i, j, handleNum=0;
6991         PPACKET_IRP_HCIEVENT_DATA PPacketIrpEvent;
6992         u16 *pPackets, *pHandle;
6993         u8 sent = 0;
6994
6995         PPacketIrpEvent = (PPACKET_IRP_HCIEVENT_DATA)(&localBuf[0]);
6996         // Return parameters starts from here
6997         pRetPar = &PPacketIrpEvent->Data[0];
6998         pDouble = &pRetPar[1];
6999         for (j=0; j<MAX_BT_ASOC_ENTRY_NUM; j++)
7000         {
7001                 for (i=0; i<MAX_LOGICAL_LINK_NUM; i++)
7002                 {
7003                         if (pBTInfo->BtAsocEntry[j].LogLinkCmdData[i].BtLogLinkhandle)
7004                         {
7005                                 handleNum++;
7006                                 pHandle = (u16*)&pDouble[0];    // Handle[i]
7007                                 pPackets = (u16*)&pDouble[2];   // Num_Of_Completed_Packets[i]
7008                                 PlatformAcquireSpinLock(padapter, RT_TX_SPINLOCK);
7009                                 *pHandle = pBTInfo->BtAsocEntry[j].LogLinkCmdData[i].BtLogLinkhandle;
7010                                 *pPackets = (u16)pBTInfo->BtAsocEntry[j].LogLinkCmdData[i].TxPacketCount;
7011                                 if (pBTInfo->BtAsocEntry[j].LogLinkCmdData[i].TxPacketCount)
7012                                         sent = 1;
7013                                 pBTInfo->BtAsocEntry[j].LogLinkCmdData[i].TxPacketCount = 0;
7014                                 PlatformReleaseSpinLock(padapter, RT_TX_SPINLOCK);
7015                                 len += 4;
7016                                 pDouble += len;
7017                         }
7018                 }
7019         }
7020
7021         pRetPar[0] = handleNum;                         // Number_of_Handles
7022         len += 1;
7023
7024         PPacketIrpEvent->EventCode = HCI_EVENT_NUMBER_OF_COMPLETE_PACKETS;
7025         PPacketIrpEvent->Length = len;
7026         if (handleNum && sent)
7027         {
7028                 RTPRINT(FIOCTL, IOCTL_BT_EVENT, ("BTHCI_EventNumOfCompletedPackets \n"));
7029                 bthci_IndicateEvent(padapter, PPacketIrpEvent, len+2);
7030         }
7031 }
7032
7033 void
7034 BTHCI_EventAMPStatusChange(
7035         PADAPTER                                        padapter,
7036         u8                                              AMP_Status
7037         )
7038 {
7039 //      PMGNT_INFO pMgntInfo = &padapter->MgntInfo;
7040         PBT30Info       pBTInfo = GET_BT_INFO(padapter);
7041         PBT_MGNT                pBtMgnt = &pBTInfo->BtMgnt;
7042         u8 len = 0;
7043         u8 localBuf[7] = "";
7044         u8 *pRetPar;
7045         PPACKET_IRP_HCIEVENT_DATA PPacketIrpEvent;
7046
7047         if (AMP_Status==AMP_STATUS_NO_CAPACITY_FOR_BT)
7048         {
7049                 pBtMgnt->BTNeedAMPStatusChg = _TRUE;
7050                 pBtMgnt->bNeedNotifyAMPNoCap = _FALSE;
7051
7052                 BTHCI_DisconnectAll(padapter);
7053         }
7054         else if (AMP_Status == AMP_STATUS_FULL_CAPACITY_FOR_BT)
7055         {
7056                 pBtMgnt->BTNeedAMPStatusChg = _FALSE;
7057         }
7058
7059         PPacketIrpEvent = (PPACKET_IRP_HCIEVENT_DATA)(&localBuf[0]);
7060         // Return parameters starts from here
7061         pRetPar = &PPacketIrpEvent->Data[0];
7062
7063         pRetPar[0] = 0; // Status
7064         len += 1;
7065         pRetPar[1] = AMP_Status;        // AMP_Status
7066         len += 1;
7067
7068         PPacketIrpEvent->EventCode = HCI_EVENT_AMP_STATUS_CHANGE;
7069         PPacketIrpEvent->Length = len;
7070         if (bthci_IndicateEvent(padapter, PPacketIrpEvent, len+2) == RT_STATUS_SUCCESS)
7071         {
7072                 RTPRINT(FIOCTL, (IOCTL_BT_EVENT|IOCTL_STATE), ("[BT event], AMP Status Change, AMP_Status = %d\n", AMP_Status));
7073         }
7074 }
7075
7076 void BTHCI_DisconnectAll(PADAPTER padapter)
7077 {
7078         PADAPTER                pDefaultAdapter = GetDefaultAdapter(padapter);
7079 //      PMGNT_INFO              pMgntInfo = &(pDefaultAdapter->MgntInfo);
7080         PBT30Info               pBTInfo = GET_BT_INFO(padapter);
7081
7082         u8 i;
7083
7084         RTPRINT(FIOCTL, IOCTL_STATE, (" DisconnectALL()\n"));
7085
7086         for (i=0; i<MAX_BT_ASOC_ENTRY_NUM; i++)
7087         {
7088                 if (pBTInfo->BtAsocEntry[i].b4waySuccess == _TRUE)
7089                 {
7090                         BTHCI_SM_WITH_INFO(padapter, HCI_STATE_CONNECTED, STATE_CMD_DISCONNECT_PHY_LINK, i);
7091                 }
7092                 else if (pBTInfo->BtAsocEntry[i].bUsed == _TRUE)
7093                 {
7094                         if (pBTInfo->BtAsocEntry[i].BtCurrentState == HCI_STATE_CONNECTING)
7095                         {
7096                                 BTHCI_SM_WITH_INFO(padapter, HCI_STATE_CONNECTING, STATE_CMD_MAC_CONNECT_CANCEL_INDICATE, i);
7097                         }
7098                         else if (pBTInfo->BtAsocEntry[i].BtCurrentState == HCI_STATE_DISCONNECTING)
7099                         {
7100                                 BTHCI_SM_WITH_INFO(padapter, HCI_STATE_DISCONNECTING, STATE_CMD_MAC_CONNECT_CANCEL_INDICATE, i);
7101                         }
7102                 }
7103         }
7104 }
7105
7106 HCI_STATUS
7107 BTHCI_HandleHCICMD(
7108         PADAPTER                                        padapter,
7109         PPACKET_IRP_HCICMD_DATA pHciCmd
7110         )
7111 {
7112         HCI_STATUS      status = HCI_STATUS_SUCCESS;
7113         PBT30Info       pBTInfo = GET_BT_INFO(padapter);
7114         PBT_DBG         pBtDbg = &pBTInfo->BtDbg;
7115
7116         RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("\n"));
7117         RTPRINT(FIOCTL, (IOCTL_BT_HCICMD_DETAIL|IOCTL_BT_LOGO), ("HCI Command start, OGF=0x%x, OCF=0x%x, Length=0x%x\n",
7118                 pHciCmd->OGF, pHciCmd->OCF, pHciCmd->Length));
7119         if (pHciCmd->Length)
7120         {
7121                 RTPRINT_DATA(FIOCTL, (IOCTL_BT_HCICMD_DETAIL|IOCTL_BT_LOGO), "HCI Command, Hex Data :\n",
7122                         &pHciCmd->Data[0], pHciCmd->Length);
7123         }
7124         if (pHciCmd->OGF == OGF_EXTENSION)
7125         {
7126                 if (pHciCmd->OCF == HCI_SET_RSSI_VALUE)
7127                 {
7128                         RTPRINT(FIOCTL, IOCTL_BT_EVENT_PERIODICAL, ("[BT cmd], "));
7129                 }
7130                 else
7131                 {
7132                         RTPRINT(FIOCTL, IOCTL_BT_HCICMD_EXT, ("[BT cmd], "));
7133                 }
7134         }
7135         else
7136         {
7137                 RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("[BT cmd], "));
7138         }
7139
7140         pBtDbg->dbgHciInfo.hciCmdCnt++;
7141
7142         switch (pHciCmd->OGF)
7143         {
7144                 case OGF_LINK_CONTROL_COMMANDS:
7145                         status = bthci_HandleOGFLinkControlCMD(padapter, pHciCmd);
7146                         break;
7147                 case OGF_HOLD_MODE_COMMAND:
7148                         break;
7149                 case OGF_SET_EVENT_MASK_COMMAND:
7150                         status = bthci_HandleOGFSetEventMaskCMD(padapter, pHciCmd);
7151                         break;
7152                 case OGF_INFORMATIONAL_PARAMETERS:
7153                         status = bthci_HandleOGFInformationalParameters(padapter, pHciCmd);
7154                         break;
7155                 case OGF_STATUS_PARAMETERS:
7156                         status = bthci_HandleOGFStatusParameters(padapter, pHciCmd);
7157                         break;
7158                 case OGF_TESTING_COMMANDS:
7159                         status = bthci_HandleOGFTestingCMD(padapter, pHciCmd);
7160                         break;
7161                 case OGF_EXTENSION:
7162                         status = bthci_HandleOGFExtension(padapter,pHciCmd);
7163                         break;
7164                 default:
7165                         RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI Command(), Unknown OGF = 0x%x\n", pHciCmd->OGF));
7166                         RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_UNKNOWN_COMMAND\n"));
7167                         status = bthci_UnknownCMD(padapter, pHciCmd);
7168                         break;
7169         }
7170         RTPRINT(FIOCTL, IOCTL_BT_HCICMD_DETAIL, ("HCI Command execution end!!\n"));
7171
7172         return status;
7173 }
7174
7175 void
7176 BTHCI_SetLinkStatusNotify(
7177         PADAPTER                                        padapter,
7178         PPACKET_IRP_HCICMD_DATA pHciCmd
7179         )
7180 {
7181         bthci_CmdLinkStatusNotify(padapter, pHciCmd);
7182 }
7183
7184 // ===== End of sync from SD7 driver COMMOM/bt_hci.c =====
7185 #endif
7186
7187 #ifdef __HALBTC87231ANT_C__ // HAL/BTCoexist/HalBtc87231Ant.c
7188
7189 const char *const BtStateString[] =
7190 {
7191         "BT_DISABLED",
7192         "BT_NO_CONNECTION",
7193         "BT_CONNECT_IDLE",
7194         "BT_INQ_OR_PAG",
7195         "BT_ACL_ONLY_BUSY",
7196         "BT_SCO_ONLY_BUSY",
7197         "BT_ACL_SCO_BUSY",
7198         "BT_ACL_INQ_OR_PAG",
7199         "BT_STATE_NOT_DEFINED"
7200 };
7201
7202 extern s32 FillH2CCmd(PADAPTER padapter, u8 ElementID, u32 CmdLen, u8 *pCmdBuffer);
7203
7204 // ===== Below this line is sync from SD7 driver HAL/BTCoexist/HalBtc87231Ant.c =====
7205
7206 void
7207 btdm_SetFw50(
7208         PADAPTER        padapter,
7209         u8              byte1,
7210         u8              byte2,
7211         u8              byte3
7212         )
7213 {
7214         u8                      H2C_Parameter[3] = {0};
7215
7216         H2C_Parameter[0] = byte1;
7217         H2C_Parameter[1] = byte2;
7218         H2C_Parameter[2] = byte3;
7219
7220         RTPRINT(FBT, BT_TRACE, ("[BTCoex], FW write 0x50=0x%06x\n",
7221                 H2C_Parameter[0]<<16|H2C_Parameter[1]<<8|H2C_Parameter[2]));
7222
7223         FillH2CCmd(padapter, 0x50, 3, H2C_Parameter);
7224 }
7225
7226 void btdm_SetFwIgnoreWlanAct(PADAPTER padapter, u8 bEnable)
7227 {
7228         PHAL_DATA_TYPE  pHalData = GET_HAL_DATA(padapter);
7229         u8                      H2C_Parameter[1] = {0};
7230
7231         if (bEnable)
7232         {
7233                 RTPRINT(FBT, BT_TRACE, ("[BTCoex], BT Ignore Wlan_Act !!\n"));
7234                 H2C_Parameter[0] |= BIT(0);             // function enable
7235                 pHalData->bt_coexist.bFWCoexistAllOff = _FALSE;
7236         }
7237         else
7238         {
7239                 RTPRINT(FBT, BT_TRACE, ("[BTCoex], BT don't ignore Wlan_Act !!\n"));
7240         }
7241
7242         RTPRINT(FBT, BT_TRACE, ("[BTCoex], set FW for BT Ignore Wlan_Act, write 0x25=0x%02x\n",
7243                 H2C_Parameter[0]));
7244
7245         FillH2CCmd(padapter, BT_IGNORE_WLAN_ACT_EID, 1, H2C_Parameter);
7246 }
7247
7248 void btdm_NotifyFwScan(PADAPTER padapter, u8 scanType)
7249 {
7250         u8                      H2C_Parameter[1] = {0};
7251
7252         if (scanType == _TRUE)
7253                 H2C_Parameter[0] = 0x1;
7254
7255         RTPRINT(FBT, BT_TRACE, ("[BTCoex], Notify FW for wifi scan, write 0x3b=0x%02x\n",
7256                 H2C_Parameter[0]));
7257
7258         FillH2CCmd(padapter, 0x3b, 1, H2C_Parameter);
7259 }
7260
7261 void btdm_1AntSetPSMode(PADAPTER padapter, u8 enable, u8 smartps, u8 mode)
7262 {
7263         struct pwrctrl_priv *pwrctrl;
7264
7265
7266         RTPRINT(FBT, BT_TRACE, ("[BTCoex], Current LPS(%s, %d), smartps=%d\n", enable==_TRUE?"ON":"OFF", mode, smartps));
7267
7268         pwrctrl = &padapter->pwrctrlpriv;
7269
7270         if (enable == _TRUE) {
7271                 rtw_set_ps_mode(padapter, PS_MODE_MIN, smartps, mode);
7272         } else {
7273                 rtw_set_ps_mode(padapter, PS_MODE_ACTIVE, 0, 0);
7274                 LPS_RF_ON_check(padapter, 100);
7275         }
7276 }
7277
7278 void btdm_1AntTSFSwitch(PADAPTER padapter, u8 enable)
7279 {
7280         u8 oldVal, newVal;
7281
7282
7283         oldVal = rtw_read8(padapter, 0x550);
7284
7285         if (enable)
7286                 newVal = oldVal | EN_BCN_FUNCTION;
7287         else
7288                 newVal = oldVal & ~EN_BCN_FUNCTION;
7289
7290         if (oldVal != newVal)
7291                 rtw_write8(padapter, 0x550, newVal);
7292 }
7293
7294 u8 btdm_Is1AntPsTdmaStateChange(PADAPTER padapter)
7295 {
7296         PHAL_DATA_TYPE  pHalData = GET_HAL_DATA(padapter);
7297         PBTDM_8723A_1ANT        pBtdm8723 = &pHalData->bt_coexist.halCoex8723.btdm1Ant;
7298
7299
7300         if ((pBtdm8723->bPrePsTdmaOn != pBtdm8723->bCurPsTdmaOn) ||
7301                 (pBtdm8723->prePsTdma != pBtdm8723->curPsTdma))
7302         {
7303                 return _TRUE;
7304         }
7305         else
7306         {
7307                 return _FALSE;
7308         }
7309 }
7310
7311 // Before enter TDMA, make sure Power Saving is enable!
7312 void
7313 btdm_1AntPsTdma(
7314         PADAPTER        padapter,
7315         u8              bTurnOn,
7316         u8              type
7317         )
7318 {
7319         PHAL_DATA_TYPE          pHalData = GET_HAL_DATA(padapter);
7320         PBTDM_8723A_1ANT        pBtdm8723 = &pHalData->bt_coexist.halCoex8723.btdm1Ant;
7321
7322
7323 //      RTPRINT(FBT, BT_TRACE, ("[BTCoex], TDMA(%s, %d)\n", (bTurnOn? "ON":"OFF"), type));
7324         pBtdm8723->bCurPsTdmaOn = bTurnOn;
7325         pBtdm8723->curPsTdma = type;
7326         if (bTurnOn)
7327         {
7328                 switch (type)
7329                 {
7330                         case 1: // A2DP Level-1 or FTP/OPP
7331                         default:
7332                                 if (btdm_Is1AntPsTdmaStateChange(padapter))
7333                                 {
7334                                         // wide duration for WiFi
7335                                         BTDM_SetFw3a(padapter, 0xd3, 0x1a, 0x1a, 0x0, 0x58);
7336                                 }
7337                                 break;
7338                         case 2: // A2DP Level-2
7339                                 if (btdm_Is1AntPsTdmaStateChange(padapter))
7340                                 {
7341                                         // normal duration for WiFi
7342                                         BTDM_SetFw3a(padapter, 0xd3, 0x12, 0x12, 0x0, 0x58);
7343                                 }
7344                                 break;
7345                         case 3: // BT FTP/OPP
7346                                 if (btdm_Is1AntPsTdmaStateChange(padapter))
7347                                 {
7348                                         // normal duration for WiFi
7349                                         BTDM_SetFw3a(padapter, 0xd3, 0x30, 0x03, 0x10, 0x58);
7350
7351                                 }
7352                                 break;
7353                         case 4: // for wifi scan & BT is connected
7354                                 if (btdm_Is1AntPsTdmaStateChange(padapter))
7355                                 {
7356                                         // protect 3 beacons in 3-beacon period & no Tx pause at BT slot
7357                                         BTDM_SetFw3a(padapter, 0x93, 0x15, 0x03, 0x14, 0x0);
7358                                 }
7359                                 break;
7360                         case 5: // for WiFi connected-busy & BT is Non-Connected-Idle
7361                                 if (btdm_Is1AntPsTdmaStateChange(padapter))
7362                                 {
7363                                         // SCO mode, Ant fixed at WiFi, WLAN_Act toggle
7364                                         BTDM_SetFw3a(padapter, 0x61, 0x15, 0x03, 0x31, 0x00);
7365                                 }
7366                                 break;
7367                         case 9: // ACL high-retry type - 2
7368                                 if (btdm_Is1AntPsTdmaStateChange(padapter))
7369                                 {
7370                                         // narrow duration for WiFi
7371                                         BTDM_SetFw3a(padapter, 0xd3, 0xa, 0xa, 0x0, 0x58); //narrow duration for WiFi
7372                                 }
7373                                 break;
7374                         case 10: // for WiFi connect idle & BT ACL busy or WiFi Connected-Busy & BT is Inquiry
7375                                 if (btdm_Is1AntPsTdmaStateChange(padapter))
7376                                 {
7377                                         BTDM_SetFw3a(padapter, 0x13, 0xa, 0xa, 0x0, 0x40);
7378                                 }
7379                                 break;
7380                         case 11: // ACL high-retry type - 3
7381                                 if (btdm_Is1AntPsTdmaStateChange(padapter))
7382                                 {
7383                                         // narrow duration for WiFi
7384                                         BTDM_SetFw3a(padapter, 0xd3, 0x05, 0x05, 0x00, 0x58);
7385                                 }
7386                                 break;
7387                         case 12: // for WiFi Connected-Busy & BT is Connected-Idle
7388                                 if (btdm_Is1AntPsTdmaStateChange(padapter))
7389                                 {
7390                                         // Allow High-Pri BT
7391                                         BTDM_SetFw3a(padapter, 0xeb, 0x0a, 0x03, 0x31, 0x18);
7392                                 }
7393                                 break;
7394                         case 20: // WiFi only busy ,TDMA mode for power saving
7395                                 if (btdm_Is1AntPsTdmaStateChange(padapter))
7396                                 {
7397                                         BTDM_SetFw3a(padapter, 0x13, 0x25, 0x25, 0x00, 0x00);
7398                                 }
7399                                 break;
7400                         case 27: // WiFi DHCP/Site Survey & BT SCO busy
7401                                 if (btdm_Is1AntPsTdmaStateChange(padapter))
7402                                 {
7403                                         BTDM_SetFw3a(padapter, 0xa3, 0x25, 0x03, 0x31, 0x98);
7404                                 }
7405                                 break;
7406                         case 28: // WiFi DHCP/Site Survey & BT idle
7407                                 if (btdm_Is1AntPsTdmaStateChange(padapter))
7408                                 {
7409                                         BTDM_SetFw3a(padapter, 0x69, 0x25, 0x03, 0x31, 0x00);
7410                                 }
7411                                 break;
7412                         case 29: // WiFi DHCP/Site Survey & BT ACL busy
7413                                 if (btdm_Is1AntPsTdmaStateChange(padapter))
7414                                 {
7415                                         BTDM_SetFw3a(padapter, 0xeb, 0x1a, 0x1a, 0x01, 0x18);
7416                                         rtw_write32(padapter, 0x6c0, 0x5afa5afa);
7417                                         rtw_write32(padapter, 0x6c4, 0x5afa5afa);
7418                                 }
7419                                 break;
7420                         case 30: // WiFi idle & BT Inquiry
7421                                 if (btdm_Is1AntPsTdmaStateChange(padapter))
7422                                 {
7423                                         BTDM_SetFw3a(padapter, 0x93, 0x15, 0x03, 0x14, 0x00);
7424                                 }
7425                                 break;
7426                         case 31:  // BT HID
7427                                 if (btdm_Is1AntPsTdmaStateChange(padapter))
7428                                 {
7429                                         BTDM_SetFw3a(padapter, 0xd3, 0x1a, 0x1a, 0x00, 0x58);
7430                                 }
7431                                 break;
7432                         case 32:  // BT SCO & Inquiry
7433                                 if (btdm_Is1AntPsTdmaStateChange(padapter))
7434                                 {
7435                                         BTDM_SetFw3a(padapter, 0xab, 0x0a, 0x03, 0x11, 0x98);
7436                                 }
7437                                 break;
7438                         case 33:  // BT SCO & WiFi site survey
7439                                 if (btdm_Is1AntPsTdmaStateChange(padapter))
7440                                 {
7441                                         BTDM_SetFw3a(padapter, 0xa3, 0x25, 0x03, 0x30, 0x98);
7442                                 }
7443                                 break;
7444                         case 34:  // BT HID & WiFi site survey
7445                                 if (btdm_Is1AntPsTdmaStateChange(padapter))
7446                                 {
7447                                         BTDM_SetFw3a(padapter, 0xd3, 0x1a, 0x1a, 0x00, 0x18);
7448                                 }
7449                                 break;
7450                         case 35:  // BT HID & WiFi Connecting
7451                                 if (btdm_Is1AntPsTdmaStateChange(padapter))
7452                                 {
7453                                         BTDM_SetFw3a(padapter, 0xe3, 0x1a, 0x1a, 0x00, 0x18);
7454                                 }
7455                                 break;
7456                 }
7457         }
7458         else
7459         {
7460                 // disable PS-TDMA
7461                 switch (type)
7462                 {
7463                         case 8:
7464                                 if (btdm_Is1AntPsTdmaStateChange(padapter))
7465                                 {
7466                                         // Antenna control by PTA, 0x870 = 0x310
7467                                         BTDM_SetFw3a(padapter, 0x8, 0x0, 0x0, 0x0, 0x0);
7468                                 }
7469                                 break;
7470                         case 0:
7471                         default:
7472                                 if (btdm_Is1AntPsTdmaStateChange(padapter))
7473                                 {
7474                                         // Antenna control by PTA, 0x870 = 0x310
7475                                         BTDM_SetFw3a(padapter, 0x0, 0x0, 0x0, 0x8, 0x0);
7476                                 }
7477                                 rtw_write16(padapter, 0x860, 0x210); // Switch Antenna to BT
7478                                 RTPRINT(FBT, BT_TRACE, ("[BTCoex], 0x860=0x210, Switch Antenna to BT\n"));
7479                                 break;
7480                         case 9:
7481                                 if (btdm_Is1AntPsTdmaStateChange(padapter))
7482                                 {
7483                                         // Antenna control by PTA, 0x870 = 0x310
7484                                         BTDM_SetFw3a(padapter, 0x0, 0x0, 0x0, 0x8, 0x0);
7485                                 }
7486                                 rtw_write16(padapter, 0x860, 0x110); // Switch Antenna to WiFi
7487                                 RTPRINT(FBT, BT_TRACE, ("[BTCoex], 0x860=0x110, Switch Antenna to WiFi\n"));
7488                                 break;
7489                 }
7490         }
7491
7492         RTPRINT(FBT, BT_TRACE, ("[BTCoex], Current TDMA(%s, %d)\n",
7493                 pBtdm8723->bCurPsTdmaOn?"ON":"OFF", pBtdm8723->curPsTdma));
7494
7495         // update pre state
7496         pBtdm8723->bPrePsTdmaOn = pBtdm8723->bCurPsTdmaOn;
7497         pBtdm8723->prePsTdma = pBtdm8723->curPsTdma;
7498 }
7499
7500 void _btdm_1AntSetPSTDMA(PADAPTER padapter, u8 bPSEn, u8 smartps, u8 psOption, u8 bTDMAOn, u8 tdmaType)
7501 {
7502         struct pwrctrl_priv *pwrctrl;
7503         PHAL_DATA_TYPE pHalData;
7504         PBTDM_8723A_1ANT pBtdm8723;
7505         u8 psMode;
7506         u8 bSwitchPS;
7507
7508
7509         if ((check_fwstate(&padapter->mlmepriv, WIFI_STATION_STATE) == _FALSE) &&
7510                 (get_fwstate(&padapter->mlmepriv) != WIFI_NULL_STATE))
7511         {
7512                 btdm_1AntPsTdma(padapter, bTDMAOn, tdmaType);
7513                 return;
7514         }
7515
7516 #ifdef DIS_PS_RX_BCN
7517         psOption &= ~BIT(0);
7518 #endif
7519
7520         RTPRINT(FBT, BT_TRACE,
7521                         ("[BTCoex], Set LPS(%s, %d) TDMA(%s, %d)\n",
7522                          bPSEn==_TRUE?"ON":"OFF", psOption,
7523                          bTDMAOn==_TRUE?"ON":"OFF", tdmaType));
7524
7525         pwrctrl = &padapter->pwrctrlpriv;
7526         pHalData = GET_HAL_DATA(padapter);
7527         pBtdm8723 = &pHalData->bt_coexist.halCoex8723.btdm1Ant;
7528
7529         if (bPSEn == _TRUE)
7530         {
7531                 if (_TRUE == pBtdm8723->bWiFiHalt) {
7532                         RTPRINT(FBT, BT_TRACE, ("[BTCoex], Enable PS Fail, WiFi in Halt!!\n"));
7533                         return;
7534                 }
7535
7536                 if (_TRUE == pwrctrl->bInSuspend) {
7537                         RTPRINT(FBT, BT_TRACE, ("[BTCoex], Enable PS Fail, WiFi in Suspend!!\n"));
7538                         return;
7539                 }
7540
7541                 if (_TRUE == padapter->bDriverStopped) {
7542                         RTPRINT(FBT, BT_TRACE, ("[BTCoex], Enable PS Fail, WiFi driver stopped!!\n"));
7543                         return;
7544                 }
7545
7546                 if (_TRUE == padapter->bSurpriseRemoved) {
7547                         RTPRINT(FBT, BT_TRACE, ("[BTCoex], Enable PS Fail, WiFi Surprise Removed!!\n"));
7548                         return;
7549                 }
7550
7551                 psMode = PS_MODE_MIN;
7552         }
7553         else
7554         {
7555                 psMode = PS_MODE_ACTIVE;
7556                 psOption = 0;
7557         }
7558
7559         if (psMode != pwrctrl->pwr_mode)
7560                 bSwitchPS = _TRUE;
7561         else if (psMode != PS_MODE_ACTIVE)
7562         {
7563                 if (psOption != pwrctrl->bcn_ant_mode)
7564                         bSwitchPS = _TRUE;
7565                 else if (smartps != pwrctrl->smart_ps)
7566                         bSwitchPS = _TRUE;
7567                 else
7568                         bSwitchPS = _FALSE;
7569         }
7570         else
7571                 bSwitchPS = _FALSE;
7572
7573         if (_TRUE == bSwitchPS)
7574         {
7575                 // disable TDMA
7576                 if (pBtdm8723->bCurPsTdmaOn == _TRUE)
7577                 {
7578                         if (bTDMAOn == _FALSE)
7579                                 btdm_1AntPsTdma(padapter, _FALSE, tdmaType);
7580                         else
7581                         {
7582                                 if ((BT_IsBtDisabled(padapter) == _TRUE) ||
7583                                         (pHalData->bt_coexist.halCoex8723.c2hBtInfo == BT_INFO_STATE_NO_CONNECTION) ||
7584                                         (pHalData->bt_coexist.halCoex8723.c2hBtInfo == BT_INFO_STATE_CONNECT_IDLE)
7585                                 || (tdmaType == 29))
7586                                         btdm_1AntPsTdma(padapter, _FALSE, 9);
7587                                 else
7588                                         btdm_1AntPsTdma(padapter, _FALSE, 0);
7589                         }
7590                 }
7591
7592                 // change Power Save State
7593                 btdm_1AntSetPSMode(padapter, bPSEn, smartps, psOption);
7594         }
7595
7596         btdm_1AntPsTdma(padapter, bTDMAOn, tdmaType);
7597 }
7598
7599 void btdm_1AntSetPSTDMA(PADAPTER padapter, u8 bPSEn, u8 psOption, u8 bTDMAOn, u8 tdmaType)
7600 {
7601         _btdm_1AntSetPSTDMA(padapter, bPSEn, 0, psOption, bTDMAOn, tdmaType);
7602 }
7603
7604 void btdm_1AntWifiParaAdjust(PADAPTER padapter, u8 bEnable)
7605 {
7606         PHAL_DATA_TYPE  pHalData = GET_HAL_DATA(padapter);
7607         PBTDM_8723A_1ANT        pBtdm8723 = &pHalData->bt_coexist.halCoex8723.btdm1Ant;
7608
7609         if (bEnable)
7610         {
7611 //              RTPRINT(FBT, BT_TRACE, ("[BTCoex], wifi para adjust enable!!\n"));
7612                 pBtdm8723->curWifiPara = 1;
7613                 if (pBtdm8723->preWifiPara != pBtdm8723->curWifiPara)
7614                 {
7615                         BTDM_SetSwPenaltyTxRateAdaptive(padapter, BT_TX_RATE_ADAPTIVE_LOW_PENALTY);
7616                 }
7617         }
7618         else
7619         {
7620 //              RTPRINT(FBT, BT_TRACE, ("[BTCoex], wifi para adjust disable!!\n"));
7621                 pBtdm8723->curWifiPara = 2;
7622                 if (pBtdm8723->preWifiPara != pBtdm8723->curWifiPara)
7623                 {
7624                         BTDM_SetSwPenaltyTxRateAdaptive(padapter, BT_TX_RATE_ADAPTIVE_NORMAL);
7625                 }
7626         }
7627
7628 //      RTPRINT(FBT, BT_TRACE, ("[BTCoex], preWifiPara = %d, curWifiPara = %d!!\n",
7629 //              pBtdm8723->preWifiPara, pBtdm8723->curWifiPara));
7630 //      pBtdm8723->preWifiPara = pBtdm8723->curWifiPara;
7631 }
7632
7633 void btdm_1AntPtaParaReload(PADAPTER padapter)
7634 {
7635         // PTA parameter
7636         rtw_write8(padapter, 0x6cc, 0x0);                       // 1-Ant coex
7637         rtw_write32(padapter, 0x6c8, 0xffff);           // wifi break table
7638         rtw_write32(padapter, 0x6c4, 0x55555555);       // coex table
7639
7640         // Antenna switch control parameter
7641         rtw_write32(padapter, 0x858, 0xaaaaaaaa);
7642         if (IS_8723A_A_CUT(GET_HAL_DATA(padapter)->VersionID))
7643         {
7644                 rtw_write32(padapter, 0x870, 0x0);      // SPDT(connected with TRSW) control by hardware PTA
7645                 rtw_write8(padapter, 0x40, 0x24);
7646         }
7647         else
7648         {
7649                 rtw_write8(padapter, 0x40, 0x20);
7650                 rtw_write16(padapter, 0x860, 0x210);    // set antenna at bt side if ANTSW is software control
7651                 rtw_write32(padapter, 0x870, 0x300);    // SPDT(connected with TRSW) control by hardware PTA
7652                 rtw_write32(padapter, 0x874, 0x22804000);       // ANTSW keep by GNT_BT
7653         }
7654
7655         // coexistence parameters
7656         rtw_write8(padapter, 0x778, 0x1);       // enable RTK mode PTA
7657
7658         // BT don't ignore WLAN_Act
7659         btdm_SetFwIgnoreWlanAct(padapter, _FALSE);
7660 }
7661
7662 /*
7663  * Return
7664  *      1: upgrade (add WiFi duration time)
7665  *      0: keep
7666  *      -1: downgrade (add BT duration time)
7667  */
7668 s8 btdm_1AntTdmaJudgement(PADAPTER padapter, u8 retry)
7669 {
7670         PHAL_DATA_TYPE          pHalData;
7671         PBTDM_8723A_1ANT        pBtdm8723;
7672         static s8 up = 0, dn = 0, m = 1, n = 3, WaitCount= 0;
7673         s8 ret;
7674
7675
7676         pHalData = GET_HAL_DATA(padapter);
7677         pBtdm8723 = &pHalData->bt_coexist.halCoex8723.btdm1Ant;
7678         ret = 0;
7679
7680         if (pBtdm8723->psTdmaMonitorCnt == 0)
7681         {
7682                 up = 0;
7683                 dn = 0;
7684                 m = 1;
7685                 n = 3;
7686                 WaitCount = 0;
7687         }
7688         else
7689         {
7690                 WaitCount++;
7691         }
7692
7693         if (retry == 0)  // no retry in the last 2-second duration
7694         {
7695                 up++;
7696                 dn--;
7697                 if (dn < 0) dn = 0;
7698
7699                 if (up >= 3*m)
7700                 {
7701                         // retry=0 in consecutive 3m*(2s), add WiFi duration
7702                         ret = 1;
7703
7704                         n = 3;
7705                         up = 0;
7706                         dn = 0;
7707                         WaitCount = 0;
7708                 }
7709         }
7710         else if (retry <= 3)  // retry<=3 in the last 2-second duration
7711         {
7712                 up--;
7713                 dn++;
7714                 if (up < 0) up = 0;
7715
7716                 if (dn == 2)
7717                 {
7718                         // retry<=3 in consecutive 2*(2s), minus WiFi duration (add BT duration)
7719                         ret = -1;
7720
7721                         // record how many time downgrad WiFi duration
7722                         if (WaitCount <= 2)
7723                                 m++;
7724                         else
7725                                 m = 1;
7726                         // the max number of m is 20
7727                         // the longest time of upgrade WiFi duration is 20*3*2s = 120s
7728                         if (m >= 20) m = 20;
7729
7730                         up = 0;
7731                         dn = 0;
7732                         WaitCount = 0;
7733                 }
7734         }
7735         else  // retry count > 3
7736         {
7737                 // retry>3, minus WiFi duration (add BT duration)
7738                 ret = -1;
7739
7740                 // record how many time downgrad WiFi duration
7741                 if (WaitCount == 1)
7742                         m++;
7743                 else
7744                         m = 1;
7745                 if (m >= 20) m = 20;
7746
7747                 up = 0;
7748                 dn = 0;
7749                 WaitCount = 0;
7750         }
7751
7752         return ret;
7753 }
7754
7755 void btdm_1AntTdmaDurationAdjustForACL(PADAPTER padapter)
7756 {
7757         PHAL_DATA_TYPE          pHalData = GET_HAL_DATA(padapter);
7758         PBTDM_8723A_1ANT        pBtdm8723 = &pHalData->bt_coexist.halCoex8723.btdm1Ant;
7759
7760
7761 //      RTPRINT(FBT, BT_TRACE, ("[BTCoex], %s\n", __FUNCTION__));
7762         if (pBtdm8723->psTdmaGlobalCnt != pBtdm8723->psTdmaMonitorCnt)
7763         {
7764                 pBtdm8723->psTdmaMonitorCnt = 0;
7765                 pBtdm8723->psTdmaGlobalCnt = 0;
7766         }
7767         if (pBtdm8723->psTdmaMonitorCnt == 0)
7768         {
7769 //              RTPRINT(FBT, BT_TRACE, ("[BTCoex], 1AntTdmaAdjACL, first time execute!!\n"));
7770                 btdm_1AntSetPSTDMA(padapter, _TRUE, 0, _TRUE, 2);
7771                 pBtdm8723->psTdmaDuAdjType = 2;
7772         }
7773         else
7774         {
7775                 // Now we only have 4 level Ps Tdma,
7776                 // if that's not the following 4 level(will changed by wifi scan, dhcp...),
7777                 // then we have to adjust it back to the previous record one.
7778                 if ((pBtdm8723->curPsTdma != 1) &&
7779                         (pBtdm8723->curPsTdma != 2) &&
7780                         (pBtdm8723->curPsTdma != 9) &&
7781                         (pBtdm8723->curPsTdma != 11))
7782                 {
7783 //                      RTPRINT(FBT, BT_TRACE, ("[BTCoex], tdma adjust type can only be 1/2/9/11 !!!\n"));
7784 //                      RTPRINT(FBT, BT_TRACE, ("[BTCoex], the latest adjust type = %d\n", pBtdm8723->psTdmaDuAdjType));
7785
7786                         btdm_1AntSetPSTDMA(padapter, _TRUE, 0, _TRUE, pBtdm8723->psTdmaDuAdjType);
7787                 }
7788                 else
7789                 {
7790                         s32 judge = 0;
7791
7792                         judge = btdm_1AntTdmaJudgement(padapter, pHalData->bt_coexist.halCoex8723.btRetryCnt);
7793                         if (judge == -1)
7794                         {
7795 //                              RTPRINT(FBT, BT_TRACE, ("[BTCoex], 1AntTdmaAdjACL, Upgrade WiFi duration\n"));
7796                                 if (pBtdm8723->curPsTdma == 1)
7797                                 {
7798                                         // Decrease WiFi duration for high BT retry
7799                                         if(pHalData->bt_coexist.halCoex8723.btInfoExt){
7800                                                 pBtdm8723->psTdmaDuAdjType = 9;
7801 //                                              RTPRINT(FBT, BT_TRACE, ("[BTCoex], 1AntTdmaAdjACL,  limit to type9 \n"));
7802                                         }
7803                                         else
7804                                                 pBtdm8723->psTdmaDuAdjType = 2;
7805                                         btdm_1AntSetPSTDMA(padapter, _TRUE, 0, _TRUE, pBtdm8723->psTdmaDuAdjType);
7806
7807                                 }
7808                                 else if (pBtdm8723->curPsTdma == 2)
7809                                 {
7810                                         btdm_1AntSetPSTDMA(padapter, _TRUE, 0, _TRUE, 9);
7811                                         pBtdm8723->psTdmaDuAdjType = 9;
7812                                 }
7813                                 else if (pBtdm8723->curPsTdma == 9)
7814                                 {
7815                                         btdm_1AntSetPSTDMA(padapter, _TRUE, 0, _TRUE, 11);
7816                                         pBtdm8723->psTdmaDuAdjType = 11;
7817                                 }
7818                         }
7819                         else if (judge == 1)
7820                         {
7821 //                              RTPRINT(FBT, BT_TRACE, ("[BTCoex], 1AntTdmaAdjACL, Downgrade WiFi duration!!\n"));
7822
7823                                 if (pBtdm8723->curPsTdma == 11)
7824                                 {
7825                                         btdm_1AntSetPSTDMA(padapter, _TRUE, 0, _TRUE, 9);
7826                                         pBtdm8723->psTdmaDuAdjType = 9;
7827                                 }
7828                                 else if (pBtdm8723->curPsTdma == 9)
7829                                 {
7830                                         if (pHalData->bt_coexist.halCoex8723.btInfoExt){
7831                                                 pBtdm8723->psTdmaDuAdjType = 9;
7832 //                                              RTPRINT(FBT, BT_TRACE, ("[BTCoex], 1AntTdmaAdjACL,  limit to type9 \n"));
7833                                         }
7834                                         else
7835                                                 pBtdm8723->psTdmaDuAdjType = 2;
7836                                         btdm_1AntSetPSTDMA(padapter, _TRUE, 0, _TRUE, pBtdm8723->psTdmaDuAdjType);
7837                                 }
7838                                 else if (pBtdm8723->curPsTdma == 2)
7839                                 {
7840                                         if (pHalData->bt_coexist.halCoex8723.btInfoExt){
7841                                                 pBtdm8723->psTdmaDuAdjType = 9;
7842 //                                              RTPRINT(FBT, BT_TRACE, ("[BTCoex], 1AntTdmaAdjACL,  limit to type9 \n"));
7843                                         }
7844                                         else
7845                                                 pBtdm8723->psTdmaDuAdjType = 1;
7846                                         btdm_1AntSetPSTDMA(padapter, _TRUE, 0, _TRUE, pBtdm8723->psTdmaDuAdjType);
7847                                 }
7848                         }
7849                         else
7850                         {
7851 //                              RTPRINT(FBT, BT_TRACE, ("[BTCoex], 1AntTdmaAdjACL, no need to change\n"));
7852                         }
7853                 }
7854
7855                 RTPRINT(FBT, BT_TRACE, ("[BTCoex], ACL current TDMA(%s, %d)\n",
7856                         (pBtdm8723->bCurPsTdmaOn? "ON":"OFF"), pBtdm8723->curPsTdma));
7857         }
7858
7859         pBtdm8723->psTdmaMonitorCnt++;
7860 }
7861
7862 u8 btdm_1AntAdjustbyWiFiRSSI(u8 RSSI_Now, u8 RSSI_Last, u8 RSSI_Th)
7863 {
7864         u8 type;
7865
7866         if (RSSI_Now>RSSI_Last)
7867         {
7868                 if (RSSI_Now > (RSSI_Th + 5))
7869                         type = 26;
7870                 else
7871                         type = 25;
7872         }
7873         else
7874         {
7875                 if (RSSI_Now > RSSI_Th)
7876                         type = 26;
7877                 else
7878                         type = 25;
7879         }
7880
7881         return type;
7882 }
7883
7884 void btdm_1AntTdmaDurationAdjustForSCO(PADAPTER padapter)
7885 {
7886         PHAL_DATA_TYPE pHalData;
7887         PBTDM_8723A_1ANT pBtdm8723;
7888         PDM_ODM_T podm;
7889         pDIG_T pDigTable;
7890         u8 RSSITh_WiFi, RSSITh12_BT, RSSITh23_BT;
7891         u8 Type, RSSIOffset;
7892         u8 RSSI_WiFi_Now, RSSI_BT_Now;
7893
7894
7895 //      RTPRINT(FBT, BT_TRACE, ("[BTCoex], %s\n", __FUNCTION__));
7896         pHalData = GET_HAL_DATA(padapter);
7897         pBtdm8723 = &pHalData->bt_coexist.halCoex8723.btdm1Ant;
7898         podm = &pHalData->odmpriv;
7899         pDigTable = &podm->DM_DigTable;
7900         RSSITh_WiFi = 47;
7901         RSSITh12_BT = 36;
7902         RSSITh23_BT = 30;
7903         RSSIOffset = 22;
7904         RSSI_WiFi_Now = pDigTable->Rssi_val_min;
7905         RSSI_BT_Now = pHalData->bt_coexist.halCoex8723.btRssi;
7906
7907         if (pBtdm8723->psTdmaGlobalCnt != pBtdm8723->psTdmaMonitorCntForSCO)
7908         {
7909                 pBtdm8723->psTdmaMonitorCntForSCO = 0;
7910                 pBtdm8723->psTdmaGlobalCnt = 0;
7911         }
7912
7913         if (pBtdm8723->psTdmaMonitorCntForSCO == 0)
7914         {
7915                 RTPRINT(FBT, BT_TRACE, ("[BTCoex], 1AntTdmaAdjSCO, first time execute!!\n"));
7916                 pBtdm8723->RSSI_WiFi_Last = 0;
7917                 pBtdm8723->RSSI_BT_Last = 0;
7918         }
7919         else
7920         {
7921                 if ((pBtdm8723->curPsTdma != 23) &&
7922                                 (pBtdm8723->curPsTdma != 24) &&
7923                                 (pBtdm8723->curPsTdma != 25) &&
7924                                 (pBtdm8723->curPsTdma != 26))
7925                 {
7926                         RTPRINT(FBT, BT_TRACE, ("[BTCoex], 1AntTdmaAdjSCO, tdma adjust type can only be 23/24/25/26 !!!\n"));
7927                         RTPRINT(FBT, BT_TRACE, ("[BTCoex], 1AntTdmaAdjSCO, the latest adjust type=%d\n", pBtdm8723->psTdmaDuAdjTypeForSCO));
7928
7929                         Type = pBtdm8723->psTdmaDuAdjTypeForSCO;
7930
7931                         goto _exit_1AntTdmaDurationAdjustForSCO;
7932                 }
7933                 else
7934                 {
7935                         RTPRINT(FBT, BT_TRACE, ("[BTCoex], 1AntTdmaAdjSCO, pre curPsTdma=%d\n", pBtdm8723->curPsTdma));
7936                 }
7937         }
7938
7939         BTDM_1AntSignalCompensation(padapter, &RSSI_WiFi_Now, &RSSI_BT_Now);
7940
7941         if (!BTDM_IsWifiBusy(padapter)) // WiFi LPS
7942         {
7943                 //Type = btdm_1AntAdjustbyWiFiRSSI(RSSI_WiFi_Now, pBtdm8723->RSSI_WiFi_Last, RSSITh_WiFi);
7944                 if (Type == 26)
7945                 {
7946                 if(RSSI_BT_Now >=  RSSITh12_BT + 4)
7947                         Type = 23;
7948                 else
7949                         Type = 26;
7950                 }
7951                 else
7952                 {
7953                 if (RSSI_BT_Now >=  RSSITh12_BT)
7954                         Type = 23;
7955                 else
7956                         Type = 26;
7957                 }
7958
7959         }
7960         else // WiFi busy
7961         {
7962                 //if (RSSI_BT_Now > pBtdm8723->RSSI_BT_Last)
7963                 if (Type !=23)
7964                 {
7965                         if (RSSI_BT_Now >= RSSITh12_BT + 4)
7966                                 Type = 23;
7967                         else if (RSSI_BT_Now >= RSSITh23_BT + 4)
7968                                 Type = 24;
7969                         else
7970                                 Type = btdm_1AntAdjustbyWiFiRSSI(RSSI_WiFi_Now, pBtdm8723->RSSI_WiFi_Last, RSSITh_WiFi);
7971                 }
7972                 else
7973                 {
7974                         if (RSSI_BT_Now >= RSSITh12_BT)
7975                                 Type = 23;
7976                         else if  (RSSI_BT_Now >= RSSITh23_BT)
7977                                 Type = 24;
7978                         else
7979                                 Type = btdm_1AntAdjustbyWiFiRSSI(RSSI_WiFi_Now, pBtdm8723->RSSI_WiFi_Last, RSSITh_WiFi);
7980                 }
7981         }
7982
7983 _exit_1AntTdmaDurationAdjustForSCO:
7984
7985         pBtdm8723->RSSI_WiFi_Last = RSSI_WiFi_Now;
7986         pBtdm8723->RSSI_BT_Last = RSSI_BT_Now;
7987
7988         if (Type != pBtdm8723->curPsTdma)
7989                 btdm_1AntSetPSTDMA(padapter, _FALSE, 0, _TRUE, Type);
7990
7991         RTPRINT(FBT, BT_TRACE, ("[BTCoex], SCO current TDMA(ON, %d), RSSI_WiFi=%d, RSSI_BT=%d\n",
7992                         Type, RSSI_WiFi_Now, RSSI_BT_Now));
7993
7994         pBtdm8723->psTdmaDuAdjTypeForSCO = Type;
7995
7996         pBtdm8723->psTdmaMonitorCntForSCO++;
7997 }
7998
7999 void btdm_1AntCoexProcessForWifiConnect(PADAPTER padapter)
8000 {
8001         struct mlme_priv *pmlmepriv;
8002         PHAL_DATA_TYPE pHalData;
8003         PBT_COEXIST_8723A pBtCoex;
8004         PBTDM_8723A_1ANT pBtdm8723;
8005         u8 BtState;
8006
8007
8008 //      RTPRINT(FBT, BT_TRACE, ("[BTCoex], 1AntCoexProcessForWifiConnect!!\n"));
8009
8010         pmlmepriv = &padapter->mlmepriv;
8011         pHalData = GET_HAL_DATA(padapter);
8012         pBtCoex = &pHalData->bt_coexist.halCoex8723;
8013         pBtdm8723 = &pBtCoex->btdm1Ant;
8014         BtState = pBtCoex->c2hBtInfo;
8015
8016         RTPRINT(FBT, BT_TRACE, ("[BTCoex], WiFi is %s\n", BTDM_IsWifiBusy(padapter)?"Busy":"IDLE"));
8017         RTPRINT(FBT, BT_TRACE, ("[BTCoex], BT is %s\n", BtStateString[BtState]));
8018
8019         padapter->pwrctrlpriv.btcoex_rfon = _FALSE;
8020
8021         if ((!BTDM_IsWifiBusy(padapter)) &&(check_fwstate(&padapter->mlmepriv, WIFI_AP_STATE) != _TRUE)&&
8022                 ((BtState == BT_INFO_STATE_NO_CONNECTION) || (BtState == BT_INFO_STATE_CONNECT_IDLE)))
8023         {
8024                 switch (BtState)
8025                 {
8026                         case BT_INFO_STATE_NO_CONNECTION:
8027                                 _btdm_1AntSetPSTDMA(padapter, _TRUE, 2, 0x26, _FALSE, 9);
8028                                 break;
8029                         case BT_INFO_STATE_CONNECT_IDLE:
8030                                 _btdm_1AntSetPSTDMA(padapter, _TRUE, 2, 0x26, _FALSE, 0);
8031                                 break;
8032                 }
8033         }
8034         else
8035         {
8036 #ifdef BTCOEX_DECREASE_WIFI_POWER
8037                 u8 val8;
8038
8039                 val8 = rtw_read8(padapter, 0x883);
8040                 val8 &= 0x07;
8041                 if ((BtState == BT_INFO_STATE_SCO_ONLY_BUSY) ||
8042                         (BtState == BT_INFO_STATE_ACL_SCO_BUSY))
8043                 {
8044                         if (BTDM_IsHT40(padapter) == _TRUE)
8045                                 val8 |= 0x80; //0x880[31:27] = 10000;
8046                         else
8047                                 val8 |= 0x60; //0x880[31:27] = 01100;
8048                 }
8049                 else
8050                 {
8051                         val8 |= 0xC0; // 0x880[31:27] = 11000;
8052                 }
8053                 rtw_write8(padapter, 0x883, val8);
8054 #endif // BTCOEX_DECREASE_WIFI_POWER
8055
8056                 switch (BtState)
8057                 {
8058                         case BT_INFO_STATE_NO_CONNECTION:
8059                         case BT_INFO_STATE_CONNECT_IDLE:
8060                                 // WiFi is Busy
8061                                 btdm_1AntSetPSTDMA(padapter, _FALSE, 0, _TRUE, 5);
8062                                 rtw_write32(padapter, 0x6c0, 0x5a5a5a5a);
8063                                 rtw_write32(padapter, 0x6c4, 0x5a5a5a5a);
8064                                 break;
8065                         case BT_INFO_STATE_ACL_INQ_OR_PAG:
8066                                 RTPRINT(FBT, BT_TRACE, ("[BTCoex], BT PROFILE is BT_INFO_STATE_ACL_INQ_OR_PAG\n"));
8067                         case BT_INFO_STATE_INQ_OR_PAG:
8068                                 padapter->pwrctrlpriv.btcoex_rfon = _TRUE;
8069                                 btdm_1AntSetPSTDMA(padapter, _TRUE, 0, _TRUE, 30);
8070                                 break;
8071                         case BT_INFO_STATE_SCO_ONLY_BUSY:
8072                         case BT_INFO_STATE_ACL_SCO_BUSY:
8073                                 if (_TRUE == pBtCoex->bC2hBtInquiryPage)
8074                                         btdm_1AntSetPSTDMA(padapter, _FALSE, 0, _TRUE, 32);
8075                                 else
8076                                 {
8077 #ifdef BTCOEX_CMCC_TEST
8078                                         btdm_1AntSetPSTDMA(padapter, _FALSE, 0, _TRUE, 23);
8079 #else // !BTCOEX_CMCC_TEST
8080                                         btdm_1AntSetPSTDMA(padapter, _FALSE, 0, _FALSE, 8);
8081                                         rtw_write32(padapter, 0x6c0, 0x5a5a5a5a);
8082                                         rtw_write32(padapter, 0x6c4, 0x5a5a5a5a);
8083 #endif // !BTCOEX_CMCC_TEST
8084                                 }
8085                                 break;
8086                         case BT_INFO_STATE_ACL_ONLY_BUSY:
8087                                 padapter->pwrctrlpriv.btcoex_rfon = _TRUE;
8088                                 if (pBtCoex->c2hBtProfile == BT_INFO_HID)
8089                                 {
8090                                         RTPRINT(FBT, BT_TRACE, ("[BTCoex], BT PROFILE is HID\n"));
8091                                         btdm_1AntSetPSTDMA(padapter, _TRUE, 0, _TRUE, 31);
8092                                 }
8093                                 else if (pBtCoex->c2hBtProfile == BT_INFO_FTP)
8094                                 {
8095                                         RTPRINT(FBT, BT_TRACE, ("[BTCoex], BT PROFILE is FTP/OPP\n"));
8096                                         btdm_1AntSetPSTDMA(padapter, _TRUE, 0, _TRUE, 3);
8097                                 }
8098                                 else if (pBtCoex->c2hBtProfile == (BT_INFO_A2DP|BT_INFO_FTP))
8099                                 {
8100                                         RTPRINT(FBT, BT_TRACE, ("[BTCoex], BT PROFILE is A2DP_FTP\n"));
8101                                         btdm_1AntSetPSTDMA(padapter, _TRUE, 0, _TRUE, 11);
8102                                 }
8103                                 else
8104                                 {
8105                                         if (pBtCoex->c2hBtProfile == BT_INFO_A2DP)
8106                                         {
8107                                                 RTPRINT(FBT, BT_TRACE, ("[BTCoex], BT PROFILE is A2DP\n"));
8108                                         }
8109                                         else
8110                                         {
8111                                                 RTPRINT(FBT, BT_TRACE, ("[BTCoex], BT PROFILE is UNKNOWN(0x%02X)! Use A2DP Profile\n", pBtCoex->c2hBtProfile));
8112                                         }
8113                                         btdm_1AntTdmaDurationAdjustForACL(padapter);
8114                                 }
8115                                 break;
8116                 }
8117         }
8118
8119         pBtdm8723->psTdmaGlobalCnt++;
8120 }
8121
8122 static void btdm_1AntUpdateHalRAMask(PADAPTER padapter, u32 mac_id, u32 filter)
8123 {
8124         u8 init_rate = 0;
8125         u8 raid;
8126         u32 mask;
8127         u8 shortGIrate = _FALSE;
8128         int     supportRateNum = 0;
8129         struct sta_info *psta;
8130         PHAL_DATA_TYPE pHalData;
8131         struct dm_priv *pdmpriv;
8132         struct mlme_ext_priv *pmlmeext;
8133         struct mlme_ext_info *pmlmeinfo;
8134         WLAN_BSSID_EX *cur_network;
8135
8136
8137         RTPRINT(FBT, BT_TRACE, ("[BTCoex], %s, MACID=%d, filter=0x%08x!!\n", __FUNCTION__, mac_id, filter));
8138
8139         pHalData = GET_HAL_DATA(padapter);
8140         pdmpriv = &pHalData->dmpriv;
8141         pmlmeext = &padapter->mlmeextpriv;
8142         pmlmeinfo = &pmlmeext->mlmext_info;
8143         cur_network = &pmlmeinfo->network;
8144
8145         if (mac_id >= NUM_STA) //CAM_SIZE
8146         {
8147                 RTPRINT(FBT, BT_TRACE, ("[BTCoex], %s, MACID=%d illegal!!\n", __FUNCTION__, mac_id));
8148                 return;
8149         }
8150
8151         psta = pmlmeinfo->FW_sta_info[mac_id].psta;
8152         if (psta == NULL)
8153         {
8154                 RTPRINT(FBT, BT_TRACE, ("[BTCoex], %s, Can't find station!!\n", __FUNCTION__));
8155                 return;
8156         }
8157
8158         raid = psta->raid;
8159
8160         switch (mac_id)
8161         {
8162                 case 0:// for infra mode
8163                         supportRateNum = rtw_get_rateset_len(cur_network->SupportedRates);
8164                         mask = update_supported_rate(cur_network->SupportedRates, supportRateNum);
8165                         mask |= (pmlmeinfo->HT_enable) ? update_MSC_rate(&(pmlmeinfo->HT_caps)):0;
8166                         if (support_short_GI(padapter, &(pmlmeinfo->HT_caps)))
8167                         {
8168                                 shortGIrate = _TRUE;
8169                         }
8170                         break;
8171
8172                 case 1://for broadcast/multicast
8173                         supportRateNum = rtw_get_rateset_len(pmlmeinfo->FW_sta_info[mac_id].SupportedRates);
8174                         mask = update_basic_rate(cur_network->SupportedRates, supportRateNum);
8175                         break;
8176
8177                 default: //for each sta in IBSS
8178                         supportRateNum = rtw_get_rateset_len(pmlmeinfo->FW_sta_info[mac_id].SupportedRates);
8179                         mask = update_supported_rate(cur_network->SupportedRates, supportRateNum);
8180                         break;
8181         }
8182         mask |= ((raid<<28)&0xf0000000);
8183         mask &= 0xffffffff;
8184         mask &= ~filter;
8185         init_rate = get_highest_rate_idx(mask)&0x3f;
8186
8187         if (pHalData->fw_ractrl == _TRUE)
8188         {
8189                 u8 arg = 0;
8190
8191                 arg = mac_id&0x1f;//MACID
8192                 arg |= BIT(7);
8193                 if (_TRUE == shortGIrate)
8194                         arg |= BIT(5);
8195
8196                 RTPRINT(FBT, BT_TRACE, ("[BTCoex], Update FW RAID entry, MASK=0x%08x, arg=0x%02x\n", mask, arg));
8197
8198                 rtl8192c_set_raid_cmd(padapter, mask, arg);
8199         }
8200         else
8201         {
8202                 if (_TRUE == shortGIrate)
8203                         init_rate |= BIT(6);
8204
8205                 rtw_write8(padapter, (REG_INIDATA_RATE_SEL+mac_id), init_rate);
8206         }
8207
8208         psta->init_rate = init_rate;
8209         pdmpriv->INIDATA_RATE[mac_id] = init_rate;
8210 }
8211
8212 static void btdm_1AntUpdateHalRAMaskForSCO(PADAPTER padapter, u8 forceUpdate)
8213 {
8214         PBTDM_8723A_1ANT pBtdm8723;
8215         struct sta_priv *pstapriv;
8216         WLAN_BSSID_EX *cur_network;
8217         struct sta_info *psta;
8218         u32 macid;
8219         u32 filter = 0;
8220
8221
8222         pBtdm8723 = &GET_HAL_DATA(padapter)->bt_coexist.halCoex8723.btdm1Ant;
8223
8224         if ((pBtdm8723->bRAChanged == _TRUE) && (forceUpdate == _FALSE))
8225                 return;
8226
8227         pstapriv = &padapter->stapriv;
8228         cur_network = &padapter->mlmeextpriv.mlmext_info.network;
8229         psta = rtw_get_stainfo(pstapriv, cur_network->MacAddress);
8230         macid = psta->mac_id;
8231
8232         filter |= BIT(_1M_RATE_);
8233         filter |= BIT(_2M_RATE_);
8234         filter |= BIT(_5M_RATE_);
8235         filter |= BIT(_11M_RATE_);
8236         filter |= BIT(_6M_RATE_);
8237         filter |= BIT(_9M_RATE_);
8238
8239         btdm_1AntUpdateHalRAMask(padapter, macid, filter);
8240
8241         pBtdm8723->bRAChanged = _TRUE;
8242 }
8243
8244 static void btdm_1AntRecoverHalRAMask(PADAPTER padapter)
8245 {
8246         PBTDM_8723A_1ANT pBtdm8723;
8247         struct sta_priv *pstapriv;
8248         WLAN_BSSID_EX *cur_network;
8249         struct sta_info *psta;
8250         u32 macid;
8251
8252
8253         pBtdm8723 = &GET_HAL_DATA(padapter)->bt_coexist.halCoex8723.btdm1Ant;
8254
8255         if (pBtdm8723->bRAChanged == _FALSE)
8256                 return;
8257
8258         pstapriv = &padapter->stapriv;
8259         cur_network = &padapter->mlmeextpriv.mlmext_info.network;
8260         psta = rtw_get_stainfo(pstapriv, cur_network->MacAddress);
8261
8262         Update_RA_Entry(padapter, psta);
8263
8264         pBtdm8723->bRAChanged = _FALSE;
8265 }
8266
8267 void btdm_1AntBTStateChangeHandler(PADAPTER padapter, BT_STATE_1ANT oldState, BT_STATE_1ANT newState)
8268 {
8269         RTPRINT(FBT, BT_TRACE, ("[BTCoex], BT state change, %s => %s\n", BtStateString[oldState], BtStateString[newState]));
8270
8271         // BT default ignore wlan active,
8272         // WiFi MUST disable this when BT is enable
8273         if (newState > BT_INFO_STATE_DISABLED)
8274         {
8275                 btdm_SetFwIgnoreWlanAct(padapter, _FALSE);
8276         }
8277
8278         if ((check_fwstate(&padapter->mlmepriv, WIFI_STATION_STATE) == _TRUE) &&
8279                 (BTDM_IsWifiConnectionExist(padapter) == _TRUE))
8280         {
8281                 if ((newState == BT_INFO_STATE_SCO_ONLY_BUSY) ||
8282                         (newState == BT_INFO_STATE_ACL_SCO_BUSY))
8283                 {
8284                         btdm_1AntUpdateHalRAMaskForSCO(padapter, _FALSE);
8285                 }
8286                 else
8287                 {
8288                         // Recover original RA setting
8289                         btdm_1AntRecoverHalRAMask(padapter);
8290                 }
8291         }
8292         else
8293         {
8294                 GET_HAL_DATA(padapter)->bt_coexist.halCoex8723.btdm1Ant.bRAChanged = _FALSE;
8295         }
8296
8297         if (oldState == newState)
8298                 return;
8299
8300         if (oldState == BT_INFO_STATE_ACL_ONLY_BUSY)
8301         {
8302                 PHAL_DATA_TYPE  pHalData = GET_HAL_DATA(padapter);
8303                 pHalData->bt_coexist.halCoex8723.btdm1Ant.psTdmaMonitorCnt = 0;
8304                 pHalData->bt_coexist.halCoex8723.btdm1Ant.psTdmaMonitorCntForSCO = 0;
8305         }
8306
8307         if ((oldState == BT_INFO_STATE_SCO_ONLY_BUSY) ||
8308                 (oldState == BT_INFO_STATE_ACL_SCO_BUSY))
8309         {
8310                 PHAL_DATA_TYPE  pHalData = GET_HAL_DATA(padapter);
8311                 pHalData->bt_coexist.halCoex8723.btdm1Ant.psTdmaMonitorCntForSCO = 0;
8312         }
8313
8314         // Active 2Ant mechanism when BT Connected
8315         if ((oldState == BT_INFO_STATE_DISABLED) ||
8316                 (oldState == BT_INFO_STATE_NO_CONNECTION))
8317         {
8318                 if ((newState != BT_INFO_STATE_DISABLED) &&
8319                         (newState != BT_INFO_STATE_NO_CONNECTION))
8320                 {
8321                         BTDM_SetSwRfRxLpfCorner(padapter, BT_RF_RX_LPF_CORNER_SHRINK);
8322                         BTDM_AGCTable(padapter, BT_AGCTABLE_ON);
8323                         BTDM_BBBackOffLevel(padapter, BT_BB_BACKOFF_ON);
8324                 }
8325         }
8326         else
8327         {
8328                 if ((newState == BT_INFO_STATE_DISABLED) ||
8329                         (newState == BT_INFO_STATE_NO_CONNECTION))
8330                 {
8331                         BTDM_SetSwRfRxLpfCorner(padapter, BT_RF_RX_LPF_CORNER_RESUME);
8332                         BTDM_AGCTable(padapter, BT_AGCTABLE_OFF);
8333                         BTDM_BBBackOffLevel(padapter, BT_BB_BACKOFF_OFF);
8334                 }
8335         }
8336 }
8337
8338 void btdm_1AntBtCoexistHandler(PADAPTER padapter)
8339 {
8340         PHAL_DATA_TYPE          pHalData;
8341         PBT_COEXIST_8723A       pBtCoex8723;
8342         PBTDM_8723A_1ANT        pBtdm8723;
8343         u8                      u1tmp;
8344
8345
8346         pHalData = GET_HAL_DATA(padapter);
8347         pBtCoex8723 = &pHalData->bt_coexist.halCoex8723;
8348         pBtdm8723 = &pBtCoex8723->btdm1Ant;
8349         padapter->pwrctrlpriv.btcoex_rfon = _FALSE;
8350         if (BT_IsBtDisabled(padapter) == _TRUE)
8351         {
8352                 RTPRINT(FBT, BT_TRACE, ("[BTCoex], BT is disabled\n"));
8353
8354                 if (BTDM_IsWifiConnectionExist(padapter) == _TRUE)
8355                 {
8356                         RTPRINT(FBT, BT_TRACE, ("[BTCoex], wifi is connected\n"));
8357
8358                         if (BTDM_IsWifiBusy(padapter) == _TRUE)
8359                         {
8360                                 RTPRINT(FBT, BT_TRACE, ("[BTCoex], Wifi is busy\n"));
8361                                 btdm_1AntSetPSTDMA(padapter, _FALSE, 0, _FALSE, 9);
8362                         }
8363                         else
8364                         {
8365                                 RTPRINT(FBT, BT_TRACE, ("[BTCoex], Wifi is idle\n"));
8366                                 _btdm_1AntSetPSTDMA(padapter, _TRUE, 2, 1, _FALSE, 9);
8367                         }
8368                 }
8369                 else
8370                 {
8371                         RTPRINT(FBT, BT_TRACE, ("[BTCoex], wifi is disconnected\n"));
8372
8373                         btdm_1AntSetPSTDMA(padapter, _FALSE, 0, _FALSE, 9);
8374                 }
8375         }
8376         else
8377         {
8378                 RTPRINT(FBT, BT_TRACE, ("[BTCoex], BT is enabled\n"));
8379
8380                 if (BTDM_IsWifiConnectionExist(padapter) == _TRUE)
8381                 {
8382                         RTPRINT(FBT, BT_TRACE, ("[BTCoex], wifi is connected\n"));
8383
8384                         btdm_1AntWifiParaAdjust(padapter, _TRUE);
8385                         btdm_1AntCoexProcessForWifiConnect(padapter);
8386                 }
8387                 else
8388                 {
8389                         RTPRINT(FBT, BT_TRACE, ("[BTCoex], wifi is disconnected\n"));
8390
8391                         // Antenna switch at BT side(0x870 = 0x300, 0x860 = 0x210) after PSTDMA off
8392                         btdm_1AntWifiParaAdjust(padapter, _FALSE);
8393                         btdm_1AntSetPSTDMA(padapter, _FALSE, 0, _FALSE, 0);
8394                 }
8395         }
8396
8397         btdm_1AntBTStateChangeHandler(padapter, pBtCoex8723->prec2hBtInfo, pBtCoex8723->c2hBtInfo);
8398         pBtCoex8723->prec2hBtInfo = pBtCoex8723->c2hBtInfo;
8399 }
8400
8401 void BTDM_1AntSignalCompensation(PADAPTER padapter, u8 *rssi_wifi, u8 *rssi_bt)
8402 {
8403         PHAL_DATA_TYPE pHalData;
8404         PBTDM_8723A_1ANT pBtdm8723;
8405         u8 RSSI_WiFi_Cmpnstn, RSSI_BT_Cmpnstn;
8406
8407
8408 //      RTPRINT(FBT, BT_TRACE, ("[BTCoex], %s\n", __FUNCTION__));
8409         pHalData = GET_HAL_DATA(padapter);
8410         pBtdm8723 = &pHalData->bt_coexist.halCoex8723.btdm1Ant;
8411         RSSI_WiFi_Cmpnstn = 0;
8412         RSSI_BT_Cmpnstn = 0;
8413
8414         switch (pBtdm8723->curPsTdma)
8415         {
8416                 case 1: // WiFi 52ms
8417                         RSSI_WiFi_Cmpnstn = 11; // 22*0.48
8418                         break;
8419                 case 2: // WiFi 36ms
8420                         RSSI_WiFi_Cmpnstn = 14; // 22*0.64
8421                         break;
8422                 case 9: // WiFi 20ms
8423                         RSSI_WiFi_Cmpnstn = 18; // 22*0.80
8424                         break;
8425                 case 11: // WiFi 10ms
8426                         RSSI_WiFi_Cmpnstn = 20; // 22*0.90
8427                         break;
8428                 case 4: // WiFi 21ms
8429                         RSSI_WiFi_Cmpnstn = 17; // 22*0.79
8430                         break;
8431                 case 16: // WiFi 24ms
8432                         RSSI_WiFi_Cmpnstn = 18; // 22*0.76
8433                         break;
8434                 case 18: // WiFi 37ms
8435                         RSSI_WiFi_Cmpnstn = 14; // 22*0.64
8436                         break;
8437                 case 23: //Level-1, Antenna switch to BT at all time
8438                 case 24: //Level-2, Antenna switch to BT at all time
8439                 case 25: //Level-3a, Antenna switch to BT at all time
8440                 case 26: //Level-3b, Antenna switch to BT at all time
8441                 case 27: //Level-3b, Antenna switch to BT at all time
8442                 case 33: //BT SCO & WiFi site survey
8443                         RSSI_WiFi_Cmpnstn = 22;
8444                         break;
8445                 default:
8446                         break;
8447         }
8448
8449         if (rssi_wifi && RSSI_WiFi_Cmpnstn)
8450         {
8451                 RTPRINT(FBT, BT_TRACE, ("[BTCoex], 1AntSgnlCmpnstn, case %d, WiFiCmpnstn=%d(%d => %d)\n",
8452                                 pBtdm8723->curPsTdma, RSSI_WiFi_Cmpnstn, *rssi_wifi, *rssi_wifi+RSSI_WiFi_Cmpnstn));
8453                 *rssi_wifi += RSSI_WiFi_Cmpnstn;
8454         }
8455
8456         if (rssi_bt && RSSI_BT_Cmpnstn)
8457         {
8458                 RTPRINT(FBT, BT_TRACE, ("[BTCoex], 1AntSgnlCmpnstn, case %d, BTCmpnstn=%d(%d => %d)\n",
8459                                 pBtdm8723->curPsTdma, RSSI_BT_Cmpnstn, *rssi_bt, *rssi_bt+RSSI_BT_Cmpnstn));
8460                 *rssi_bt += RSSI_BT_Cmpnstn;
8461         }
8462 }
8463
8464 void
8465 BTDM_1AntSetWifiRssiThresh(
8466         PADAPTER        padapter,
8467         u8              rssiThresh
8468         )
8469 {
8470         PHAL_DATA_TYPE  pHalData = GET_HAL_DATA(padapter);
8471         PBTDM_8723A_1ANT pBtdm8723 = &pHalData->bt_coexist.halCoex8723.btdm1Ant;
8472
8473         pBtdm8723->wifiRssiThresh = rssiThresh;
8474         DBG_8723A("cosa set rssi thresh = %d\n", pBtdm8723->wifiRssiThresh);
8475 }
8476
8477 void BTDM_1AntParaInit(PADAPTER padapter)
8478 {
8479         PHAL_DATA_TYPE pHalData;
8480         PBT_COEXIST_8723A pBtCoex;
8481         PBTDM_8723A_1ANT pBtdm8723;
8482
8483
8484         pHalData = GET_HAL_DATA(padapter);
8485         pBtCoex = &pHalData->bt_coexist.halCoex8723;
8486         pBtdm8723 = &pBtCoex->btdm1Ant;
8487
8488         // Enable counter statistics
8489         rtw_write8(padapter, 0x76e, 0x4);
8490         btdm_1AntPtaParaReload(padapter);
8491
8492         pBtdm8723->wifiRssiThresh = 48;
8493
8494         pBtdm8723->bWiFiHalt = _FALSE;
8495         pBtdm8723->bRAChanged = _FALSE;
8496
8497         if ((pBtCoex->c2hBtInfo != BT_INFO_STATE_DISABLED) &&
8498                 (pBtCoex->c2hBtInfo != BT_INFO_STATE_NO_CONNECTION))
8499         {
8500                 BTDM_SetSwRfRxLpfCorner(padapter, BT_RF_RX_LPF_CORNER_SHRINK);
8501                 BTDM_AGCTable(padapter, BT_AGCTABLE_ON);
8502                 BTDM_BBBackOffLevel(padapter, BT_BB_BACKOFF_ON);
8503         }
8504 }
8505
8506 void BTDM_1AntForHalt(PADAPTER padapter)
8507 {
8508         RTPRINT(FBT, BT_TRACE, ("\n[BTCoex], 1Ant for halt\n"));
8509
8510         GET_HAL_DATA(padapter)->bt_coexist.halCoex8723.btdm1Ant.bWiFiHalt = _TRUE;
8511
8512         btdm_1AntWifiParaAdjust(padapter, _FALSE);
8513
8514         // don't use btdm_1AntSetPSTDMA() here
8515         // it will call rtw_set_ps_mode() and request pwrpriv->lock.
8516         // This will lead to deadlock, if this function is called in IPS
8517         // Lucas@20130205
8518         btdm_1AntPsTdma(padapter, _FALSE, 0);
8519
8520         btdm_SetFwIgnoreWlanAct(padapter, _TRUE);
8521 }
8522
8523 void BTDM_1AntLpsLeave(PADAPTER padapter)
8524 {
8525         RTPRINT(FBT, BT_TRACE, ("\n[BTCoex], 1Ant for LPS Leave\n"));
8526
8527         // Prevent from entering LPS again
8528         GET_HAL_DATA(padapter)->bt_coexist.halCoex8723.btdm1Ant.bWiFiHalt == _TRUE;
8529
8530         btdm_1AntSetPSTDMA(padapter, _FALSE, 0, _FALSE, 8);
8531 //      btdm_1AntPsTdma(padapter, _FALSE, 8);
8532 }
8533
8534 void BTDM_1AntWifiAssociateNotify(PADAPTER padapter, u8 type)
8535 {
8536         PHAL_DATA_TYPE pHalData = GET_HAL_DATA(padapter);
8537
8538
8539         RTPRINT(FBT, BT_TRACE, ("\n[BTCoex], 1Ant for associate, type=%d\n", type));
8540
8541         if (type)
8542         {
8543                 rtl8723a_CheckAntenna_Selection(padapter);
8544                 if (BT_IsBtDisabled(padapter) == _TRUE)
8545                 {
8546                         btdm_1AntSetPSTDMA(padapter, _FALSE, 0, _FALSE, 9);
8547                 }
8548                 else
8549                 {
8550                         PBT_COEXIST_8723A pBtCoex;
8551                         u8 BtState;
8552
8553                         pBtCoex = &pHalData->bt_coexist.halCoex8723;
8554                         BtState = pBtCoex->c2hBtInfo;
8555
8556                         btdm_1AntTSFSwitch(padapter, _TRUE);
8557
8558                         if ((BtState == BT_INFO_STATE_NO_CONNECTION) ||
8559                                  (BtState == BT_INFO_STATE_CONNECT_IDLE))
8560                         {
8561                                 btdm_1AntSetPSTDMA(padapter, _FALSE, 0, _TRUE, 28);
8562                         }
8563                         else if ((BtState == BT_INFO_STATE_SCO_ONLY_BUSY) ||
8564                                         (BtState == BT_INFO_STATE_ACL_SCO_BUSY))
8565                         {
8566                                 btdm_1AntSetPSTDMA(padapter, _FALSE, 0, _FALSE, 8);
8567                                 rtw_write32(padapter, 0x6c0, 0x5a5a5a5a);
8568                                 rtw_write32(padapter, 0x6c4, 0x5a5a5a5a);
8569                         }
8570                         else if ((BtState == BT_INFO_STATE_ACL_ONLY_BUSY) ||
8571                                         (BtState == BT_INFO_STATE_ACL_INQ_OR_PAG))
8572                         {
8573                                 if (pBtCoex->c2hBtProfile == BT_INFO_HID)
8574                                         btdm_1AntSetPSTDMA(padapter, _FALSE, 0, _TRUE, 35);
8575                                 else
8576                                         btdm_1AntSetPSTDMA(padapter, _FALSE, 0, _TRUE, 29);
8577                         }
8578                 }
8579         }
8580         else
8581         {
8582                 if (BT_IsBtDisabled(padapter) == _FALSE)
8583                 {
8584                         if (BTDM_IsWifiConnectionExist(padapter) == _FALSE)
8585                         {
8586                                 btdm_1AntPsTdma(padapter, _FALSE, 0);
8587                                 btdm_1AntTSFSwitch(padapter, _FALSE);
8588                         }
8589                 }
8590
8591                 btdm_1AntBtCoexistHandler(padapter);
8592         }
8593 }
8594
8595 void BTDM_1AntMediaStatusNotify(PADAPTER padapter, RT_MEDIA_STATUS mstatus)
8596 {
8597         PBT_COEXIST_8723A pBtCoex;
8598
8599
8600         pBtCoex = &GET_HAL_DATA(padapter)->bt_coexist.halCoex8723;
8601
8602         RTPRINT(FBT, BT_TRACE, ("\n\n[BTCoex]******************************\n"));
8603         RTPRINT(FBT, BT_TRACE, ("[BTCoex], MediaStatus, WiFi %s !!\n",
8604                         mstatus==RT_MEDIA_CONNECT?"CONNECT":"DISCONNECT"));
8605         RTPRINT(FBT, BT_TRACE, ("[BTCoex]******************************\n"));
8606
8607         if (RT_MEDIA_CONNECT == mstatus)
8608         {
8609                 if (check_fwstate(&padapter->mlmepriv, WIFI_STATION_STATE) == _TRUE)
8610                 {
8611                         if ((pBtCoex->c2hBtInfo == BT_INFO_STATE_SCO_ONLY_BUSY) ||
8612                                 (pBtCoex->c2hBtInfo == BT_INFO_STATE_ACL_SCO_BUSY))
8613                         {
8614                                 btdm_1AntUpdateHalRAMaskForSCO(padapter, _TRUE);
8615                         }
8616                 }
8617
8618                 padapter->pwrctrlpriv.DelayLPSLastTimeStamp = rtw_get_current_time();
8619                 BTDM_1AntForDhcp(padapter);
8620         }
8621         else
8622         {
8623                 //DBG_8723A("%s rtl8723a_DeinitAntenna_Selection\n",__func__);
8624                 rtl8723a_DeinitAntenna_Selection(padapter);
8625                 btdm_1AntBtCoexistHandler(padapter);
8626                 pBtCoex->btdm1Ant.bRAChanged = _FALSE;
8627         }
8628 }
8629
8630 void BTDM_1AntForDhcp(PADAPTER padapter)
8631 {
8632         PHAL_DATA_TYPE pHalData;
8633         u8 u1tmp;
8634         u8 BtState;
8635         PBT_COEXIST_8723A pBtCoex;
8636         PBTDM_8723A_1ANT pBtdm8723;
8637
8638
8639         pHalData = GET_HAL_DATA(padapter);
8640         pBtCoex = &pHalData->bt_coexist.halCoex8723;
8641         BtState = pBtCoex->c2hBtInfo;
8642         pBtdm8723 = &pBtCoex->btdm1Ant;
8643
8644         RTPRINT(FBT, BT_TRACE, ("\n[BTCoex], 1Ant for DHCP\n"));
8645         RTPRINT(FBT, BT_TRACE, ("[BTCoex], 1Ant for DHCP, WiFi is %s\n", BTDM_IsWifiBusy(padapter)?"Busy":"IDLE"));
8646         RTPRINT(FBT, BT_TRACE, ("[BTCoex], 1Ant for DHCP, %s\n", BtStateString[BtState]));
8647
8648 #if 1
8649
8650         BTDM_1AntWifiAssociateNotify(padapter, _TRUE);
8651
8652 #else
8653
8654 //      rtl8723a_set_lowpwr_lps_cmd(padapter, _FALSE);
8655
8656         if (BT_IsBtDisabled(padapter) == _TRUE)
8657         {
8658                 RTPRINT(FBT, BT_TRACE, ("[BTCoex], 1Ant for DHCP, BT is disabled\n"));
8659                 btdm_1AntSetPSTDMA(padapter, _FALSE, 0, _FALSE, 9);
8660         }
8661         else
8662         {
8663                 if ((BtState == BT_INFO_STATE_SCO_ONLY_BUSY) ||
8664                         (BtState == BT_INFO_STATE_ACL_SCO_BUSY))
8665                 {
8666                         if (_TRUE == pBtCoex->bC2hBtInquiryPage)
8667                                 btdm_1AntSetPSTDMA(padapter, _FALSE, 0, _TRUE, 32);
8668                         else
8669                                 btdm_1AntSetPSTDMA(padapter, _FALSE, 0, _TRUE, 27);
8670                 }
8671                 else if (BtState == BT_INFO_STATE_ACL_ONLY_BUSY)
8672                 {
8673                         padapter->pwrctrlpriv.btcoex_rfon = _TRUE;
8674                         if(padapter->securitypriv.ndisencryptstatus != Ndis802_11EncryptionDisabled)
8675                         {
8676                                 btdm_1AntSetPSTDMA(padapter, _TRUE, 0, _TRUE, 18);
8677                                 RTPRINT(FBT, BT_TRACE,
8678                                                 ("[BTCoex], 1Ant for DHCP, Encrypted AP, set TDMA(%s, %d)\n",
8679                                                 pBtdm8723->bCurPsTdmaOn?"ON":"OFF", pBtdm8723->curPsTdma));
8680                         }
8681                         else
8682                         {
8683                                 switch (pBtdm8723->curPsTdma)
8684                                 {
8685                                         case 1:
8686                                         case 2:
8687                                                 RTPRINT(FBT, BT_TRACE,
8688                                                                 ("[BTCoex], 1Ant for DHCP, Keep TDMA(%s, %d)\n",
8689                                                                 pBtdm8723->bCurPsTdmaOn?"ON":"OFF", pBtdm8723->curPsTdma));
8690                                                 break;
8691                                         default:
8692                                                 btdm_1AntSetPSTDMA(padapter, _TRUE, 0, _TRUE, 16);
8693                                                 break;
8694                                 }
8695                         }
8696                 }
8697                 else
8698                 {
8699                         btdm_1AntSetPSTDMA(padapter, _FALSE, 0, _TRUE, 28);
8700                 }
8701         }
8702 #endif
8703 }
8704
8705 void BTDM_1AntWifiScanNotify(PADAPTER padapter, u8 scanType)
8706 {
8707         PHAL_DATA_TYPE  pHalData;
8708         u8 u1tmp;
8709         u8 BtState;
8710         PBT_COEXIST_8723A pBtCoex;
8711         PBTDM_8723A_1ANT pBtdm8723;
8712
8713
8714         pHalData = GET_HAL_DATA(padapter);
8715         BtState = pHalData->bt_coexist.halCoex8723.c2hBtInfo;
8716         pBtCoex = &pHalData->bt_coexist.halCoex8723;
8717         pBtdm8723 = &pBtCoex->btdm1Ant;
8718
8719         RTPRINT(FBT, BT_TRACE, ("\n[BTCoex], 1Ant for wifi scan=%d!!\n", scanType));
8720         RTPRINT(FBT, BT_TRACE, ("[BTCoex], 1Ant for wifi scan, WiFi is %s\n", BTDM_IsWifiBusy(padapter)?"Busy":"IDLE"));
8721         RTPRINT(FBT, BT_TRACE, ("[BTCoex], 1Ant for wifi scan, %s\n", BtStateString[BtState]));
8722
8723         if (scanType)
8724         {
8725                 rtl8723a_CheckAntenna_Selection(padapter);
8726                 if (BT_IsBtDisabled(padapter) == _TRUE)
8727                 {
8728                         btdm_1AntSetPSTDMA(padapter, _FALSE, 0, _FALSE, 9);
8729                 }
8730                 else if (BTDM_IsWifiConnectionExist(padapter) == _FALSE)
8731                 {
8732                         BTDM_1AntWifiAssociateNotify(padapter, _TRUE);
8733                 }
8734                 else
8735                 {
8736                         if ((BtState == BT_INFO_STATE_SCO_ONLY_BUSY) ||
8737                                 (BtState == BT_INFO_STATE_ACL_SCO_BUSY))
8738                         {
8739                                 if (_TRUE == pBtCoex->bC2hBtInquiryPage)
8740                                         btdm_1AntSetPSTDMA(padapter, _FALSE, 0, _TRUE, 32);
8741                                 else
8742                                 {
8743                                         padapter->pwrctrlpriv.btcoex_rfon = _TRUE;
8744                                         btdm_1AntSetPSTDMA(padapter, _TRUE, 0, _TRUE, 33);
8745                                 }
8746                         }
8747                         else if (_TRUE == pBtCoex->bC2hBtInquiryPage)
8748                         {
8749                                 padapter->pwrctrlpriv.btcoex_rfon = _TRUE;
8750                                 btdm_1AntSetPSTDMA(padapter, _TRUE, 0, _TRUE, 30);
8751                         }
8752                         else if (BtState == BT_INFO_STATE_ACL_ONLY_BUSY)
8753                         {
8754                                 padapter->pwrctrlpriv.btcoex_rfon = _TRUE;
8755                                 if (pBtCoex->c2hBtProfile == BT_INFO_HID)
8756                                         btdm_1AntSetPSTDMA(padapter, _TRUE, 0, _TRUE, 34);
8757                                 else
8758                                         btdm_1AntSetPSTDMA(padapter, _TRUE, 0, _TRUE, 4);
8759                         }
8760                         else
8761                         {
8762                                 padapter->pwrctrlpriv.btcoex_rfon = _TRUE;
8763                                 btdm_1AntSetPSTDMA(padapter, _TRUE, 0, _TRUE, 5);
8764                         }
8765                 }
8766
8767                 btdm_NotifyFwScan(padapter, 1);
8768         }
8769         else // WiFi_Finish_Scan
8770         {
8771                 btdm_NotifyFwScan(padapter, 0);
8772                 btdm_1AntBtCoexistHandler(padapter);
8773         }
8774 }
8775
8776 void BTDM_1AntFwC2hBtInfo8723A(PADAPTER padapter)
8777 {
8778         PHAL_DATA_TYPE  pHalData;
8779         PBT30Info               pBTInfo;
8780         PBT_MGNT                pBtMgnt;
8781         PBT_COEXIST_8723A pBtCoex;
8782         u8      u1tmp, btState;
8783
8784
8785         pHalData = GET_HAL_DATA(padapter);
8786         pBTInfo = GET_BT_INFO(padapter);
8787         pBtMgnt = &pBTInfo->BtMgnt;
8788         pBtCoex = &pHalData->bt_coexist.halCoex8723;
8789
8790         u1tmp = pBtCoex->c2hBtInfoOriginal;
8791         // sco BUSY bit is not used on voice over PCM platform
8792         btState = u1tmp & 0xF;
8793         pBtCoex->c2hBtProfile = u1tmp & 0xE0;
8794
8795         // default set bt to idle state.
8796         pBtMgnt->ExtConfig.bBTBusy = _FALSE;
8797         pHalData->bt_coexist.CurrentState |= BT_COEX_STATE_BT_IDLE;
8798
8799         // check BIT2 first ==> check if bt is under inquiry or page scan
8800         if (btState & BIT(2))
8801         {
8802                 pBtCoex->bC2hBtInquiryPage = _TRUE;
8803         }
8804         else
8805         {
8806                 pBtCoex->bC2hBtInquiryPage = _FALSE;
8807         }
8808         btState &= ~BIT(2);
8809
8810         if (!(btState & BIT(0)))
8811         {
8812                 pBtCoex->c2hBtInfo = BT_INFO_STATE_NO_CONNECTION;
8813         }
8814         else
8815         {
8816                 if (btState == 0x1)
8817                 {
8818                         pBtCoex->c2hBtInfo = BT_INFO_STATE_CONNECT_IDLE;
8819                 }
8820                 else if (btState == 0x9)
8821                 {
8822                         if(pBtCoex->bC2hBtInquiryPage == _TRUE)
8823                                 pBtCoex->c2hBtInfo = BT_INFO_STATE_ACL_INQ_OR_PAG;
8824                         else
8825                                 pBtCoex->c2hBtInfo = BT_INFO_STATE_ACL_ONLY_BUSY;
8826                         pBtMgnt->ExtConfig.bBTBusy = _TRUE;
8827                 }
8828                 else if (btState == 0x3)
8829                 {
8830                         pBtCoex->c2hBtInfo = BT_INFO_STATE_SCO_ONLY_BUSY;
8831                         pBtMgnt->ExtConfig.bBTBusy = _TRUE;
8832                 }
8833                 else if (btState == 0xb)
8834                 {
8835                         pBtCoex->c2hBtInfo = BT_INFO_STATE_ACL_SCO_BUSY;
8836                         pBtMgnt->ExtConfig.bBTBusy = _TRUE;
8837                 }
8838                 else
8839                 {
8840                         pBtCoex->c2hBtInfo = BT_INFO_STATE_MAX;
8841                 }
8842                 if (_TRUE == pBtMgnt->ExtConfig.bBTBusy)
8843                         pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_BT_IDLE;
8844         }
8845
8846         if ((BT_INFO_STATE_NO_CONNECTION == pBtCoex->c2hBtInfo) ||
8847                 (BT_INFO_STATE_CONNECT_IDLE == pBtCoex->c2hBtInfo))
8848         {
8849                 if (pBtCoex->bC2hBtInquiryPage)
8850                         pBtCoex->c2hBtInfo = BT_INFO_STATE_INQ_OR_PAG;
8851         }
8852
8853         RTPRINT(FBT, BT_TRACE, ("[BTC2H], %s(%d)\n",
8854                         BtStateString[pBtCoex->c2hBtInfo], pBtCoex->c2hBtInfo));
8855
8856         if(pBtCoex->c2hBtProfile != BT_INFO_HID)
8857                 pBtCoex->c2hBtProfile &= ~BT_INFO_HID;
8858 }
8859
8860 void BTDM_1AntBtCoexist8723A(PADAPTER padapter)
8861 {
8862         struct mlme_priv *pmlmepriv;
8863         PHAL_DATA_TYPE  pHalData;
8864         u32 curr_time, delta_time;
8865
8866
8867         pmlmepriv = &padapter->mlmepriv;
8868         pHalData = GET_HAL_DATA(padapter);
8869
8870         if (check_fwstate(pmlmepriv, WIFI_SITE_MONITOR) == _TRUE)
8871         {
8872                 // already done in BTDM_1AntForScan()
8873                 RTPRINT(FBT, BT_TRACE, ("[BTCoex], wifi is under scan progress!!\n"));
8874                 return;
8875         }
8876
8877         if (check_fwstate(pmlmepriv, WIFI_UNDER_LINKING) == _TRUE)
8878         {
8879                 RTPRINT(FBT, BT_TRACE, ("[BTCoex], wifi is under link progress!!\n"));
8880                 return;
8881         }
8882
8883         // under DHCP(Special packet)
8884         curr_time = rtw_get_current_time();
8885         delta_time = curr_time - padapter->pwrctrlpriv.DelayLPSLastTimeStamp;
8886         delta_time = rtw_systime_to_ms(delta_time);
8887         if (delta_time < 500) // 500ms
8888         {
8889                 RTPRINT(FBT, BT_TRACE, ("[BTCoex], wifi is under DHCP progress(%d ms)!!\n", delta_time));
8890                 return;
8891         }
8892
8893         BTDM_CheckWiFiState(padapter);
8894
8895         btdm_1AntBtCoexistHandler(padapter);
8896 }
8897
8898 // ===== End of sync from SD7 driver HAL/BTCoexist/HalBtc87231Ant.c =====
8899 #endif
8900
8901 #ifdef __HALBTC87232ANT_C__ // HAL/BTCoexist/HalBtc87232Ant.c
8902 // ===== Below this line is sync from SD7 driver HAL/BTCoexist/HalBtc87232Ant.c =====
8903
8904 //============================================================
8905 // local function proto type if needed
8906 //============================================================
8907 //============================================================
8908 // local function start with btdm_
8909 //============================================================
8910 u8 btdm_ActionAlgorithm(PADAPTER        padapter)
8911 {
8912         PBT30Info               pBTInfo = GET_BT_INFO(padapter);
8913         PBT_MGNT                pBtMgnt = &pBTInfo->BtMgnt;
8914         PHAL_DATA_TYPE  pHalData = GET_HAL_DATA(padapter);
8915         PBTDM_8723A_2ANT pBtdm8723 = &pHalData->bt_coexist.halCoex8723.btdm2Ant;
8916         u8                      bScoExist=_FALSE, bBtLinkExist=_FALSE, bBtHsModeExist=_FALSE;
8917         u8                      algorithm=BT_2ANT_COEX_ALGO_UNDEFINED;
8918
8919         if(pBtMgnt->ExtConfig.NumberOfHandle)
8920         {
8921                 bBtLinkExist = _TRUE;
8922         }
8923         if(pBtMgnt->ExtConfig.NumberOfSCO)
8924                 {
8925                 bScoExist = _TRUE;
8926                 }
8927         if(BT_HsConnectionEstablished(padapter))
8928         {
8929                 bBtHsModeExist = _TRUE;
8930         }
8931
8932         //======================
8933         // here we get BT status first
8934         //======================
8935         // 1) initialize
8936         pBtdm8723->btStatus = BT_2ANT_BT_STATUS_IDLE;
8937
8938         if( (bScoExist) ||(bBtHsModeExist) ||
8939                 (BTHCI_CheckProfileExist(padapter,BT_PROFILE_HID)))
8940         {
8941                 RTPRINT(FBT, BT_TRACE, ("[BTCoex], SCO or HID or HS exists, set BT non-idle !!!\n"));
8942                 pBtdm8723->btStatus = BT_2ANT_BT_STATUS_NON_IDLE;
8943         }
8944         else
8945                 {
8946                 // A2dp profile
8947                 if( (pBtMgnt->ExtConfig.NumberOfHandle == 1) &&
8948                         (BTHCI_CheckProfileExist(padapter, BT_PROFILE_A2DP)) )
8949                 {
8950                         if(BTDM_BtTxRxCounterL(padapter) < 100)
8951                         {
8952                                 RTPRINT(FBT, BT_TRACE, ("[BTCoex], A2DP, low priority tx+rx < 100, set BT connected-idle!!!\n"));
8953                                 pBtdm8723->btStatus = BT_2ANT_BT_STATUS_CONNECTED_IDLE;
8954                 }
8955         else
8956         {
8957                                 RTPRINT(FBT, BT_TRACE, ("[BTCoex], A2DP, low priority tx+rx >= 100, set BT non-idle!!!\n"));
8958                                 pBtdm8723->btStatus = BT_2ANT_BT_STATUS_NON_IDLE;
8959         }
8960 }
8961                 // Pan profile
8962                 if( (pBtMgnt->ExtConfig.NumberOfHandle == 1) &&
8963                         (BTHCI_CheckProfileExist(padapter, BT_PROFILE_PAN)) )
8964 {
8965                         if(BTDM_BtTxRxCounterL(padapter) < 600)
8966         {
8967                                 RTPRINT(FBT, BT_TRACE, ("[BTCoex], PAN, low priority tx+rx < 600, set BT connected-idle!!!\n"));
8968                                 pBtdm8723->btStatus = BT_2ANT_BT_STATUS_CONNECTED_IDLE;
8969 }
8970                         else
8971 {
8972                                 if(pHalData->bt_coexist.halCoex8723.lowPriorityTx)
8973                                 {
8974                                         if((pHalData->bt_coexist.halCoex8723.lowPriorityRx /pHalData->bt_coexist.halCoex8723.lowPriorityTx)>9 )
8975                                         {
8976                                                 RTPRINT(FBT, BT_TRACE, ("[BTCoex], PAN, low priority rx/tx > 9, set BT connected-idle!!!\n"));
8977                                                 pBtdm8723->btStatus = BT_2ANT_BT_STATUS_CONNECTED_IDLE;
8978 }
8979                                 }
8980                         }
8981                         if(BT_2ANT_BT_STATUS_CONNECTED_IDLE != pBtdm8723->btStatus)
8982 {
8983                                 RTPRINT(FBT, BT_TRACE, ("[BTCoex], PAN, set BT non-idle!!!\n"));
8984                                 pBtdm8723->btStatus = BT_2ANT_BT_STATUS_NON_IDLE;
8985 }
8986                 }
8987                 // Pan+A2dp profile
8988                 if( (pBtMgnt->ExtConfig.NumberOfHandle == 2) &&
8989                         (BTHCI_CheckProfileExist(padapter, BT_PROFILE_A2DP)) &&
8990                         (BTHCI_CheckProfileExist(padapter, BT_PROFILE_PAN)) )
8991 {
8992                         if(BTDM_BtTxRxCounterL(padapter) < 600)
8993         {
8994                                 RTPRINT(FBT, BT_TRACE, ("[BTCoex], PAN+A2DP, low priority tx+rx < 600, set BT connected-idle!!!\n"));
8995                                 pBtdm8723->btStatus = BT_2ANT_BT_STATUS_CONNECTED_IDLE;
8996         }
8997         else
8998         {
8999                                 if(pHalData->bt_coexist.halCoex8723.lowPriorityTx)
9000                                 {
9001                                         if((pHalData->bt_coexist.halCoex8723.lowPriorityRx /pHalData->bt_coexist.halCoex8723.lowPriorityTx)>9 )
9002                                         {
9003                                                 RTPRINT(FBT, BT_TRACE, ("[BTCoex], PAN+A2DP, low priority rx/tx > 9, set BT connected-idle!!!\n"));
9004                                                 pBtdm8723->btStatus = BT_2ANT_BT_STATUS_CONNECTED_IDLE;
9005         }
9006 }
9007                         }
9008                         if(BT_2ANT_BT_STATUS_CONNECTED_IDLE != pBtdm8723->btStatus)
9009 {
9010                                 RTPRINT(FBT, BT_TRACE, ("[BTCoex], PAN+A2DP, set BT non-idle!!!\n"));
9011                                 pBtdm8723->btStatus = BT_2ANT_BT_STATUS_NON_IDLE;
9012 }
9013                 }
9014         }
9015         if(BT_2ANT_BT_STATUS_IDLE != pBtdm8723->btStatus)
9016 {
9017                 pBtMgnt->ExtConfig.bBTBusy = _TRUE;
9018         }
9019         else
9020         {
9021                 pBtMgnt->ExtConfig.bBTBusy = _FALSE;
9022 }
9023         //======================
9024
9025         if(!bBtLinkExist)
9026 {
9027                 RTPRINT(FBT, BT_TRACE, ("[BTCoex], No profile exists!!!\n"));
9028                 return algorithm;
9029         }
9030
9031         if(pBtMgnt->ExtConfig.NumberOfHandle == 1)
9032         {
9033                 if(bScoExist)
9034                 {
9035                         RTPRINT(FBT, BT_TRACE, ("[BTCoex], SCO only\n"));
9036                         algorithm = BT_2ANT_COEX_ALGO_SCO;
9037         }
9038                 else
9039         {
9040                         if(BTHCI_CheckProfileExist(padapter,BT_PROFILE_HID))
9041                         {
9042                                 RTPRINT(FBT, BT_TRACE, ("[BTCoex], HID only\n"));
9043                                 algorithm = BT_2ANT_COEX_ALGO_HID;
9044         }
9045                         else if(BTHCI_CheckProfileExist(padapter,BT_PROFILE_A2DP))
9046         {
9047                                 RTPRINT(FBT, BT_TRACE, ("[BTCoex], A2DP only\n"));
9048                                 algorithm = BT_2ANT_COEX_ALGO_A2DP;
9049         }
9050                         else if(BTHCI_CheckProfileExist(padapter,BT_PROFILE_PAN))
9051         {
9052                                 if(bBtHsModeExist)
9053                 {
9054                                         RTPRINT(FBT, BT_TRACE, ("[BTCoex], PAN(HS) only\n"));
9055                                         algorithm = BT_2ANT_COEX_ALGO_PANHS;
9056                 }
9057                 else
9058                 {
9059                                         RTPRINT(FBT, BT_TRACE, ("[BTCoex], PAN(EDR) only\n"));
9060                                         algorithm = BT_2ANT_COEX_ALGO_PANEDR;
9061                 }
9062         }
9063                         else
9064         {
9065                                 RTPRINT(FBT, BT_TRACE, ("[BTCoex], Error!!! NO matched profile for NumberOfHandle=%d \n",
9066                                         pBtMgnt->ExtConfig.NumberOfHandle));
9067         }
9068                 }
9069         }
9070         else if(pBtMgnt->ExtConfig.NumberOfHandle == 2)
9071         {
9072                 if(bScoExist)
9073                 {
9074                         if(BTHCI_CheckProfileExist(padapter, BT_PROFILE_HID))
9075                         {
9076                                 RTPRINT(FBT, BT_TRACE, ("[BTCoex], SCO + HID\n"));
9077                                 algorithm = BT_2ANT_COEX_ALGO_HID;
9078         }
9079                         else if(BTHCI_CheckProfileExist(padapter,BT_PROFILE_A2DP))
9080         {
9081                                 RTPRINT(FBT, BT_TRACE, ("[BTCoex], Error!!! SCO + A2DP\n"));
9082         }
9083                         else if(BTHCI_CheckProfileExist(padapter,BT_PROFILE_PAN))
9084                         {
9085                                 if(bBtHsModeExist)
9086                                 {
9087                                         RTPRINT(FBT, BT_TRACE, ("[BTCoex], SCO + PAN(HS)\n"));
9088                                         algorithm = BT_2ANT_COEX_ALGO_SCO;
9089 }
9090                                 else
9091 {
9092                                         RTPRINT(FBT, BT_TRACE, ("[BTCoex], SCO + PAN(EDR)\n"));
9093                                         algorithm = BT_2ANT_COEX_ALGO_PANEDR_HID;
9094                                 }
9095                         }
9096                         else
9097         {
9098                                 RTPRINT(FBT, BT_TRACE, ("[BTCoex], Error!!! SCO exists but why NO matched ACL profile for NumberOfHandle=%d\n",
9099                                         pBtMgnt->ExtConfig.NumberOfHandle));
9100                         }
9101         }
9102         else
9103         {
9104                         if( BTHCI_CheckProfileExist(padapter,BT_PROFILE_HID) &&
9105                                 BTHCI_CheckProfileExist(padapter,BT_PROFILE_A2DP) )
9106                         {
9107                                 RTPRINT(FBT, BT_TRACE, ("[BTCoex], HID + A2DP\n"));
9108                                 algorithm = BT_2ANT_COEX_ALGO_HID_A2DP;
9109         }
9110                         else if( BTHCI_CheckProfileExist(padapter,BT_PROFILE_HID) &&
9111                                 BTHCI_CheckProfileExist(padapter,BT_PROFILE_PAN) )
9112                         {
9113                                 if(bBtHsModeExist)
9114                                 {
9115                                         RTPRINT(FBT, BT_TRACE, ("[BTCoex], HID + PAN(HS)\n"));
9116                                         algorithm = BT_2ANT_COEX_ALGO_HID_A2DP;
9117 }
9118                                 else
9119 {
9120                                         RTPRINT(FBT, BT_TRACE, ("[BTCoex], HID + PAN(EDR)\n"));
9121                                         algorithm = BT_2ANT_COEX_ALGO_PANEDR_HID;
9122                                 }
9123                         }
9124                         else if( BTHCI_CheckProfileExist(padapter,BT_PROFILE_PAN) &&
9125                                 BTHCI_CheckProfileExist(padapter,BT_PROFILE_A2DP) )
9126         {
9127                                 if(bBtHsModeExist)
9128                                 {
9129                                         RTPRINT(FBT, BT_TRACE, ("[BTCoex], A2DP + PAN(HS)\n"));
9130                                         algorithm = BT_2ANT_COEX_ALGO_A2DP;
9131         }
9132                                 else
9133         {
9134                                         RTPRINT(FBT, BT_TRACE, ("[BTCoex], A2DP + PAN(EDR)\n"));
9135                                         algorithm = BT_2ANT_COEX_ALGO_PANEDR_A2DP;
9136         }
9137 }
9138                         else
9139 {
9140                                 RTPRINT(FBT, BT_TRACE, ("[BTCoex], Error!!! NO matched profile for NumberOfHandle=%d\n",
9141                                         pBtMgnt->ExtConfig.NumberOfHandle));
9142                         }
9143                 }
9144         }
9145         else if(pBtMgnt->ExtConfig.NumberOfHandle == 3)
9146         {
9147                 if(bScoExist)
9148                 {
9149                         if( BTHCI_CheckProfileExist(padapter,BT_PROFILE_HID) &&
9150                                 BTHCI_CheckProfileExist(padapter,BT_PROFILE_A2DP) )
9151                         {
9152                                 RTPRINT(FBT, BT_TRACE, ("[BTCoex], Error!!! SCO + HID + A2DP\n"));
9153                 }
9154                         else if( BTHCI_CheckProfileExist(padapter,BT_PROFILE_HID) &&
9155                                 BTHCI_CheckProfileExist(padapter,BT_PROFILE_PAN) )
9156                         {
9157                                 if(bBtHsModeExist)
9158                 {
9159                                         RTPRINT(FBT, BT_TRACE, ("[BTCoex], SCO + HID + PAN(HS)\n"));
9160                                         algorithm = BT_2ANT_COEX_ALGO_HID_A2DP;
9161                 }
9162                 else
9163                 {
9164                                         RTPRINT(FBT, BT_TRACE, ("[BTCoex], SCO + HID + PAN(EDR)\n"));
9165                                         algorithm = BT_2ANT_COEX_ALGO_PANEDR_HID;
9166                 }
9167                 }
9168                         else if( BTHCI_CheckProfileExist(padapter,BT_PROFILE_PAN) &&
9169                                 BTHCI_CheckProfileExist(padapter,BT_PROFILE_A2DP) )
9170                         {
9171                                 if(bBtHsModeExist)
9172                 {
9173                                         RTPRINT(FBT, BT_TRACE, ("[BTCoex], Error!!! SCO + A2DP + PAN(HS)\n"));
9174                                         algorithm = BT_2ANT_COEX_ALGO_SCO;
9175                 }
9176                                 else
9177                                 {
9178                                         RTPRINT(FBT, BT_TRACE, ("[BTCoex], Error!!! SCO + A2DP + PAN(EDR)\n"));
9179
9180                                 }
9181                         }
9182                         else
9183                 {
9184                                 RTPRINT(FBT, BT_TRACE, ("[BTCoex], Error!!! SCO exists but why NO matched profile for NumberOfHandle=%d\n",
9185                                         pBtMgnt->ExtConfig.NumberOfHandle));
9186                         }
9187                 }
9188                 else
9189                 {
9190                         if( BTHCI_CheckProfileExist(padapter,BT_PROFILE_HID) &&
9191                                 BTHCI_CheckProfileExist(padapter,BT_PROFILE_PAN) &&
9192                                 BTHCI_CheckProfileExist(padapter,BT_PROFILE_A2DP) )
9193                         {
9194                                 if(bBtHsModeExist)
9195                                 {
9196                                         RTPRINT(FBT, BT_TRACE, ("[BTCoex], HID + A2DP + PAN(HS)\n"));
9197                                         algorithm = BT_2ANT_COEX_ALGO_HID_A2DP_PANHS;
9198                 }
9199                                 else
9200                 {
9201                                         RTPRINT(FBT, BT_TRACE, ("[BTCoex], HID + A2DP + PAN(EDR)\n"));
9202                                         algorithm = BT_2ANT_COEX_ALGO_HID_A2DP_PANEDR;
9203                 }
9204         }
9205         else
9206         {
9207                                 RTPRINT(FBT, BT_TRACE, ("[BTCoex], Error!!! NO matched profile for NumberOfHandle=%d\n",
9208                                         pBtMgnt->ExtConfig.NumberOfHandle));
9209         }
9210                 }
9211         }
9212         else if(pBtMgnt->ExtConfig.NumberOfHandle >= 3)
9213         {
9214                 if(bScoExist)
9215                 {
9216                         if( BTHCI_CheckProfileExist(padapter,BT_PROFILE_HID) &&
9217                                 BTHCI_CheckProfileExist(padapter,BT_PROFILE_PAN) &&
9218                                 BTHCI_CheckProfileExist(padapter,BT_PROFILE_A2DP) )
9219                         {
9220                                 if(bBtHsModeExist)
9221                                 {
9222                                         RTPRINT(FBT, BT_TRACE, ("[BTCoex], Error!!! SCO + HID + A2DP + PAN(HS)\n"));
9223
9224                                 }
9225                                 else
9226                                 {
9227                                         RTPRINT(FBT, BT_TRACE, ("[BTCoex], Error!!! SCO + HID + A2DP + PAN(EDR)\n"));
9228
9229                                 }
9230                         }
9231                         else
9232         {
9233                                 RTPRINT(FBT, BT_TRACE, ("[BTCoex], Error!!! SCO exists but why NO matched profile for NumberOfHandle=%d\n",
9234                                         pBtMgnt->ExtConfig.NumberOfHandle));
9235         }
9236 }
9237                 else
9238 {
9239                         RTPRINT(FBT, BT_TRACE, ("[BTCoex], Error!!! NO matched profile for NumberOfHandle=%d\n",
9240                                 pBtMgnt->ExtConfig.NumberOfHandle));
9241                 }
9242         }
9243
9244         return algorithm;
9245         }
9246
9247 u8 btdm_NeedToDecBtPwr(PADAPTER padapter)
9248         {
9249         PHAL_DATA_TYPE  pHalData = GET_HAL_DATA(padapter);
9250         PADAPTER        pDefaultAdapter = GetDefaultAdapter(padapter);
9251         u8      bRet=_FALSE;
9252
9253         if(BT_Operation(padapter)) {
9254                 if(pHalData->dmpriv.EntryMinUndecoratedSmoothedPWDB > 47) {
9255                         RTPRINT(FBT, BT_TRACE, ("Need to decrease bt power for HS mode!!\n"));
9256                         bRet = _TRUE;
9257                 } else {
9258                         RTPRINT(FBT, BT_TRACE, ("NO Need to decrease bt power for HS mode!!\n"));
9259                 }
9260         } else {
9261                 if(BTDM_IsWifiConnectionExist(padapter)) {
9262                         RTPRINT(FBT, BT_TRACE, ("Need to decrease bt power for Wifi is connected!!\n"));
9263                         bRet = _TRUE;
9264                 }
9265         }
9266         return bRet;
9267 }
9268
9269
9270 u8 btdm_IsBadIsolation(PADAPTER padapter)
9271 {
9272         return _FALSE;
9273 }
9274
9275 void
9276 btdm_SetCoexTable(
9277         PADAPTER        padapter,
9278         u32             val0x6c0,
9279         u32             val0x6c8,
9280         u8              val0x6cc
9281         )
9282                 {
9283         RTPRINT(FBT, BT_TRACE, ("set coex table, set 0x6c0=0x%x\n", val0x6c0));
9284         rtw_write32(padapter, 0x6c0, val0x6c0);
9285
9286         RTPRINT(FBT, BT_TRACE, ("set coex table, set 0x6c8=0x%x\n", val0x6c8));
9287         rtw_write32(padapter, 0x6c8, val0x6c8);
9288
9289         RTPRINT(FBT, BT_TRACE, ("set coex table, set 0x6cc=0x%x\n", val0x6cc));
9290         rtw_write8(padapter, 0x6cc, val0x6cc);
9291                 }
9292
9293
9294 void btdm_SetSwFullTimeDacSwing(PADAPTER                padapter,u8     bSwDacSwingOn,u32       swDacSwingLvl)
9295 {
9296         PHAL_DATA_TYPE  pHalData = GET_HAL_DATA(padapter);
9297
9298         if(bSwDacSwingOn)
9299         {
9300                 RTPRINT(FBT, BT_TRACE, ("[BTCoex], SwDacSwing = 0x%x\n", swDacSwingLvl));
9301                 PHY_SetBBReg(padapter, 0x880, 0xff000000, swDacSwingLvl);
9302                 pHalData->bt_coexist.bSWCoexistAllOff = _FALSE;
9303         }
9304         else
9305         {
9306                 RTPRINT(FBT, BT_TRACE, ("[BTCoex], SwDacSwing Off!\n"));
9307                 PHY_SetBBReg(padapter, 0x880, 0xff000000, 0xc0);
9308         }
9309 }
9310
9311
9312 void btdm_SetFwDacSwingLevel(PADAPTER padapter, u8 dacSwingLvl)
9313 {
9314         u1Byte                  H2C_Parameter[1] ={0};
9315
9316         H2C_Parameter[0] = dacSwingLvl;
9317
9318         RTPRINT(FBT, BT_TRACE, ("[BTCoex], Set Dac Swing Level=0x%x\n", dacSwingLvl));
9319         RTPRINT(FBT, BT_TRACE, ("[BTCoex], write 0x29=0x%x\n", H2C_Parameter[0]));
9320
9321         FillH2CCmd(padapter, 0x29, 1, H2C_Parameter);
9322 }
9323
9324 void btdm_2AntDecBtPwr(PADAPTER padapter,u8     bDecBtPwr)
9325 {
9326         PHAL_DATA_TYPE  pHalData = GET_HAL_DATA(padapter);
9327         PBTDM_8723A_2ANT pBtdm8723 = &pHalData->bt_coexist.halCoex8723.btdm2Ant;
9328
9329         RTPRINT(FBT, BT_TRACE, ("[BTCoex], Dec BT power = %s\n",  ((bDecBtPwr)? "ON":"OFF")));
9330         pBtdm8723->bCurDecBtPwr = bDecBtPwr;
9331
9332         //RTPRINT(FBT, BT_TRACE, ("[BTCoex], bPreDecBtPwr=%d, bCurDecBtPwr=%d\n",
9333         //      pBtdm8723->bPreDecBtPwr, pBtdm8723->bCurDecBtPwr));
9334
9335         if(pBtdm8723->bPreDecBtPwr == pBtdm8723->bCurDecBtPwr)
9336                 return;
9337
9338         BTDM_SetFwDecBtPwr(padapter, pBtdm8723->bCurDecBtPwr);
9339
9340         pBtdm8723->bPreDecBtPwr = pBtdm8723->bCurDecBtPwr;
9341 }
9342
9343  void btdm_2AntFwDacSwingLvl(PADAPTER   padapter,u8     fwDacSwingLvl)
9344 {
9345         PHAL_DATA_TYPE  pHalData = GET_HAL_DATA(padapter);
9346         PBTDM_8723A_2ANT        pBtdm8723 = &pHalData->bt_coexist.halCoex8723.btdm2Ant;
9347
9348         RTPRINT(FBT, BT_TRACE, ("[BTCoex], set FW Dac Swing level = %d\n",  fwDacSwingLvl));
9349         pBtdm8723->curFwDacSwingLvl = fwDacSwingLvl;
9350
9351         //RTPRINT(FBT, BT_TRACE, ("[BTCoex], preFwDacSwingLvl=%d, curFwDacSwingLvl=%d\n",
9352         //      pBtdm8723->preFwDacSwingLvl, pBtdm8723->curFwDacSwingLvl));
9353
9354         if(pBtdm8723->preFwDacSwingLvl == pBtdm8723->curFwDacSwingLvl)
9355                 return;
9356
9357         btdm_SetFwDacSwingLevel(padapter, pBtdm8723->curFwDacSwingLvl);
9358
9359         pBtdm8723->preFwDacSwingLvl = pBtdm8723->curFwDacSwingLvl;
9360 }
9361
9362 void btdm_2AntRfShrink( PADAPTER        padapter, u8    bRxRfShrinkOn)
9363 {
9364         PHAL_DATA_TYPE  pHalData = GET_HAL_DATA(padapter);
9365         PBTDM_8723A_2ANT        pBtdm8723 = &pHalData->bt_coexist.halCoex8723.btdm2Ant;
9366
9367         RTPRINT(FBT, BT_TRACE, ("[BTCoex], turn Rx RF Shrink = %s\n",  ((bRxRfShrinkOn)? "ON":"OFF")));
9368         pBtdm8723->bCurRfRxLpfShrink = bRxRfShrinkOn;
9369
9370         //RTPRINT(FBT, BT_TRACE, ("[BTCoex], bPreRfRxLpfShrink=%d, bCurRfRxLpfShrink=%d\n",
9371         //      pBtdm8723->bPreRfRxLpfShrink, pBtdm8723->bCurRfRxLpfShrink));
9372
9373         if(pBtdm8723->bPreRfRxLpfShrink == pBtdm8723->bCurRfRxLpfShrink)
9374                 return;
9375
9376         BTDM_SetSwRfRxLpfCorner(padapter, (u8)pBtdm8723->bCurRfRxLpfShrink);
9377
9378         pBtdm8723->bPreRfRxLpfShrink = pBtdm8723->bCurRfRxLpfShrink;
9379 }
9380
9381 void btdm_2AntLowPenaltyRa(PADAPTER     padapter, u8    bLowPenaltyRa)
9382 {
9383         PHAL_DATA_TYPE  pHalData = GET_HAL_DATA(padapter);
9384         PBTDM_8723A_2ANT        pBtdm8723 = &pHalData->bt_coexist.halCoex8723.btdm2Ant;
9385
9386         RTPRINT(FBT, BT_TRACE, ("[BTCoex], turn LowPenaltyRA = %s\n",  ((bLowPenaltyRa)? "ON":"OFF")));
9387         pBtdm8723->bCurLowPenaltyRa = bLowPenaltyRa;
9388
9389         //RTPRINT(FBT, BT_TRACE, ("[BTCoex], bPreLowPenaltyRa=%d, bCurLowPenaltyRa=%d\n",
9390         //      pBtdm8723->bPreLowPenaltyRa, pBtdm8723->bCurLowPenaltyRa));
9391
9392         if(pBtdm8723->bPreLowPenaltyRa == pBtdm8723->bCurLowPenaltyRa)
9393                 return;
9394
9395         BTDM_SetSwPenaltyTxRateAdaptive(padapter, (u1Byte)pBtdm8723->bCurLowPenaltyRa);
9396
9397         pBtdm8723->bPreLowPenaltyRa = pBtdm8723->bCurLowPenaltyRa;
9398         }
9399
9400
9401
9402 void btdm_2AntDacSwing(PADAPTER padapter,u8     bDacSwingOn,u32 dacSwingLvl     )
9403                 {
9404         PHAL_DATA_TYPE  pHalData = GET_HAL_DATA(padapter);
9405         PBTDM_8723A_2ANT        pBtdm8723 = &pHalData->bt_coexist.halCoex8723.btdm2Ant;
9406
9407         RTPRINT(FBT, BT_TRACE, ("[BTCoex], turn DacSwing=%s, dacSwingLvl=0x%x\n",
9408                 ((bDacSwingOn)? "ON":"OFF"), dacSwingLvl));
9409         pBtdm8723->bCurDacSwingOn = bDacSwingOn;
9410         pBtdm8723->curDacSwingLvl = dacSwingLvl;
9411
9412         //RTPRINT(FBT, BT_TRACE, ("[BTCoex], bPreDacSwingOn=%d, preDacSwingLvl=0x%x, bCurDacSwingOn=%d, curDacSwingLvl=0x%x\n",
9413         //      pBtdm8723->bPreDacSwingOn, pBtdm8723->preDacSwingLvl,
9414         //      pBtdm8723->bCurDacSwingOn, pBtdm8723->curDacSwingLvl));
9415
9416         if( (pBtdm8723->bPreDacSwingOn == pBtdm8723->bCurDacSwingOn) &&
9417                 (pBtdm8723->preDacSwingLvl == pBtdm8723->curDacSwingLvl) )
9418                 return;
9419
9420         rtw_mdelay_os(30);
9421         btdm_SetSwFullTimeDacSwing(padapter, bDacSwingOn, dacSwingLvl);
9422
9423         pBtdm8723->bPreDacSwingOn = pBtdm8723->bCurDacSwingOn;
9424         pBtdm8723->preDacSwingLvl = pBtdm8723->curDacSwingLvl;
9425         }
9426
9427
9428 void btdm_2AntAdcBackOff(PADAPTER       padapter,u8     bAdcBackOff)
9429         {
9430         PHAL_DATA_TYPE  pHalData = GET_HAL_DATA(padapter);
9431         PBTDM_8723A_2ANT        pBtdm8723 = &pHalData->bt_coexist.halCoex8723.btdm2Ant;
9432
9433         RTPRINT(FBT, BT_TRACE, ("[BTCoex], turn AdcBackOff = %s\n",  ((bAdcBackOff)? "ON":"OFF")));
9434         pBtdm8723->bCurAdcBackOff = bAdcBackOff;
9435
9436         //RTPRINT(FBT, BT_TRACE, ("[BTCoex], bPreAdcBackOff=%d, bCurAdcBackOff=%d\n",
9437         //      pBtdm8723->bPreAdcBackOff, pBtdm8723->bCurAdcBackOff));
9438
9439         if(pBtdm8723->bPreAdcBackOff == pBtdm8723->bCurAdcBackOff)
9440                 return;
9441
9442         BTDM_BBBackOffLevel(padapter, (u8)pBtdm8723->bCurAdcBackOff);
9443
9444         pBtdm8723->bPreAdcBackOff = pBtdm8723->bCurAdcBackOff;
9445         }
9446
9447 void btdm_2AntAgcTable(PADAPTER padapter,u8     bAgcTableEn)
9448         {
9449         PHAL_DATA_TYPE  pHalData = GET_HAL_DATA(padapter);
9450         PBTDM_8723A_2ANT        pBtdm8723 = &pHalData->bt_coexist.halCoex8723.btdm2Ant;
9451
9452         RTPRINT(FBT, BT_TRACE, ("[BTCoex], %s Agc Table\n",  ((bAgcTableEn)? "Enable":"Disable")));
9453         pBtdm8723->bCurAgcTableEn = bAgcTableEn;
9454
9455         //RTPRINT(FBT, BT_TRACE, ("[BTCoex], bPreAgcTableEn=%d, bCurAgcTableEn=%d\n",
9456         //      pBtdm8723->bPreAgcTableEn, pBtdm8723->bCurAgcTableEn));
9457
9458         if(pBtdm8723->bPreAgcTableEn == pBtdm8723->bCurAgcTableEn)
9459                 return;
9460
9461         BTDM_AGCTable(padapter, (u8)bAgcTableEn);
9462
9463         pBtdm8723->bPreAgcTableEn = pBtdm8723->bCurAgcTableEn;
9464         }
9465
9466 void btdm_2AntCoexTable( PADAPTER       padapter,u32    val0x6c0,u32    val0x6c8,u8     val0x6cc)
9467 {
9468         PHAL_DATA_TYPE  pHalData = GET_HAL_DATA(padapter);
9469         PBTDM_8723A_2ANT        pBtdm8723 = &pHalData->bt_coexist.halCoex8723.btdm2Ant;
9470
9471         RTPRINT(FBT, BT_TRACE, ("[BTCoex], write Coex Table 0x6c0=0x%x, 0x6c8=0x%x, 0x6cc=0x%x\n",
9472                 val0x6c0, val0x6c8, val0x6cc));
9473         pBtdm8723->curVal0x6c0 = val0x6c0;
9474         pBtdm8723->curVal0x6c8 = val0x6c8;
9475         pBtdm8723->curVal0x6cc = val0x6cc;
9476
9477         //RTPRINT(FBT, BT_TRACE, ("[BTCoex], preVal0x6c0=0x%x, preVal0x6c8=0x%x, preVal0x6cc=0x%x !!\n",
9478         //      pBtdm8723->preVal0x6c0, pBtdm8723->preVal0x6c8, pBtdm8723->preVal0x6cc));
9479         //RTPRINT(FBT, BT_TRACE, ("[BTCoex], curVal0x6c0=0x%x, curVal0x6c8=0x%x, curVal0x6cc=0x%x !!\n",
9480         //      pBtdm8723->curVal0x6c0, pBtdm8723->curVal0x6c8, pBtdm8723->curVal0x6cc));
9481
9482         if( (pBtdm8723->preVal0x6c0 == pBtdm8723->curVal0x6c0) &&
9483                 (pBtdm8723->preVal0x6c8 == pBtdm8723->curVal0x6c8) &&
9484                 (pBtdm8723->preVal0x6cc == pBtdm8723->curVal0x6cc) )
9485                 return;
9486
9487         btdm_SetCoexTable(padapter, val0x6c0, val0x6c8, val0x6cc);
9488
9489         pBtdm8723->preVal0x6c0 = pBtdm8723->curVal0x6c0;
9490         pBtdm8723->preVal0x6c8 = pBtdm8723->curVal0x6c8;
9491         pBtdm8723->preVal0x6cc = pBtdm8723->curVal0x6cc;
9492 }
9493
9494 void btdm_2AntIgnoreWlanAct(PADAPTER    padapter,u8     bEnable)
9495 {
9496         PHAL_DATA_TYPE  pHalData = GET_HAL_DATA(padapter);
9497         PBTDM_8723A_2ANT        pBtdm8723 = &pHalData->bt_coexist.halCoex8723.btdm2Ant;
9498
9499         RTPRINT(FBT, BT_TRACE, ("[BTCoex], turn Ignore WlanAct %s\n", (bEnable? "ON":"OFF")));
9500         pBtdm8723->bCurIgnoreWlanAct = bEnable;
9501
9502         //RTPRINT(FBT, BT_TRACE, ("[BTCoex], bPreIgnoreWlanAct = %d, bCurIgnoreWlanAct = %d!!\n",
9503         //      pBtdm8723->bPreIgnoreWlanAct, pBtdm8723->bCurIgnoreWlanAct));
9504
9505         if(pBtdm8723->bPreIgnoreWlanAct == pBtdm8723->bCurIgnoreWlanAct)
9506                 return;
9507
9508         btdm_SetFwIgnoreWlanAct(padapter,bEnable);
9509         pBtdm8723->bPreIgnoreWlanAct = pBtdm8723->bCurIgnoreWlanAct;
9510 }
9511
9512 void btdm_2AntSetFw3a(PADAPTER  padapter,u8     byte1,u8        byte2,u8                byte3,u8                byte4,u8                byte5)
9513         {
9514         u8              H2C_Parameter[5] ={0};
9515
9516         PHAL_DATA_TYPE  pHalData = GET_HAL_DATA(padapter);
9517
9518         // byte1[1:0] != 0 means enable pstdma
9519         // for 2Ant bt coexist, if byte1 != 0 means enable pstdma
9520         if(byte1)
9521         {
9522                 pHalData->bt_coexist.bFWCoexistAllOff = _FALSE;
9523         }
9524         H2C_Parameter[0] = byte1;
9525         H2C_Parameter[1] = byte2;
9526         H2C_Parameter[2] = byte3;
9527         H2C_Parameter[3] = byte4;
9528         H2C_Parameter[4] = byte5;
9529
9530         pHalData->bt_coexist.fw3aVal[0] = byte1;
9531         pHalData->bt_coexist.fw3aVal[1] = byte2;
9532         pHalData->bt_coexist.fw3aVal[2] = byte3;
9533         pHalData->bt_coexist.fw3aVal[3] = byte4;
9534         pHalData->bt_coexist.fw3aVal[4] = byte5;
9535
9536         RTPRINT(FBT, BT_TRACE, ("[BTCoex], FW write 0x3a(5bytes)=0x%x%08x\n",
9537                 H2C_Parameter[0],
9538                 H2C_Parameter[1]<<24|H2C_Parameter[2]<<16|H2C_Parameter[3]<<8|H2C_Parameter[4]));
9539
9540         FillH2CCmd(padapter, 0x3a, 5, H2C_Parameter);
9541         }
9542
9543 void btdm_2AntPsTdma(PADAPTER   padapter,u8     bTurnOn,u8      type)
9544         {
9545         PHAL_DATA_TYPE  pHalData = GET_HAL_DATA(padapter);
9546         PBTDM_8723A_2ANT        pBtdm8723 = &pHalData->bt_coexist.halCoex8723.btdm2Ant;
9547         u32                     btTxRxCnt=0;
9548         u8                      bTurnOnByCnt=_FALSE;
9549         u8                      psTdmaTypeByCnt=0;
9550
9551         btTxRxCnt = BTDM_BtTxRxCounterH(padapter)+BTDM_BtTxRxCounterL(padapter);
9552         RTPRINT(FBT, BT_TRACE, ("[BTCoex], BT TxRx Counters = %d\n", btTxRxCnt));
9553         if(btTxRxCnt > 3000)
9554         {
9555                 bTurnOnByCnt = _TRUE;
9556                 psTdmaTypeByCnt = 8;
9557
9558                 RTPRINT(FBT, BT_TRACE, ("[BTCoex], For BTTxRxCounters, turn %s PS TDMA, type=%d\n", (bTurnOnByCnt? "ON":"OFF"), psTdmaTypeByCnt));
9559                 pBtdm8723->bCurPsTdmaOn = bTurnOnByCnt;
9560                 pBtdm8723->curPsTdma = psTdmaTypeByCnt;
9561         }
9562         else
9563         {
9564                 RTPRINT(FBT, BT_TRACE, ("[BTCoex], turn %s PS TDMA, type=%d\n", (bTurnOn? "ON":"OFF"), type));
9565                 pBtdm8723->bCurPsTdmaOn = bTurnOn;
9566                 pBtdm8723->curPsTdma = type;
9567         }
9568
9569         //RTPRINT(FBT, BT_TRACE, ("[BTCoex], bPrePsTdmaOn = %d, bCurPsTdmaOn = %d!!\n",
9570         //      pBtdm8723->bPrePsTdmaOn, pBtdm8723->bCurPsTdmaOn));
9571         //RTPRINT(FBT, BT_TRACE, ("[BTCoex], prePsTdma = %d, curPsTdma = %d!!\n",
9572         //      pBtdm8723->prePsTdma, pBtdm8723->curPsTdma));
9573
9574         if( (pBtdm8723->bPrePsTdmaOn == pBtdm8723->bCurPsTdmaOn) &&
9575                 (pBtdm8723->prePsTdma == pBtdm8723->curPsTdma) )
9576                 return;
9577
9578         if(bTurnOn)
9579         {
9580                 switch(type)
9581                 {
9582                         case 1:
9583                         default:
9584                                 btdm_2AntSetFw3a(padapter, 0xe3, 0x1a, 0x1a, 0xa1, 0x98);
9585                                 break;
9586                         case 2:
9587                                 btdm_2AntSetFw3a(padapter, 0xe3, 0x12, 0x12, 0xa1, 0x98);
9588                                 break;
9589                         case 3:
9590                                 btdm_2AntSetFw3a(padapter, 0xe3, 0xa, 0xa, 0xa1, 0x98);
9591                                 break;
9592                         case 4:
9593                                 btdm_2AntSetFw3a(padapter, 0xa3, 0x5, 0x5, 0xa1, 0x80);
9594                                 break;
9595                         case 5:
9596                                 btdm_2AntSetFw3a(padapter, 0xe3, 0x1a, 0x1a, 0x20, 0x98);
9597                                 break;
9598                         case 6:
9599                                 btdm_2AntSetFw3a(padapter, 0xe3, 0x12, 0x12, 0x20, 0x98);
9600                                 break;
9601                         case 7:
9602                                 btdm_2AntSetFw3a(padapter, 0xe3, 0xa, 0xa, 0x20, 0x98);
9603                                 break;
9604                         case 8:
9605                                 btdm_2AntSetFw3a(padapter, 0xa3, 0x5, 0x5, 0x20, 0x80);
9606                                 break;
9607                         case 9:
9608                                 btdm_2AntSetFw3a(padapter, 0xe3, 0x1a, 0x1a, 0xa1, 0x98);
9609                                 break;
9610                         case 10:
9611                                 btdm_2AntSetFw3a(padapter, 0xe3, 0x12, 0x12, 0xa1, 0x98);
9612                                 break;
9613                         case 11:
9614                                 btdm_2AntSetFw3a(padapter, 0xe3, 0xa, 0xa, 0xa1, 0x98);
9615                                 break;
9616                         case 12:
9617                                 btdm_2AntSetFw3a(padapter, 0xe3, 0x5, 0x5, 0xa1, 0x98);
9618                                 break;
9619                         case 13:
9620                                 btdm_2AntSetFw3a(padapter, 0xe3, 0x1a, 0x1a, 0x20, 0x98);
9621                                 break;
9622                         case 14:
9623                                 btdm_2AntSetFw3a(padapter, 0xe3, 0x12, 0x12, 0x20, 0x98);
9624                                 break;
9625                         case 15:
9626                                 btdm_2AntSetFw3a(padapter, 0xe3, 0xa, 0xa, 0x20, 0x98);
9627                                 break;
9628                         case 16:
9629                                 btdm_2AntSetFw3a(padapter, 0xe3, 0x5, 0x5, 0x20, 0x98);
9630                                 break;
9631                         case 17:
9632                                 btdm_2AntSetFw3a(padapter, 0xa3, 0x2f, 0x2f, 0x20, 0x80);
9633                                 break;
9634                         case 18:
9635                                 btdm_2AntSetFw3a(padapter, 0xe3, 0x5, 0x5, 0xa1, 0x98);
9636                                 break;
9637                         case 19:
9638                                 btdm_2AntSetFw3a(padapter, 0xe3, 0x25, 0x25, 0xa1, 0x98);
9639                                 break;
9640                         case 20:
9641                                 btdm_2AntSetFw3a(padapter, 0xe3, 0x25, 0x25, 0x20, 0x98);
9642                                 break;
9643                 }
9644                 }
9645                 else
9646                 {
9647                 // disable PS tdma
9648                 switch(type)
9649                 {
9650                         case 0:
9651                                 btdm_2AntSetFw3a(padapter, 0x0, 0x0, 0x0, 0x8, 0x0);
9652                                 break;
9653                         case 1:
9654                                 btdm_2AntSetFw3a(padapter, 0x0, 0x0, 0x0, 0x0, 0x0);
9655                                 break;
9656                         default:
9657                                 btdm_2AntSetFw3a(padapter, 0x0, 0x0, 0x0, 0x8, 0x0);
9658                                 break;
9659                 }
9660                 }
9661
9662         // update pre state
9663         pBtdm8723->bPrePsTdmaOn =  pBtdm8723->bCurPsTdmaOn;
9664         pBtdm8723->prePsTdma = pBtdm8723->curPsTdma;
9665         }
9666
9667
9668
9669 void btdm_2AntBtInquiryPage(PADAPTER    padapter)
9670 {
9671         btdm_2AntCoexTable(padapter, 0x55555555, 0xffff, 0x3);
9672         btdm_2AntIgnoreWlanAct(padapter, _FALSE);
9673         btdm_2AntPsTdma(padapter, _TRUE, 8);
9674 }
9675
9676
9677 u8 btdm_HoldForBtInqPage( PADAPTER      padapter)
9678         {
9679         PHAL_DATA_TYPE  pHalData = GET_HAL_DATA(padapter);
9680         u32                     curTime=rtw_get_current_time();
9681
9682         if(pHalData->bt_coexist.halCoex8723.bC2hBtInquiryPage)
9683         {
9684                 // bt inquiry or page is started.
9685                 if(pHalData->bt_coexist.halCoex8723.btInqPageStartTime == 0)
9686                 {
9687                         pHalData->bt_coexist.halCoex8723.btInqPageStartTime = curTime;
9688                         RTPRINT(FBT, BT_TRACE, ("[BTCoex], BT Inquiry/page is started at time : 0x%"i64fmt"x \n",
9689                         pHalData->bt_coexist.halCoex8723.btInqPageStartTime));
9690                 }
9691         }
9692         RTPRINT(FBT, BT_TRACE, ("[BTCoex], BT Inquiry/page started time : 0x%"i64fmt"x, curTime : 0x%x \n",
9693                 pHalData->bt_coexist.halCoex8723.btInqPageStartTime, curTime));
9694
9695         if(pHalData->bt_coexist.halCoex8723.btInqPageStartTime)
9696         {
9697                 if(( (curTime - pHalData->bt_coexist.halCoex8723.btInqPageStartTime)/1000000) >= 10)
9698                 {
9699                         RTPRINT(FBT, BT_TRACE, ("[BTCoex], BT Inquiry/page >= 10sec!!!"));
9700                         pHalData->bt_coexist.halCoex8723.btInqPageStartTime = 0;
9701                 }
9702                 }
9703
9704         if(pHalData->bt_coexist.halCoex8723.btInqPageStartTime)
9705                 {
9706                 btdm_2AntCoexTable(padapter, 0x55555555, 0xffff, 0x3);
9707                 btdm_2AntIgnoreWlanAct(padapter, _FALSE);
9708                 btdm_2AntPsTdma(padapter, _TRUE, 8);
9709                 return _TRUE;
9710                 }
9711                 else
9712                 return _FALSE;
9713                 }
9714
9715
9716 u8 btdm_Is2Ant8723ACommonAction(PADAPTER        padapter)
9717 {
9718         PHAL_DATA_TYPE  pHalData = GET_HAL_DATA(padapter);
9719         PBTDM_8723A_2ANT pBtdm8723 = &pHalData->bt_coexist.halCoex8723.btdm2Ant;
9720         u8                      bCommon=_FALSE;
9721
9722         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));
9723
9724
9725 //      if(!BTDM_IsWifiBusy(padapter) &&
9726         if((BTDM_IsWifiConnectionExist(padapter) == _FALSE)&&(check_fwstate(&padapter->mlmepriv, (_FW_UNDER_SURVEY|_FW_UNDER_LINKING))== _FALSE)&&
9727                 (BT_2ANT_BT_STATUS_IDLE == pBtdm8723->btStatus) )
9728         {
9729                 RTPRINT(FBT, BT_TRACE, ("Wifi idle + Bt idle!!\n"));
9730
9731                 btdm_2AntLowPenaltyRa(padapter, _FALSE);
9732                 btdm_2AntRfShrink(padapter, _FALSE);
9733                 btdm_2AntCoexTable(padapter, 0x55555555, 0xffff, 0x3);
9734
9735                 btdm_2AntIgnoreWlanAct(padapter, _FALSE);
9736                 btdm_2AntPsTdma(padapter, _FALSE, 0);
9737                 btdm_2AntFwDacSwingLvl(padapter, 0x20);
9738                 btdm_2AntDecBtPwr(padapter, _FALSE);
9739
9740                 btdm_2AntAgcTable(padapter, _FALSE);
9741                 btdm_2AntAdcBackOff(padapter, _FALSE);
9742                 btdm_2AntDacSwing(padapter, _FALSE, 0xc0);
9743
9744                 bCommon = _TRUE;
9745         }
9746 //      else if( BTDM_IsWifiBusy(padapter) &&
9747         else if(((BTDM_IsWifiConnectionExist(padapter) == _TRUE)||(check_fwstate(&padapter->mlmepriv, (_FW_UNDER_SURVEY|_FW_UNDER_LINKING))== _TRUE))&&
9748                         (BT_2ANT_BT_STATUS_IDLE == pBtdm8723->btStatus) )
9749         {
9750                 RTPRINT(FBT, BT_TRACE, ("Wifi non-idle + BT idle!!\n"));
9751
9752                 btdm_2AntLowPenaltyRa(padapter, _TRUE);
9753                 btdm_2AntRfShrink(padapter, _FALSE);
9754                 btdm_2AntCoexTable(padapter, 0x55555555, 0xffff, 0x3);
9755
9756                 btdm_2AntIgnoreWlanAct(padapter, _FALSE);
9757                 btdm_2AntPsTdma(padapter, _FALSE, 0);
9758                 btdm_2AntFwDacSwingLvl(padapter, 0x20);
9759                 btdm_2AntDecBtPwr(padapter, _TRUE);
9760
9761                 btdm_2AntAgcTable(padapter, _FALSE);
9762                 btdm_2AntAdcBackOff(padapter, _FALSE);
9763                 btdm_2AntDacSwing(padapter, _FALSE, 0xc0);
9764
9765                 bCommon = _TRUE;
9766 }
9767 //      else if(!BTDM_IsWifiBusy(padapter) &&
9768         else if((BTDM_IsWifiConnectionExist(padapter) == _FALSE)&&(check_fwstate(&padapter->mlmepriv, (_FW_UNDER_SURVEY|_FW_UNDER_LINKING))== _FALSE)&&
9769                 (BT_2ANT_BT_STATUS_CONNECTED_IDLE == pBtdm8723->btStatus) )
9770         {
9771                 RTPRINT(FBT, BT_TRACE, ("Wifi idle + Bt connected idle!!\n"));
9772
9773                 btdm_2AntLowPenaltyRa(padapter, _TRUE);
9774                 btdm_2AntRfShrink(padapter, _TRUE);
9775                 btdm_2AntCoexTable(padapter, 0x55555555, 0xffff, 0x3);
9776
9777                 btdm_2AntIgnoreWlanAct(padapter, _FALSE);
9778                 btdm_2AntPsTdma(padapter, _FALSE, 0);
9779                 btdm_2AntFwDacSwingLvl(padapter, 0x20);
9780                 btdm_2AntDecBtPwr(padapter, _FALSE);
9781
9782                 btdm_2AntAgcTable(padapter, _FALSE);
9783                 btdm_2AntAdcBackOff(padapter, _FALSE);
9784                 btdm_2AntDacSwing(padapter, _FALSE, 0xc0);
9785
9786                 bCommon = _TRUE;
9787         }
9788 //      else if(BTDM_IsWifiBusy(padapter) &&
9789         else if(((BTDM_IsWifiConnectionExist(padapter) == _TRUE)||(check_fwstate(&padapter->mlmepriv, (_FW_UNDER_SURVEY|_FW_UNDER_LINKING))== _TRUE))&&
9790                 (BT_2ANT_BT_STATUS_CONNECTED_IDLE == pBtdm8723->btStatus) )
9791 {
9792                 RTPRINT(FBT, BT_TRACE, ("Wifi non-idle + Bt connected idle!!\n"));
9793
9794                 btdm_2AntLowPenaltyRa(padapter, _TRUE);
9795                 btdm_2AntRfShrink(padapter, _TRUE);
9796                 btdm_2AntCoexTable(padapter, 0x55555555, 0xffff, 0x3);
9797
9798                 btdm_2AntIgnoreWlanAct(padapter, _FALSE);
9799                 btdm_2AntPsTdma(padapter, _FALSE, 0);
9800                 btdm_2AntFwDacSwingLvl(padapter, 0x20);
9801                 btdm_2AntDecBtPwr(padapter, _TRUE);
9802
9803                 btdm_2AntAgcTable(padapter, _FALSE);
9804                 btdm_2AntAdcBackOff(padapter, _FALSE);
9805                 btdm_2AntDacSwing(padapter, _FALSE, 0xc0);
9806
9807                 bCommon = _TRUE;
9808         }
9809 //      else if(!BTDM_IsWifiBusy(padapter) &&
9810         else if((BTDM_IsWifiConnectionExist(padapter) == _FALSE)&&(check_fwstate(&padapter->mlmepriv, (_FW_UNDER_SURVEY|_FW_UNDER_LINKING))== _FALSE)&&
9811                         (BT_2ANT_BT_STATUS_NON_IDLE == pBtdm8723->btStatus) )
9812         {
9813                 RTPRINT(FBT, BT_TRACE, ("Wifi idle + BT non-idle!!\n"));
9814
9815                 btdm_2AntLowPenaltyRa(padapter, _TRUE);
9816                 btdm_2AntRfShrink(padapter, _TRUE);
9817                 btdm_2AntCoexTable(padapter, 0x55555555, 0xffff, 0x3);
9818
9819                 btdm_2AntIgnoreWlanAct(padapter, _FALSE);
9820                 btdm_2AntPsTdma(padapter, _FALSE, 0);
9821                 btdm_2AntFwDacSwingLvl(padapter, 0x20);
9822                 btdm_2AntDecBtPwr(padapter, _FALSE);
9823
9824                 btdm_2AntAgcTable(padapter, _FALSE);
9825                 btdm_2AntAdcBackOff(padapter, _FALSE);
9826                 btdm_2AntDacSwing(padapter, _FALSE, 0xc0);
9827
9828                 bCommon = _TRUE;
9829         }
9830         else
9831         {
9832                 RTPRINT(FBT, BT_TRACE, ("Wifi non-idle + BT non-idle!!\n"));
9833                 btdm_2AntLowPenaltyRa(padapter, _TRUE);
9834                 btdm_2AntRfShrink(padapter, _TRUE);
9835                 btdm_2AntCoexTable(padapter, 0x55555555, 0xffff, 0x3);
9836                 btdm_2AntIgnoreWlanAct(padapter, _FALSE);
9837                 btdm_2AntFwDacSwingLvl(padapter, 0x20);
9838
9839                 bCommon = _FALSE;
9840         }
9841
9842         return bCommon;
9843 }
9844
9845
9846 void btdm_2AntTdmaDurationAdjust(PADAPTER        padapter,u8            bScoHid,u8      bTxPause,u8             maxInterval)
9847 {
9848         PHAL_DATA_TYPE  pHalData = GET_HAL_DATA(padapter);
9849         PBT_MGNT                pBtMgnt = &pHalData->BtInfo.BtMgnt;
9850         PBTDM_8723A_2ANT pBtdm8723 = &pHalData->bt_coexist.halCoex8723.btdm2Ant;
9851         static s32              up,dn,m,n,WaitCount;
9852         s32                     result;   //0: no change, +1: increase WiFi duration, -1: decrease WiFi duration
9853         u8                      retryCount=0;
9854 //      u8                      BtState;
9855
9856 //      BtState = pHalData->bt_coexist.halCoex8723.c2hBtInfo;
9857
9858         RTPRINT(FBT, BT_TRACE, ("[BTCoex], TdmaDurationAdjust()\n"));
9859
9860         if(pBtdm8723->bResetTdmaAdjust)
9861         {
9862                 pBtdm8723->bResetTdmaAdjust = _FALSE;
9863                 RTPRINT(FBT, BT_TRACE, ("[BTCoex], first run TdmaDurationAdjust()!!\n"));
9864                 {
9865                         if(bScoHid)
9866                         {
9867                                 if(bTxPause)
9868                                 {
9869                                         if(maxInterval == 1)
9870                                         {
9871                                                 btdm_2AntPsTdma(padapter, _TRUE, 15);
9872                                                 pBtdm8723->psTdmaDuAdjType = 15;
9873 }
9874                                         else if(maxInterval == 2)
9875 {
9876                                                 btdm_2AntPsTdma(padapter, _TRUE, 15);
9877                                                 pBtdm8723->psTdmaDuAdjType = 15;
9878                                         }
9879                                         else if(maxInterval == 3)
9880         {
9881                                                 btdm_2AntPsTdma(padapter, _TRUE, 15);
9882                                                 pBtdm8723->psTdmaDuAdjType = 15;
9883         }
9884         else
9885         {
9886                                                 btdm_2AntPsTdma(padapter, _TRUE, 15);
9887                                                 pBtdm8723->psTdmaDuAdjType = 15;
9888         }
9889 }
9890                                 else
9891 {
9892                                         if(maxInterval == 1)
9893         {
9894                                                 btdm_2AntPsTdma(padapter, _TRUE, 11);
9895                                                 pBtdm8723->psTdmaDuAdjType = 11;
9896                                         }
9897                                         else if(maxInterval == 2)
9898                 {
9899                                                 btdm_2AntPsTdma(padapter, _TRUE, 11);
9900                                                 pBtdm8723->psTdmaDuAdjType = 11;
9901                 }
9902                                         else if(maxInterval == 3)
9903                 {
9904                                                 btdm_2AntPsTdma(padapter, _TRUE, 11);
9905                                                 pBtdm8723->psTdmaDuAdjType = 11;
9906                                         }
9907                                         else
9908                         {
9909                                                 btdm_2AntPsTdma(padapter, _TRUE, 11);
9910                                                 pBtdm8723->psTdmaDuAdjType = 11;
9911                         }
9912                 }
9913         }
9914         else
9915         {
9916                                 if(bTxPause)
9917                 {
9918                                         if(maxInterval == 1)
9919                                         {
9920                                                 btdm_2AntPsTdma(padapter, _TRUE, 7);
9921                                                 pBtdm8723->psTdmaDuAdjType = 7;
9922                 }
9923                                         else if(maxInterval == 2)
9924                 {
9925                                                 btdm_2AntPsTdma(padapter, _TRUE, 7);
9926                                                 pBtdm8723->psTdmaDuAdjType = 7;
9927                                         }
9928                                         else if(maxInterval == 3)
9929                         {
9930                                                 btdm_2AntPsTdma(padapter, _TRUE, 7);
9931                                                 pBtdm8723->psTdmaDuAdjType = 7;
9932                         }
9933                                         else
9934                                         {
9935                                                 btdm_2AntPsTdma(padapter, _TRUE, 7);
9936                                                 pBtdm8723->psTdmaDuAdjType = 7;
9937                 }
9938         }
9939                                 else
9940         {
9941                                         if(maxInterval == 1)
9942                                         {
9943                                                 btdm_2AntPsTdma(padapter, _TRUE, 3);
9944                                                 pBtdm8723->psTdmaDuAdjType = 3;
9945                                         }
9946                                         else if(maxInterval == 2)
9947                                         {
9948                                                 btdm_2AntPsTdma(padapter, _TRUE, 3);
9949                                                 pBtdm8723->psTdmaDuAdjType = 3;
9950                                         }
9951                                         else if(maxInterval == 3)
9952                                         {
9953                                                 btdm_2AntPsTdma(padapter, _TRUE, 3);
9954                                                 pBtdm8723->psTdmaDuAdjType = 3;
9955         }
9956         else
9957         {
9958                                                 btdm_2AntPsTdma(padapter, _TRUE, 3);
9959                                                 pBtdm8723->psTdmaDuAdjType = 3;
9960         }
9961 }
9962                         }
9963                 }
9964                 //============
9965                 up = 0;
9966                 dn = 0;
9967                 m = 1;
9968                 n= 3;
9969                 result = 0;
9970                 WaitCount = 0;
9971         }
9972         else
9973         {
9974                 //accquire the BT TRx retry count from BT_Info byte2
9975                 retryCount = pHalData->bt_coexist.halCoex8723.btRetryCnt;
9976                 RTPRINT(FBT, BT_TRACE, ("[BTCoex], retryCount = %d\n", retryCount));
9977                 result = 0;
9978                 WaitCount++;
9979
9980                 if(retryCount == 0)  // no retry in the last 2-second duration
9981 {
9982                         up++;
9983                         dn--;
9984
9985                         if (dn <= 0)
9986                                 dn = 0;
9987
9988                         if(up >= n)     // if ³sÄò n Ó2¬í retry count¬°0, «h½Õ¼eWiFi duration
9989 {
9990                                 WaitCount = 0;
9991                                 n = 3;
9992                                 up = 0;
9993                                 dn = 0;
9994                                 result = 1;
9995                                 RTPRINT(FBT, BT_TRACE, ("[BTCoex], Increase wifi duration!!\n"));
9996 }
9997                 }
9998                 else if (retryCount <= 3)       // <=3 retry in the last 2-second duration
9999 {
10000                         up--;
10001                         dn++;
10002
10003                         if (up <= 0)
10004                                 up = 0;
10005
10006                         if (dn == 2)    // if ³sÄò 2 Ó2¬í retry count< 3, «h½Õ¯¶WiFi duration
10007         {
10008                                 if (WaitCount <= 2)
10009                                         m++; // Á×§K¤@ª½¦b¨âÓlevel¤¤¨Ó¦^
10010         else
10011                                         m = 1;
10012
10013                                 if ( m >= 20) //m ³Ì¤jÈ = 20 ' ³Ì¤j120¬í recheck¬O§_½Õ¾ã WiFi duration.
10014                                         m = 20;
10015
10016                                 n = 3*m;
10017                                 up = 0;
10018                                 dn = 0;
10019                                 WaitCount = 0;
10020                                 result = -1;
10021                                 RTPRINT(FBT, BT_TRACE, ("[BTCoex], Decrease wifi duration for retryCounter<3!!\n"));
10022         }
10023 }
10024                 else  //retry count > 3, ¥un1¦¸ retry count > 3, «h½Õ¯¶WiFi duration
10025 {
10026                         if (WaitCount == 1)
10027                                 m++; // Á×§K¤@ª½¦b¨âÓlevel¤¤¨Ó¦^
10028                         else
10029                                 m = 1;
10030
10031                         if ( m >= 20) //m ³Ì¤jÈ = 20 ' ³Ì¤j120¬í recheck¬O§_½Õ¾ã WiFi duration.
10032                                 m = 20;
10033
10034                         n = 3*m;
10035                         up = 0;
10036                         dn = 0;
10037                         WaitCount = 0;
10038                         result = -1;
10039                         RTPRINT(FBT, BT_TRACE, ("[BTCoex], Decrease wifi duration for retryCounter>3!!\n"));
10040                 }
10041
10042                 RTPRINT(FBT, BT_TRACE, ("[BTCoex], max Interval = %d\n", maxInterval));
10043                 if(maxInterval == 1)
10044                 {
10045                         if(bTxPause)
10046         {
10047                                 RTPRINT(FBT, BT_TRACE, ("[BTCoex], TxPause = 1\n"));
10048                                 if(pBtdm8723->curPsTdma == 1)
10049                                 {
10050                                         btdm_2AntPsTdma(padapter, _TRUE, 5);
10051                                         pBtdm8723->psTdmaDuAdjType = 5;
10052         }
10053                                 else if(pBtdm8723->curPsTdma == 2)
10054         {
10055                                         btdm_2AntPsTdma(padapter, _TRUE, 6);
10056                                         pBtdm8723->psTdmaDuAdjType = 6;
10057         }
10058                                 else if(pBtdm8723->curPsTdma == 3)
10059         {
10060                                         btdm_2AntPsTdma(padapter, _TRUE, 7);
10061                                         pBtdm8723->psTdmaDuAdjType = 7;
10062         }
10063                                 else if(pBtdm8723->curPsTdma == 4)
10064         {
10065                                         btdm_2AntPsTdma(padapter, _TRUE, 8);
10066                                         pBtdm8723->psTdmaDuAdjType = 8;
10067         }
10068                                 if(pBtdm8723->curPsTdma == 9)
10069                                 {
10070                                         btdm_2AntPsTdma(padapter, _TRUE, 13);
10071                                         pBtdm8723->psTdmaDuAdjType = 13;
10072 }
10073                                 else if(pBtdm8723->curPsTdma == 10)
10074 {
10075                                         btdm_2AntPsTdma(padapter, _TRUE, 14);
10076                                         pBtdm8723->psTdmaDuAdjType = 14;
10077 }
10078                                 else if(pBtdm8723->curPsTdma == 11)
10079 {
10080                                         btdm_2AntPsTdma(padapter, _TRUE, 15);
10081                                         pBtdm8723->psTdmaDuAdjType = 15;
10082                                 }
10083                                 else if(pBtdm8723->curPsTdma == 12)
10084                                 {
10085                                         btdm_2AntPsTdma(padapter, _TRUE, 16);
10086                                         pBtdm8723->psTdmaDuAdjType = 16;
10087                                 }
10088
10089                                 if(result == -1)
10090         {
10091                                         if(pBtdm8723->curPsTdma == 5)
10092                                         {
10093                                                 btdm_2AntPsTdma(padapter, _TRUE, 6);
10094                                                 pBtdm8723->psTdmaDuAdjType = 6;
10095         }
10096                                         else if(pBtdm8723->curPsTdma == 6)
10097         {
10098                                                 btdm_2AntPsTdma(padapter, _TRUE, 7);
10099                                                 pBtdm8723->psTdmaDuAdjType = 7;
10100                                         }
10101                                         else if(pBtdm8723->curPsTdma == 7)
10102                 {
10103                                                 btdm_2AntPsTdma(padapter, _TRUE, 8);
10104                                                 pBtdm8723->psTdmaDuAdjType = 8;
10105                 }
10106                                         else if(pBtdm8723->curPsTdma == 13)
10107                 {
10108                                                 btdm_2AntPsTdma(padapter, _TRUE, 14);
10109                                                 pBtdm8723->psTdmaDuAdjType = 14;
10110                 }
10111                                         else if(pBtdm8723->curPsTdma == 14)
10112                                         {
10113                                                 btdm_2AntPsTdma(padapter, _TRUE, 15);
10114                                                 pBtdm8723->psTdmaDuAdjType = 15;
10115         }
10116                                         else if(pBtdm8723->curPsTdma == 15)
10117         {
10118                                                 btdm_2AntPsTdma(padapter, _TRUE, 16);
10119                                                 pBtdm8723->psTdmaDuAdjType = 16;
10120         }
10121                                 }
10122                                 else if (result == 1)
10123         {
10124                                         if(pBtdm8723->curPsTdma == 8)
10125                                         {
10126                                                 btdm_2AntPsTdma(padapter, _TRUE, 7);
10127                                                 pBtdm8723->psTdmaDuAdjType = 7;
10128         }
10129                                         else if(pBtdm8723->curPsTdma == 7)
10130                                         {
10131                                                 btdm_2AntPsTdma(padapter, _TRUE, 6);
10132                                                 pBtdm8723->psTdmaDuAdjType = 6;
10133 }
10134                                         else if(pBtdm8723->curPsTdma == 6)
10135 {
10136                                                 btdm_2AntPsTdma(padapter, _TRUE, 5);
10137                                                 pBtdm8723->psTdmaDuAdjType = 5;
10138                                         }
10139                                         else if(pBtdm8723->curPsTdma == 16)
10140         {
10141                                                 btdm_2AntPsTdma(padapter, _TRUE, 15);
10142                                                 pBtdm8723->psTdmaDuAdjType = 15;
10143         }
10144                                         else if(pBtdm8723->curPsTdma == 15)
10145         {
10146                                                 btdm_2AntPsTdma(padapter, _TRUE, 14);
10147                                                 pBtdm8723->psTdmaDuAdjType = 14;
10148                                         }
10149                                         else if(pBtdm8723->curPsTdma == 14)
10150                 {
10151                                                 btdm_2AntPsTdma(padapter, _TRUE, 13);
10152                                                 pBtdm8723->psTdmaDuAdjType = 13;
10153                                         }
10154                                 }
10155                 }
10156                 else
10157                 {
10158                                 RTPRINT(FBT, BT_TRACE, ("[BTCoex], TxPause = 0\n"));
10159                                 if(pBtdm8723->curPsTdma == 5)
10160                                 {
10161                                         btdm_2AntPsTdma(padapter, _TRUE, 1);
10162                                         pBtdm8723->psTdmaDuAdjType = 1;
10163                 }
10164                                 else if(pBtdm8723->curPsTdma == 6)
10165                                 {
10166                                         btdm_2AntPsTdma(padapter, _TRUE, 2);
10167                                         pBtdm8723->psTdmaDuAdjType = 2;
10168         }
10169                                 else if(pBtdm8723->curPsTdma == 7)
10170         {
10171                                         btdm_2AntPsTdma(padapter, _TRUE, 3);
10172                                         pBtdm8723->psTdmaDuAdjType = 3;
10173         }
10174                                 else if(pBtdm8723->curPsTdma == 8)
10175         {
10176                                         btdm_2AntPsTdma(padapter, _TRUE, 4);
10177                                         pBtdm8723->psTdmaDuAdjType = 4;
10178         }
10179                                 if(pBtdm8723->curPsTdma == 13)
10180                                 {
10181                                         btdm_2AntPsTdma(padapter, _TRUE, 9);
10182                                         pBtdm8723->psTdmaDuAdjType = 9;
10183 }
10184                                 else if(pBtdm8723->curPsTdma == 14)
10185 {
10186                                         btdm_2AntPsTdma(padapter, _TRUE, 10);
10187                                         pBtdm8723->psTdmaDuAdjType = 10;
10188                                 }
10189                                 else if(pBtdm8723->curPsTdma == 15)
10190                                 {
10191                                         btdm_2AntPsTdma(padapter, _TRUE, 11);
10192                                         pBtdm8723->psTdmaDuAdjType = 11;
10193                                 }
10194                                 else if(pBtdm8723->curPsTdma == 16)
10195                                 {
10196                                         btdm_2AntPsTdma(padapter, _TRUE, 12);
10197                                         pBtdm8723->psTdmaDuAdjType = 12;
10198                                 }
10199
10200                                 if(result == -1)
10201         {
10202                                         if(pBtdm8723->curPsTdma == 1)
10203                 {
10204                                                 btdm_2AntPsTdma(padapter, _TRUE, 2);
10205                                                 pBtdm8723->psTdmaDuAdjType = 2;
10206                                         }
10207                                         else if(pBtdm8723->curPsTdma == 2)
10208                         {
10209                                                 btdm_2AntPsTdma(padapter, _TRUE, 3);
10210                                                 pBtdm8723->psTdmaDuAdjType = 3;
10211                         }
10212                                         else if(pBtdm8723->curPsTdma == 3)
10213                         {
10214                                                 btdm_2AntPsTdma(padapter, _TRUE, 4);
10215                                                 pBtdm8723->psTdmaDuAdjType = 4;
10216                         }
10217                                         else if(pBtdm8723->curPsTdma == 9)
10218                                         {
10219                                                 btdm_2AntPsTdma(padapter, _TRUE, 10);
10220                                                 pBtdm8723->psTdmaDuAdjType = 10;
10221                 }
10222                                         else if(pBtdm8723->curPsTdma == 10)
10223                 {
10224                                                 btdm_2AntPsTdma(padapter, _TRUE, 11);
10225                                                 pBtdm8723->psTdmaDuAdjType = 11;
10226                                         }
10227                                         else if(pBtdm8723->curPsTdma == 11)
10228                         {
10229                                                 btdm_2AntPsTdma(padapter, _TRUE, 12);
10230                                                 pBtdm8723->psTdmaDuAdjType = 12;
10231                         }
10232                                 }
10233                                 else if (result == 1)
10234                                 {
10235                                         if(pBtdm8723->curPsTdma == 4)
10236                         {
10237                                                 btdm_2AntPsTdma(padapter, _TRUE, 3);
10238                                                 pBtdm8723->psTdmaDuAdjType = 3;
10239                         }
10240                                         else if(pBtdm8723->curPsTdma == 3)
10241                                         {
10242                                                 btdm_2AntPsTdma(padapter, _TRUE, 2);
10243                                                 pBtdm8723->psTdmaDuAdjType = 2;
10244                 }
10245                                         else if(pBtdm8723->curPsTdma == 2)
10246                                         {
10247                                                 btdm_2AntPsTdma(padapter, _TRUE, 1);
10248                                                 pBtdm8723->psTdmaDuAdjType = 1;
10249         }
10250                                         else if(pBtdm8723->curPsTdma == 12)
10251         {
10252                                                 btdm_2AntPsTdma(padapter, _TRUE, 11);
10253                                                 pBtdm8723->psTdmaDuAdjType = 11;
10254                                         }
10255                                         else if(pBtdm8723->curPsTdma == 11)
10256                 {
10257                                                 btdm_2AntPsTdma(padapter, _TRUE, 10);
10258                                                 pBtdm8723->psTdmaDuAdjType = 10;
10259                                         }
10260                                         else if(pBtdm8723->curPsTdma == 10)
10261                         {
10262                                                 btdm_2AntPsTdma(padapter, _TRUE, 9);
10263                                                 pBtdm8723->psTdmaDuAdjType = 9;
10264                         }
10265                                 }
10266                         }
10267                 }
10268                 else if(maxInterval == 2)
10269                         {
10270                         if(bTxPause)
10271                         {
10272                                 RTPRINT(FBT, BT_TRACE, ("[BTCoex], TxPause = 1\n"));
10273                                 if(pBtdm8723->curPsTdma == 1)
10274                                 {
10275                                         btdm_2AntPsTdma(padapter, _TRUE, 6);
10276                                         pBtdm8723->psTdmaDuAdjType = 6;
10277                         }
10278                                 else if(pBtdm8723->curPsTdma == 2)
10279                         {
10280                                         btdm_2AntPsTdma(padapter, _TRUE, 6);
10281                                         pBtdm8723->psTdmaDuAdjType = 6;
10282                         }
10283                                 else if(pBtdm8723->curPsTdma == 3)
10284                         {
10285                                         btdm_2AntPsTdma(padapter, _TRUE, 7);
10286                                         pBtdm8723->psTdmaDuAdjType = 7;
10287                         }
10288                                 else if(pBtdm8723->curPsTdma == 4)
10289                                 {
10290                                         btdm_2AntPsTdma(padapter, _TRUE, 8);
10291                                         pBtdm8723->psTdmaDuAdjType = 8;
10292                 }
10293                                 if(pBtdm8723->curPsTdma == 9)
10294                 {
10295                                         btdm_2AntPsTdma(padapter, _TRUE, 14);
10296                                         pBtdm8723->psTdmaDuAdjType = 14;
10297                                 }
10298                                 else if(pBtdm8723->curPsTdma == 10)
10299                         {
10300                                         btdm_2AntPsTdma(padapter, _TRUE, 14);
10301                                         pBtdm8723->psTdmaDuAdjType = 14;
10302                                 }
10303                                 else if(pBtdm8723->curPsTdma == 11)
10304                                 {
10305                                         btdm_2AntPsTdma(padapter, _TRUE, 15);
10306                                         pBtdm8723->psTdmaDuAdjType = 15;
10307                                 }
10308                                 else if(pBtdm8723->curPsTdma == 12)
10309                                 {
10310                                         btdm_2AntPsTdma(padapter, _TRUE, 16);
10311                                         pBtdm8723->psTdmaDuAdjType = 16;
10312                                 }
10313                                 if(result == -1)
10314                                 {
10315                                         if(pBtdm8723->curPsTdma == 5)
10316                                         {
10317                                                 btdm_2AntPsTdma(padapter, _TRUE, 6);
10318                                                 pBtdm8723->psTdmaDuAdjType = 6;
10319                                         }
10320                                         else if(pBtdm8723->curPsTdma == 6)
10321                                         {
10322                                                 btdm_2AntPsTdma(padapter, _TRUE, 7);
10323                                                 pBtdm8723->psTdmaDuAdjType = 7;
10324                                         }
10325                                         else if(pBtdm8723->curPsTdma == 7)
10326                                         {
10327                                                 btdm_2AntPsTdma(padapter, _TRUE, 8);
10328                                                 pBtdm8723->psTdmaDuAdjType = 8;
10329                                         }
10330                                         else if(pBtdm8723->curPsTdma == 13)
10331                                         {
10332                                                 btdm_2AntPsTdma(padapter, _TRUE, 14);
10333                                                 pBtdm8723->psTdmaDuAdjType = 14;
10334                                         }
10335                                         else if(pBtdm8723->curPsTdma == 14)
10336                                         {
10337                                                 btdm_2AntPsTdma(padapter, _TRUE, 15);
10338                                                 pBtdm8723->psTdmaDuAdjType = 15;
10339                                         }
10340                                         else if(pBtdm8723->curPsTdma == 15)
10341                                         {
10342                                                 btdm_2AntPsTdma(padapter, _TRUE, 16);
10343                                                 pBtdm8723->psTdmaDuAdjType = 16;
10344                                         }
10345                                 }
10346                                 else if (result == 1)
10347                                 {
10348                                         if(pBtdm8723->curPsTdma == 8)
10349                                         {
10350                                                 btdm_2AntPsTdma(padapter, _TRUE, 7);
10351                                                 pBtdm8723->psTdmaDuAdjType = 7;
10352                                         }
10353                                         else if(pBtdm8723->curPsTdma == 7)
10354                                         {
10355                                                 btdm_2AntPsTdma(padapter, _TRUE, 6);
10356                                                 pBtdm8723->psTdmaDuAdjType = 6;
10357                                         }
10358                                         else if(pBtdm8723->curPsTdma == 6)
10359                                         {
10360                                                 btdm_2AntPsTdma(padapter, _TRUE, 6);
10361                                                 pBtdm8723->psTdmaDuAdjType = 6;
10362                                         }
10363                                         else if(pBtdm8723->curPsTdma == 16)
10364                                         {
10365                                                 btdm_2AntPsTdma(padapter, _TRUE, 15);
10366                                                 pBtdm8723->psTdmaDuAdjType = 15;
10367                                         }
10368                                         else if(pBtdm8723->curPsTdma == 15)
10369                                         {
10370                                                 btdm_2AntPsTdma(padapter, _TRUE, 14);
10371                                                 pBtdm8723->psTdmaDuAdjType = 14;
10372                                         }
10373                                         else if(pBtdm8723->curPsTdma == 14)
10374                                         {
10375                                                 btdm_2AntPsTdma(padapter, _TRUE, 14);
10376                                                 pBtdm8723->psTdmaDuAdjType = 14;
10377                                         }
10378                                 }
10379                         }
10380                         else
10381                         {
10382                                 RTPRINT(FBT, BT_TRACE, ("[BTCoex], TxPause = 0\n"));
10383                                 if(pBtdm8723->curPsTdma == 5)
10384                                 {
10385                                         btdm_2AntPsTdma(padapter, _TRUE, 2);
10386                                         pBtdm8723->psTdmaDuAdjType = 2;
10387                         }
10388                                 else if(pBtdm8723->curPsTdma == 6)
10389                                 {
10390                                         btdm_2AntPsTdma(padapter, _TRUE, 2);
10391                                         pBtdm8723->psTdmaDuAdjType = 2;
10392                                 }
10393                                 else if(pBtdm8723->curPsTdma == 7)
10394                                 {
10395                                         btdm_2AntPsTdma(padapter, _TRUE, 3);
10396                                         pBtdm8723->psTdmaDuAdjType = 3;
10397                                 }
10398                                 else if(pBtdm8723->curPsTdma == 8)
10399                                 {
10400                                         btdm_2AntPsTdma(padapter, _TRUE, 4);
10401                                         pBtdm8723->psTdmaDuAdjType = 4;
10402                                 }
10403                                 if(pBtdm8723->curPsTdma == 13)
10404                                 {
10405                                         btdm_2AntPsTdma(padapter, _TRUE, 10);
10406                                         pBtdm8723->psTdmaDuAdjType = 10;
10407                                 }
10408                                 else if(pBtdm8723->curPsTdma == 14)
10409                                 {
10410                                         btdm_2AntPsTdma(padapter, _TRUE, 10);
10411                                         pBtdm8723->psTdmaDuAdjType = 10;
10412                                 }
10413                                 else if(pBtdm8723->curPsTdma == 15)
10414                                 {
10415                                         btdm_2AntPsTdma(padapter, _TRUE, 11);
10416                                         pBtdm8723->psTdmaDuAdjType = 11;
10417                                 }
10418                                 else if(pBtdm8723->curPsTdma == 16)
10419                                 {
10420                                         btdm_2AntPsTdma(padapter, _TRUE, 12);
10421                                         pBtdm8723->psTdmaDuAdjType = 12;
10422                                 }
10423                                 if(result == -1)
10424                                 {
10425                                         if(pBtdm8723->curPsTdma == 1)
10426                                         {
10427                                                 btdm_2AntPsTdma(padapter, _TRUE, 2);
10428                                                 pBtdm8723->psTdmaDuAdjType = 2;
10429                                         }
10430                                         else if(pBtdm8723->curPsTdma == 2)
10431                                         {
10432                                                 btdm_2AntPsTdma(padapter, _TRUE, 3);
10433                                                 pBtdm8723->psTdmaDuAdjType = 3;
10434                                         }
10435                                         else if(pBtdm8723->curPsTdma == 3)
10436                                         {
10437                                                 btdm_2AntPsTdma(padapter, _TRUE, 4);
10438                                                 pBtdm8723->psTdmaDuAdjType = 4;
10439                                         }
10440                                         else if(pBtdm8723->curPsTdma == 9)
10441                                         {
10442                                                 btdm_2AntPsTdma(padapter, _TRUE, 10);
10443                                                 pBtdm8723->psTdmaDuAdjType = 10;
10444                                         }
10445                                         else if(pBtdm8723->curPsTdma == 10)
10446                                         {
10447                                                 btdm_2AntPsTdma(padapter, _TRUE, 11);
10448                                                 pBtdm8723->psTdmaDuAdjType = 11;
10449                                         }
10450                                         else if(pBtdm8723->curPsTdma == 11)
10451                                         {
10452                                                 btdm_2AntPsTdma(padapter, _TRUE, 12);
10453                                                 pBtdm8723->psTdmaDuAdjType = 12;
10454                                         }
10455                                 }
10456                                 else if (result == 1)
10457                                 {
10458                                         if(pBtdm8723->curPsTdma == 4)
10459                                         {
10460                                                 btdm_2AntPsTdma(padapter, _TRUE, 3);
10461                                                 pBtdm8723->psTdmaDuAdjType = 3;
10462                                         }
10463                                         else if(pBtdm8723->curPsTdma == 3)
10464                                         {
10465                                                 btdm_2AntPsTdma(padapter, _TRUE, 2);
10466                                                 pBtdm8723->psTdmaDuAdjType = 2;
10467                                         }
10468                                         else if(pBtdm8723->curPsTdma == 2)
10469                                         {
10470                                                 btdm_2AntPsTdma(padapter, _TRUE, 2);
10471                                                 pBtdm8723->psTdmaDuAdjType = 2;
10472                                         }
10473                                         else if(pBtdm8723->curPsTdma == 12)
10474                                         {
10475                                                 btdm_2AntPsTdma(padapter, _TRUE, 11);
10476                                                 pBtdm8723->psTdmaDuAdjType = 11;
10477                                         }
10478                                         else if(pBtdm8723->curPsTdma == 11)
10479                                         {
10480                                                 btdm_2AntPsTdma(padapter, _TRUE, 10);
10481                                                 pBtdm8723->psTdmaDuAdjType = 10;
10482                                         }
10483                                         else if(pBtdm8723->curPsTdma == 10)
10484                                         {
10485                                                 btdm_2AntPsTdma(padapter, _TRUE, 10);
10486                                                 pBtdm8723->psTdmaDuAdjType = 10;
10487                                         }
10488                                 }
10489                         }
10490                 }
10491                 else if(maxInterval == 3)
10492                 {
10493                         if(bTxPause)
10494                         {
10495                                 RTPRINT(FBT, BT_TRACE, ("[BTCoex], TxPause = 1\n"));
10496                                 if(pBtdm8723->curPsTdma == 1)
10497                                 {
10498                                         btdm_2AntPsTdma(padapter, _TRUE, 7);
10499                                         pBtdm8723->psTdmaDuAdjType = 7;
10500                                 }
10501                                 else if(pBtdm8723->curPsTdma == 2)
10502                                 {
10503                                         btdm_2AntPsTdma(padapter, _TRUE, 7);
10504                                         pBtdm8723->psTdmaDuAdjType = 7;
10505                                 }
10506                                 else if(pBtdm8723->curPsTdma == 3)
10507                                 {
10508                                         btdm_2AntPsTdma(padapter, _TRUE, 7);
10509                                         pBtdm8723->psTdmaDuAdjType = 7;
10510                                 }
10511                                 else if(pBtdm8723->curPsTdma == 4)
10512                                 {
10513                                         btdm_2AntPsTdma(padapter, _TRUE, 8);
10514                                         pBtdm8723->psTdmaDuAdjType = 8;
10515                                 }
10516                                 if(pBtdm8723->curPsTdma == 9)
10517                                 {
10518                                         btdm_2AntPsTdma(padapter, _TRUE, 15);
10519                                         pBtdm8723->psTdmaDuAdjType = 15;
10520                                 }
10521                                 else if(pBtdm8723->curPsTdma == 10)
10522                                 {
10523                                         btdm_2AntPsTdma(padapter, _TRUE, 15);
10524                                         pBtdm8723->psTdmaDuAdjType = 15;
10525                                 }
10526                                 else if(pBtdm8723->curPsTdma == 11)
10527                                 {
10528                                         btdm_2AntPsTdma(padapter, _TRUE, 15);
10529                                         pBtdm8723->psTdmaDuAdjType = 15;
10530                                 }
10531                                 else if(pBtdm8723->curPsTdma == 12)
10532                                 {
10533                                         btdm_2AntPsTdma(padapter, _TRUE, 16);
10534                                         pBtdm8723->psTdmaDuAdjType = 16;
10535                                 }
10536                                 if(result == -1)
10537                                 {
10538                                         if(pBtdm8723->curPsTdma == 5)
10539                                         {
10540                                                 btdm_2AntPsTdma(padapter, _TRUE, 7);
10541                                                 pBtdm8723->psTdmaDuAdjType = 7;
10542                                         }
10543                                         else if(pBtdm8723->curPsTdma == 6)
10544                                         {
10545                                                 btdm_2AntPsTdma(padapter, _TRUE, 7);
10546                                                 pBtdm8723->psTdmaDuAdjType = 7;
10547                                         }
10548                                         else if(pBtdm8723->curPsTdma == 7)
10549                                         {
10550                                                 btdm_2AntPsTdma(padapter, _TRUE, 8);
10551                                                 pBtdm8723->psTdmaDuAdjType = 8;
10552                                         }
10553                                         else if(pBtdm8723->curPsTdma == 13)
10554                                         {
10555                                                 btdm_2AntPsTdma(padapter, _TRUE, 15);
10556                                                 pBtdm8723->psTdmaDuAdjType = 15;
10557                                         }
10558                                         else if(pBtdm8723->curPsTdma == 14)
10559                                         {
10560                                                 btdm_2AntPsTdma(padapter, _TRUE, 15);
10561                                                 pBtdm8723->psTdmaDuAdjType = 15;
10562                                         }
10563                                         else if(pBtdm8723->curPsTdma == 15)
10564                                         {
10565                                                 btdm_2AntPsTdma(padapter, _TRUE, 16);
10566                                                 pBtdm8723->psTdmaDuAdjType = 16;
10567                                         }
10568                                 }
10569                                 else if (result == 1)
10570                                 {
10571                                         if(pBtdm8723->curPsTdma == 8)
10572                         {
10573                                                 btdm_2AntPsTdma(padapter, _TRUE, 7);
10574                                                 pBtdm8723->psTdmaDuAdjType = 7;
10575                                         }
10576                                         else if(pBtdm8723->curPsTdma == 7)
10577                                         {
10578                                                 btdm_2AntPsTdma(padapter, _TRUE, 7);
10579                                                 pBtdm8723->psTdmaDuAdjType = 7;
10580                                         }
10581                                         else if(pBtdm8723->curPsTdma == 6)
10582                                         {
10583                                                 btdm_2AntPsTdma(padapter, _TRUE, 7);
10584                                                 pBtdm8723->psTdmaDuAdjType = 7;
10585                                         }
10586                                         else if(pBtdm8723->curPsTdma == 16)
10587                                         {
10588                                                 btdm_2AntPsTdma(padapter, _TRUE, 15);
10589                                                 pBtdm8723->psTdmaDuAdjType = 15;
10590                                         }
10591                                         else if(pBtdm8723->curPsTdma == 15)
10592                                         {
10593                                                 btdm_2AntPsTdma(padapter, _TRUE, 15);
10594                                                 pBtdm8723->psTdmaDuAdjType = 15;
10595                                         }
10596                                         else if(pBtdm8723->curPsTdma == 14)
10597                                         {
10598                                                 btdm_2AntPsTdma(padapter, _TRUE, 15);
10599                                                 pBtdm8723->psTdmaDuAdjType = 15;
10600                                         }
10601                                 }
10602                         }
10603                         else
10604                         {
10605                                 RTPRINT(FBT, BT_TRACE, ("[BTCoex], TxPause = 0\n"));
10606                                 if(pBtdm8723->curPsTdma == 5)
10607                                 {
10608                                         btdm_2AntPsTdma(padapter, _TRUE, 3);
10609                                         pBtdm8723->psTdmaDuAdjType = 3;
10610                         }
10611                                 else if(pBtdm8723->curPsTdma == 6)
10612                                 {
10613                                         btdm_2AntPsTdma(padapter, _TRUE, 3);
10614                                         pBtdm8723->psTdmaDuAdjType = 3;
10615                 }
10616                                 else if(pBtdm8723->curPsTdma == 7)
10617                                 {
10618                                         btdm_2AntPsTdma(padapter, _TRUE, 3);
10619                                         pBtdm8723->psTdmaDuAdjType = 3;
10620         }
10621                                 else if(pBtdm8723->curPsTdma == 8)
10622                                 {
10623                                         btdm_2AntPsTdma(padapter, _TRUE, 4);
10624                                         pBtdm8723->psTdmaDuAdjType = 4;
10625                                 }
10626                                 if(pBtdm8723->curPsTdma == 13)
10627                                 {
10628                                         btdm_2AntPsTdma(padapter, _TRUE, 11);
10629                                         pBtdm8723->psTdmaDuAdjType = 11;
10630                                 }
10631                                 else if(pBtdm8723->curPsTdma == 14)
10632                                 {
10633                                         btdm_2AntPsTdma(padapter, _TRUE, 11);
10634                                         pBtdm8723->psTdmaDuAdjType = 11;
10635                                 }
10636                                 else if(pBtdm8723->curPsTdma == 15)
10637                                 {
10638                                         btdm_2AntPsTdma(padapter, _TRUE, 11);
10639                                         pBtdm8723->psTdmaDuAdjType = 11;
10640                                 }
10641                                 else if(pBtdm8723->curPsTdma == 16)
10642         {
10643                                         btdm_2AntPsTdma(padapter, _TRUE, 12);
10644                                         pBtdm8723->psTdmaDuAdjType = 12;
10645                                 }
10646                                 if(result == -1)
10647                                 {
10648                                         if(pBtdm8723->curPsTdma == 1)
10649                                         {
10650                                                 btdm_2AntPsTdma(padapter, _TRUE, 3);
10651                                                 pBtdm8723->psTdmaDuAdjType = 3;
10652                                         }
10653                                         else if(pBtdm8723->curPsTdma == 2)
10654                                         {
10655                                                 btdm_2AntPsTdma(padapter, _TRUE, 3);
10656                                                 pBtdm8723->psTdmaDuAdjType = 3;
10657                                         }
10658                                         else if(pBtdm8723->curPsTdma == 3)
10659                                         {
10660                                                 btdm_2AntPsTdma(padapter, _TRUE, 4);
10661                                                 pBtdm8723->psTdmaDuAdjType = 4;
10662                                         }
10663                                         else if(pBtdm8723->curPsTdma == 9)
10664                                         {
10665                                                 btdm_2AntPsTdma(padapter, _TRUE, 11);
10666                                                 pBtdm8723->psTdmaDuAdjType = 11;
10667                                         }
10668                                         else if(pBtdm8723->curPsTdma == 10)
10669                                         {
10670                                                 btdm_2AntPsTdma(padapter, _TRUE, 11);
10671                                                 pBtdm8723->psTdmaDuAdjType = 11;
10672                                         }
10673                                         else if(pBtdm8723->curPsTdma == 11)
10674                                         {
10675                                                 btdm_2AntPsTdma(padapter, _TRUE, 12);
10676                                                 pBtdm8723->psTdmaDuAdjType = 12;
10677                                         }
10678                                 }
10679                                 else if (result == 1)
10680                                 {
10681                                         if(pBtdm8723->curPsTdma == 4)
10682                                         {
10683                                                 btdm_2AntPsTdma(padapter, _TRUE, 3);
10684                                                 pBtdm8723->psTdmaDuAdjType = 3;
10685                                         }
10686                                         else if(pBtdm8723->curPsTdma == 3)
10687                                         {
10688                                                 btdm_2AntPsTdma(padapter, _TRUE, 3);
10689                                                 pBtdm8723->psTdmaDuAdjType = 3;
10690                                         }
10691                                         else if(pBtdm8723->curPsTdma == 2)
10692                                         {
10693                                                 btdm_2AntPsTdma(padapter, _TRUE, 3);
10694                                                 pBtdm8723->psTdmaDuAdjType = 3;
10695                                         }
10696                                         else if(pBtdm8723->curPsTdma == 12)
10697                                         {
10698                                                 btdm_2AntPsTdma(padapter, _TRUE, 11);
10699                                                 pBtdm8723->psTdmaDuAdjType = 11;
10700                                         }
10701                                         else if(pBtdm8723->curPsTdma == 11)
10702                                         {
10703                                                 btdm_2AntPsTdma(padapter, _TRUE, 11);
10704                                                 pBtdm8723->psTdmaDuAdjType = 11;
10705                                         }
10706                                         else if(pBtdm8723->curPsTdma == 10)
10707                                         {
10708                                                 btdm_2AntPsTdma(padapter, _TRUE, 11);
10709                                                 pBtdm8723->psTdmaDuAdjType = 11;
10710                                         }
10711                                 }
10712                         }
10713                 }
10714         }
10715         RTPRINT(FBT, BT_TRACE, ("[BTCoex], PsTdma type : recordPsTdma=%d\n",pBtdm8723->psTdmaDuAdjType));
10716         // if current PsTdma not match with the recorded one (when scan, dhcp...),
10717         // then we have to adjust it back to the previous record one.
10718         if(pBtdm8723->curPsTdma != pBtdm8723->psTdmaDuAdjType)
10719         {
10720                 RTPRINT(FBT, BT_TRACE, ("[BTCoex], PsTdma type dismatch!!!, curPsTdma=%d, recordPsTdma=%d\n",
10721                         pBtdm8723->curPsTdma, pBtdm8723->psTdmaDuAdjType));
10722
10723                 if( check_fwstate(&padapter->mlmepriv, _FW_UNDER_SURVEY|_FW_UNDER_LINKING) == _FALSE )
10724                 {
10725                         btdm_2AntPsTdma(padapter, _TRUE, pBtdm8723->psTdmaDuAdjType);
10726                 }
10727                 else
10728         {
10729                         RTPRINT(FBT, BT_TRACE, ("[BTCoex], roaming/link/scan is under progress, will adjust next time!!!\n"));
10730                 }
10731         }
10732 }
10733
10734 // default Action
10735 void btdm_2Ant8723AAction0(PADAPTER     padapter)
10736 {
10737         btdm_2AntIgnoreWlanAct(padapter, _FALSE);
10738         btdm_2AntPsTdma(padapter, _FALSE, 0);
10739         btdm_2AntDecBtPwr(padapter, _FALSE);
10740
10741         btdm_2AntAgcTable(padapter, _FALSE);
10742         btdm_2AntAdcBackOff(padapter, _FALSE);
10743         btdm_2AntLowPenaltyRa(padapter, _FALSE);
10744         btdm_2AntRfShrink(padapter, _FALSE);
10745         btdm_2AntDacSwing(padapter, _FALSE, 0xc0);
10746
10747         btdm_2AntCoexTable(padapter, 0x55555555, 0xffff, 0x3);
10748 }
10749
10750 // SCO only or SCO+PAN(HS)
10751 void btdm_2Ant8723ASCOAction(PADAPTER padapter)
10752 {
10753         u8      btRssiState, btRssiState1;
10754
10755
10756         if(btdm_NeedToDecBtPwr(padapter))
10757                 btdm_2AntDecBtPwr(padapter, _TRUE);
10758         else
10759                 btdm_2AntDecBtPwr(padapter, _FALSE);
10760
10761         if (BTDM_IsHT40(padapter))
10762         {
10763                 RTPRINT(FBT, BT_TRACE, ("HT40\n"));
10764                 btRssiState = BTDM_CheckCoexRSSIState(padapter, 2, 37, 0);
10765                 // fw mechanism
10766                 if ((btRssiState == BT_RSSI_STATE_HIGH) ||
10767                         (btRssiState == BT_RSSI_STATE_STAY_HIGH))
10768                 {
10769                         RTPRINT(FBT, BT_TRACE, ("Wifi rssi-1 high \n"));
10770                         PlatformEFIOWrite1Byte(padapter, 0x883, 0x40);
10771                         btdm_2AntPsTdma(padapter, _TRUE, 11);
10772                 }
10773                 else
10774                 {
10775                         RTPRINT(FBT, BT_TRACE, ("Wifi rssi-1 low \n"));
10776                         btdm_2AntPsTdma(padapter, _TRUE, 15);
10777                 }
10778
10779                 // sw mechanism
10780                 btdm_2AntAgcTable(padapter, _FALSE);
10781                 btdm_2AntAdcBackOff(padapter, _TRUE);
10782                 btdm_2AntDacSwing(padapter, _FALSE, 0xc0);
10783         }
10784         else
10785         {
10786                 RTPRINT(FBT, BT_TRACE, ("HT20 or Legacy\n"));
10787                 btRssiState = BTDM_CheckCoexRSSIState(padapter, 2, 37, 0);
10788                 btRssiState1 = BTDM_CheckCoexRSSIState1(padapter, 2, 27, 0);
10789
10790                 // fw mechanism
10791                 if( (btRssiState1 == BT_RSSI_STATE_HIGH) ||
10792                         (btRssiState1 == BT_RSSI_STATE_STAY_HIGH) )
10793                 {
10794                         RTPRINT(FBT, BT_TRACE, ("Wifi rssi-1 high \n"));
10795                         PlatformEFIOWrite1Byte(padapter, 0x883, 0x40);
10796                         btdm_2AntPsTdma(padapter, _TRUE, 11);
10797                 }
10798                 else
10799                 {
10800                         RTPRINT(FBT, BT_TRACE, ("Wifi rssi-1 low \n"));
10801                         btdm_2AntPsTdma(padapter, _TRUE, 15);
10802                 }
10803
10804
10805                 // sw mechanism
10806                 if ((btRssiState == BT_RSSI_STATE_HIGH) ||
10807                         (btRssiState == BT_RSSI_STATE_STAY_HIGH))
10808                 {
10809                         RTPRINT(FBT, BT_TRACE, ("Wifi rssi high \n"));
10810                         btdm_2AntAgcTable(padapter, _TRUE);
10811                         btdm_2AntAdcBackOff(padapter, _TRUE);
10812                         btdm_2AntDacSwing(padapter, _FALSE, 0xc0);
10813                 }
10814                 else
10815                 {
10816                         RTPRINT(FBT, BT_TRACE, ("Wifi rssi low \n"));
10817                         btdm_2AntAgcTable(padapter, _FALSE);
10818                         btdm_2AntAdcBackOff(padapter, _FALSE);
10819                         btdm_2AntDacSwing(padapter, _FALSE, 0xc0);
10820                 }
10821         }
10822         }
10823
10824
10825 void btdm_2Ant8723AHIDAction(PADAPTER padapter)
10826 {
10827         u8              btRssiState, btRssiState1;
10828
10829         if(btdm_NeedToDecBtPwr(padapter))
10830                 btdm_2AntDecBtPwr(padapter, _TRUE);
10831         else
10832                 btdm_2AntDecBtPwr(padapter, _FALSE);
10833
10834         if (BTDM_IsHT40(padapter))
10835         {
10836                 RTPRINT(FBT, BT_TRACE, ("HT40\n"));
10837                 btRssiState = BTDM_CheckCoexRSSIState(padapter, 2, 37, 0);
10838                         // fw mechanism
10839                 if( (btRssiState == BT_RSSI_STATE_HIGH) ||
10840                         (btRssiState == BT_RSSI_STATE_STAY_HIGH) )
10841                 {
10842                         RTPRINT(FBT, BT_TRACE, ("Wifi rssi-1 high \n"));
10843                         PlatformEFIOWrite1Byte(padapter, 0x883, 0x40);
10844                         btdm_2AntPsTdma(padapter, _TRUE, 9);
10845                 }
10846                 else
10847                 {
10848                         RTPRINT(FBT, BT_TRACE, ("Wifi rssi-1 low \n"));
10849                         btdm_2AntPsTdma(padapter, _TRUE, 13);
10850                 }
10851
10852                 // sw mechanism
10853                 btdm_2AntAgcTable(padapter, _FALSE);
10854                 btdm_2AntAdcBackOff(padapter, _FALSE);
10855                 btdm_2AntDacSwing(padapter, _FALSE, 0xc0);
10856         }
10857         else
10858         {
10859                 RTPRINT(FBT, BT_TRACE, ("HT20 or Legacy\n"));
10860                 btRssiState = BTDM_CheckCoexRSSIState(padapter, 2, 37, 0);
10861                 btRssiState1 = BTDM_CheckCoexRSSIState1(padapter, 2, 27, 0);
10862
10863                 // fw mechanism
10864                 if( (btRssiState1 == BT_RSSI_STATE_HIGH) ||
10865                         (btRssiState1 == BT_RSSI_STATE_STAY_HIGH) )
10866                 {
10867                         RTPRINT(FBT, BT_TRACE, ("Wifi rssi-1 high \n"));
10868                         PlatformEFIOWrite1Byte(padapter, 0x883, 0x40);
10869                         btdm_2AntPsTdma(padapter, _TRUE, 9);
10870                 }
10871                 else
10872                 {
10873                         RTPRINT(FBT, BT_TRACE, ("Wifi rssi-1 low \n"));
10874                         btdm_2AntPsTdma(padapter, _TRUE, 13);
10875                 }
10876
10877                         // sw mechanism
10878                         if ((btRssiState == BT_RSSI_STATE_HIGH) ||
10879                                 (btRssiState == BT_RSSI_STATE_STAY_HIGH))
10880                         {
10881                                 RTPRINT(FBT, BT_TRACE, ("Wifi rssi high \n"));
10882                         btdm_2AntAgcTable(padapter, _TRUE);
10883                         btdm_2AntAdcBackOff(padapter, _TRUE);
10884                         btdm_2AntDacSwing(padapter, _FALSE, 0xc0);
10885                         }
10886                         else
10887                         {
10888                                 RTPRINT(FBT, BT_TRACE, ("Wifi rssi low \n"));
10889                         btdm_2AntAgcTable(padapter, _FALSE);
10890                         btdm_2AntAdcBackOff(padapter, _FALSE);
10891                         btdm_2AntDacSwing(padapter, _FALSE, 0xc0);
10892                 }
10893                         }
10894                 }
10895
10896 //A2DP only / PAN(EDR) only/ A2DP+PAN(HS)
10897 void btdm_2Ant8723AA2DPAction(PADAPTER padapter)
10898 {
10899         u8              btRssiState, btRssiState1;
10900         PHAL_DATA_TYPE  pHalData = GET_HAL_DATA(padapter);
10901         u8              btInfoExt=pHalData->bt_coexist.halCoex8723.btInfoExt;
10902
10903         if(btdm_NeedToDecBtPwr(padapter))
10904                 btdm_2AntDecBtPwr(padapter, _TRUE);
10905                 else
10906                 btdm_2AntDecBtPwr(padapter, _FALSE);
10907
10908         if(BTDM_IsHT40(padapter))
10909                 {
10910                 RTPRINT(FBT, BT_TRACE, ("HT40\n"));
10911                 btRssiState = BTDM_CheckCoexRSSIState(padapter, 2, 37, 0);
10912
10913                 // fw mechanism
10914                         if ((btRssiState == BT_RSSI_STATE_HIGH) ||
10915                                 (btRssiState == BT_RSSI_STATE_STAY_HIGH))
10916                         {
10917                                 RTPRINT(FBT, BT_TRACE, ("Wifi rssi high \n"));
10918                         PlatformEFIOWrite1Byte(padapter, 0x883, 0x40);
10919
10920                         if(btInfoExt&BIT(0))    //a2dp rate, 1:basic /0:edr
10921                         {
10922                                 RTPRINT(FBT, BT_TRACE, ("a2dp basic rate \n"));
10923                                 btdm_2AntTdmaDurationAdjust(padapter, _FALSE, _FALSE, 3);
10924                         }
10925                         else
10926                         {
10927                                 RTPRINT(FBT, BT_TRACE, ("a2dp edr rate \n"));
10928                         btdm_2AntTdmaDurationAdjust(padapter, _FALSE, _FALSE, 1);
10929                 }
10930                         }
10931                         else
10932                         {
10933                                 RTPRINT(FBT, BT_TRACE, ("Wifi rssi low \n"));
10934                         if(btInfoExt&BIT(0))    //a2dp rate, 1:basic /0:edr
10935                         {
10936                                 RTPRINT(FBT, BT_TRACE, ("a2dp basic rate \n"));
10937                                 btdm_2AntTdmaDurationAdjust(padapter, _FALSE, _TRUE, 3);
10938                         }
10939                         else
10940                         {
10941                                 RTPRINT(FBT, BT_TRACE, ("a2dp edr rate \n"));
10942                         btdm_2AntTdmaDurationAdjust(padapter, _FALSE, _TRUE, 1);
10943                 }
10944         }
10945
10946                 // sw mechanism
10947                 btdm_2AntAgcTable(padapter, _FALSE);
10948                 btdm_2AntAdcBackOff(padapter, _TRUE);
10949                 btdm_2AntDacSwing(padapter, _FALSE, 0xc0);
10950         }
10951         else
10952         {
10953                 RTPRINT(FBT, BT_TRACE, ("HT20 or Legacy\n"));
10954                 btRssiState = BTDM_CheckCoexRSSIState(padapter, 2, 37, 0);
10955                 btRssiState1 = BTDM_CheckCoexRSSIState1(padapter, 2, 27, 0);
10956
10957                 // fw mechanism
10958                 if( (btRssiState1 == BT_RSSI_STATE_HIGH) ||
10959                         (btRssiState1 == BT_RSSI_STATE_STAY_HIGH) )
10960         {
10961                         RTPRINT(FBT, BT_TRACE, ("Wifi rssi-1 high \n"));
10962                         PlatformEFIOWrite1Byte(padapter, 0x883, 0x40);
10963                         if(btInfoExt&BIT(0))    //a2dp rate, 1:basic /0:edr
10964                         {
10965                                 RTPRINT(FBT, BT_TRACE, ("a2dp basic rate \n"));
10966                                 btdm_2AntTdmaDurationAdjust(padapter, _FALSE, _FALSE, 3);
10967         }
10968                         else
10969                         {
10970                                 RTPRINT(FBT, BT_TRACE, ("a2dp edr rate \n"));
10971                         btdm_2AntTdmaDurationAdjust(padapter, _FALSE, _FALSE, 1);
10972 }
10973                 }
10974                 else
10975 {
10976                         RTPRINT(FBT, BT_TRACE, ("Wifi rssi-1 low \n"));
10977                         if(btInfoExt&BIT(0))    //a2dp rate, 1:basic /0:edr
10978                         {
10979                                 RTPRINT(FBT, BT_TRACE, ("a2dp basic rate \n"));
10980                                 btdm_2AntTdmaDurationAdjust(padapter, _FALSE, _TRUE, 3);
10981                         }
10982                         else
10983                         {
10984                                 RTPRINT(FBT, BT_TRACE, ("a2dp edr rate \n"));
10985                         btdm_2AntTdmaDurationAdjust(padapter, _FALSE, _TRUE, 1);
10986                 }
10987                 }
10988
10989                 // sw mechanism
10990                 if( (btRssiState == BT_RSSI_STATE_HIGH) ||
10991                         (btRssiState == BT_RSSI_STATE_STAY_HIGH) )
10992         {
10993                         RTPRINT(FBT, BT_TRACE, ("Wifi rssi high \n"));
10994                         btdm_2AntAgcTable(padapter, _TRUE);
10995                         btdm_2AntAdcBackOff(padapter, _TRUE);
10996                         btdm_2AntDacSwing(padapter, _FALSE, 0xc0);
10997         }
10998         else
10999         {
11000                         RTPRINT(FBT, BT_TRACE, ("Wifi rssi low \n"));
11001                         btdm_2AntAgcTable(padapter, _FALSE);
11002                         btdm_2AntAdcBackOff(padapter, _FALSE);
11003                         btdm_2AntDacSwing(padapter, _FALSE, 0xc0);
11004                 }
11005         }
11006 }
11007
11008
11009 void btdm_2Ant8723APANEDRAction(PADAPTER padapter)
11010 {
11011         u8              btRssiState, btRssiState1;
11012
11013         if(btdm_NeedToDecBtPwr(padapter))
11014                 btdm_2AntDecBtPwr(padapter, _TRUE);
11015         else
11016                 btdm_2AntDecBtPwr(padapter, _FALSE);
11017
11018                 if(BTDM_IsHT40(padapter))
11019                 {
11020                         RTPRINT(FBT, BT_TRACE, ("HT40\n"));
11021                         btRssiState = BTDM_CheckCoexRSSIState(padapter, 2, 37, 0);
11022
11023                         // fw mechanism
11024                         if( (btRssiState == BT_RSSI_STATE_HIGH) ||
11025                                 (btRssiState == BT_RSSI_STATE_STAY_HIGH) )
11026                         {
11027                                 RTPRINT(FBT, BT_TRACE, ("Wifi rssi high \n"));
11028                         PlatformEFIOWrite1Byte(padapter, 0x883, 0x40);
11029                         btdm_2AntPsTdma(padapter, _TRUE, 2);
11030                         }
11031                         else
11032                         {
11033                                 RTPRINT(FBT, BT_TRACE, ("Wifi rssi low \n"));
11034                         btdm_2AntPsTdma(padapter, _TRUE, 6);
11035                         }
11036
11037                 // sw mechanism
11038                 btdm_2AntAgcTable(padapter, _FALSE);
11039                 btdm_2AntAdcBackOff(padapter, _TRUE);
11040                 btdm_2AntDacSwing(padapter, _FALSE, 0xc0);
11041                 }
11042                 else
11043                 {
11044                         RTPRINT(FBT, BT_TRACE, ("HT20 or Legacy\n"));
11045                 btRssiState = BTDM_CheckCoexRSSIState(padapter, 2, 37, 0);
11046                         btRssiState1 = BTDM_CheckCoexRSSIState1(padapter, 2, 27, 0);
11047
11048                 // fw mechanism
11049                 if( (btRssiState1 == BT_RSSI_STATE_HIGH) ||
11050                         (btRssiState1 == BT_RSSI_STATE_STAY_HIGH) )
11051                         {
11052                                 RTPRINT(FBT, BT_TRACE, ("Wifi rssi-1 high \n"));
11053                         PlatformEFIOWrite1Byte(padapter, 0x883, 0x40);
11054                         btdm_2AntPsTdma(padapter, _TRUE, 2);
11055                         }
11056                         else
11057 {
11058                                 RTPRINT(FBT, BT_TRACE, ("Wifi rssi-1 low \n"));
11059                         btdm_2AntPsTdma(padapter, _TRUE, 6);
11060                         }
11061
11062                 // sw mechanism
11063                 if( (btRssiState == BT_RSSI_STATE_HIGH) ||
11064                         (btRssiState == BT_RSSI_STATE_STAY_HIGH) )
11065                         {
11066                                 RTPRINT(FBT, BT_TRACE, ("Wifi rssi high \n"));
11067                         btdm_2AntAgcTable(padapter, _TRUE);
11068                         btdm_2AntAdcBackOff(padapter, _TRUE);
11069                         btdm_2AntDacSwing(padapter, _FALSE, 0xc0);
11070                         }
11071                         else
11072                         {
11073                                 RTPRINT(FBT, BT_TRACE, ("Wifi rssi low \n"));
11074                         btdm_2AntAgcTable(padapter, _FALSE);
11075                         btdm_2AntAdcBackOff(padapter, _FALSE);
11076                         btdm_2AntDacSwing(padapter, _FALSE, 0xc0);
11077                         }
11078                 }
11079         }
11080
11081
11082
11083 //PAN(HS) only
11084 void btdm_2Ant8723APANHSAction(PADAPTER padapter)
11085 {
11086         u8              btRssiState, btRssiState1;
11087
11088         if (BTDM_IsHT40(padapter))
11089         {
11090                 RTPRINT(FBT, BT_TRACE, ("HT40\n"));
11091                 btRssiState = BTDM_CheckCoexRSSIState(padapter, 2, 47, 0);
11092                 // fw mechanism
11093                 if( (btRssiState == BT_RSSI_STATE_HIGH) ||
11094                         (btRssiState == BT_RSSI_STATE_STAY_HIGH) )
11095                 {
11096                         RTPRINT(FBT, BT_TRACE, ("Wifi rssi high \n"));
11097                         btdm_2AntDecBtPwr(padapter, _TRUE);
11098                 }
11099                 else
11100                 {
11101                         RTPRINT(FBT, BT_TRACE, ("Wifi rssi low \n"));
11102                         btdm_2AntDecBtPwr(padapter, _FALSE);
11103                 }
11104                 btdm_2AntPsTdma(padapter, _FALSE, 0);
11105
11106                 // sw mechanism
11107                 btdm_2AntAgcTable(padapter, _FALSE);
11108                 btdm_2AntAdcBackOff(padapter, _TRUE);
11109                 btdm_2AntDacSwing(padapter, _FALSE, 0xc0);
11110         }
11111         else
11112         {
11113                 RTPRINT(FBT, BT_TRACE, ("HT20 or Legacy\n"));
11114                 btRssiState = BTDM_CheckCoexRSSIState(padapter, 2, 47, 0);
11115
11116                 if ((btRssiState == BT_RSSI_STATE_HIGH) ||
11117                         (btRssiState == BT_RSSI_STATE_STAY_HIGH))
11118                 {
11119                         RTPRINT(FBT, BT_TRACE, ("Wifi rssi high\n"));
11120                         // fw mechanism
11121                         btdm_2AntDecBtPwr(padapter, _TRUE);
11122                         btdm_2AntPsTdma(padapter, _FALSE, 0);
11123
11124                         // sw mechanism
11125                         btdm_2AntAgcTable(padapter, _TRUE);
11126                         btdm_2AntAdcBackOff(padapter, _TRUE);
11127                         btdm_2AntDacSwing(padapter, _FALSE, 0xc0);
11128                 }
11129                 else
11130                 {
11131                         RTPRINT(FBT, BT_TRACE, ("Wifi rssi low\n"));
11132                         // fw mechanism
11133                         btdm_2AntDecBtPwr(padapter, _FALSE);
11134                         btdm_2AntPsTdma(padapter, _FALSE, 0);
11135
11136                         // sw mechanism
11137                         btdm_2AntAgcTable(padapter, _FALSE);
11138                         btdm_2AntAdcBackOff(padapter, _FALSE);
11139                         btdm_2AntDacSwing(padapter, _FALSE, 0xc0);
11140         }
11141         }
11142 }
11143
11144
11145 //PAN(EDR)+A2DP
11146 void btdm_2Ant8723APANEDRA2DPAction(PADAPTER    padapter)
11147 {
11148         u8              btRssiState, btRssiState1, btInfoExt;
11149         PHAL_DATA_TYPE  pHalData = GET_HAL_DATA(padapter);
11150
11151         btInfoExt = pHalData->bt_coexist.halCoex8723.btInfoExt;
11152
11153         if(btdm_NeedToDecBtPwr(padapter))
11154                 btdm_2AntDecBtPwr(padapter, _TRUE);
11155         else
11156                 btdm_2AntDecBtPwr(padapter, _FALSE);
11157
11158                 if(BTDM_IsHT40(padapter))
11159                 {
11160                         RTPRINT(FBT, BT_TRACE, ("HT40\n"));
11161                 btRssiState = BTDM_CheckCoexRSSIState(padapter, 2, 37, 0);
11162
11163                         if( (btRssiState == BT_RSSI_STATE_HIGH) ||
11164                                 (btRssiState == BT_RSSI_STATE_STAY_HIGH) )
11165                         {
11166                                 RTPRINT(FBT, BT_TRACE, ("Wifi rssi high \n"));
11167                                 // fw mechanism
11168                         PlatformEFIOWrite1Byte(padapter, 0x883, 0x40);
11169
11170                         if(btInfoExt&BIT(0))    //a2dp rate, 1:basic /0:edr
11171                         {
11172                                 RTPRINT(FBT, BT_TRACE, ("a2dp basic rate \n"));
11173                                 btdm_2AntPsTdma(padapter, _TRUE, 4);
11174                         }
11175                         else
11176                         {
11177                                 RTPRINT(FBT, BT_TRACE, ("a2dp edr rate \n"));
11178                                 btdm_2AntPsTdma(padapter, _TRUE, 2);
11179                         }
11180                         }
11181                         else
11182                         {
11183                                 RTPRINT(FBT, BT_TRACE, ("Wifi rssi low \n"));
11184                                 // fw mechanism
11185                         if(btInfoExt&BIT(0))    //a2dp rate, 1:basic /0:edr
11186                         {
11187                                 RTPRINT(FBT, BT_TRACE, ("a2dp basic rate \n"));
11188                                 btdm_2AntPsTdma(padapter, _TRUE, 8);
11189                         }
11190                         else
11191                         {
11192                                 RTPRINT(FBT, BT_TRACE, ("a2dp edr rate \n"));
11193                                 btdm_2AntPsTdma(padapter, _TRUE, 6);
11194                         }
11195                 }
11196
11197                 // sw mechanism
11198                 btdm_2AntAgcTable(padapter, _FALSE);
11199                 btdm_2AntAdcBackOff(padapter, _TRUE);
11200                 btdm_2AntDacSwing(padapter, _FALSE, 0xc0);
11201         }
11202         else
11203         {
11204                 RTPRINT(FBT, BT_TRACE, ("HT20 or Legacy\n"));
11205                 btRssiState = BTDM_CheckCoexRSSIState(padapter, 2, 37, 0);
11206                 btRssiState1 = BTDM_CheckCoexRSSIState1(padapter, 2, 27, 0);
11207
11208                 if( (btRssiState1 == BT_RSSI_STATE_HIGH) ||
11209                         (btRssiState1 == BT_RSSI_STATE_STAY_HIGH) )
11210                 {
11211                         RTPRINT(FBT, BT_TRACE, ("Wifi rssi-1 high \n"));
11212                         PlatformEFIOWrite1Byte(padapter, 0x883, 0x40);
11213                         // fw mechanism
11214                         if(btInfoExt&BIT(0))    //a2dp rate, 1:basic /0:edr
11215                         {
11216                                 RTPRINT(FBT, BT_TRACE, ("a2dp basic rate \n"));
11217                                 btdm_2AntPsTdma(padapter, _TRUE, 4);
11218                         }
11219                         else
11220                         {
11221                                 RTPRINT(FBT, BT_TRACE, ("a2dp edr rate \n"));
11222                                 btdm_2AntPsTdma(padapter, _TRUE, 2);
11223                         }
11224                 }
11225                 else
11226                 {
11227                         RTPRINT(FBT, BT_TRACE, ("Wifi rssi-1 low \n"));
11228                         // fw mechanism
11229                         if(btInfoExt&BIT(0))    //a2dp rate, 1:basic /0:edr
11230                         {
11231                                 RTPRINT(FBT, BT_TRACE, ("a2dp basic rate \n"));
11232                                 btdm_2AntPsTdma(padapter, _TRUE, 8);
11233                         }
11234                         else
11235                         {
11236                                 RTPRINT(FBT, BT_TRACE, ("a2dp edr rate \n"));
11237                                 btdm_2AntPsTdma(padapter, _TRUE, 6);
11238                         }
11239                 }
11240
11241                 // sw mechanism
11242                 if( (btRssiState == BT_RSSI_STATE_HIGH) ||
11243                         (btRssiState == BT_RSSI_STATE_STAY_HIGH) )
11244                 {
11245                         RTPRINT(FBT, BT_TRACE, ("Wifi rssi high \n"));
11246                         btdm_2AntAgcTable(padapter, _TRUE);
11247                         btdm_2AntAdcBackOff(padapter, _TRUE);
11248                         btdm_2AntDacSwing(padapter, _FALSE, 0xc0);
11249                 }
11250                 else
11251                 {
11252                         RTPRINT(FBT, BT_TRACE, ("Wifi rssi low \n"));
11253                         btdm_2AntAgcTable(padapter, _FALSE);
11254                         btdm_2AntAdcBackOff(padapter, _FALSE);
11255                         btdm_2AntDacSwing(padapter, _FALSE, 0xc0);
11256                 }
11257         }
11258 }
11259
11260
11261 void btdm_2Ant8723APANEDRHIDAction(PADAPTER     padapter)
11262 {
11263         u8              btRssiState, btRssiState1;
11264
11265         if(btdm_NeedToDecBtPwr(padapter))
11266                 btdm_2AntDecBtPwr(padapter, _TRUE);
11267         else
11268                 btdm_2AntDecBtPwr(padapter, _FALSE);
11269
11270         if(BTDM_IsHT40(padapter))
11271         {
11272                 RTPRINT(FBT, BT_TRACE, ("HT40\n"));
11273                 btRssiState = BTDM_CheckCoexRSSIState(padapter, 2, 37, 0);
11274                 // fw mechanism
11275                         if ((btRssiState == BT_RSSI_STATE_HIGH) ||
11276                                 (btRssiState == BT_RSSI_STATE_STAY_HIGH))
11277                         {
11278                                 RTPRINT(FBT, BT_TRACE, ("Wifi rssi high \n"));
11279                         PlatformEFIOWrite1Byte(padapter, 0x883, 0x40);
11280                         btdm_2AntPsTdma(padapter, _TRUE, 10);
11281                         }
11282                         else
11283                         {
11284                                 RTPRINT(FBT, BT_TRACE, ("Wifi rssi low \n"));
11285                         btdm_2AntPsTdma(padapter, _TRUE, 14);
11286                 }
11287
11288                                 // sw mechanism
11289                 btdm_2AntAgcTable(padapter, _FALSE);
11290                 btdm_2AntAdcBackOff(padapter, _TRUE);
11291                 btdm_2AntDacSwing(padapter, _FALSE, 0xc0);
11292                         }
11293         else
11294         {
11295                 RTPRINT(FBT, BT_TRACE, ("HT20 or Legacy\n"));
11296                 btRssiState = BTDM_CheckCoexRSSIState(padapter, 2, 37, 0);
11297                 btRssiState1 = BTDM_CheckCoexRSSIState1(padapter, 2, 27, 0);
11298
11299                 // fw mechanism
11300                 if( (btRssiState1 == BT_RSSI_STATE_HIGH) ||
11301                         (btRssiState1 == BT_RSSI_STATE_STAY_HIGH) )
11302                 {
11303                         RTPRINT(FBT, BT_TRACE, ("Wifi rssi-1 high \n"));
11304                         PlatformEFIOWrite1Byte(padapter, 0x883, 0x40);
11305                         btdm_2AntPsTdma(padapter, _TRUE, 10);
11306                 }
11307                 else
11308                 {
11309                         RTPRINT(FBT, BT_TRACE, ("Wifi rssi-1 low \n"));
11310                         btdm_2AntPsTdma(padapter, _TRUE, 14);
11311         }
11312
11313                 // sw mechanism
11314                 if( (btRssiState == BT_RSSI_STATE_HIGH) ||
11315                         (btRssiState == BT_RSSI_STATE_STAY_HIGH) )
11316         {
11317                         RTPRINT(FBT, BT_TRACE, ("Wifi rssi high \n"));
11318                         btdm_2AntAgcTable(padapter, _TRUE);
11319                         btdm_2AntAdcBackOff(padapter, _TRUE);
11320                         btdm_2AntDacSwing(padapter, _FALSE, 0xc0);
11321         }
11322                 else
11323         {
11324                         RTPRINT(FBT, BT_TRACE, ("Wifi rssi low \n"));
11325                         btdm_2AntAgcTable(padapter, _FALSE);
11326                         btdm_2AntAdcBackOff(padapter, _FALSE);
11327                         btdm_2AntDacSwing(padapter, _FALSE, 0xc0);
11328                 }
11329         }
11330 }
11331
11332 // HID+A2DP+PAN(EDR)
11333 void btdm_2Ant8723AHIDA2DPPANEDRAction(PADAPTER padapter)
11334 {
11335         u8              btRssiState, btRssiState1, btInfoExt;
11336         PHAL_DATA_TYPE  pHalData = GET_HAL_DATA(padapter);
11337
11338         btInfoExt = pHalData->bt_coexist.halCoex8723.btInfoExt;
11339
11340         if(btdm_NeedToDecBtPwr(padapter))
11341                 btdm_2AntDecBtPwr(padapter, _TRUE);
11342         else
11343                 btdm_2AntDecBtPwr(padapter, _FALSE);
11344
11345                 if (BTDM_IsHT40(padapter))
11346                 {
11347                         RTPRINT(FBT, BT_TRACE, ("HT40\n"));
11348                         btRssiState = BTDM_CheckCoexRSSIState(padapter, 2, 37, 0);
11349                         if( (btRssiState == BT_RSSI_STATE_HIGH) ||
11350                                 (btRssiState == BT_RSSI_STATE_STAY_HIGH) )
11351                         {
11352                                 RTPRINT(FBT, BT_TRACE, ("Wifi rssi high \n"));
11353                         PlatformEFIOWrite1Byte(padapter, 0x883, 0x40);
11354
11355                         if(btInfoExt&BIT(0))    //a2dp rate, 1:basic /0:edr
11356                         {
11357                                 RTPRINT(FBT, BT_TRACE, ("a2dp basic rate \n"));
11358                                 btdm_2AntPsTdma(padapter, _TRUE, 12);
11359                         }
11360                         else
11361                         {
11362                                 RTPRINT(FBT, BT_TRACE, ("a2dp edr rate \n"));
11363                                 btdm_2AntPsTdma(padapter, _TRUE, 10);
11364                         }
11365                 }
11366                 else
11367                 {
11368                         RTPRINT(FBT, BT_TRACE, ("Wifi rssi low \n"));
11369                         if(btInfoExt&BIT(0))    //a2dp rate, 1:basic /0:edr
11370                         {
11371                                 RTPRINT(FBT, BT_TRACE, ("a2dp basic rate \n"));
11372                                 btdm_2AntPsTdma(padapter, _TRUE, 16);
11373                         }
11374                         else
11375                         {
11376                                 RTPRINT(FBT, BT_TRACE, ("a2dp edr rate \n"));
11377                                 btdm_2AntPsTdma(padapter, _TRUE, 14);
11378                         }
11379                 }
11380
11381                 // sw mechanism
11382                 btdm_2AntAgcTable(padapter, _FALSE);
11383                 btdm_2AntAdcBackOff(padapter, _TRUE);
11384                 btdm_2AntDacSwing(padapter, _FALSE, 0xc0);
11385         }
11386         else
11387         {
11388                 RTPRINT(FBT, BT_TRACE, ("HT20 or Legacy\n"));
11389                 btRssiState1 = BTDM_CheckCoexRSSIState1(padapter, 2, 37, 0);
11390                 btRssiState = BTDM_CheckCoexRSSIState(padapter, 2, 27, 0);
11391                         if ((btRssiState == BT_RSSI_STATE_HIGH) ||
11392                                 (btRssiState == BT_RSSI_STATE_STAY_HIGH))
11393                         {
11394                                 RTPRINT(FBT, BT_TRACE, ("Wifi rssi high \n"));
11395                         PlatformEFIOWrite1Byte(padapter, 0x883, 0x40);
11396
11397                         if(btInfoExt&BIT(0))    //a2dp rate, 1:basic /0:edr
11398                         {
11399                                 RTPRINT(FBT, BT_TRACE, ("a2dp basic rate \n"));
11400                                 btdm_2AntPsTdma(padapter, _TRUE, 12);
11401                         }
11402                         else
11403                         {
11404                                 RTPRINT(FBT, BT_TRACE, ("a2dp edr rate \n"));
11405                                 btdm_2AntPsTdma(padapter, _TRUE, 10);
11406                         }
11407                         }
11408                         else
11409                         {
11410                                 RTPRINT(FBT, BT_TRACE, ("Wifi rssi low \n"));
11411                         if(btInfoExt&BIT(0))    //a2dp rate, 1:basic /0:edr
11412                         {
11413                                 RTPRINT(FBT, BT_TRACE, ("a2dp basic rate \n"));
11414                                 btdm_2AntPsTdma(padapter, _TRUE, 16);
11415                         }
11416                         else
11417                         {
11418                                 RTPRINT(FBT, BT_TRACE, ("a2dp edr rate \n"));
11419                                 btdm_2AntPsTdma(padapter, _TRUE, 14);
11420                         }
11421                         }
11422
11423                         // sw mechanism
11424                         if ((btRssiState1 == BT_RSSI_STATE_HIGH) ||
11425                                 (btRssiState1 == BT_RSSI_STATE_STAY_HIGH))
11426                         {
11427                         RTPRINT(FBT, BT_TRACE, ("Wifi rssi-1 high \n"));
11428                         btdm_2AntAgcTable(padapter, _TRUE);
11429                         btdm_2AntAdcBackOff(padapter, _TRUE);
11430                         btdm_2AntDacSwing(padapter, _FALSE, 0xc0);
11431                         }
11432                         else
11433                         {
11434                         RTPRINT(FBT, BT_TRACE, ("Wifi rssi-1 high \n"));
11435                         btdm_2AntAgcTable(padapter, _FALSE);
11436                         btdm_2AntAdcBackOff(padapter, _FALSE);
11437                         btdm_2AntDacSwing(padapter, _FALSE, 0xc0);
11438                         }
11439                 }
11440         }
11441
11442
11443 void btdm_2Ant8723AHIDA2DPAction(PADAPTER       padapter)
11444         {
11445         PHAL_DATA_TYPE  pHalData = GET_HAL_DATA(padapter);
11446         u8              btRssiState, btRssiState1, btInfoExt;
11447
11448         btInfoExt = pHalData->bt_coexist.halCoex8723.btInfoExt;
11449
11450         if(btdm_NeedToDecBtPwr(padapter))
11451                 btdm_2AntDecBtPwr(padapter, _TRUE);
11452         else
11453                 btdm_2AntDecBtPwr(padapter, _FALSE);
11454
11455                 if (BTDM_IsHT40(padapter))
11456                 {
11457                         RTPRINT(FBT, BT_TRACE, ("HT40\n"));
11458                 btRssiState = BTDM_CheckCoexRSSIState(padapter, 2, 37, 0);
11459                         if( (btRssiState == BT_RSSI_STATE_HIGH) ||
11460                                 (btRssiState == BT_RSSI_STATE_STAY_HIGH) )
11461                         {
11462                                 RTPRINT(FBT, BT_TRACE, ("Wifi rssi high \n"));
11463                         PlatformEFIOWrite1Byte(padapter, 0x883, 0x40);
11464
11465                         if(btInfoExt&BIT(0))    //a2dp rate, 1:basic /0:edr
11466                         {
11467                                 RTPRINT(FBT, BT_TRACE, ("a2dp basic rate \n"));
11468                                 btdm_2AntTdmaDurationAdjust(padapter, _TRUE, _FALSE, 3);
11469                         }
11470                         else
11471                         {
11472                                 RTPRINT(FBT, BT_TRACE, ("a2dp edr rate \n"));
11473                                 btdm_2AntTdmaDurationAdjust(padapter, _TRUE, _FALSE, 1);
11474                         }
11475                         }
11476                         else
11477                         {
11478                                 RTPRINT(FBT, BT_TRACE, ("Wifi rssi low \n"));
11479                         if(btInfoExt&BIT(0))    //a2dp rate, 1:basic /0:edr
11480                         {
11481                                 RTPRINT(FBT, BT_TRACE, ("a2dp basic rate \n"));
11482                                 btdm_2AntTdmaDurationAdjust(padapter, _TRUE, _TRUE, 3);
11483                         }
11484                         else
11485                         {
11486                                 RTPRINT(FBT, BT_TRACE, ("a2dp edr rate \n"));
11487                                 btdm_2AntTdmaDurationAdjust(padapter, _TRUE, _TRUE, 1);
11488                         }
11489                 }
11490
11491                 // sw mechanism
11492                 btdm_2AntAgcTable(padapter, _FALSE);
11493                 btdm_2AntAdcBackOff(padapter, _TRUE);
11494                 btdm_2AntDacSwing(padapter, _FALSE, 0xc0);
11495                 }
11496                 else
11497                 {
11498                         RTPRINT(FBT, BT_TRACE, ("HT20 or Legacy\n"));
11499                 btRssiState = BTDM_CheckCoexRSSIState(padapter, 2, 37, 0);
11500                 btRssiState1 = BTDM_CheckCoexRSSIState(padapter, 2, 27, 0);
11501
11502                         if ((btRssiState == BT_RSSI_STATE_HIGH) ||
11503                                 (btRssiState == BT_RSSI_STATE_STAY_HIGH))
11504                         {
11505                                 RTPRINT(FBT, BT_TRACE, ("Wifi rssi high \n"));
11506                         PlatformEFIOWrite1Byte(padapter, 0x883, 0x40);
11507
11508                         if(btInfoExt&BIT(0))    //a2dp rate, 1:basic /0:edr
11509                         {
11510                                 RTPRINT(FBT, BT_TRACE, ("a2dp basic rate \n"));
11511                                 btdm_2AntTdmaDurationAdjust(padapter, _TRUE, _FALSE, 3);
11512                         }
11513                         else
11514                         {
11515                                 RTPRINT(FBT, BT_TRACE, ("a2dp edr rate \n"));
11516                                 btdm_2AntTdmaDurationAdjust(padapter, _TRUE, _FALSE, 1);
11517                         }
11518                         }
11519                         else
11520                         {
11521                                 RTPRINT(FBT, BT_TRACE, ("Wifi rssi low \n"));
11522                         if(btInfoExt&BIT(0))    //a2dp rate, 1:basic /0:edr
11523                         {
11524                                 RTPRINT(FBT, BT_TRACE, ("a2dp basic rate \n"));
11525                                 btdm_2AntTdmaDurationAdjust(padapter, _TRUE, _TRUE, 3);
11526                         }
11527                         else
11528                         {
11529                                 RTPRINT(FBT, BT_TRACE, ("a2dp edr rate \n"));
11530                                 btdm_2AntTdmaDurationAdjust(padapter, _TRUE, _TRUE, 1);
11531                 }
11532         }
11533                 if( (btRssiState1 == BT_RSSI_STATE_HIGH) ||
11534                         (btRssiState1 == BT_RSSI_STATE_STAY_HIGH) )
11535         {
11536                         RTPRINT(FBT, BT_TRACE, ("Wifi rssi-1 high \n"));
11537                         // sw mechanism
11538                         btdm_2AntAgcTable(padapter, _TRUE);
11539                         btdm_2AntAdcBackOff(padapter, _TRUE);
11540                         btdm_2AntDacSwing(padapter, _FALSE, 0xc0);
11541         }
11542                 else
11543         {
11544                         RTPRINT(FBT, BT_TRACE, ("Wifi rssi-1 low \n"));
11545                         // sw mechanism
11546                         btdm_2AntAgcTable(padapter, _FALSE);
11547                         btdm_2AntAdcBackOff(padapter, _FALSE);
11548                         btdm_2AntDacSwing(padapter, _FALSE, 0xc0);
11549                 }
11550         }
11551 }
11552
11553
11554 void btdm_2Ant8723AHidScoEsco(PADAPTER  padapter        )
11555 {
11556         PHAL_DATA_TYPE  pHalData = GET_HAL_DATA(padapter);
11557         u8              btRssiState, btRssiState1, btInfoExt;
11558
11559         btInfoExt = pHalData->bt_coexist.halCoex8723.btInfoExt;
11560
11561         if(btdm_NeedToDecBtPwr(padapter))
11562                 btdm_2AntDecBtPwr(padapter, _TRUE);
11563         else
11564                 btdm_2AntDecBtPwr(padapter, _FALSE);
11565         // coex table
11566         btdm_2AntCoexTable(padapter, 0x55555555, 0xffff, 0x3);
11567         btdm_2AntIgnoreWlanAct(padapter, _FALSE);
11568
11569         if(BTDM_IsHT40(padapter))
11570         {
11571                 RTPRINT(FBT, BT_TRACE, ("HT40\n"));
11572                 btRssiState = BTDM_CheckCoexRSSIState(padapter, 2, 37, 0);
11573                 // fw mechanism
11574                 if( (btRssiState == BT_RSSI_STATE_HIGH) ||
11575                         (btRssiState == BT_RSSI_STATE_STAY_HIGH) )
11576                 {
11577                         RTPRINT(FBT, BT_TRACE, ("Wifi rssi-1 high \n"));
11578                         PlatformEFIOWrite1Byte(padapter, 0x883, 0x40);
11579                         if(btInfoExt&BIT(0))    //a2dp rate, 1:basic /0:edr
11580                 {
11581                                 RTPRINT(FBT, BT_TRACE, ("a2dp basic rate \n"));
11582                                 btdm_2AntTdmaDurationAdjust(padapter, _TRUE, _FALSE, 3);
11583                 }
11584                 else
11585                 {
11586                                 RTPRINT(FBT, BT_TRACE, ("a2dp edr rate \n"));
11587                                 btdm_2AntTdmaDurationAdjust(padapter, _TRUE, _FALSE, 2);
11588                 }
11589         }
11590         else
11591         {
11592                         RTPRINT(FBT, BT_TRACE, ("Wifi rssi-1 low \n"));
11593                         if(btInfoExt&BIT(0))    //a2dp rate, 1:basic /0:edr
11594                 {
11595                                 RTPRINT(FBT, BT_TRACE, ("a2dp basic rate \n"));
11596                                 btdm_2AntTdmaDurationAdjust(padapter, _TRUE, _TRUE, 3);
11597                 }
11598                 else
11599                 {
11600                                 RTPRINT(FBT, BT_TRACE, ("a2dp edr rate \n"));
11601                                 btdm_2AntTdmaDurationAdjust(padapter, _TRUE, _TRUE, 2);
11602                         }
11603                 }
11604
11605                 // sw mechanism
11606                 btdm_2AntAgcTable(padapter, _FALSE);
11607                 btdm_2AntAdcBackOff(padapter, _FALSE);
11608                 btdm_2AntDacSwing(padapter, _FALSE, 0xc0);
11609         }
11610         else
11611         {
11612                 RTPRINT(FBT, BT_TRACE, ("HT20 or Legacy\n"));
11613                 btRssiState = BTDM_CheckCoexRSSIState(padapter, 2, 47, 0);
11614                 btRssiState1 = BTDM_CheckCoexRSSIState1(padapter, 2, 27, 0);
11615
11616                 // fw mechanism
11617                 if( (btRssiState1 == BT_RSSI_STATE_HIGH) ||
11618                         (btRssiState1 == BT_RSSI_STATE_STAY_HIGH) )
11619                 {
11620                         RTPRINT(FBT, BT_TRACE, ("Wifi rssi-1 high \n"));
11621                         PlatformEFIOWrite1Byte(padapter, 0x883, 0x40);
11622                         if(btInfoExt&BIT(0))    //a2dp rate, 1:basic /0:edr
11623                         {
11624                                 RTPRINT(FBT, BT_TRACE, ("a2dp basic rate \n"));
11625                                 btdm_2AntTdmaDurationAdjust(padapter, _TRUE, _FALSE, 3);
11626                         }
11627                         else
11628                         {
11629                                 RTPRINT(FBT, BT_TRACE, ("a2dp edr rate \n"));
11630                                 btdm_2AntTdmaDurationAdjust(padapter, _TRUE, _FALSE, 2);
11631                         }
11632                 }
11633                 else
11634                 {
11635                         RTPRINT(FBT, BT_TRACE, ("Wifi rssi-1 low \n"));
11636                         if(btInfoExt&BIT(0))    //a2dp rate, 1:basic /0:edr
11637                         {
11638                                 RTPRINT(FBT, BT_TRACE, ("a2dp basic rate \n"));
11639                                 btdm_2AntTdmaDurationAdjust(padapter, _TRUE, _TRUE, 3);
11640                         }
11641                         else
11642                         {
11643                                 RTPRINT(FBT, BT_TRACE, ("a2dp edr rate \n"));
11644                                 btdm_2AntTdmaDurationAdjust(padapter, _TRUE, _TRUE, 2);
11645                 }
11646         }
11647
11648                 // sw mechanism
11649                 if( (btRssiState == BT_RSSI_STATE_HIGH) ||
11650                         (btRssiState == BT_RSSI_STATE_STAY_HIGH) )
11651         {
11652                         RTPRINT(FBT, BT_TRACE, ("Wifi rssi high \n"));
11653                         btdm_2AntAgcTable(padapter, _TRUE);
11654                         btdm_2AntAdcBackOff(padapter, _TRUE);
11655                         btdm_2AntDacSwing(padapter, _FALSE, 0xc0);
11656         }
11657                 else
11658         {
11659                         RTPRINT(FBT, BT_TRACE, ("Wifi rssi low \n"));
11660                         btdm_2AntAgcTable(padapter, _FALSE);
11661                         btdm_2AntAdcBackOff(padapter, _FALSE);
11662                         btdm_2AntDacSwing(padapter, _FALSE, 0xc0);
11663         }
11664         }
11665 }
11666
11667 void btdm_2Ant8723AFtpA2dp(     PADAPTER        padapter        )
11668 {
11669         PHAL_DATA_TYPE  pHalData = GET_HAL_DATA(padapter);
11670         u8              btRssiState, btRssiState1, btInfoExt;
11671
11672         btInfoExt = pHalData->bt_coexist.halCoex8723.btInfoExt;
11673
11674         if(btdm_NeedToDecBtPwr(padapter))
11675                 btdm_2AntDecBtPwr(padapter, _TRUE);
11676         else
11677                 btdm_2AntDecBtPwr(padapter, _FALSE);
11678         // coex table
11679         btdm_2AntCoexTable(padapter, 0x55555555, 0xffff, 0x3);
11680         btdm_2AntIgnoreWlanAct(padapter, _FALSE);
11681
11682         if(BTDM_IsHT40(padapter))
11683         {
11684                 RTPRINT(FBT, BT_TRACE, ("HT40\n"));
11685                 btRssiState = BTDM_CheckCoexRSSIState(padapter, 2, 27, 0);
11686                 // fw mechanism
11687                 if( (btRssiState == BT_RSSI_STATE_HIGH) ||
11688                         (btRssiState == BT_RSSI_STATE_STAY_HIGH) )
11689                 {
11690                         RTPRINT(FBT, BT_TRACE, ("Wifi rssi-1 high \n"));
11691                         PlatformEFIOWrite1Byte(padapter, 0x883, 0x40);
11692                         btdm_2AntPsTdma(padapter, _TRUE, 3);
11693                         }
11694                         else
11695                         {
11696                         RTPRINT(FBT, BT_TRACE, ("Wifi rssi-1 low \n"));
11697                         btdm_2AntPsTdma(padapter, _TRUE, 7);
11698                         }
11699
11700                 // sw mechanism
11701                 btdm_2AntAgcTable(padapter, _FALSE);
11702                 btdm_2AntAdcBackOff(padapter, _TRUE);
11703                 btdm_2AntDacSwing(padapter, _FALSE, 0xc0);
11704                 }
11705                 else
11706                 {
11707                 RTPRINT(FBT, BT_TRACE, ("HT20 or Legacy\n"));
11708                 btRssiState = BTDM_CheckCoexRSSIState(padapter, 2, 47, 0);
11709                 btRssiState1 = BTDM_CheckCoexRSSIState1(padapter, 2, 27, 0);
11710
11711                 // fw mechanism
11712                 if( (btRssiState1 == BT_RSSI_STATE_HIGH) ||
11713                         (btRssiState1 == BT_RSSI_STATE_STAY_HIGH) )
11714                 {
11715                         RTPRINT(FBT, BT_TRACE, ("Wifi rssi-1 high \n"));
11716                         PlatformEFIOWrite1Byte(padapter, 0x883, 0x40);
11717                         btdm_2AntPsTdma(padapter, _TRUE, 3);
11718                 }
11719                 else
11720                         {
11721                         RTPRINT(FBT, BT_TRACE, ("Wifi rssi-1 low \n"));
11722                         btdm_2AntPsTdma(padapter,  _TRUE, 7);
11723                         }
11724
11725                 // sw mechanism
11726                 if( (btRssiState == BT_RSSI_STATE_HIGH) ||
11727                         (btRssiState == BT_RSSI_STATE_STAY_HIGH) )
11728                         {
11729                         RTPRINT(FBT, BT_TRACE, ("Wifi rssi high \n"));
11730                         btdm_2AntAgcTable(padapter, _TRUE);
11731                         btdm_2AntAdcBackOff(padapter, _TRUE);
11732                         btdm_2AntDacSwing(padapter, _FALSE, 0xc0);
11733                         }
11734                         else
11735                         {
11736                         RTPRINT(FBT, BT_TRACE, ("Wifi rssi low \n"));
11737                         btdm_2AntAgcTable(padapter, _FALSE);
11738                         btdm_2AntAdcBackOff(padapter, _FALSE);
11739                         btdm_2AntDacSwing(padapter, _FALSE, 0xc0);
11740                         }
11741                 }
11742         }
11743
11744
11745 void btdm_2Ant8723AA2dp(PADAPTER padapter)
11746         {
11747         PHAL_DATA_TYPE  pHalData = GET_HAL_DATA(padapter);
11748         u8              btRssiState, btRssiState1, btInfoExt;
11749
11750         btInfoExt = pHalData->bt_coexist.halCoex8723.btInfoExt;
11751
11752         if(btdm_NeedToDecBtPwr(padapter))
11753                 btdm_2AntDecBtPwr(padapter, _TRUE);
11754         else
11755                 btdm_2AntDecBtPwr(padapter, _FALSE);
11756                 // coex table
11757         btdm_2AntCoexTable(padapter, 0x55555555, 0xffff, 0x3);
11758         btdm_2AntIgnoreWlanAct(padapter, _FALSE);
11759
11760         if(BTDM_IsHT40(padapter))
11761         {
11762                 RTPRINT(FBT, BT_TRACE, ("HT40\n"));
11763                 btRssiState = BTDM_CheckCoexRSSIState(padapter, 2, 37, 0);
11764                 // fw mechanism
11765                 if( (btRssiState == BT_RSSI_STATE_HIGH) ||
11766                         (btRssiState == BT_RSSI_STATE_STAY_HIGH) )
11767                 {
11768                         RTPRINT(FBT, BT_TRACE, ("Wifi rssi-1 high \n"));
11769                         PlatformEFIOWrite1Byte(padapter, 0x883, 0x40);
11770                         btdm_2AntTdmaDurationAdjust(padapter, _FALSE, _FALSE, 1);
11771                 }
11772                 else
11773                 {
11774                         RTPRINT(FBT, BT_TRACE, ("Wifi rssi-1 low \n"));
11775                         btdm_2AntTdmaDurationAdjust(padapter, _FALSE, _TRUE, 1);
11776                 }
11777
11778                 // sw mechanism
11779                 btdm_2AntAgcTable(padapter, _FALSE);
11780                 btdm_2AntAdcBackOff(padapter, _TRUE);
11781                 btdm_2AntDacSwing(padapter, _FALSE, 0xc0);
11782         }
11783         else
11784         {
11785                 RTPRINT(FBT, BT_TRACE, ("HT20 or Legacy\n"));
11786                 btRssiState = BTDM_CheckCoexRSSIState(padapter, 2, 47, 0);
11787                 btRssiState1 = BTDM_CheckCoexRSSIState1(padapter, 2, 27, 0);
11788
11789                 // fw mechanism
11790                 if( (btRssiState1 == BT_RSSI_STATE_HIGH) ||
11791                         (btRssiState1 == BT_RSSI_STATE_STAY_HIGH) )
11792                 {
11793                         RTPRINT(FBT, BT_TRACE, ("Wifi rssi-1 high \n"));
11794                         PlatformEFIOWrite1Byte(padapter, 0x883, 0x40);
11795                         btdm_2AntTdmaDurationAdjust(padapter, _FALSE, _FALSE, 1);
11796                 }
11797                 else
11798                         {
11799                         RTPRINT(FBT, BT_TRACE, ("Wifi rssi-1 low \n"));
11800                         btdm_2AntTdmaDurationAdjust(padapter, _FALSE, _TRUE, 1);
11801                         }
11802
11803                 // sw mechanism
11804                 if( (btRssiState == BT_RSSI_STATE_HIGH) ||
11805                         (btRssiState == BT_RSSI_STATE_STAY_HIGH) )
11806                         {
11807                         RTPRINT(FBT, BT_TRACE, ("Wifi rssi high \n"));
11808                         btdm_2AntAgcTable(padapter, _TRUE);
11809                         btdm_2AntAdcBackOff(padapter, _TRUE);
11810                         btdm_2AntDacSwing(padapter, _FALSE, 0xc0);
11811                         }
11812                         else
11813                         {
11814                         RTPRINT(FBT, BT_TRACE, ("Wifi rssi low \n"));
11815                         btdm_2AntAgcTable(padapter, _FALSE);
11816                         btdm_2AntAdcBackOff(padapter, _FALSE);
11817                         btdm_2AntDacSwing(padapter, _FALSE, 0xc0);
11818                         }
11819                 }
11820 }
11821
11822
11823 void btdm_2Ant8723Ftp(PADAPTER  padapter)
11824                 {
11825         PHAL_DATA_TYPE  pHalData = GET_HAL_DATA(padapter);
11826         u8              btRssiState, btRssiState1, btInfoExt;
11827
11828         btInfoExt = pHalData->bt_coexist.halCoex8723.btInfoExt;
11829
11830         if(btdm_NeedToDecBtPwr(padapter))
11831                 btdm_2AntDecBtPwr(padapter, _TRUE);
11832         else
11833                 btdm_2AntDecBtPwr(padapter, _FALSE);
11834         // coex table
11835         btdm_2AntCoexTable(padapter, 0x55555555, 0xffff, 0x3);
11836         btdm_2AntIgnoreWlanAct(padapter, _FALSE);
11837
11838         if(BTDM_IsHT40(padapter))
11839                         {
11840                 RTPRINT(FBT, BT_TRACE, ("HT40\n"));
11841                 btRssiState = BTDM_CheckCoexRSSIState(padapter, 2, 37, 0);
11842                 // fw mechanism
11843                 if( (btRssiState == BT_RSSI_STATE_HIGH) ||
11844                         (btRssiState == BT_RSSI_STATE_STAY_HIGH) )
11845                         {
11846                         RTPRINT(FBT, BT_TRACE, ("Wifi rssi-1 high \n"));
11847                         PlatformEFIOWrite1Byte(padapter, 0x883, 0x40);
11848                         btdm_2AntPsTdma(padapter, _TRUE, 1);
11849                         }
11850                         else
11851                         {
11852                         RTPRINT(FBT, BT_TRACE, ("Wifi rssi-1 low \n"));
11853                         btdm_2AntPsTdma(padapter, _TRUE, 5);
11854                 }
11855
11856                 // sw mechanism
11857                 btdm_2AntAgcTable(padapter, _FALSE);
11858                 btdm_2AntAdcBackOff(padapter, _TRUE);
11859                 btdm_2AntDacSwing(padapter, _FALSE, 0xc0);
11860         }
11861         else
11862         {
11863                 RTPRINT(FBT, BT_TRACE, ("HT20 or Legacy\n"));
11864                 btRssiState = BTDM_CheckCoexRSSIState(padapter, 2, 47, 0);
11865                 btRssiState1 = BTDM_CheckCoexRSSIState1(padapter, 2, 27, 0);
11866
11867                 // fw mechanism
11868                 if( (btRssiState1 == BT_RSSI_STATE_HIGH) ||
11869                         (btRssiState1 == BT_RSSI_STATE_STAY_HIGH) )
11870         {
11871                         RTPRINT(FBT, BT_TRACE, ("Wifi rssi-1 high \n"));
11872                         PlatformEFIOWrite1Byte(padapter, 0x883, 0x40);
11873                         btdm_2AntPsTdma(padapter, _TRUE, 1);
11874                 }
11875                 else
11876                 {
11877                         RTPRINT(FBT, BT_TRACE, ("Wifi rssi-1 low \n"));
11878                         btdm_2AntPsTdma(padapter, _TRUE, 5);
11879         }
11880
11881                 // sw mechanism
11882                 if( (btRssiState == BT_RSSI_STATE_HIGH) ||
11883                         (btRssiState == BT_RSSI_STATE_STAY_HIGH) )
11884         {
11885                         RTPRINT(FBT, BT_TRACE, ("Wifi rssi high \n"));
11886                         btdm_2AntAgcTable(padapter, _TRUE);
11887                         btdm_2AntAdcBackOff(padapter, _TRUE);
11888                         btdm_2AntDacSwing(padapter, _FALSE, 0xc0);
11889         }
11890                 else
11891         {
11892                         RTPRINT(FBT, BT_TRACE, ("Wifi rssi low \n"));
11893                         btdm_2AntAgcTable(padapter, _FALSE);
11894                         btdm_2AntAdcBackOff(padapter, _FALSE);
11895                         btdm_2AntDacSwing(padapter, _FALSE, 0xc0);
11896                 }
11897         }
11898 }
11899
11900 //============================================================
11901 // extern function start with BTDM_
11902 //============================================================
11903 void BTDM_2AntParaInit(PADAPTER padapter)
11904 {
11905
11906         PHAL_DATA_TYPE  pHalData = GET_HAL_DATA(padapter);
11907         PBTDM_8723A_2ANT        pBtdm8723 = &pHalData->bt_coexist.halCoex8723.btdm2Ant;
11908
11909         RTPRINT(FBT, BT_TRACE, ("[BTCoex], 2Ant Parameter Init!!\n"));
11910
11911         // Enable counter statistics
11912         rtw_write8(padapter, 0x76e, 0x4);
11913         rtw_write8(padapter, 0x778, 0x3);
11914         rtw_write8(padapter, 0x40, 0x20);
11915
11916         // force to reset coex mechanism
11917         pBtdm8723->preVal0x6c0 = 0x0;
11918         btdm_2AntCoexTable(padapter, 0x55555555, 0xffff, 0x3);
11919
11920         pBtdm8723->bPrePsTdmaOn = _TRUE;
11921         btdm_2AntPsTdma(padapter, _FALSE, 0);
11922
11923         pBtdm8723->preFwDacSwingLvl = 0x10;
11924         btdm_2AntFwDacSwingLvl(padapter, 0x20);
11925
11926         pBtdm8723->bPreDecBtPwr = _TRUE;
11927         btdm_2AntDecBtPwr(padapter, _FALSE);
11928
11929         pBtdm8723->bPreAgcTableEn = _TRUE;
11930         btdm_2AntAgcTable(padapter, _FALSE);
11931
11932         pBtdm8723->bPreAdcBackOff = _TRUE;
11933         btdm_2AntAdcBackOff(padapter, _FALSE);
11934
11935         pBtdm8723->bPreLowPenaltyRa = _TRUE;
11936         btdm_2AntLowPenaltyRa(padapter, _FALSE);
11937
11938         pBtdm8723->bPreRfRxLpfShrink = _TRUE;
11939         btdm_2AntRfShrink(padapter, _FALSE);
11940
11941         pBtdm8723->bPreDacSwingOn = _TRUE;
11942         btdm_2AntDacSwing(padapter, _FALSE, 0xc0);
11943
11944         pBtdm8723->bPreIgnoreWlanAct = _TRUE;
11945         btdm_2AntIgnoreWlanAct(padapter, _FALSE);
11946 }
11947
11948 void BTDM_2AntHwCoexAllOff8723A(PADAPTER padapter)
11949 {
11950         btdm_2AntCoexTable(padapter, 0x55555555, 0xffff, 0x3);
11951 }
11952
11953 void BTDM_2AntFwCoexAllOff8723A(PADAPTER padapter)
11954 {
11955         btdm_2AntIgnoreWlanAct(padapter, _FALSE);
11956         btdm_2AntPsTdma(padapter, _FALSE, 0);
11957         btdm_2AntFwDacSwingLvl(padapter, 0x20);
11958         btdm_2AntDecBtPwr(padapter, _FALSE);
11959 }
11960
11961 void BTDM_2AntSwCoexAllOff8723A(PADAPTER padapter)
11962 {
11963         btdm_2AntAgcTable(padapter, _FALSE);
11964         btdm_2AntAdcBackOff(padapter, _FALSE);
11965         btdm_2AntLowPenaltyRa(padapter, _FALSE);
11966         btdm_2AntRfShrink(padapter, _FALSE);
11967         btdm_2AntDacSwing(padapter, _FALSE, 0xc0);
11968 }
11969
11970
11971 void BTDM_2AntIpsNotify8723A(PADAPTER   padapter,u8             type)
11972 {
11973         PBT30Info               pBTInfo = GET_BT_INFO(padapter);
11974         PBT_MGNT                pBtMgnt=&pBTInfo->BtMgnt;
11975
11976         if(pBtMgnt->bSupportProfile && (rf_off==type))
11977         {
11978                 RTPRINT(FBT, BT_TRACE, ("[BT][DM], enter IPS, turn off all BT Coexist DM\n"));
11979                 BTDM_CoexAllOff(padapter);
11980 }
11981 }
11982
11983
11984 void BTDM_2AntNotifyBtOperation8723(PADAPTER padapter)
11985 {
11986         PBT30Info               pBTInfo = GET_BT_INFO(padapter);
11987         PBT_MGNT                pBtMgnt = &pBTInfo->BtMgnt;
11988         PHAL_DATA_TYPE  pHalData = GET_HAL_DATA(padapter);
11989
11990         switch (pBtMgnt->ExtConfig.btOperationCode)
11991         {
11992                 case HCI_BT_OP_NONE:
11993                         RTPRINT(FIOCTL, IOCTL_BT_HCICMD_EXT, ("[BT OP] : Adjust for operation None!!\n"));
11994                         break;
11995                 case HCI_BT_OP_INQUIRY_START:
11996                         RTPRINT(FIOCTL, IOCTL_BT_HCICMD_EXT, ("[BT OP] : Adjust for Inquiry start!!\n"));
11997                         pBtMgnt->ExtConfig.bHoldForBtOperation = _TRUE;
11998                         pBtMgnt->ExtConfig.bHoldPeriodCnt = 1;
11999                         btdm_2AntBtInquiryPage(padapter);
12000                         break;
12001                 case HCI_BT_OP_INQUIRY_FINISH:
12002                         RTPRINT(FIOCTL, IOCTL_BT_HCICMD_EXT, ("[BT OP] : Adjust for Inquiry finished!!\n"));
12003                         pBtMgnt->ExtConfig.bHoldForBtOperation = _FALSE;
12004                         break;
12005                 case HCI_BT_OP_PAGING_START:
12006                         RTPRINT(FIOCTL, IOCTL_BT_HCICMD_EXT, ("[BT OP] : Adjust for paging start!!\n"));
12007                         pBtMgnt->ExtConfig.bHoldForBtOperation = _TRUE;
12008                         pBtMgnt->ExtConfig.bHoldPeriodCnt = 1;
12009                         btdm_2AntBtInquiryPage(padapter);
12010                         break;
12011                 case HCI_BT_OP_PAGING_SUCCESS:
12012                         RTPRINT(FIOCTL, IOCTL_BT_HCICMD_EXT, ("[BT OP] : Adjust for paging successfully!!\n"));
12013                         pBtMgnt->ExtConfig.bHoldForBtOperation = _FALSE;
12014                         break;
12015                 case HCI_BT_OP_PAGING_UNSUCCESS:
12016                         RTPRINT(FIOCTL, IOCTL_BT_HCICMD_EXT, ("[BT OP] : Adjust for paging unsuccessfully!!\n"));
12017                         pBtMgnt->ExtConfig.bHoldForBtOperation = _FALSE;
12018                         break;
12019                 case HCI_BT_OP_PAIRING_START:
12020                         RTPRINT(FIOCTL, IOCTL_BT_HCICMD_EXT, ("[BT OP] : Adjust for Pairing start!!\n"));
12021                         pBtMgnt->ExtConfig.bHoldForBtOperation = _TRUE;
12022                         pBtMgnt->ExtConfig.bHoldPeriodCnt = 1;
12023                         btdm_2AntBtInquiryPage(padapter);
12024                         break;
12025                 case HCI_BT_OP_PAIRING_FINISH:
12026                         RTPRINT(FIOCTL, IOCTL_BT_HCICMD_EXT, ("[BT OP] : Adjust for Pairing finished!!\n"));
12027                         pBtMgnt->ExtConfig.bHoldForBtOperation = _FALSE;
12028                         break;
12029
12030                 case HCI_BT_OP_BT_DEV_ENABLE:
12031                         RTPRINT(FIOCTL, IOCTL_BT_HCICMD_EXT, ("[BT OP] : Adjust for BT Device enable!!\n"));
12032                         break;
12033                 case HCI_BT_OP_BT_DEV_DISABLE:
12034                         RTPRINT(FIOCTL, IOCTL_BT_HCICMD_EXT, ("[BT OP] : Adjust for BT Device disable!!\n"));
12035                         break;
12036                 default:
12037                         RTPRINT(FIOCTL, IOCTL_BT_HCICMD_EXT, ("[BT OP] : Adjust for Unknown, error!!\n"));
12038                         break;
12039         }
12040 }
12041
12042
12043
12044 void btdm_BtHwCountersMonitor(PADAPTER padapter);
12045 VOID
12046 BTDM_2AntFwC2hBtInfo8723A(
12047         PADAPTER        padapter
12048         )
12049 {
12050         PBT30Info               pBTInfo = GET_BT_INFO(padapter);
12051         PBT_MGNT                pBtMgnt = &pBTInfo->BtMgnt;
12052         PHAL_DATA_TYPE  pHalData = GET_HAL_DATA(padapter);
12053         PBTDM_8723A_2ANT pBtdm8723 = &pHalData->bt_coexist.halCoex8723.btdm2Ant;
12054         u1Byte  btInfo=0;
12055         u8                      algorithm=BT_2ANT_COEX_ALGO_UNDEFINED;
12056         u8                      bScoExist=_FALSE, bBtLinkExist=_FALSE, bBtHsModeExist=_FALSE;
12057         btInfo = pHalData->bt_coexist.halCoex8723.c2hBtInfoOriginal;
12058
12059
12060         pBtdm8723->btStatus = BT_2ANT_BT_STATUS_IDLE;
12061
12062         // check BIT2 first ==> check if bt is under inquiry or page scan
12063         if(btInfo & BIT(2))
12064         {
12065                 if(pHalData->bt_coexist.halCoex8723.bC2hBtInquiryPage == _FALSE){
12066                         pBtMgnt->ExtConfig.bHoldForBtOperation = _TRUE;
12067                         pBtMgnt->ExtConfig.bHoldPeriodCnt = 1;
12068                         btdm_2AntBtInquiryPage(padapter);
12069                 }
12070                 else{
12071                         pBtMgnt->ExtConfig.bHoldPeriodCnt++;
12072                         btdm_HoldForBtInqPage(padapter);
12073                 }
12074                 pHalData->bt_coexist.halCoex8723.bC2hBtInquiryPage = _TRUE;
12075
12076         }
12077         else
12078         {
12079                 pHalData->bt_coexist.halCoex8723.bC2hBtInquiryPage = _FALSE;
12080                 pBtMgnt->ExtConfig.bHoldForBtOperation = _FALSE;
12081                 pBtMgnt->ExtConfig.bHoldPeriodCnt = 0;
12082
12083
12084         }
12085         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));
12086
12087         RTPRINT(FBT, BT_TRACE, ("[BTC2H],   btInfo=%x   pHalData->bt_coexist.halCoex8723.c2hBtInfoOriginal=%x\n",btInfo,pHalData->bt_coexist.halCoex8723.c2hBtInfoOriginal));
12088 //      btdm_BtHwCountersMonitor(padapter);
12089 //      btdm_2AntBtEnableDisableCheck8723A(padapter);
12090         if(btInfo&BT_INFO_ACL)
12091         {
12092                 RTPRINT(FBT, BT_TRACE, ("[BTC2H], BTInfo: bConnect=TRUE   btInfo=%x\n",btInfo));
12093                 //pBtMgnt->ExtConfig.bBTBusy = _TRUE;
12094                 bBtLinkExist = _TRUE;
12095                 if(((btInfo&(BT_INFO_FTP|BT_INFO_A2DP|BT_INFO_HID|BT_INFO_SCO_BUSY))!=0) || pHalData->bt_coexist.halCoex8723.btRetryCnt>0){
12096                         pBtdm8723->btStatus =BT_2ANT_BT_STATUS_NON_IDLE;
12097                 }
12098                 else
12099                         pBtdm8723->btStatus =BT_2ANT_BT_STATUS_CONNECTED_IDLE;
12100
12101
12102                 if(btInfo&BT_INFO_SCO|| btInfo&BT_INFO_SCO_BUSY){
12103                         if(btInfo&BT_INFO_FTP|| btInfo&BT_INFO_A2DP||btInfo&BT_INFO_HID){
12104                                 switch(btInfo&0xe0){
12105                                         case BT_INFO_HID :
12106                                                 RTPRINT(FBT, BT_TRACE, ("[BTCoex], SCO + HID\n"));
12107                                                 algorithm = BT_2ANT_COEX_ALGO_HID;
12108                                                 break;
12109                                         case BT_INFO_A2DP :
12110                                                 RTPRINT(FBT, BT_TRACE, ("[BTCoex], Error!!! SCO + A2DP\n"));
12111                                                 break;
12112                                         case BT_INFO_FTP :
12113                                                 if(bBtHsModeExist)
12114                                                 {
12115                                                         RTPRINT(FBT, BT_TRACE, ("[BTCoex], SCO + PAN(HS)\n"));
12116                                                         algorithm = BT_2ANT_COEX_ALGO_SCO;
12117                                                 }
12118                                                 else
12119                                                 {
12120                                                         RTPRINT(FBT, BT_TRACE, ("[BTCoex], SCO + PAN(EDR)\n"));
12121                                                         algorithm = BT_2ANT_COEX_ALGO_PANEDR_HID;
12122                                                 }
12123                                                 break;
12124                                         case (BT_INFO_HID|BT_INFO_A2DP) :
12125                                                 RTPRINT(FBT, BT_TRACE, ("[BTCoex], HID + A2DP\n"));
12126                                                 algorithm = BT_2ANT_COEX_ALGO_HID_A2DP;
12127                                                 break;
12128                                         case (BT_INFO_HID|BT_INFO_FTP) :
12129                                                 if(bBtHsModeExist)
12130                                                 {
12131                                                         RTPRINT(FBT, BT_TRACE, ("[BTCoex], HID + PAN(HS)\n"));
12132                                                         algorithm = BT_2ANT_COEX_ALGO_HID_A2DP;
12133                                                 }
12134                                                 else
12135                                                 {
12136                                                         RTPRINT(FBT, BT_TRACE, ("[BTCoex], HID + PAN(EDR)\n"));
12137                                                         algorithm = BT_2ANT_COEX_ALGO_PANEDR_HID;
12138                                                 }
12139                                                 break;
12140                                         case (BT_INFO_A2DP|BT_INFO_FTP) :
12141                                                 if(bBtHsModeExist)
12142                                                 {
12143                                                         RTPRINT(FBT, BT_TRACE, ("[BTCoex], A2DP + PAN(HS)\n"));
12144                                                         algorithm = BT_2ANT_COEX_ALGO_A2DP;
12145                                                 }
12146                                                 else
12147                                                 {
12148                                                         RTPRINT(FBT, BT_TRACE, ("[BTCoex], A2DP + PAN(EDR)\n"));
12149                                                         algorithm = BT_2ANT_COEX_ALGO_PANEDR_A2DP;
12150                                                 }
12151                                                 break;
12152                                         case (BT_INFO_HID|BT_INFO_A2DP|BT_INFO_FTP) :
12153                                                 if(bBtHsModeExist)
12154                                                 {
12155                                                         RTPRINT(FBT, BT_TRACE, ("[BTCoex], HID + A2DP + PAN(HS)\n"));
12156                                                         algorithm = BT_2ANT_COEX_ALGO_HID_A2DP;
12157                                                 }
12158                                                 else
12159                                                 {
12160                                                         RTPRINT(FBT, BT_TRACE, ("[BTCoex], HID + A2DP + PAN(EDR)\n"));
12161                                                         algorithm = BT_2ANT_COEX_ALGO_HID_A2DP_PANEDR;
12162                                                 }
12163                                                 break;
12164
12165                                 }
12166                         }
12167                         else{
12168                                 RTPRINT(FBT, BT_TRACE, ("[BTCoex], SCO only\n"));
12169                                 algorithm = BT_2ANT_COEX_ALGO_SCO;
12170                         }
12171                 }
12172                 else{
12173                                 RTPRINT(FBT, BT_TRACE, ("[BTCoex], non SCO\n"));
12174                                 switch(btInfo&0xe0){
12175                                         case BT_INFO_HID :
12176                                                 RTPRINT(FBT, BT_TRACE, ("[BTCoex], HID\n"));
12177                                                 algorithm = BT_2ANT_COEX_ALGO_HID;
12178                                                 break;
12179                                         case BT_INFO_A2DP :
12180                                                 RTPRINT(FBT, BT_TRACE, ("[BTCoex],  A2DP\n"));
12181                                                 algorithm = BT_2ANT_COEX_ALGO_A2DP;
12182                                                 break;
12183                                         case BT_INFO_FTP :
12184                                                 RTPRINT(FBT, BT_TRACE, ("[BTCoex], PAN(EDR)\n"));
12185                                                 algorithm = BT_2ANT_COEX_ALGO_PANEDR_HID;
12186                                                 break;
12187                                         case (BT_INFO_HID|BT_INFO_A2DP) :
12188                                                 RTPRINT(FBT, BT_TRACE, ("[BTCoex], HID + A2DP\n"));
12189                                                 algorithm = BT_2ANT_COEX_ALGO_HID_A2DP;
12190                                                 break;
12191                                         case (BT_INFO_HID|BT_INFO_FTP) :
12192                                                 if(bBtHsModeExist)
12193                                                 {
12194                                                         RTPRINT(FBT, BT_TRACE, ("[BTCoex], HID + PAN(HS)\n"));
12195                                                         algorithm = BT_2ANT_COEX_ALGO_HID_A2DP;
12196                                                 }
12197                                                 else
12198                                                 {
12199                                                         RTPRINT(FBT, BT_TRACE, ("[BTCoex], HID + PAN(EDR)\n"));
12200                                                         algorithm = BT_2ANT_COEX_ALGO_PANEDR_HID;
12201                                                 }
12202                                                 break;
12203                                         case (BT_INFO_A2DP|BT_INFO_FTP) :
12204                                                 if(bBtHsModeExist)
12205                                                 {
12206                                                         RTPRINT(FBT, BT_TRACE, ("[BTCoex], A2DP + PAN(HS)\n"));
12207                                                         algorithm = BT_2ANT_COEX_ALGO_A2DP;
12208                                                 }
12209                                                 else
12210                                                 {
12211                                                         RTPRINT(FBT, BT_TRACE, ("[BTCoex], A2DP + PAN(EDR)\n"));
12212                                                         algorithm = BT_2ANT_COEX_ALGO_PANEDR_A2DP;
12213                                                 }
12214                                                 break;
12215                                         case (BT_INFO_HID|BT_INFO_A2DP|BT_INFO_FTP) :
12216                                                 if(bBtHsModeExist)
12217                                                 {
12218                                                         RTPRINT(FBT, BT_TRACE, ("[BTCoex], HID + A2DP + PAN(HS)\n"));
12219                                                         algorithm = BT_2ANT_COEX_ALGO_HID_A2DP;
12220                                                 }
12221                                                 else
12222                                                 {
12223                                                         RTPRINT(FBT, BT_TRACE, ("[BTCoex], HID + A2DP + PAN(EDR)\n"));
12224                                                         algorithm = BT_2ANT_COEX_ALGO_HID_A2DP_PANEDR;
12225                                                 }
12226                                                 break;
12227
12228                                 }
12229
12230                 }
12231         }
12232         else
12233         {
12234                 RTPRINT(FBT, BT_TRACE, ("[BTC2H], BTInfo: bConnect=FALSE\n"));
12235                 //pBtMgnt->ExtConfig.bBTBusy = _FALSE;
12236                 pBtdm8723->btStatus =BT_2ANT_BT_STATUS_IDLE;
12237         }
12238
12239         pBtdm8723->curAlgorithm =algorithm;
12240         RTPRINT(FBT, BT_TRACE, ("[BTCoex], Algorithm = %d \n", pBtdm8723->curAlgorithm));
12241
12242 //From
12243         BTDM_CheckWiFiState(padapter);
12244         if(pBtMgnt->ExtConfig.bManualControl)
12245         {
12246                 RTPRINT(FBT, BT_TRACE, ("Action Manual control, won't execute bt coexist mechanism!!\n"));
12247                 return;
12248         }
12249
12250 }
12251
12252
12253 void BTDM_2AntBtCoexist8723A(PADAPTER padapter)
12254 {
12255         PBT30Info               pBTInfo = GET_BT_INFO(padapter);
12256         PBT_MGNT                pBtMgnt = &pBTInfo->BtMgnt;
12257         PBT_DBG                 pBtDbg = &pBTInfo->BtDbg;
12258         u8                              BtState = 0, btInfoOriginal=0, btRetryCnt=0;
12259         PHAL_DATA_TYPE  pHalData = GET_HAL_DATA(padapter);
12260         PBTDM_8723A_2ANT        pBtdm8723 = &pHalData->bt_coexist.halCoex8723.btdm2Ant;
12261
12262         if (BTDM_BtProfileSupport(padapter))
12263         {
12264                 if (pBtMgnt->ExtConfig.bHoldForBtOperation)
12265                 {
12266                         RTPRINT(FBT, BT_TRACE, ("Action for BT Operation adjust!!\n"));
12267                         return;
12268                 }
12269                 if(pBtMgnt->ExtConfig.bHoldPeriodCnt)
12270                 {
12271                         RTPRINT(FBT, BT_TRACE, ("Hold BT inquiry/page scan setting (cnt = %d)!!\n",
12272                                 pBtMgnt->ExtConfig.bHoldPeriodCnt));
12273                         if(pBtMgnt->ExtConfig.bHoldPeriodCnt >= 11)
12274                         {
12275                                 pBtMgnt->ExtConfig.bHoldPeriodCnt = 0;
12276                                 // next time the coexist parameters should be reset again.
12277                         }
12278                         else
12279                                 pBtMgnt->ExtConfig.bHoldPeriodCnt++;
12280                         return;
12281                 }
12282
12283                 if(pBtDbg->dbgCtrl)
12284                 {
12285                         RTPRINT(FBT, BT_TRACE, ("[Dbg control], "));
12286                 }
12287
12288                 pBtdm8723->curAlgorithm = btdm_ActionAlgorithm(padapter);
12289                 RTPRINT(FBT, BT_TRACE, ("[BTCoex], Algorithm = %d \n", pBtdm8723->curAlgorithm));
12290
12291                 if (btdm_Is2Ant8723ACommonAction(padapter))
12292                 {
12293                         RTPRINT(FBT, BT_TRACE, ("Action 2-Ant common.\n"));
12294                         pBtdm8723->bResetTdmaAdjust = _TRUE;
12295                 }
12296                 else
12297                 {
12298                         if(pBtdm8723->curAlgorithm != pBtdm8723->preAlgorithm)
12299                         {
12300                                 RTPRINT(FBT, BT_TRACE, ("[BTCoex], preAlgorithm=%d, curAlgorithm=%d\n",
12301                                 pBtdm8723->preAlgorithm, pBtdm8723->curAlgorithm));
12302                                 pBtdm8723->bResetTdmaAdjust = _TRUE;
12303                         }
12304                         switch(pBtdm8723->curAlgorithm)
12305                         {
12306                                 case BT_2ANT_COEX_ALGO_SCO:
12307                                         RTPRINT(FBT, BT_TRACE, ("Action 2-Ant, algorithm = SCO.\n"));
12308                                         btdm_2Ant8723ASCOAction(padapter);
12309                                         break;
12310                                 case BT_2ANT_COEX_ALGO_HID:
12311                                         RTPRINT(FBT, BT_TRACE, ("Action 2-Ant, algorithm = HID.\n"));
12312                                         btdm_2Ant8723AHIDAction(padapter);
12313                                         break;
12314                                 case BT_2ANT_COEX_ALGO_A2DP:
12315                                         RTPRINT(FBT, BT_TRACE, ("Action 2-Ant, algorithm = A2DP.\n"));
12316                                         btdm_2Ant8723AA2DPAction(padapter);
12317                                         break;
12318                                 case BT_2ANT_COEX_ALGO_PANEDR:
12319                                         RTPRINT(FBT, BT_TRACE, ("Action 2-Ant, algorithm = PAN(EDR).\n"));
12320                                         btdm_2Ant8723APANEDRAction(padapter);
12321                                         break;
12322                                 case BT_2ANT_COEX_ALGO_PANHS:
12323                                         RTPRINT(FBT, BT_TRACE, ("Action 2-Ant, algorithm = HS mode.\n"));
12324                                         btdm_2Ant8723APANHSAction(padapter);
12325                                         break;
12326                                 case BT_2ANT_COEX_ALGO_PANEDR_A2DP:
12327                                         RTPRINT(FBT, BT_TRACE, ("Action 2-Ant, algorithm = PAN+A2DP.\n"));
12328                                         btdm_2Ant8723APANEDRA2DPAction(padapter);
12329                                         break;
12330                                 case BT_2ANT_COEX_ALGO_PANEDR_HID:
12331                                         RTPRINT(FBT, BT_TRACE, ("Action 2-Ant, algorithm = PAN(EDR)+HID.\n"));
12332                                         btdm_2Ant8723APANEDRHIDAction(padapter);
12333                                         break;
12334                                 case BT_2ANT_COEX_ALGO_HID_A2DP_PANEDR:
12335                                         RTPRINT(FBT, BT_TRACE, ("Action 2-Ant, algorithm = HID+A2DP+PAN.\n"));
12336                                         btdm_2Ant8723AHIDA2DPPANEDRAction(padapter);
12337                                         break;
12338                                 case BT_2ANT_COEX_ALGO_HID_A2DP:
12339                                         RTPRINT(FBT, BT_TRACE, ("Action 2-Ant, algorithm = HID+A2DP.\n"));
12340                                         btdm_2Ant8723AHIDA2DPAction(padapter);
12341                                         break;
12342                                 default:
12343                                         RTPRINT(FBT, BT_TRACE, ("Action 2-Ant, algorithm = 0.\n"));
12344                                         btdm_2Ant8723AA2DPAction(padapter);
12345                                         break;
12346                         }
12347                         pBtdm8723->preAlgorithm = pBtdm8723->curAlgorithm;
12348                 }
12349         }
12350         else
12351         {
12352                 RTPRINT(FBT, BT_TRACE, ("[BTCoex] Get bt info by fw!!\n"));
12353                 //msg shows c2h rsp for bt_info is received or not.
12354                 if (pHalData->bt_coexist.halCoex8723.bC2hBtInfoReqSent)
12355                 {
12356                         RTPRINT(FBT, BT_TRACE, ("[BTCoex] c2h for btInfo not rcvd yet!!\n"));
12357                 }
12358
12359                 //btRetryCnt = pHalData->bt_coexist.halCoex8723.btRetryCnt;
12360                 btInfoOriginal = pHalData->bt_coexist.halCoex8723.c2hBtInfoOriginal;
12361
12362                 if(pBtMgnt->ExtConfig.bHoldForBtOperation)
12363                 {
12364                         RTPRINT(FBT, BT_TRACE, ("Action for BT Operation adjust!!\n"));
12365                         return;
12366                 }
12367                 if(pBtMgnt->ExtConfig.bHoldPeriodCnt)
12368                 {
12369                         RTPRINT(FBT, BT_TRACE, ("Hold BT inquiry/page scan setting (cnt = %d)!!\n", pBtMgnt->ExtConfig.bHoldPeriodCnt));
12370                         if(pBtMgnt->ExtConfig.bHoldPeriodCnt >= 11)
12371                         {
12372                                 pBtMgnt->ExtConfig.bHoldPeriodCnt = 0;
12373                                 // next time the coexist parameters should be reset again.
12374                         }
12375                         else
12376                                 pBtMgnt->ExtConfig.bHoldPeriodCnt++;
12377                         return;
12378                 }
12379
12380                 if(pBtDbg->dbgCtrl)
12381                 {
12382                         RTPRINT(FBT, BT_TRACE, ("[Dbg control], "));
12383                 }
12384                 if (btdm_Is2Ant8723ACommonAction(padapter))
12385                 {
12386                         RTPRINT(FBT, BT_TRACE, ("Action 2-Ant common.\n"));
12387                         pBtdm8723->bResetTdmaAdjust = _TRUE;
12388                 }
12389                 else
12390                 {
12391                         if(pBtdm8723->curAlgorithm != pBtdm8723->preAlgorithm)
12392                         {
12393                                 RTPRINT(FBT, BT_TRACE, ("[BTCoex], preAlgorithm=%d, curAlgorithm=%d\n", pBtdm8723->preAlgorithm, pBtdm8723->curAlgorithm));
12394                                 pBtdm8723->bResetTdmaAdjust = _TRUE;
12395                         }
12396                         switch(pBtdm8723->curAlgorithm)
12397                         {
12398                                 case BT_2ANT_COEX_ALGO_SCO:
12399                                         RTPRINT(FBT, BT_TRACE, ("Action 2-Ant, algorithm = SCO.\n"));
12400                                         btdm_2Ant8723ASCOAction(padapter);
12401                                         break;
12402                                 case BT_2ANT_COEX_ALGO_HID:
12403                                         RTPRINT(FBT, BT_TRACE, ("Action 2-Ant, algorithm = HID.\n"));
12404                                         btdm_2Ant8723AHIDAction(padapter);
12405                                         break;
12406                                 case BT_2ANT_COEX_ALGO_A2DP:
12407                                         RTPRINT(FBT, BT_TRACE, ("Action 2-Ant, algorithm = A2DP.\n"));
12408                                         btdm_2Ant8723AA2dp(padapter);
12409                                         break;
12410                                 case BT_2ANT_COEX_ALGO_PANEDR:
12411                                         RTPRINT(FBT, BT_TRACE, ("Action 2-Ant, algorithm = PAN(EDR).\n"));
12412                                         btdm_2Ant8723APANEDRAction(padapter);
12413                                         break;
12414                                 case BT_2ANT_COEX_ALGO_PANHS:
12415                                         RTPRINT(FBT, BT_TRACE, ("Action 2-Ant, algorithm = HS mode.\n"));
12416                                         btdm_2Ant8723APANHSAction(padapter);
12417                                         break;
12418                                 case BT_2ANT_COEX_ALGO_PANEDR_A2DP:
12419                                         RTPRINT(FBT, BT_TRACE, ("Action 2-Ant, algorithm = PAN+A2DP.\n"));
12420                                         btdm_2Ant8723APANEDRA2DPAction(padapter);
12421                                         break;
12422                                 case BT_2ANT_COEX_ALGO_PANEDR_HID:
12423                                         RTPRINT(FBT, BT_TRACE, ("Action 2-Ant, algorithm = PAN(EDR)+HID.\n"));
12424                                         btdm_2Ant8723APANEDRHIDAction(padapter);
12425                                         break;
12426                                 case BT_2ANT_COEX_ALGO_HID_A2DP_PANEDR:
12427                                         RTPRINT(FBT, BT_TRACE, ("Action 2-Ant, algorithm = HID+A2DP+PAN.\n"));
12428                                         btdm_2Ant8723AHIDA2DPPANEDRAction(padapter);
12429                                         break;
12430                                 case BT_2ANT_COEX_ALGO_HID_A2DP:
12431                                         RTPRINT(FBT, BT_TRACE, ("Action 2-Ant, algorithm = HID+A2DP.\n"));
12432                                         btdm_2Ant8723AHIDA2DPAction(padapter);
12433                                         break;
12434                                 default:
12435                                         RTPRINT(FBT, BT_TRACE, ("Action 2-Ant, algorithm = 0.\n"));
12436                                         //btdm_2Ant8723AAction0(padapter);
12437                                         btdm_2Ant8723AA2DPAction(padapter);
12438                                         break;
12439                         }
12440                         pBtdm8723->preAlgorithm = pBtdm8723->curAlgorithm;
12441                 }
12442
12443         }
12444 }
12445
12446 // ===== End of sync from SD7 driver HAL/BTCoexist/HalBtc87232Ant.c =====
12447 #endif
12448
12449 #ifdef __HALBTC8723_C__ // HAL/BTCoexist/HalBtc8723.c
12450 // ===== Below this line is sync from SD7 driver HAL/BTCoexist/HalBtc8723.c =====
12451
12452 static u8 btCoexDbgBuf[BT_TMP_BUF_SIZE];
12453 const char *const BtProfileString[]={
12454         "NONE",
12455         "A2DP",
12456         "PAN",
12457         "HID",
12458         "SCO",
12459 };
12460 const char *const BtSpecString[]={
12461         "1.0b",
12462         "1.1",
12463         "1.2",
12464         "2.0+EDR",
12465         "2.1+EDR",
12466         "3.0+HS",
12467         "4.0",
12468 };
12469 const char *const BtLinkRoleString[]={
12470         "Master",
12471         "Slave",
12472 };
12473
12474 u8 btdm_BtWifiAntNum(PADAPTER padapter)
12475 {
12476         PHAL_DATA_TYPE  pHalData = GET_HAL_DATA(padapter);
12477         PBT_COEXIST_8723A       pBtCoex = &pHalData->bt_coexist.halCoex8723;
12478
12479 //      RTPRINT(FBT, BT_TRACE, ("%s pHalData->bt_coexist.BluetoothCoexist =%x pHalData->EEPROMBluetoothCoexist=%x \n",
12480 //              __func__,pHalData->bt_coexist.BluetoothCoexist,pHalData->EEPROMBluetoothCoexist));
12481 //      RTPRINT(FBT, BT_TRACE, ("%s pHalData->bt_coexist.BT_Ant_Num =%x pHalData->EEPROMBluetoothAntNum=%x \n",
12482 //              __func__,pHalData->bt_coexist.BT_Ant_Num,pHalData->EEPROMBluetoothAntNum));
12483         if (Ant_x2 == pHalData->bt_coexist.BT_Ant_Num)
12484         {
12485                 if (Ant_x2 == pBtCoex->TotalAntNum)
12486                         return Ant_x2;
12487                 else
12488                         return Ant_x1;
12489         }
12490         else
12491         {
12492                 return Ant_x1;
12493         }
12494
12495         return Ant_x2;
12496 }
12497
12498 void btdm_BtHwCountersMonitor(PADAPTER padapter)
12499 {
12500         PHAL_DATA_TYPE  pHalData = GET_HAL_DATA(padapter);
12501         u32                             regHPTxRx, regLPTxRx, u4Tmp;
12502         u32                             regHPTx=0, regHPRx=0, regLPTx=0, regLPRx=0;
12503 //      u8                              u1Tmp;
12504
12505
12506         regHPTxRx = REG_HIGH_PRIORITY_TXRX;
12507         regLPTxRx = REG_LOW_PRIORITY_TXRX;
12508
12509         u4Tmp = rtw_read32(padapter, regHPTxRx);
12510         regHPTx = u4Tmp & bMaskLWord;
12511         regHPRx = (u4Tmp & bMaskHWord)>>16;
12512
12513         u4Tmp = rtw_read32(padapter, regLPTxRx);
12514         regLPTx = u4Tmp & bMaskLWord;
12515         regLPRx = (u4Tmp & bMaskHWord)>>16;
12516
12517         pHalData->bt_coexist.halCoex8723.highPriorityTx = regHPTx;
12518         pHalData->bt_coexist.halCoex8723.highPriorityRx = regHPRx;
12519         pHalData->bt_coexist.halCoex8723.lowPriorityTx = regLPTx;
12520         pHalData->bt_coexist.halCoex8723.lowPriorityRx = regLPRx;
12521
12522         RTPRINT(FBT, BT_TRACE, ("High Priority Tx/Rx= %d / %d\n", regHPTx, regHPRx));
12523         RTPRINT(FBT, BT_TRACE, ("Low Priority Tx/Rx= %d / %d\n", regLPTx, regLPRx));
12524
12525         // reset counter
12526         //u1Tmp = rtw_read8(padapter, 0x76e);
12527         //DbgPrint("read 2 back 0x76e= 0x%x\n", u1Tmp);
12528         //u4Tmp |= BIT3;
12529         rtw_write8(padapter, 0x76e, 0xc);
12530 }
12531
12532 // This function check if 8723 bt is disabled
12533 void btdm_BtEnableDisableCheck8723A(PADAPTER padapter)
12534 {
12535         u8              btAlife = _TRUE;
12536         PHAL_DATA_TYPE  pHalData = GET_HAL_DATA(padapter);
12537
12538
12539 #ifdef CHECK_BT_EXIST_FROM_REG
12540         u8              val8;
12541
12542         // ox68[28]=1 => BT enable; otherwise disable
12543         val8 = rtw_read8(padapter, 0x6B);
12544         if (!(val8 & BIT(4))) btAlife = _FALSE;
12545
12546         if (btAlife)
12547         {
12548                 pHalData->bt_coexist.bCurBtDisabled = _FALSE;
12549 //              RTPRINT(FBT, BT_TRACE, ("8723A BT is enabled !!\n"));
12550         }
12551         else
12552         {
12553                 pHalData->bt_coexist.bCurBtDisabled = _TRUE;
12554 //              RTPRINT(FBT, BT_TRACE, ("8723A BT is disabled !!\n"));
12555         }
12556 #else
12557         if (pHalData->bt_coexist.halCoex8723.highPriorityTx == 0 &&
12558                 pHalData->bt_coexist.halCoex8723.highPriorityRx == 0 &&
12559                 pHalData->bt_coexist.halCoex8723.lowPriorityTx == 0 &&
12560                 pHalData->bt_coexist.halCoex8723.lowPriorityRx == 0)
12561         {
12562                 btAlife = _FALSE;
12563         }
12564         if (pHalData->bt_coexist.halCoex8723.highPriorityTx == 0xeaea &&
12565                 pHalData->bt_coexist.halCoex8723.highPriorityRx == 0xeaea &&
12566                 pHalData->bt_coexist.halCoex8723.lowPriorityTx == 0xeaea &&
12567                 pHalData->bt_coexist.halCoex8723.lowPriorityRx == 0xeaea)
12568         {
12569                 btAlife = _FALSE;
12570         }
12571         if (pHalData->bt_coexist.halCoex8723.highPriorityTx == 0xffff &&
12572                 pHalData->bt_coexist.halCoex8723.highPriorityRx == 0xffff &&
12573                 pHalData->bt_coexist.halCoex8723.lowPriorityTx == 0xffff &&
12574                 pHalData->bt_coexist.halCoex8723.lowPriorityRx == 0xffff)
12575         {
12576                 btAlife = _FALSE;
12577         }
12578         if (btAlife)
12579         {
12580                 pHalData->bt_coexist.btActiveZeroCnt = 0;
12581                 pHalData->bt_coexist.bCurBtDisabled = _FALSE;
12582                 RTPRINT(FBT, BT_TRACE, ("8723A BT is enabled !!\n"));
12583         }
12584         else
12585         {
12586                 pHalData->bt_coexist.btActiveZeroCnt++;
12587                 RTPRINT(FBT, BT_TRACE, ("8723A bt all counters=0, %d times!!\n",
12588                                 pHalData->bt_coexist.btActiveZeroCnt));
12589                 if (pHalData->bt_coexist.btActiveZeroCnt >= 2)
12590                 {
12591                         pHalData->bt_coexist.bCurBtDisabled = _TRUE;
12592                         RTPRINT(FBT, BT_TRACE, ("8723A BT is disabled !!\n"));
12593                 }
12594         }
12595 #endif
12596
12597         if (pHalData->bt_coexist.bCurBtDisabled == _FALSE) {
12598                 if (BTDM_IsWifiConnectionExist(padapter) == _TRUE)
12599                         BTDM_SetFwChnlInfo(padapter, RT_MEDIA_CONNECT);
12600                 else
12601                         BTDM_SetFwChnlInfo(padapter, RT_MEDIA_DISCONNECT);
12602         }
12603
12604         if (pHalData->bt_coexist.bPreBtDisabled !=
12605                 pHalData->bt_coexist.bCurBtDisabled)
12606         {
12607                 RTPRINT(FBT, BT_TRACE, ("8723A BT is from %s to %s!!\n",
12608                         (pHalData->bt_coexist.bPreBtDisabled ? "disabled":"enabled"),
12609                         (pHalData->bt_coexist.bCurBtDisabled ? "disabled":"enabled")));
12610                 pHalData->bt_coexist.bPreBtDisabled = pHalData->bt_coexist.bCurBtDisabled;
12611         }
12612 }
12613
12614 void btdm_BTCoexist8723AHandler(PADAPTER padapter)
12615 {
12616         PHAL_DATA_TYPE  pHalData;
12617
12618
12619         pHalData = GET_HAL_DATA(padapter);
12620
12621         if (btdm_BtWifiAntNum(padapter) == Ant_x2)
12622         {
12623                 RTPRINT(FBT, BT_TRACE, ("[BTCoex], 2 Ant mechanism\n"));
12624                 BTDM_2AntBtCoexist8723A(padapter);
12625         }
12626         else
12627         {
12628                 RTPRINT(FBT, BT_TRACE, ("[BTCoex], 1 Ant mechanism\n"));
12629                 BTDM_1AntBtCoexist8723A(padapter);
12630         }
12631
12632         if (!BTDM_IsSameCoexistState(padapter))
12633         {
12634                 RTPRINT(FBT, BT_TRACE, ("[BTCoex], Coexist State[bitMap] change from 0x%"i64fmt"x to 0x%"i64fmt"x\n",
12635                         pHalData->bt_coexist.PreviousState,
12636                         pHalData->bt_coexist.CurrentState));
12637                 pHalData->bt_coexist.PreviousState = pHalData->bt_coexist.CurrentState;
12638
12639                 RTPRINT(FBT, BT_TRACE, ("["));
12640                 if (pHalData->bt_coexist.CurrentState & BT_COEX_STATE_BT30)
12641                         RTPRINT(FBT, BT_TRACE, ("BT 3.0, "));
12642                 if (pHalData->bt_coexist.CurrentState & BT_COEX_STATE_WIFI_HT20)
12643                         RTPRINT(FBT, BT_TRACE, ("HT20, "));
12644                 if (pHalData->bt_coexist.CurrentState & BT_COEX_STATE_WIFI_HT40)
12645                         RTPRINT(FBT, BT_TRACE, ("HT40, "));
12646                 if (pHalData->bt_coexist.CurrentState & BT_COEX_STATE_WIFI_LEGACY)
12647                         RTPRINT(FBT, BT_TRACE, ("Legacy, "));
12648                 if (pHalData->bt_coexist.CurrentState & BT_COEX_STATE_WIFI_RSSI_LOW)
12649                         RTPRINT(FBT, BT_TRACE, ("Rssi_Low, "));
12650                 if (pHalData->bt_coexist.CurrentState & BT_COEX_STATE_WIFI_RSSI_MEDIUM)
12651                         RTPRINT(FBT, BT_TRACE, ("Rssi_Mid, "));
12652                 if (pHalData->bt_coexist.CurrentState & BT_COEX_STATE_WIFI_RSSI_HIGH)
12653                         RTPRINT(FBT, BT_TRACE, ("Rssi_High, "));
12654                 if (pHalData->bt_coexist.CurrentState & BT_COEX_STATE_WIFI_IDLE)
12655                         RTPRINT(FBT, BT_TRACE, ("Wifi_Idle, "));
12656                 if (pHalData->bt_coexist.CurrentState & BT_COEX_STATE_WIFI_UPLINK)
12657                         RTPRINT(FBT, BT_TRACE, ("Wifi_Uplink, "));
12658                 if (pHalData->bt_coexist.CurrentState & BT_COEX_STATE_WIFI_DOWNLINK)
12659                         RTPRINT(FBT, BT_TRACE, ("Wifi_Downlink, "));
12660                 if (pHalData->bt_coexist.CurrentState & BT_COEX_STATE_BT_IDLE)
12661                         RTPRINT(FBT, BT_TRACE, ("BT_idle, "));
12662                 if (pHalData->bt_coexist.CurrentState & BT_COEX_STATE_PROFILE_HID)
12663                         RTPRINT(FBT, BT_TRACE, ("PRO_HID, "));
12664                 if (pHalData->bt_coexist.CurrentState & BT_COEX_STATE_PROFILE_A2DP)
12665                         RTPRINT(FBT, BT_TRACE, ("PRO_A2DP, "));
12666                 if (pHalData->bt_coexist.CurrentState & BT_COEX_STATE_PROFILE_PAN)
12667                         RTPRINT(FBT, BT_TRACE, ("PRO_PAN, "));
12668                 if (pHalData->bt_coexist.CurrentState & BT_COEX_STATE_PROFILE_SCO)
12669                         RTPRINT(FBT, BT_TRACE, ("PRO_SCO, "));
12670                 RTPRINT(FBT, BT_TRACE, ("]\n"));
12671         }
12672 }
12673
12674 //============================================================
12675 // extern function start with BTDM_
12676 //============================================================
12677 u32 BTDM_BtTxRxCounterH(        PADAPTER        padapter)
12678 {
12679         PHAL_DATA_TYPE  pHalData = GET_HAL_DATA(padapter);
12680         u32     counters=0;
12681
12682         counters = pHalData->bt_coexist.halCoex8723.highPriorityTx+
12683                 pHalData->bt_coexist.halCoex8723.highPriorityRx ;
12684         return counters;
12685 }
12686
12687 u32 BTDM_BtTxRxCounterL(        PADAPTER        padapter        )
12688 {
12689         PHAL_DATA_TYPE  pHalData = GET_HAL_DATA(padapter);
12690         u4Byte  counters=0;
12691
12692         counters = pHalData->bt_coexist.halCoex8723.lowPriorityTx+
12693                 pHalData->bt_coexist.halCoex8723.lowPriorityRx ;
12694         return counters;
12695 }
12696
12697 void BTDM_SetFwChnlInfo(PADAPTER padapter, RT_MEDIA_STATUS mstatus)
12698 {
12699 //      PMGNT_INFO      pMgntInfo = &padapter->MgntInfo;
12700         struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
12701         PBT30Info       pBTInfo = GET_BT_INFO(padapter);
12702         PBT_MGNT        pBtMgnt = &pBTInfo->BtMgnt;
12703         u8              H2C_Parameter[3] ={0};
12704         u8              chnl;
12705
12706
12707         if (!IS_HARDWARE_TYPE_8723A(padapter))
12708                 return;
12709
12710         // opMode
12711         if (RT_MEDIA_CONNECT == mstatus)
12712         {
12713                 H2C_Parameter[0] = 0x1; // 0: disconnected, 1:connected
12714         }
12715
12716         if (check_fwstate(&padapter->mlmepriv, WIFI_ASOC_STATE) == _TRUE)
12717         {
12718                 // channel
12719                 chnl = pmlmeext->cur_channel;
12720                 if (BTDM_IsHT40(padapter))
12721                 {
12722                         if (pmlmeext->cur_ch_offset == HAL_PRIME_CHNL_OFFSET_UPPER)
12723                         {
12724                                 chnl -= 2;
12725                         }
12726                         else if (pmlmeext->cur_ch_offset == HAL_PRIME_CHNL_OFFSET_LOWER)
12727                         {
12728                                 chnl += 2;
12729                         }
12730                 }
12731                 H2C_Parameter[1] = chnl;
12732 //              RTPRINT(FBT, BT_TRACE, ("[BTCoex], pmlmeext->cur_channel=0x%x  pmlmeext->cur_ch_offset=0x%x chnl=0x%x\n",pmlmeext->cur_channel,pmlmeext->cur_ch_offset,chnl ));
12733         }
12734         else    // check if HS link is exists
12735         {
12736                 // channel
12737                 if (BT_Operation(padapter))
12738                         H2C_Parameter[1] = pBtMgnt->BTChannel;
12739                 else
12740                         H2C_Parameter[1] = pmlmeext->cur_channel;
12741         }
12742
12743         if (BTDM_IsHT40(padapter))
12744         {
12745                 H2C_Parameter[2] = 0x30;
12746         }
12747         else
12748         {
12749                 H2C_Parameter[2] = 0x20;
12750         }
12751
12752 //      RTPRINT(FBT, BT_TRACE, ("[BTCoex], FW write 0x19=0x%x\n",
12753 //              H2C_Parameter[0]<<16|H2C_Parameter[1]<<8|H2C_Parameter[2]));
12754
12755         FillH2CCmd(padapter, 0x19, 3, H2C_Parameter);
12756 }
12757
12758 u8 BTDM_IsWifiConnectionExist(PADAPTER padapter)
12759 {
12760         u8 bRet = _FALSE;
12761
12762
12763         if (BTHCI_HsConnectionEstablished(padapter))
12764                 bRet = _TRUE;
12765
12766         if (check_fwstate(&padapter->mlmepriv, WIFI_ASOC_STATE) == _TRUE)
12767                 bRet = _TRUE;
12768
12769         return bRet;
12770 }
12771
12772 void BTDM_SetFw3a(
12773         PADAPTER        padapter,
12774         u8              byte1,
12775         u8              byte2,
12776         u8              byte3,
12777         u8              byte4,
12778         u8              byte5
12779         )
12780 {
12781         u8                      H2C_Parameter[5] = {0};
12782
12783         if (BTDM_1Ant8723A(padapter) == _TRUE)
12784         {
12785                 if ((check_fwstate(&padapter->mlmepriv, WIFI_STATION_STATE) == _FALSE) &&
12786                         (get_fwstate(&padapter->mlmepriv) != WIFI_NULL_STATE)) // for softap mode
12787                 {
12788                         PHAL_DATA_TYPE pHalData = GET_HAL_DATA(padapter);
12789                         PBT_COEXIST_8723A pBtCoex = &pHalData->bt_coexist.halCoex8723;
12790                         u8 BtState = pBtCoex->c2hBtInfo;
12791
12792                         if ((BtState != BT_INFO_STATE_NO_CONNECTION) &&
12793                                 (BtState != BT_INFO_STATE_CONNECT_IDLE))
12794                         {
12795                                 if (byte1 & BIT(4))
12796                                 {
12797                                         byte1 &= ~BIT(4);
12798                                         byte1 |= BIT(5);
12799                                 }
12800
12801                                 byte5 |= BIT(5);
12802                                 if (byte5 & BIT(6))
12803                                 {
12804                                         byte5 &= ~BIT(6);
12805                                 }
12806                         }
12807                 }
12808         }
12809
12810         H2C_Parameter[0] = byte1;
12811         H2C_Parameter[1] = byte2;
12812         H2C_Parameter[2] = byte3;
12813         H2C_Parameter[3] = byte4;
12814         H2C_Parameter[4] = byte5;
12815
12816         RTPRINT(FBT, BT_TRACE, ("[BTCoex], FW write 0x3a(5bytes)=0x%02x%08x\n",
12817                 H2C_Parameter[0],
12818                 H2C_Parameter[1]<<24|H2C_Parameter[2]<<16|H2C_Parameter[3]<<8|H2C_Parameter[4]));
12819
12820         FillH2CCmd(padapter, 0x3a, 5, H2C_Parameter);
12821 }
12822
12823 void BTDM_ForceBtCoexMechanism(PADAPTER padapter, u8 type)
12824 {
12825         PHAL_DATA_TYPE  pHalData = GET_HAL_DATA(padapter);
12826
12827
12828         pHalData->bt_coexist.halCoex8723.bForceFwBtInfo = type;
12829
12830         if (pHalData->bt_coexist.halCoex8723.bForceFwBtInfo)
12831         {
12832                 DbgPrint("cosa force bt info from wifi fw !!!\n");
12833         }
12834         else
12835         {
12836                 DbgPrint("cosa force bt coexist bt info from bt stack\n");
12837         }
12838 }
12839
12840 void BTDM_QueryBtInformation(PADAPTER padapter)
12841 {
12842         u8 H2C_Parameter[1] = {0};
12843         PHAL_DATA_TYPE pHalData;
12844         PBT_COEXIST_8723A pBtCoex;
12845
12846
12847         pHalData = GET_HAL_DATA(padapter);
12848         pBtCoex = &pHalData->bt_coexist.halCoex8723;
12849
12850         if (BT_IsBtDisabled(padapter) == _TRUE)
12851         {
12852                 pBtCoex->c2hBtInfo = BT_INFO_STATE_DISABLED;
12853                 pBtCoex->bC2hBtInfoReqSent = _FALSE;
12854                 return;
12855         }
12856
12857         if (pBtCoex->c2hBtInfo == BT_INFO_STATE_DISABLED)
12858                 pBtCoex->c2hBtInfo = BT_INFO_STATE_NO_CONNECTION;
12859
12860         if (pBtCoex->bC2hBtInfoReqSent == _TRUE)
12861         {
12862                 RTPRINT(FBT, BT_TRACE, ("[BTCoex], didn't recv previous BtInfo report!\n"));
12863         }
12864         else
12865         {
12866                 pBtCoex->bC2hBtInfoReqSent = _TRUE;
12867         }
12868
12869         H2C_Parameter[0] |= BIT(0);     // trigger
12870
12871 //      RTPRINT(FBT, BT_TRACE, ("[BTCoex], Query Bt information, write 0x38=0x%x\n",
12872 //              H2C_Parameter[0]));
12873
12874         FillH2CCmd(padapter, 0x38, 1, H2C_Parameter);
12875 }
12876
12877 void BTDM_SetSwRfRxLpfCorner(PADAPTER padapter, u8 type)
12878 {
12879         PHAL_DATA_TYPE  pHalData = GET_HAL_DATA(padapter);
12880
12881         if (BT_RF_RX_LPF_CORNER_SHRINK == type)
12882         {
12883                 //Shrink RF Rx LPF corner
12884                 RTPRINT(FBT, BT_TRACE, ("Shrink RF Rx LPF corner!!\n"));
12885                 PHY_SetRFReg(padapter, PathA, 0x1e, bRFRegOffsetMask, 0xf0ff7);
12886                 pHalData->bt_coexist.bSWCoexistAllOff = _FALSE;
12887         }
12888         else if (BT_RF_RX_LPF_CORNER_RESUME == type)
12889         {
12890                 //Resume RF Rx LPF corner
12891                 RTPRINT(FBT, BT_TRACE, ("Resume RF Rx LPF corner!!\n"));
12892                 PHY_SetRFReg(padapter, PathA, 0x1e, bRFRegOffsetMask, pHalData->bt_coexist.BtRfRegOrigin1E);
12893         }
12894 }
12895
12896 void
12897 BTDM_SetSwPenaltyTxRateAdaptive(
12898         PADAPTER        padapter,
12899         u8              raType
12900         )
12901 {
12902         PHAL_DATA_TYPE  pHalData = GET_HAL_DATA(padapter);
12903         u8      tmpU1;
12904
12905         tmpU1 = rtw_read8(padapter, 0x4fd);
12906         tmpU1 |= BIT(0);
12907         if (BT_TX_RATE_ADAPTIVE_LOW_PENALTY == raType)
12908         {
12909 //              RTPRINT(FBT, BT_TRACE, ("Tx rate adaptive, set low penalty!!\n"));
12910                 tmpU1 &= ~BIT(2);
12911                 pHalData->bt_coexist.bSWCoexistAllOff = _FALSE;
12912         }
12913         else if (BT_TX_RATE_ADAPTIVE_NORMAL == raType)
12914         {
12915 //              RTPRINT(FBT, BT_TRACE, ("Tx rate adaptive, set normal!!\n"));
12916                 tmpU1 |= BIT(2);
12917         }
12918
12919         rtw_write8(padapter, 0x4fd, tmpU1);
12920 }
12921
12922 void BTDM_SetFwDecBtPwr(PADAPTER padapter, u8 bDecBtPwr)
12923 {
12924         PHAL_DATA_TYPE  pHalData = GET_HAL_DATA(padapter);
12925         u8                      H2C_Parameter[1] = {0};
12926
12927
12928         H2C_Parameter[0] = 0;
12929
12930         if (bDecBtPwr)
12931         {
12932                 H2C_Parameter[0] |= BIT(1);
12933                 pHalData->bt_coexist.bFWCoexistAllOff = _FALSE;
12934         }
12935
12936         RTPRINT(FBT, BT_TRACE, ("[BTCoex], decrease Bt Power : %s, write 0x21=0x%x\n",
12937                 (bDecBtPwr? "Yes!!":"No!!"), H2C_Parameter[0]));
12938
12939         FillH2CCmd(padapter, 0x21, 1, H2C_Parameter);
12940 }
12941
12942 u8 BTDM_BtProfileSupport(PADAPTER padapter)
12943 {
12944         u8                      bRet = _FALSE;
12945         PBT30Info               pBTInfo = GET_BT_INFO(padapter);
12946         PBT_MGNT                pBtMgnt = &pBTInfo->BtMgnt;
12947         PHAL_DATA_TYPE  pHalData = GET_HAL_DATA(padapter);
12948
12949
12950         if (pBtMgnt->bSupportProfile &&
12951                 !pHalData->bt_coexist.halCoex8723.bForceFwBtInfo)
12952         {
12953                 bRet = _TRUE;
12954         }
12955
12956         return bRet;
12957 }
12958
12959 void BTDM_AdjustForBtOperation8723A(PADAPTER padapter)
12960 {
12961         //BTDM_2AntAdjustForBtOperation8723(padapter);
12962 }
12963
12964 void BTDM_FwC2hBtRssi8723A(PADAPTER padapter, u8 *tmpBuf)
12965 {
12966         PHAL_DATA_TYPE  pHalData = GET_HAL_DATA(padapter);
12967         u8                      percent=0, u1tmp=0;
12968
12969         u1tmp = tmpBuf[0];
12970         percent = u1tmp*2+10;
12971
12972         pHalData->bt_coexist.halCoex8723.btRssi = percent;
12973 //      RTPRINT(FBT, BT_TRACE, ("[BTC2H], BT RSSI=%d\n", percent));
12974 }
12975
12976 void BTDM_FwC2hBtInfo8723A(PADAPTER padapter, u8 *tmpBuf, u8 length)
12977 {
12978         PHAL_DATA_TYPE  pHalData;
12979         PBT30Info               pBTInfo;
12980         PBT_MGNT                pBtMgnt;
12981         PBT_COEXIST_8723A pBtCoex;
12982         u8      i;
12983
12984
12985         pHalData = GET_HAL_DATA(padapter);
12986         pBTInfo = GET_BT_INFO(padapter);
12987         pBtMgnt = &pBTInfo->BtMgnt;
12988         pBtCoex = &pHalData->bt_coexist.halCoex8723;
12989
12990         pBtCoex->bC2hBtInfoReqSent = _FALSE;
12991
12992         RTPRINT(FBT, BT_TRACE, ("[BTC2H], BT info[%d]=[", length));
12993
12994         pBtCoex->btRetryCnt = 0;
12995         for (i=0; i<length; i++)
12996         {
12997                 switch (i)
12998                 {
12999                         case 0:
13000                                 pBtCoex->c2hBtInfoOriginal = tmpBuf[i];
13001                                 break;
13002                         case 1:
13003                                 pBtCoex->btRetryCnt = tmpBuf[i];
13004                                 break;
13005                         case 2:
13006                                 BTDM_FwC2hBtRssi8723A(padapter, &tmpBuf[i]);
13007                                 break;
13008                         case 3:
13009                                 pBtCoex->btInfoExt=tmpBuf[i]&BIT(0);
13010                                 break;
13011                 }
13012
13013                 if (i == length-1)
13014                 {
13015                         RTPRINT(FBT, BT_TRACE, ("0x%02x]\n", tmpBuf[i]));
13016                 }
13017                 else
13018                 {
13019                         RTPRINT(FBT, BT_TRACE, ("0x%02x, ", tmpBuf[i]));
13020                 }
13021         }
13022         RTPRINT(FBT, BT_TRACE, ("[BTC2H], BT RSSI=%d\n", pBtCoex->btRssi));
13023         if (pBtCoex->btInfoExt)
13024                 RTPRINT(FBT, BT_TRACE, ("[BTC2H], pBtCoex->btInfoExt=%x\n", pBtCoex->btInfoExt));
13025
13026         if (btdm_BtWifiAntNum(padapter) == Ant_x1)
13027                 BTDM_1AntFwC2hBtInfo8723A(padapter);
13028         else
13029                 BTDM_2AntFwC2hBtInfo8723A(padapter);
13030
13031         if (pBtMgnt->ExtConfig.bManualControl)
13032         {
13033                 RTPRINT(FBT, BT_TRACE, ("%s: Action Manual control!!\n", __FUNCTION__));
13034                 return;
13035         }
13036
13037         btdm_BTCoexist8723AHandler(padapter);
13038 }
13039
13040 void BTDM_Display8723ABtCoexInfo(PADAPTER padapter)
13041 {
13042         PHAL_DATA_TYPE  pHalData = GET_HAL_DATA(padapter);
13043         PBT_COEXIST_8723A       pBtCoex = &pHalData->bt_coexist.halCoex8723;
13044         PBT30Info                       pBTInfo = GET_BT_INFO(padapter);
13045         PBT_MGNT                        pBtMgnt = &pBTInfo->BtMgnt;
13046         PBT_DBG                         pBtDbg = &pBTInfo->BtDbg;
13047         u8                      u1Tmp, u1Tmp1, u1Tmp2, i, btInfoExt, psTdmaCase=0;
13048         u32                     u4Tmp[4];
13049         u8                      antNum=Ant_x2;
13050
13051         rsprintf(btCoexDbgBuf, BT_TMP_BUF_SIZE, "\r\n ============[BT Coexist info]============");
13052         DCMD_Printf(btCoexDbgBuf);
13053
13054         if (!pHalData->bt_coexist.BluetoothCoexist)
13055         {
13056                 rsprintf(btCoexDbgBuf, BT_TMP_BUF_SIZE, "\r\n BT not exists !!!");
13057                 DCMD_Printf(btCoexDbgBuf);
13058                 return;
13059         }
13060
13061         antNum = btdm_BtWifiAntNum(padapter);
13062         rsprintf(btCoexDbgBuf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d/%d ", "Ant mechanism PG/Now run :", \
13063                 ((pHalData->bt_coexist.BT_Ant_Num==Ant_x2)? 2:1), ((antNum==Ant_x2)? 2:1));
13064         DCMD_Printf(btCoexDbgBuf);
13065
13066         if (pBtMgnt->ExtConfig.bManualControl)
13067         {
13068                 rsprintf(btCoexDbgBuf, BT_TMP_BUF_SIZE, "\r\n %-35s", "[Action Manual control]!!");
13069                 DCMD_Printf(btCoexDbgBuf);
13070         }
13071         else
13072         {
13073                 rsprintf(btCoexDbgBuf, BT_TMP_BUF_SIZE, "\r\n %-35s = %s / %d", "BT stack/ hci ext ver", \
13074                         ((pBtMgnt->bSupportProfile)? "Yes":"No"), pBtMgnt->ExtConfig.HCIExtensionVer);
13075                 DCMD_Printf(btCoexDbgBuf);
13076         }
13077
13078         rsprintf(btCoexDbgBuf, BT_TMP_BUF_SIZE, "\r\n %-35s = / %d", "Dot11 channel / BT channel", \
13079                 pBtMgnt->BTChannel);
13080                 DCMD_Printf(btCoexDbgBuf);
13081
13082         rsprintf(btCoexDbgBuf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d / %d / %d", "Wifi/BT/HS rssi", \
13083                 BTDM_GetRxSS(padapter),
13084                 pHalData->bt_coexist.halCoex8723.btRssi,
13085                 pHalData->dmpriv.EntryMinUndecoratedSmoothedPWDB);
13086                         DCMD_Printf(btCoexDbgBuf);
13087
13088         if(!pBtMgnt->ExtConfig.bManualControl)
13089                 {
13090                 rsprintf(btCoexDbgBuf, BT_TMP_BUF_SIZE, "\r\n %-35s = %s / %s ", "WIfi status", \
13091                         ((BTDM_Legacy(padapter))? "Legacy": (((BTDM_IsHT40(padapter))? "HT40":"HT20"))),
13092                         ((!BTDM_IsWifiBusy(padapter))? "idle": ((BTDM_IsWifiUplink(padapter))? "uplink":"downlink")));
13093                 DCMD_Printf(btCoexDbgBuf);
13094
13095                 if(pBtMgnt->bSupportProfile)
13096                 {
13097                         rsprintf(btCoexDbgBuf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d / %d / %d / %d", "SCO/HID/PAN/A2DP", \
13098                                 ((BTHCI_CheckProfileExist(padapter, BT_PROFILE_SCO))? 1: 0),
13099                                 ((BTHCI_CheckProfileExist(padapter, BT_PROFILE_HID))? 1: 0),
13100                                 ((BTHCI_CheckProfileExist(padapter, BT_PROFILE_PAN))? 1: 0),
13101                                 ((BTHCI_CheckProfileExist(padapter, BT_PROFILE_A2DP))? 1: 0) );
13102                 DCMD_Printf(btCoexDbgBuf);
13103
13104                         for (i=0; i<pBtMgnt->ExtConfig.NumberOfHandle; i++)
13105                         {
13106                                 if (pBtMgnt->ExtConfig.HCIExtensionVer >= 1)
13107                                 {
13108                                         rsprintf(btCoexDbgBuf, BT_TMP_BUF_SIZE, "\r\n %-35s = %s/ %s/ %s", "Bt link type/spec/role", \
13109                                                 BtProfileString[pBtMgnt->ExtConfig.linkInfo[i].BTProfile],
13110                                                 BtSpecString[pBtMgnt->ExtConfig.linkInfo[i].BTCoreSpec],
13111                                                 BtLinkRoleString[pBtMgnt->ExtConfig.linkInfo[i].linkRole]);
13112                                         DCMD_Printf(btCoexDbgBuf);
13113
13114                                         btInfoExt = pHalData->bt_coexist.halCoex8723.btInfoExt;
13115                                         rsprintf(btCoexDbgBuf, BT_TMP_BUF_SIZE, "\r\n %-35s = %s", "A2DP rate", \
13116                                                 (btInfoExt&BIT0)? "Basic rate":"EDR rate");
13117                                         DCMD_Printf(btCoexDbgBuf);
13118                                 }
13119                                 else
13120                                 {
13121                                         rsprintf(btCoexDbgBuf, BT_TMP_BUF_SIZE, "\r\n %-35s = %s/ %s", "Bt link type/spec", \
13122                                                 BtProfileString[pBtMgnt->ExtConfig.linkInfo[i].BTProfile],
13123                                                 BtSpecString[pBtMgnt->ExtConfig.linkInfo[i].BTCoreSpec]);
13124                                         DCMD_Printf(btCoexDbgBuf);
13125                                 }
13126                         }
13127                 }
13128         }
13129
13130         // Sw mechanism
13131         if (!pBtMgnt->ExtConfig.bManualControl)
13132         {
13133                 rsprintf(btCoexDbgBuf, BT_TMP_BUF_SIZE, "\r\n %-35s", "============[Sw BT Coex mechanism]============");
13134                 DCMD_Printf(btCoexDbgBuf);
13135                 rsprintf(btCoexDbgBuf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d ", "AGC Table", \
13136                         pBtCoex->btdm2Ant.bCurAgcTableEn);
13137                 DCMD_Printf(btCoexDbgBuf);
13138                 rsprintf(btCoexDbgBuf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d ", "ADC Backoff", \
13139                         pBtCoex->btdm2Ant.bCurAdcBackOff);
13140                 DCMD_Printf(btCoexDbgBuf);
13141                 rsprintf(btCoexDbgBuf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d ", "Low penalty RA", \
13142                         pBtCoex->btdm2Ant.bCurLowPenaltyRa);
13143                 DCMD_Printf(btCoexDbgBuf);
13144                 rsprintf(btCoexDbgBuf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d ", "RF Rx LPF Shrink", \
13145                         pBtCoex->btdm2Ant.bCurRfRxLpfShrink);
13146                 DCMD_Printf(btCoexDbgBuf);
13147         }
13148         u4Tmp[0] = PHY_QueryRFReg(padapter, PathA, 0x1e, 0xff0);
13149         rsprintf(btCoexDbgBuf, BT_TMP_BUF_SIZE, "\r\n %-35s = 0x%x/ 0x%x", "RF-A, 0x1e[11:4]/original val", \
13150                 u4Tmp[0], pHalData->bt_coexist.BtRfRegOrigin1E);
13151         DCMD_Printf(btCoexDbgBuf);
13152
13153         // Fw mechanism
13154         if (!pBtMgnt->ExtConfig.bManualControl)
13155         {
13156                 rsprintf(btCoexDbgBuf, BT_TMP_BUF_SIZE, "\r\n %-35s", "============[Fw BT Coex mechanism]============");
13157                 DCMD_Printf(btCoexDbgBuf);
13158         }
13159         if (!pBtMgnt->ExtConfig.bManualControl)
13160         {
13161                 if(btdm_BtWifiAntNum(padapter) == Ant_x1)
13162                         psTdmaCase = pHalData->bt_coexist.halCoex8723.btdm1Ant.curPsTdma;
13163                 else
13164                         psTdmaCase = pHalData->bt_coexist.halCoex8723.btdm2Ant.curPsTdma;
13165                 rsprintf(btCoexDbgBuf, BT_TMP_BUF_SIZE, "\r\n %-35s = %02x %02x %02x %02x %02x case-%d", "PS TDMA(0x3a)", \
13166                         pHalData->bt_coexist.fw3aVal[0], pHalData->bt_coexist.fw3aVal[1],
13167                         pHalData->bt_coexist.fw3aVal[2], pHalData->bt_coexist.fw3aVal[3],
13168                         pHalData->bt_coexist.fw3aVal[4], psTdmaCase);
13169                 DCMD_Printf(btCoexDbgBuf);
13170
13171                 rsprintf(btCoexDbgBuf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d ", "Decrease Bt Power", \
13172                         pBtCoex->btdm2Ant.bCurDecBtPwr);
13173                 DCMD_Printf(btCoexDbgBuf);
13174         }
13175         u1Tmp = rtw_read8(padapter, 0x778);
13176         u1Tmp1 = rtw_read8(padapter, 0x783);
13177         u1Tmp2 = rtw_read8(padapter, 0x796);
13178         rsprintf(btCoexDbgBuf, BT_TMP_BUF_SIZE, "\r\n %-35s = 0x%x/ 0x%x/ 0x%x", "0x778/ 0x783/ 0x796", \
13179                 u1Tmp, u1Tmp1, u1Tmp2);
13180         DCMD_Printf(btCoexDbgBuf);
13181
13182         if (!pBtMgnt->ExtConfig.bManualControl)
13183         {
13184                 rsprintf(btCoexDbgBuf, BT_TMP_BUF_SIZE, "\r\n %-35s = 0x%x / 0x%x", "Sw DacSwing Ctrl/Val", \
13185                         pBtCoex->btdm2Ant.bCurDacSwingOn, pBtCoex->btdm2Ant.curDacSwingLvl);
13186                 DCMD_Printf(btCoexDbgBuf);
13187         }
13188         u4Tmp[0] =  rtw_read32(padapter, 0x880);
13189         rsprintf(btCoexDbgBuf, BT_TMP_BUF_SIZE, "\r\n %-35s = 0x%x", "0x880", \
13190                 u4Tmp[0]);
13191         DCMD_Printf(btCoexDbgBuf);
13192
13193         // Hw mechanism
13194         if (!pBtMgnt->ExtConfig.bManualControl)
13195         {
13196                 rsprintf(btCoexDbgBuf, BT_TMP_BUF_SIZE, "\r\n %-35s", "============[Hw BT Coex mechanism]============");
13197                 DCMD_Printf(btCoexDbgBuf);
13198         }
13199
13200         u1Tmp = rtw_read8(padapter, 0x40);
13201         rsprintf(btCoexDbgBuf, BT_TMP_BUF_SIZE, "\r\n %-35s = 0x%x", "0x40", \
13202                 u1Tmp);
13203         DCMD_Printf(btCoexDbgBuf);
13204
13205         u4Tmp[0] = rtw_read32(padapter, 0x550);
13206         u1Tmp = rtw_read8(padapter, 0x522);
13207         rsprintf(btCoexDbgBuf, BT_TMP_BUF_SIZE, "\r\n %-35s = 0x%x/0x%x", "0x550(bcn contrl)/0x522", \
13208                 u4Tmp[0], u1Tmp);
13209         DCMD_Printf(btCoexDbgBuf);
13210
13211         u4Tmp[0] = rtw_read32(padapter, 0x484);
13212         rsprintf(btCoexDbgBuf, BT_TMP_BUF_SIZE, "\r\n %-35s = 0x%x", "0x484(rate adaptive)", \
13213                 u4Tmp[0]);
13214         DCMD_Printf(btCoexDbgBuf);
13215
13216         u4Tmp[0] = rtw_read32(padapter, 0x50);
13217         rsprintf(btCoexDbgBuf, BT_TMP_BUF_SIZE, "\r\n %-35s = 0x%x", "0xc50(dig)", \
13218                 u4Tmp[0]);
13219         DCMD_Printf(btCoexDbgBuf);
13220
13221         u4Tmp[0] = rtw_read32(padapter, 0xda0);
13222         u4Tmp[1] = rtw_read32(padapter, 0xda4);
13223         u4Tmp[2] = rtw_read32(padapter, 0xda8);
13224         u4Tmp[3] = rtw_read32(padapter, 0xdac);
13225         rsprintf(btCoexDbgBuf, BT_TMP_BUF_SIZE, "\r\n %-35s = 0x%x/ 0x%x/ 0x%x/ 0x%x", "0xda0/0xda4/0xda8/0xdac(FA cnt)", \
13226                 u4Tmp[0], u4Tmp[1], u4Tmp[2], u4Tmp[3]);
13227         DCMD_Printf(btCoexDbgBuf);
13228
13229         u4Tmp[0] = rtw_read32(padapter, 0x6c0);
13230         u4Tmp[1] = rtw_read32(padapter, 0x6c4);
13231         u4Tmp[2] = rtw_read32(padapter, 0x6c8);
13232         u1Tmp = rtw_read8(padapter, 0x6cc);
13233         rsprintf(btCoexDbgBuf, BT_TMP_BUF_SIZE, "\r\n %-35s = 0x%x/ 0x%x/ 0x%x/ 0x%x", "0x6c0/0x6c4/0x6c8/0x6cc(coexTable)", \
13234                 u4Tmp[0], u4Tmp[1], u4Tmp[2], u1Tmp);
13235         DCMD_Printf(btCoexDbgBuf);
13236
13237         //u4Tmp = rtw_read32(padapter, 0x770);
13238         rsprintf(btCoexDbgBuf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d / %d", "0x770(Hi pri Rx[31:16]/Tx[15:0])", \
13239                 pHalData->bt_coexist.halCoex8723.highPriorityRx,
13240                 pHalData->bt_coexist.halCoex8723.highPriorityTx);
13241         DCMD_Printf(btCoexDbgBuf);
13242         //u4Tmp = rtw_read32(padapter, 0x774);
13243         rsprintf(btCoexDbgBuf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d / %d", "0x774(Lo pri Rx[31:16]/Tx[15:0])", \
13244                 pHalData->bt_coexist.halCoex8723.lowPriorityRx,
13245                 pHalData->bt_coexist.halCoex8723.lowPriorityTx);
13246         DCMD_Printf(btCoexDbgBuf);
13247
13248         // Tx mgnt queue hang or not, 0x41b should = 0xf, ex: 0xd ==>hang
13249         u1Tmp = rtw_read8(padapter, 0x41b);
13250         rsprintf(btCoexDbgBuf, BT_TMP_BUF_SIZE, "\r\n %-35s = 0x%x", "0x41b (hang chk == 0xf)", \
13251                 u1Tmp);
13252         DCMD_Printf(btCoexDbgBuf);
13253         rsprintf(btCoexDbgBuf, BT_TMP_BUF_SIZE, "\r\n %-35s = 0x%x", "lastHMEBoxNum", \
13254                 pHalData->LastHMEBoxNum);
13255         DCMD_Printf(btCoexDbgBuf);
13256 }
13257
13258 void BTDM_8723ASignalCompensation(PADAPTER padapter, u8 *rssi_wifi, u8 *rssi_bt)
13259 {
13260         if (btdm_BtWifiAntNum(padapter) == Ant_x1)
13261                 BTDM_1AntSignalCompensation(padapter, rssi_wifi, rssi_bt);
13262 }
13263
13264 void BTDM_8723AInit(PADAPTER padapter)
13265 {
13266         if (IS_HARDWARE_TYPE_8723A(padapter))
13267         {
13268                 if (btdm_BtWifiAntNum(padapter) == Ant_x2)
13269                         BTDM_2AntParaInit(padapter);
13270                 else
13271                         BTDM_1AntParaInit(padapter);
13272         }
13273 }
13274
13275 void BTDM_HWCoexAllOff8723A(PADAPTER padapter)
13276 {
13277         PBT30Info               pBTInfo = GET_BT_INFO(padapter);
13278         PBT_MGNT                pBtMgnt = &pBTInfo->BtMgnt;
13279
13280         if (pBtMgnt->ExtConfig.bManualControl)
13281                 return;
13282
13283         if (btdm_BtWifiAntNum(padapter) == Ant_x2)
13284                 BTDM_2AntHwCoexAllOff8723A(padapter);
13285 }
13286
13287 void BTDM_FWCoexAllOff8723A(PADAPTER padapter)
13288 {
13289         PBT30Info               pBTInfo = GET_BT_INFO(padapter);
13290         PBT_MGNT                pBtMgnt = &pBTInfo->BtMgnt;
13291
13292         if (pBtMgnt->ExtConfig.bManualControl)
13293                 return;
13294
13295         if (btdm_BtWifiAntNum(padapter) == Ant_x2)
13296                 BTDM_2AntFwCoexAllOff8723A(padapter);
13297 }
13298
13299 void BTDM_SWCoexAllOff8723A(PADAPTER padapter)
13300 {
13301         PBT30Info               pBTInfo = GET_BT_INFO(padapter);
13302         PBT_MGNT                pBtMgnt = &pBTInfo->BtMgnt;
13303
13304         if (pBtMgnt->ExtConfig.bManualControl)
13305                 return;
13306
13307         if (btdm_BtWifiAntNum(padapter) == Ant_x2)
13308                 BTDM_2AntSwCoexAllOff8723A(padapter);
13309 }
13310
13311 void
13312 BTDM_Set8723ABtCoexCurrAntNum(
13313         PADAPTER        padapter,
13314         u8              antNum
13315         )
13316 {
13317         PHAL_DATA_TYPE  pHalData = GET_HAL_DATA(padapter);
13318         PBT_COEXIST_8723A       pBtCoex = &pHalData->bt_coexist.halCoex8723;
13319
13320         if (antNum == 1)
13321         {
13322                 pBtCoex->TotalAntNum = Ant_x1;
13323         }
13324         else if (antNum == 2)
13325         {
13326                 pBtCoex->TotalAntNum = Ant_x2;
13327         }
13328 }
13329
13330 void BTDM_LpsLeave(PADAPTER padapter)
13331 {
13332         PBT30Info               pBTInfo = GET_BT_INFO(padapter);
13333         PBT_MGNT                pBtMgnt = &pBTInfo->BtMgnt;
13334
13335         if (pBtMgnt->ExtConfig.bManualControl)
13336                 return;
13337
13338         if (btdm_BtWifiAntNum(padapter) == Ant_x1)
13339                 BTDM_1AntLpsLeave(padapter);
13340 }
13341
13342 void BTDM_ForHalt8723A(PADAPTER padapter)
13343 {
13344         PBT30Info               pBTInfo = GET_BT_INFO(padapter);
13345         PBT_MGNT                pBtMgnt = &pBTInfo->BtMgnt;
13346
13347         if (pBtMgnt->ExtConfig.bManualControl)
13348                 return;
13349
13350         if (btdm_BtWifiAntNum(padapter) == Ant_x1)
13351                 BTDM_1AntForHalt(padapter);
13352 }
13353
13354 void BTDM_WifiScanNotify8723A(PADAPTER padapter, u8 scanType)
13355 {
13356         PBT30Info               pBTInfo = GET_BT_INFO(padapter);
13357         PBT_MGNT                pBtMgnt = &pBTInfo->BtMgnt;
13358
13359         if (pBtMgnt->ExtConfig.bManualControl)
13360                 return;
13361
13362         if (btdm_BtWifiAntNum(padapter) == Ant_x1)
13363                 BTDM_1AntWifiScanNotify(padapter, scanType);
13364 }
13365
13366 void BTDM_WifiAssociateNotify8723A(PADAPTER padapter, u8 action)
13367 {
13368         PBT30Info               pBTInfo = GET_BT_INFO(padapter);
13369         PBT_MGNT                pBtMgnt = &pBTInfo->BtMgnt;
13370
13371         if (pBtMgnt->ExtConfig.bManualControl)
13372                 return;
13373
13374         if (btdm_BtWifiAntNum(padapter) == Ant_x1)
13375                 BTDM_1AntWifiAssociateNotify(padapter, action);
13376 }
13377
13378 void BTDM_MediaStatusNotify8723A(PADAPTER padapter, RT_MEDIA_STATUS      mstatus)
13379 {
13380         PBT30Info               pBTInfo = GET_BT_INFO(padapter);
13381         PBT_MGNT                pBtMgnt = &pBTInfo->BtMgnt;
13382
13383
13384         RTPRINT(FBT, BT_TRACE, ("[BTCoex], MediaStatusNotify, %s\n", mstatus?"connect":"disconnect"));
13385
13386         BTDM_SetFwChnlInfo(padapter, mstatus);
13387
13388         if (pBtMgnt->ExtConfig.bManualControl)
13389                 return;
13390
13391         if (btdm_BtWifiAntNum(padapter) == Ant_x1)
13392                 BTDM_1AntMediaStatusNotify(padapter, mstatus);
13393 }
13394
13395 void BTDM_ForDhcp8723A(PADAPTER padapter)
13396 {
13397         PBT30Info               pBTInfo = GET_BT_INFO(padapter);
13398         PBT_MGNT                pBtMgnt = &pBTInfo->BtMgnt;
13399
13400         if (pBtMgnt->ExtConfig.bManualControl)
13401                 return;
13402
13403         if (btdm_BtWifiAntNum(padapter) == Ant_x1)
13404                 BTDM_1AntForDhcp(padapter);
13405 }
13406
13407 u8 BTDM_1Ant8723A(PADAPTER padapter)
13408 {
13409         if (btdm_BtWifiAntNum(padapter) == Ant_x1)
13410                 return _TRUE;
13411         else
13412                 return _FALSE;
13413 }
13414
13415 void BTDM_BTCoexist8723A(PADAPTER padapter)
13416 {
13417         PHAL_DATA_TYPE  pHalData;
13418         PBT30Info               pBTInfo;
13419         PBT_MGNT                pBtMgnt;
13420         PBT_COEXIST_8723A pBtCoex;
13421
13422
13423         pHalData = GET_HAL_DATA(padapter);
13424         pBTInfo = GET_BT_INFO(padapter);
13425         pBtMgnt = &pBTInfo->BtMgnt;
13426         pBtCoex = &pHalData->bt_coexist.halCoex8723;
13427
13428         RTPRINT(FBT, BT_TRACE, ("[BTCoex], beacon RSSI=0x%x(%d)\n",
13429                 pHalData->dmpriv.EntryMinUndecoratedSmoothedPWDB,
13430                 pHalData->dmpriv.EntryMinUndecoratedSmoothedPWDB));
13431
13432         btdm_BtHwCountersMonitor(padapter);
13433         btdm_BtEnableDisableCheck8723A(padapter);
13434
13435         if (pBtMgnt->ExtConfig.bManualControl)
13436         {
13437                 RTPRINT(FBT, BT_TRACE, ("%s: Action Manual control!!\n", __FUNCTION__));
13438                 return;
13439         }
13440
13441         if (pBtCoex->bC2hBtInfoReqSent == _TRUE)
13442         {
13443                 if (BT_IsBtDisabled(padapter) == _TRUE)
13444                 {
13445                         pBtCoex->c2hBtInfo = BT_INFO_STATE_DISABLED;
13446                 }
13447                 else
13448                 {
13449                         if (pBtCoex->c2hBtInfo == BT_INFO_STATE_DISABLED)
13450                                 pBtCoex->c2hBtInfo = BT_INFO_STATE_NO_CONNECTION;
13451                 }
13452
13453                 btdm_BTCoexist8723AHandler(padapter);
13454         }
13455         else if (BT_IsBtDisabled(padapter) == _TRUE)
13456         {
13457                 pBtCoex->c2hBtInfo = BT_INFO_STATE_DISABLED;
13458                 btdm_BTCoexist8723AHandler(padapter);
13459         }
13460
13461         BTDM_QueryBtInformation(padapter);
13462 }
13463
13464 // ===== End of sync from SD7 driver HAL/BTCoexist/HalBtc8723.c =====
13465 #endif
13466
13467 #ifdef __HALBTCCSR1ANT_C__ // HAL/BTCoexist/HalBtcCsr1Ant.c
13468 // ===== Below this line is sync from SD7 driver HAL/BTCoexist/HalBtcCsr1Ant.c =====
13469
13470 //============================================================
13471 // local function start with btdm_
13472 //============================================================
13473 void btdm_WriteReg860(PADAPTER padapter, u16 value)
13474 {
13475         RTPRINT(FBT, BT_TRACE, ("btdm_WriteReg860(), value = 0x%x\n", value));
13476         PHY_SetBBReg(padapter, 0x860, bMaskLWord, value);
13477 }
13478
13479 void btdm_CheckCounterOnly1Ant(PADAPTER padapter)
13480 {
13481         PHAL_DATA_TYPE  pHalData = GET_HAL_DATA(padapter);
13482 //      PMGNT_INFO              pMgntInfo = &padapter->MgntInfo;
13483         u32                     BT_Polling, Ratio_Act, Ratio_STA;
13484         u32                     BT_Active, BT_State;
13485         u32                     regBTActive = 0, regBTState = 0, regBTPolling=0;
13486
13487         if (!pHalData->bt_coexist.BluetoothCoexist)
13488                 return;
13489         if (pHalData->bt_coexist.BT_CoexistType != BT_CSR_BC8)
13490                 return;
13491         if (pHalData->bt_coexist.BT_Ant_Num != Ant_x1)
13492                 return;
13493
13494         //
13495         // The following we only consider CSR BC8 and fw version should be >= 62
13496         //
13497         RTPRINT(FBT, BT_TRACE, ("[DM][BT], FirmwareVersion = 0x%x(%d)\n",
13498                 pHalData->FirmwareVersion, pHalData->FirmwareVersion));
13499         {
13500                 regBTActive = REG_BT_ACTIVE;
13501                 regBTState = REG_BT_STATE;
13502                 if (pHalData->FirmwareVersion >= FW_VER_BT_REG1)
13503                         regBTPolling = REG_BT_POLLING1;
13504                 else
13505                         regBTPolling = REG_BT_POLLING;
13506         }
13507
13508         BT_Active = rtw_read32(padapter, regBTActive);
13509         RTPRINT(FBT, BT_TRACE, ("[DM][BT], BT_Active(0x%x)=%x\n", regBTActive, BT_Active));
13510         BT_Active = BT_Active & 0x00ffffff;
13511
13512         BT_State = rtw_read32(padapter, regBTState);
13513         RTPRINT(FBT, BT_TRACE, ("[DM][BT], BT_State(0x%x)=%x\n", regBTState, BT_State));
13514         BT_State = BT_State & 0x00ffffff;
13515
13516         BT_Polling = rtw_read32(padapter, regBTPolling);
13517         RTPRINT(FBT, BT_TRACE, ("[DM][BT], BT_Polling(0x%x)=%x\n", regBTPolling, BT_Polling));
13518
13519         Ratio_Act = BT_Active*1000/BT_Polling;
13520         Ratio_STA = BT_State*1000/BT_Polling;
13521
13522         RTPRINT(FBT, BT_TRACE, ("[DM][BT], Ratio_Act=%d\n", Ratio_Act));
13523         RTPRINT(FBT, BT_TRACE, ("[DM][BT], Ratio_STA=%d\n", Ratio_STA));
13524 }
13525
13526 u8
13527 btdm_IsSingleAnt(
13528         PADAPTER        padapter,
13529         u8              bSingleAntOn,
13530         u8              bInterruptOn,
13531         u8              bMultiNAVOn
13532         )
13533 {
13534         PHAL_DATA_TYPE  pHalData = GET_HAL_DATA(padapter);
13535         u8 bRet = _FALSE;
13536
13537         if ((pHalData->bt_coexist.bInterruptOn == bInterruptOn) &&
13538                 (pHalData->bt_coexist.bSingleAntOn == bSingleAntOn) &&
13539                 (pHalData->bt_coexist.bMultiNAVOn == bMultiNAVOn))
13540         {
13541                 bRet = _TRUE;
13542         }
13543
13544         RTPRINT(FBT, BT_TRACE, ("[DM][BT], current SingleAntenna = [%s:%s:%s]\n",
13545                 pHalData->bt_coexist.bSingleAntOn?"ON":"OFF",
13546                 pHalData->bt_coexist.bInterruptOn?"ON":"OFF",
13547                 pHalData->bt_coexist.bMultiNAVOn?"ON":"OFF"));
13548
13549         return bRet;
13550 }
13551
13552 u8 btdm_IsBalance(PADAPTER padapter, u8 bBalanceOn)
13553 {
13554         PHAL_DATA_TYPE  pHalData = GET_HAL_DATA(padapter);
13555
13556         RTPRINT(FBT, BT_TRACE, ("[DM][BT], btdm_IsBalance(), bBalanceOn=%s\n",
13557                 bBalanceOn?"ON":"OFF"));
13558
13559         if (pHalData->bt_coexist.bBalanceOn == bBalanceOn)
13560         {
13561                 return _TRUE;
13562         }
13563         return _FALSE;
13564 }
13565
13566 u8 btdm_EarphoneSpecDetect(PADAPTER padapter)
13567 {
13568         PHAL_DATA_TYPE  pHalData = GET_HAL_DATA(padapter);
13569
13570         switch (pHalData->bt_coexist.A2DPState)
13571         {
13572                 case BT_A2DP_STATE_NOT_ENTERED:
13573                         {
13574                                 RTPRINT(FBT, BT_TRACE, (" set default balance = ON, for WLANActH=12, WLANActL=24!!\n"));
13575                                 pHalData->bt_coexist.PreWLANActH = 12;
13576                                 pHalData->bt_coexist.PreWLANActL = 24;
13577                                 pHalData->bt_coexist.WLANActH = 12;
13578                                 pHalData->bt_coexist.WLANActL = 24;
13579                                 BTDM_Balance(padapter, _TRUE, pHalData->bt_coexist.WLANActH, pHalData->bt_coexist.WLANActL);
13580                                 BTDM_SingleAnt(padapter, _TRUE, _FALSE, _FALSE);
13581                                 pHalData->bt_coexist.A2DPState = BT_A2DP_STATE_DETECTING;
13582                         }
13583                         break;
13584
13585                 case BT_A2DP_STATE_DETECTING:
13586                         {
13587                                 // 32,12; the most critical for BT
13588                                 // 12,24
13589                                 // 0,0
13590                                 if (btdm_IsSingleAnt(padapter, _TRUE, _FALSE, _FALSE))
13591                                 {
13592                                         if ((pHalData->bt_coexist.PreWLANActH == 0) &&
13593                                                 (pHalData->bt_coexist.PreWLANActL == 0))
13594                                         {
13595                                                 RTPRINT(FBT, BT_TRACE, ("[WLANActH, WLANActL] = [0,0]\n"));
13596                                                 pHalData->bt_coexist.WLANActH = 12;
13597                                                 pHalData->bt_coexist.WLANActL = 24;
13598                                         }
13599                                         else if ((pHalData->bt_coexist.PreWLANActH == 12) &&
13600                                                 (pHalData->bt_coexist.PreWLANActL == 24))
13601                                         {
13602                                                 RTPRINT(FBT, BT_TRACE, ("[WLANActH, WLANActL] = [12,24]\n"));
13603                                                 if (((pHalData->bt_coexist.Ratio_Tx>600) &&
13604                                                         (pHalData->bt_coexist.Ratio_PRI>500)) ||
13605                                                         ((pHalData->bt_coexist.Ratio_Tx*10 ) >
13606                                                         (pHalData->bt_coexist.Ratio_PRI*15)))
13607                                                 {
13608                                                         RTPRINT(FBT, BT_TRACE, ("Ratio_Act > 600 && Ratio_STA > 500 or "));
13609                                                         RTPRINT(FBT, BT_TRACE, ("Ratio_Act/Ratio_STA > 1.5\n"));
13610                                                         pHalData->bt_coexist.WLANActH = 12;
13611                                                         pHalData->bt_coexist.WLANActL = 24;
13612                                                 }
13613                                                 else
13614                                                 {
13615                                                         RTPRINT(FBT, BT_TRACE, (" cosa set to 32/12\n "));
13616                                                         pHalData->bt_coexist.WLANActH = 32;
13617                                                         pHalData->bt_coexist.WLANActL = 12;
13618                                                 }
13619                                         }
13620                                         else if ((pHalData->bt_coexist.PreWLANActH == 32) &&
13621                                                         (pHalData->bt_coexist.PreWLANActL == 12))
13622                                         {
13623                                                 RTPRINT(FBT, BT_TRACE, ("[WLANActH, WLANActL] = [32,12]\n"));
13624                                                 if (((pHalData->bt_coexist.Ratio_Tx>650) &&
13625                                                         (pHalData->bt_coexist.Ratio_PRI>550)) ||
13626                                                         ((pHalData->bt_coexist.Ratio_Tx*10 ) >
13627                                                         (pHalData->bt_coexist.Ratio_PRI*15)))
13628                                                 {
13629                                                         RTPRINT(FBT, BT_TRACE, ("Ratio_Act > 650 && Ratio_STA > 550 or "));
13630                                                         RTPRINT(FBT, BT_TRACE, ("Ratio_Act/Ratio_STA > 1.5\n"));
13631                                                         pHalData->bt_coexist.WLANActH = 12;
13632                                                         pHalData->bt_coexist.WLANActL = 24;
13633                                                 }
13634                                         }
13635                                         if ((pHalData->bt_coexist.PreWLANActH != pHalData->bt_coexist.WLANActH) ||
13636                                                 (pHalData->bt_coexist.PreWLANActL != pHalData->bt_coexist.WLANActL))
13637                                         {
13638                                                 BTDM_Balance(padapter, _TRUE, pHalData->bt_coexist.WLANActH, pHalData->bt_coexist.WLANActL);
13639                                                 pHalData->bt_coexist.PreWLANActH = pHalData->bt_coexist.WLANActH;
13640                                                 pHalData->bt_coexist.PreWLANActL = pHalData->bt_coexist.WLANActL;
13641                                         }
13642                                 }
13643
13644                                 RTPRINT(FBT, BT_TRACE, ("earphone detected result: WLANActH=%d, WLANActL=%d\n",
13645                                         pHalData->bt_coexist.WLANActH, pHalData->bt_coexist.WLANActL));
13646                         }
13647                         break;
13648
13649                 case BT_A2DP_STATE_DETECTED:
13650                         break;
13651
13652                 default:
13653                         RT_ASSERT(_FALSE, ("btdm_EarphoneSpecDetect(), unknown case\n"));
13654                         break;
13655         }
13656         return _TRUE;
13657 }
13658
13659 //==============================================================
13660 //
13661 // Note:
13662 // In the following, FW should be done before SW mechanism.
13663 //
13664 //==============================================================
13665
13666 void btdm_SCOActionBC81Ant(PADAPTER padapter)
13667 {
13668 //      PMGNT_INFO              pMgntInfo = &padapter->MgntInfo;
13669         struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
13670         u8      btRssiState;
13671
13672         if ((pmlmepriv->LinkDetectInfo.bTxBusyTraffic) ||
13673                 !(pmlmepriv->LinkDetectInfo.bBusyTraffic))
13674         {
13675                 RTPRINT(FBT, BT_TRACE, ("Wifi Uplink or Wifi is idle\n"));
13676                 if (BTDM_IsSameCoexistState(padapter))
13677                                 return;
13678                 BTDM_Balance(padapter, _FALSE, 0, 0);
13679                 BTDM_SingleAnt(padapter, _TRUE, _TRUE, _FALSE);
13680         }
13681         else if (pmlmepriv->LinkDetectInfo.bRxBusyTraffic)
13682         {
13683                 RTPRINT(FBT, BT_TRACE, ("Wifi Downlink\n"));
13684
13685                 if (btdm_IsSingleAnt(padapter, _FALSE, _FALSE, _FALSE))
13686                 {
13687                         btRssiState = BTDM_CheckCoexRSSIState(padapter, 2, BT_FW_COEX_THRESH_20, 0);
13688                         if (BTDM_IsSameCoexistState(padapter))
13689                                 return;
13690                         if ((btRssiState == BT_RSSI_STATE_LOW) ||
13691                                 (btRssiState == BT_RSSI_STATE_STAY_LOW))
13692                         {
13693                                 BTDM_Balance(padapter, _FALSE, 0, 0);
13694                                 BTDM_SingleAnt(padapter, _TRUE, _TRUE, _FALSE);
13695                         }
13696                 }
13697                 else
13698                 {
13699                         btRssiState = BTDM_CheckCoexRSSIState(padapter, 2, BT_FW_COEX_THRESH_45, 0);
13700                         if (BTDM_IsSameCoexistState(padapter))
13701                                 return;
13702                         if ((btRssiState == BT_RSSI_STATE_HIGH) ||
13703                                 (btRssiState == BT_RSSI_STATE_STAY_HIGH))
13704                         {
13705                                 BTDM_Balance(padapter, _FALSE, 0, 0);
13706                                 BTDM_SingleAnt(padapter, _FALSE, _FALSE, _FALSE);
13707                         }
13708                         else
13709                         {
13710                                 BTDM_Balance(padapter, _FALSE, 0, 0);
13711                                 BTDM_SingleAnt(padapter, _TRUE, _TRUE, _FALSE);
13712                         }
13713                 }
13714         }
13715 }
13716
13717 u8 btdm_SCOAction1Ant(PADAPTER padapter)
13718 {
13719         PHAL_DATA_TYPE  pHalData = GET_HAL_DATA(padapter);
13720         PBT30Info               pBTInfo = GET_BT_INFO(padapter);
13721         PBT_MGNT                pBtMgnt = &pBTInfo->BtMgnt;
13722
13723         if (pBtMgnt->ExtConfig.NumberOfSCO > 0)
13724         {
13725                 pHalData->bt_coexist.CurrentState |= BT_COEX_STATE_PROFILE_SCO;
13726                 btdm_SCOActionBC81Ant(padapter);
13727                 return _TRUE;
13728         }
13729         else
13730         {
13731                 pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_PROFILE_SCO;
13732                 return _FALSE;
13733         }
13734 }
13735
13736 void btdm_HIDActionBC81Ant(PADAPTER padapter)
13737 {
13738         BTDM_Balance(padapter, _FALSE, 0, 0);
13739         BTDM_SingleAnt(padapter, _TRUE, _TRUE, _FALSE);
13740 }
13741
13742 u8 btdm_HIDAction1Ant(PADAPTER padapter)
13743 {
13744         PBT30Info               pBTInfo = GET_BT_INFO(padapter) ;
13745         PBT_MGNT                pBtMgnt = &pBTInfo->BtMgnt;
13746         PHAL_DATA_TYPE  pHalData = GET_HAL_DATA(padapter);
13747
13748         if (BTHCI_CheckProfileExist(padapter,BT_PROFILE_HID) && pBtMgnt->ExtConfig.NumberOfHandle==1)
13749         {
13750                 pHalData->bt_coexist.CurrentState |= BT_COEX_STATE_PROFILE_HID;
13751                 pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_PROFILE_PAN;
13752                 pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_PROFILE_A2DP;
13753                 btdm_HIDActionBC81Ant(padapter);
13754                 return _TRUE;
13755         }
13756         else
13757         {
13758                 return _FALSE;
13759         }
13760 }
13761
13762 void btdm_A2DPActionBC81Ant(PADAPTER padapter)
13763 {
13764         PBT30Info               pBTInfo = GET_BT_INFO(padapter);
13765         PBT_MGNT                pBtMgnt = &pBTInfo->BtMgnt;
13766         PHAL_DATA_TYPE  pHalData = GET_HAL_DATA(padapter);
13767         u8                      btRssiState;
13768
13769         if (pBtMgnt->ExtConfig.bBTBusy)
13770         {
13771                 RTPRINT(FBT, BT_TRACE, ("BT is non-idle!\n"));
13772
13773                 // We have to detect BT earphone spec first.
13774                 btdm_EarphoneSpecDetect(padapter);
13775
13776                 if (!BTDM_IsHT40(padapter))
13777                 {
13778                         RTPRINT(FBT, BT_TRACE, ("HT20 or Legacy\n"));
13779                         if (btdm_IsSingleAnt(padapter, _FALSE, _FALSE, _FALSE))
13780                         {
13781                                 btRssiState = BTDM_CheckCoexRSSIState(padapter, 2, BT_FW_COEX_THRESH_30, 0);
13782                                 if (BTDM_IsSameCoexistState(padapter))
13783                                         return;
13784
13785                                 if ((btRssiState == BT_RSSI_STATE_LOW) ||
13786                                         (btRssiState == BT_RSSI_STATE_STAY_LOW))
13787                                 {
13788                                         BTDM_Balance(padapter, _TRUE, pHalData->bt_coexist.WLANActH, pHalData->bt_coexist.WLANActL);
13789                                         BTDM_SingleAnt(padapter, _TRUE, _FALSE, _FALSE);
13790                                 }
13791                         }
13792                         else
13793                         {
13794                                 btRssiState = BTDM_CheckCoexRSSIState(padapter, 2, BT_FW_COEX_THRESH_55, 0);
13795                                 if (BTDM_IsSameCoexistState(padapter))
13796                                         return;
13797
13798                                 if ((btRssiState == BT_RSSI_STATE_HIGH) ||
13799                                         (btRssiState == BT_RSSI_STATE_STAY_HIGH))
13800                                 {
13801                                         BTDM_Balance(padapter, _FALSE, 0, 0);
13802                                         BTDM_SingleAnt(padapter, _FALSE, _FALSE, _FALSE);
13803                                 }
13804                                 else
13805                                 {
13806                                         BTDM_Balance(padapter, _TRUE, pHalData->bt_coexist.WLANActH, pHalData->bt_coexist.WLANActL);
13807                                         BTDM_SingleAnt(padapter, _TRUE, _FALSE, _FALSE);
13808                                 }
13809                         }
13810                 }
13811                 else
13812                 {
13813                         RTPRINT(FBT, BT_TRACE, ("HT40\n"));
13814                         if (BTDM_IsSameCoexistState(padapter))
13815                                 return;
13816                         BTDM_Balance(padapter, _TRUE, pHalData->bt_coexist.WLANActH, pHalData->bt_coexist.WLANActL);
13817                         BTDM_SingleAnt(padapter, _TRUE, _FALSE, _FALSE);
13818                 }
13819         }
13820         else
13821         {
13822                 RTPRINT(FBT, BT_TRACE, ("BT is idle!\n"));
13823                 pHalData->bt_coexist.A2DPState = BT_A2DP_STATE_NOT_ENTERED;
13824                 if (pHalData->bt_coexist.Ratio_PRI > 3)
13825                 {
13826                         RTPRINT(FBT, BT_TRACE, ("Ratio_STA > 3\n"));
13827                 BTDM_Balance(padapter, _FALSE, 0, 0);
13828                 BTDM_SingleAnt(padapter, _TRUE, _TRUE, _FALSE);
13829         }
13830                 else
13831                 {
13832                         RTPRINT(FBT, BT_TRACE, ("Ratio_STA <= 3\n"));
13833                         BTDM_Balance(padapter, _TRUE, 32, 5);
13834                         BTDM_SingleAnt(padapter, _TRUE, _FALSE, _FALSE);
13835                 }
13836         }
13837 }
13838
13839 u8 btdm_A2DPAction1Ant(PADAPTER padapter)
13840 {
13841         PHAL_DATA_TYPE  pHalData = GET_HAL_DATA(padapter);
13842         PBT30Info               pBTInfo = GET_BT_INFO(padapter) ;
13843         PBT_MGNT                pBtMgnt = &pBTInfo->BtMgnt;
13844
13845         if (BTHCI_CheckProfileExist(padapter, BT_PROFILE_A2DP) && pBtMgnt->ExtConfig.NumberOfHandle==1)
13846         {
13847                 pHalData->bt_coexist.CurrentState |= BT_COEX_STATE_PROFILE_A2DP;
13848                 pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_PROFILE_HID;
13849                 pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_PROFILE_PAN;
13850                 btdm_A2DPActionBC81Ant(padapter);
13851                 return _TRUE;
13852         }
13853         else
13854         {
13855                 return _FALSE;
13856         }
13857 }
13858
13859 void btdm_PANActionBC81Ant(PADAPTER padapter)
13860 {
13861 //      PMGNT_INFO              pMgntInfo = &padapter->MgntInfo;
13862         struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
13863         PBT30Info               pBTInfo = GET_BT_INFO(padapter) ;
13864         PBT_MGNT                pBtMgnt = &pBTInfo->BtMgnt;
13865         PHAL_DATA_TYPE  pHalData = GET_HAL_DATA(padapter);
13866         u8                      btRssiState;
13867
13868         if (pBtMgnt->ExtConfig.bBTBusy && !pBtMgnt->BtOperationOn)
13869         {
13870                 RTPRINT(FBT, BT_TRACE, ("BT is non-idle && [BT 2.1]\n"));
13871
13872                 if (!BTDM_IsHT40(padapter))
13873                         {
13874                                 RTPRINT(FBT, BT_TRACE, ("HT20 or Legacy\n"));
13875                                 if (btdm_IsSingleAnt(padapter, _FALSE, _FALSE, _FALSE))
13876                                 {
13877                                 btRssiState = BTDM_CheckCoexRSSIState(padapter, 2, BT_FW_COEX_THRESH_20, 0);
13878                                         if (BTDM_IsSameCoexistState(padapter))
13879                                                 return;
13880
13881                                         if ((btRssiState == BT_RSSI_STATE_LOW) ||
13882                                                 (btRssiState == BT_RSSI_STATE_STAY_LOW))
13883                                         {
13884                                         BTDM_Balance(padapter, _TRUE, 0x1c, 0x20);
13885                                         BTDM_SingleAnt(padapter, _TRUE, _FALSE, _FALSE);
13886                                         }
13887                                 }
13888                                 else
13889                                 {
13890                                         btRssiState = BTDM_CheckCoexRSSIState(padapter, 2, BT_FW_COEX_THRESH_50, 0);
13891                                         if (BTDM_IsSameCoexistState(padapter))
13892                                                 return;
13893                                         if ((btRssiState == BT_RSSI_STATE_HIGH) ||
13894                                                 (btRssiState == BT_RSSI_STATE_STAY_HIGH))
13895                                         {
13896                                                 BTDM_Balance(padapter, _FALSE, 0, 0);
13897                                                 BTDM_SingleAnt(padapter, _FALSE, _FALSE, _FALSE);
13898                                         }
13899                                         else
13900                                         {
13901                                         BTDM_Balance(padapter, _TRUE, 0x1c, 0x20);
13902                                         BTDM_SingleAnt(padapter, _TRUE, _FALSE, _FALSE);
13903                                 }
13904                         }
13905                 }
13906                 else
13907                 {
13908                         RTPRINT(FBT, BT_TRACE, ("HT40\n"));
13909                         if ((pHalData->bt_coexist.BT21TrafficStatistics.bRxBusyTraffic) &&
13910                                 (pmlmepriv->LinkDetectInfo.bTxBusyTraffic))
13911                         {
13912                                 RTPRINT(FBT, BT_TRACE, ("BT is Downlink and Wifi is Uplink\n"));
13913                                 if (btdm_IsSingleAnt(padapter, _FALSE, _FALSE, _FALSE))
13914                                 {
13915                                         btRssiState = BTDM_CheckCoexRSSIState(padapter, 2, BT_FW_COEX_THRESH_20, 0);
13916                                         if (BTDM_IsSameCoexistState(padapter))
13917                                                 return;
13918                                         if ((btRssiState == BT_RSSI_STATE_LOW) ||
13919                                                 (btRssiState == BT_RSSI_STATE_STAY_LOW))
13920                                         {
13921                                                 BTDM_Balance(padapter, _TRUE, 0x1c, 0x20);
13922                                                 BTDM_SingleAnt(padapter, _TRUE, _FALSE, _FALSE);
13923                                         }
13924                                 }
13925                                 else
13926                                 {
13927                                         btRssiState = BTDM_CheckCoexRSSIState(padapter, 2, BT_FW_COEX_THRESH_45, 0);
13928                                         if (BTDM_IsSameCoexistState(padapter))
13929                                                 return;
13930                                         if ((btRssiState == BT_RSSI_STATE_HIGH) ||
13931                                                 (btRssiState == BT_RSSI_STATE_STAY_HIGH))
13932                                         {
13933                                                 BTDM_Balance(padapter, _FALSE, 0, 0);
13934                                                 BTDM_SingleAnt(padapter, _FALSE, _FALSE, _FALSE);
13935                                         }
13936                                         else
13937                                         {
13938                                                 BTDM_Balance(padapter, _TRUE, 0x1c, 0x20);
13939                                                 BTDM_SingleAnt(padapter, _TRUE, _FALSE, _FALSE);
13940                                         }
13941                                 }
13942                         }
13943                         else
13944                         {
13945                                 RTPRINT(FBT, BT_TRACE, ("BT Uplink or BTdownlink+Wifi downlink\n"));
13946                                 BTDM_Balance(padapter, _TRUE, 0x1c, 0x20);
13947                                 BTDM_SingleAnt(padapter, _TRUE, _FALSE, _FALSE);
13948                         }
13949                 }
13950         }
13951         else if (pBtMgnt->ExtConfig.bBTBusy && pBtMgnt->BtOperationOn)
13952         {
13953                 RTPRINT(FBT, BT_TRACE, ("BT is non-idle && [BT 3.0]\n"));
13954                 BTDM_FWCoexAllOff(padapter);
13955         }
13956         else
13957         {
13958                 RTPRINT(FBT, BT_TRACE, ("BT is idle\n"));
13959                 BTDM_Balance(padapter, _TRUE, 32, 5);
13960                 BTDM_SingleAnt(padapter, _TRUE, _FALSE, _FALSE);
13961         }
13962 }
13963
13964 u8 btdm_PANAction1Ant(PADAPTER padapter)
13965 {
13966         PHAL_DATA_TYPE  pHalData = GET_HAL_DATA(padapter);
13967         PBT30Info               pBTInfo = GET_BT_INFO(padapter);
13968         PBT_MGNT                pBtMgnt = &pBTInfo->BtMgnt;
13969
13970         if (BTHCI_CheckProfileExist(padapter,BT_PROFILE_PAN) && pBtMgnt->ExtConfig.NumberOfHandle==1)
13971         {
13972                 pHalData->bt_coexist.CurrentState |= BT_COEX_STATE_PROFILE_PAN;
13973                 pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_PROFILE_HID;
13974                 pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_PROFILE_A2DP;
13975                 btdm_PANActionBC81Ant(padapter);
13976                 return _TRUE;
13977         }
13978         else
13979         {
13980                 return _FALSE;
13981         }
13982 }
13983
13984 void btdm_HIDA2DPActionBC81Ant(PADAPTER padapter)
13985 {
13986         PBT30Info               pBTInfo = GET_BT_INFO(padapter);
13987         PBT_MGNT                pBtMgnt = &pBTInfo->BtMgnt;
13988
13989         if (pBtMgnt->ExtConfig.bBTBusy)
13990         {
13991                 RTPRINT(FBT, BT_TRACE, ("BT is non-idle!\n"));
13992                 BTDM_Balance(padapter, _TRUE, 0x5, 0x1a);
13993                 BTDM_SingleAnt(padapter, _TRUE, _FALSE, _FALSE);
13994         }
13995         else
13996         {
13997                 RTPRINT(FBT, BT_TRACE, ("BT is idle!\n"));
13998                 BTDM_Balance(padapter, _FALSE, 0, 0);
13999                 BTDM_SingleAnt(padapter, _TRUE, _TRUE, _FALSE);
14000         }
14001 }
14002
14003 u8 btdm_HIDA2DPAction1Ant(PADAPTER padapter)
14004 {
14005         PHAL_DATA_TYPE  pHalData = GET_HAL_DATA(padapter);
14006
14007         if (BTHCI_CheckProfileExist(padapter,BT_PROFILE_HID) && BTHCI_CheckProfileExist(padapter,BT_PROFILE_A2DP))
14008         {
14009                 pHalData->bt_coexist.CurrentState |= (BT_COEX_STATE_PROFILE_HID|BT_COEX_STATE_PROFILE_A2DP);
14010                 btdm_HIDA2DPActionBC81Ant(padapter);
14011                 return _TRUE;
14012         }
14013         else
14014         {
14015                 pHalData->bt_coexist.CurrentState &= ~(BT_COEX_STATE_PROFILE_HID|BT_COEX_STATE_PROFILE_A2DP);
14016                 return _FALSE;
14017         }
14018 }
14019
14020 void btdm_HIDPANActionBC81Ant(PADAPTER padapter)
14021 {
14022         PBT30Info               pBTInfo = GET_BT_INFO(padapter);
14023         PBT_MGNT                pBtMgnt = &pBTInfo->BtMgnt;
14024
14025         if ((pBtMgnt->ExtConfig.bBTBusy && !pBtMgnt->BtOperationOn))
14026         {
14027                 RTPRINT(FBT, BT_TRACE, ("BT is non-idle && [BT 2.1]\n"));
14028                 BTDM_Balance(padapter, _TRUE, 0x5, 0x1a);
14029                 BTDM_SingleAnt(padapter, _TRUE, _FALSE, _FALSE);
14030         }
14031         else
14032         {
14033                 RTPRINT(FBT, BT_TRACE, ("BT is idle or [BT 3.0]\n"));
14034                 BTDM_Balance(padapter, _FALSE, 0, 0);
14035                 BTDM_SingleAnt(padapter, _TRUE, _TRUE, _FALSE);
14036         }
14037 }
14038
14039 u8 btdm_HIDPANAction1Ant(PADAPTER padapter)
14040 {
14041         PHAL_DATA_TYPE  pHalData = GET_HAL_DATA(padapter);
14042
14043         if (BTHCI_CheckProfileExist(padapter,BT_PROFILE_HID) && BTHCI_CheckProfileExist(padapter,BT_PROFILE_PAN))
14044         {
14045                 pHalData->bt_coexist.CurrentState |= (BT_COEX_STATE_PROFILE_HID|BT_COEX_STATE_PROFILE_PAN);
14046                 btdm_HIDPANActionBC81Ant(padapter);
14047                 return _TRUE;
14048         }
14049         else
14050         {
14051                 pHalData->bt_coexist.CurrentState &= ~(BT_COEX_STATE_PROFILE_HID|BT_COEX_STATE_PROFILE_PAN);
14052                 return _FALSE;
14053         }
14054 }
14055
14056 void btdm_PANA2DPActionBC81Ant(PADAPTER padapter)
14057 {
14058         PBT30Info               pBTInfo = GET_BT_INFO(padapter);
14059         PBT_MGNT                pBtMgnt = &pBTInfo->BtMgnt;
14060
14061         if ((pBtMgnt->ExtConfig.bBTBusy && !pBtMgnt->BtOperationOn))
14062         {
14063                 RTPRINT(FBT, BT_TRACE, ("BT is non-idle && [BT 2.1]\n"));
14064                 BTDM_Balance(padapter, _TRUE, 0x5, 0x1a);
14065                 BTDM_SingleAnt(padapter, _TRUE, _FALSE, _FALSE);
14066         }
14067         else if ((pBtMgnt->ExtConfig.bBTBusy && pBtMgnt->BtOperationOn))
14068         {
14069                 RTPRINT(FBT, BT_TRACE, ("BT is non-idle && [BT 3.0]\n"));
14070                 btdm_A2DPActionBC81Ant(padapter);
14071         }
14072         else
14073         {
14074                 BTDM_Balance(padapter, _FALSE, 0, 0);
14075                 BTDM_SingleAnt(padapter, _TRUE, _TRUE, _FALSE);
14076         }
14077 }
14078
14079 u8 btdm_PANA2DPAction1Ant(PADAPTER padapter)
14080 {
14081         PHAL_DATA_TYPE  pHalData = GET_HAL_DATA(padapter);
14082
14083         if (BTHCI_CheckProfileExist(padapter,BT_PROFILE_PAN) && BTHCI_CheckProfileExist(padapter,BT_PROFILE_A2DP))
14084         {
14085                 pHalData->bt_coexist.CurrentState |= (BT_COEX_STATE_PROFILE_PAN|BT_COEX_STATE_PROFILE_A2DP);
14086                 btdm_PANA2DPActionBC81Ant(padapter);
14087                 return _TRUE;
14088         }
14089         else
14090         {
14091                 pHalData->bt_coexist.CurrentState &= ~(BT_COEX_STATE_PROFILE_PAN|BT_COEX_STATE_PROFILE_A2DP);
14092                 return _FALSE;
14093         }
14094 }
14095
14096 //============================================================
14097 // extern function start with BTDM_
14098 //============================================================
14099
14100 void BTDM_SetAntenna(PADAPTER padapter, u8 who)
14101 {
14102         PHAL_DATA_TYPE  pHalData = GET_HAL_DATA(padapter);
14103         PBT30Info               pBTInfo = GET_BT_INFO(padapter);
14104         PBT_MGNT                pBtMgnt = &pBTInfo->BtMgnt;
14105
14106         if (!IS_HARDWARE_TYPE_8192C(padapter))
14107                 return;
14108         if (!pHalData->bt_coexist.BluetoothCoexist)
14109                 return;
14110         if (pBtMgnt->ExtConfig.bManualControl)
14111                 return;
14112         if (pHalData->bt_coexist.BT_CoexistType != BT_CSR_BC8)
14113                 return;
14114         if (pHalData->bt_coexist.BT_Ant_Num != Ant_x1)
14115                 return;
14116 //      if (pHalData->bt_coexist.AntennaState == who)
14117 //              return;
14118
14119         switch (who)
14120         {
14121                 case BTDM_ANT_BT_IDLE:
14122                         RTPRINT(FBT, BT_TRACE, ("BTDM_SetAntenna(), BTDM_ANT_BT_IDLE\n"));
14123                         BTDM_Balance(padapter, _FALSE, 0, 0);
14124                         BTDM_SingleAnt(padapter, _TRUE, _TRUE, _FALSE);
14125                         pHalData->bt_coexist.AntennaState = BTDM_ANT_BT_IDLE;
14126                         break;
14127
14128                 case BTDM_ANT_WIFI:
14129                         RTPRINT(FBT, BT_TRACE, ("BTDM_SetAntenna(), BTDM_ANT_WIFI\n"));
14130                         BTDM_Balance(padapter, _FALSE, 0, 0);
14131                         BTDM_SingleAnt(padapter, _FALSE, _FALSE, _FALSE);
14132                         rtw_mdelay_os(3);       // 1 will fail, 2 ok
14133                         btdm_WriteReg860(padapter, 0x130);
14134                         pHalData->bt_coexist.AntennaState = BTDM_ANT_WIFI;
14135                         break;
14136
14137                 case BTDM_ANT_BT:
14138                         RTPRINT(FBT, BT_TRACE, ("BTDM_SetAntenna(), BTDM_ANT_BT\n"));
14139                         BTDM_Balance(padapter, _FALSE, 0, 0);
14140                         BTDM_SingleAnt(padapter, _FALSE, _FALSE, _FALSE);
14141                         //btdm_WriteReg860(padapter, 0x230);
14142                         pHalData->bt_coexist.AntennaState = BTDM_ANT_BT;
14143                         break;
14144
14145                 default:
14146                         RT_ASSERT(_FALSE, ("BTDM_SetAntenna(), error case\n"));
14147                         break;
14148         }
14149 }
14150
14151 void
14152 BTDM_SingleAnt(
14153         PADAPTER        padapter,
14154         u8              bSingleAntOn,
14155         u8              bInterruptOn,
14156         u8              bMultiNAVOn
14157         )
14158 {
14159         PHAL_DATA_TYPE  pHalData = GET_HAL_DATA(padapter);
14160         u8                      H2C_Parameter[3] = {0};
14161
14162         if (pHalData->bt_coexist.BT_Ant_Num != Ant_x1)
14163                 return;
14164
14165         H2C_Parameter[2] = 0;
14166         H2C_Parameter[1] = 0;
14167         H2C_Parameter[0] = 0;
14168
14169         if (bInterruptOn)
14170         {
14171                 H2C_Parameter[2] |= 0x02;       //BIT1
14172                 pHalData->bt_coexist.bFWCoexistAllOff = _FALSE;
14173         }
14174         pHalData->bt_coexist.bInterruptOn = bInterruptOn;
14175
14176         if (bSingleAntOn)
14177         {
14178                 H2C_Parameter[2] |= 0x10;       //BIT4
14179                 pHalData->bt_coexist.bFWCoexistAllOff = _FALSE;
14180         }
14181         pHalData->bt_coexist.bSingleAntOn = bSingleAntOn;
14182
14183         if (bMultiNAVOn)
14184         {
14185                 H2C_Parameter[2] |= 0x20;       //BIT5
14186                 pHalData->bt_coexist.bFWCoexistAllOff = _FALSE;
14187         }
14188         pHalData->bt_coexist.bMultiNAVOn = bMultiNAVOn;
14189
14190         RTPRINT(FBT, BT_TRACE, ("[DM][BT], SingleAntenna=[%s:%s:%s], write 0xe = 0x%x\n",
14191                 bSingleAntOn?"ON":"OFF", bInterruptOn?"ON":"OFF", bMultiNAVOn?"ON":"OFF",
14192                 H2C_Parameter[0]<<16|H2C_Parameter[1]<<8|H2C_Parameter[2]));
14193
14194         if (IS_HARDWARE_TYPE_8192C(padapter))
14195         {
14196                 FillH2CCmd(padapter, 0xe, 3, H2C_Parameter);
14197         }
14198         else if (IS_HARDWARE_TYPE_8192D(padapter))
14199         {
14200                 FillH2CCmd(padapter, 0x12, 3, H2C_Parameter);
14201         }
14202 }
14203
14204 void BTDM_CheckBTIdleChange1Ant(PADAPTER padapter)
14205 {
14206         PBT30Info               pBTInfo = GET_BT_INFO(padapter);
14207         PBT_MGNT                pBtMgnt = &pBTInfo->BtMgnt;
14208         PHAL_DATA_TYPE  pHalData = GET_HAL_DATA(padapter);
14209 //      PMGNT_INFO              pMgntInfo = &padapter->MgntInfo;
14210         u8                              stateChange = _FALSE;
14211         u32                     BT_Polling, Ratio_Act, Ratio_STA;
14212         u32                             BT_Active, BT_State;
14213         u32                             regBTActive=0, regBTState=0, regBTPolling=0;
14214
14215         if (!pHalData->bt_coexist.BluetoothCoexist)
14216                 return;
14217         if (pBtMgnt->ExtConfig.bManualControl)
14218                 return;
14219         if (pHalData->bt_coexist.BT_CoexistType != BT_CSR_BC8)
14220                 return;
14221         if (pHalData->bt_coexist.BT_Ant_Num != Ant_x1)
14222                 return;
14223
14224         //
14225         // The following we only consider CSR BC8 and fw version should be >= 62
14226         //
14227         RTPRINT(FBT, BT_TRACE, ("[DM][BT], FirmwareVersion = 0x%x(%d)\n",
14228         pHalData->FirmwareVersion, pHalData->FirmwareVersion));
14229         {
14230                 regBTActive = REG_BT_ACTIVE;
14231                 regBTState = REG_BT_STATE;
14232                 if (pHalData->FirmwareVersion >= FW_VER_BT_REG1)
14233                         regBTPolling = REG_BT_POLLING1;
14234                 else
14235                         regBTPolling = REG_BT_POLLING;
14236         }
14237
14238         BT_Active = rtw_read32(padapter, regBTActive);
14239         RTPRINT(FBT, BT_TRACE, ("[DM][BT], BT_Active(0x%x)=%x\n", regBTActive, BT_Active));
14240         BT_Active = BT_Active & 0x00ffffff;
14241
14242         BT_State = rtw_read32(padapter, regBTState);
14243         RTPRINT(FBT, BT_TRACE, ("[DM][BT], BT_State(0x%x)=%x\n", regBTState, BT_State));
14244         BT_State = BT_State & 0x00ffffff;
14245
14246         BT_Polling = rtw_read32(padapter, regBTPolling);
14247         RTPRINT(FBT, BT_TRACE, ("[DM][BT], BT_Polling(0x%x)=%x\n", regBTPolling, BT_Polling));
14248
14249         if (BT_Active==0xffffffff && BT_State==0xffffffff && BT_Polling==0xffffffff )
14250                 return;
14251         if (BT_Polling == 0)
14252                 return;
14253
14254         Ratio_Act = BT_Active*1000/BT_Polling;
14255         Ratio_STA = BT_State*1000/BT_Polling;
14256
14257         pHalData->bt_coexist.Ratio_Tx = Ratio_Act;
14258         pHalData->bt_coexist.Ratio_PRI = Ratio_STA;
14259
14260         RTPRINT(FBT, BT_TRACE, ("[DM][BT], Ratio_Act=%d\n", Ratio_Act));
14261         RTPRINT(FBT, BT_TRACE, ("[DM][BT], Ratio_STA=%d\n", Ratio_STA));
14262
14263         if (Ratio_STA<60 && Ratio_Act<500)      // BT PAN idle
14264         {
14265                 pHalData->bt_coexist.CurrentState |= BT_COEX_STATE_BT_PAN_IDLE;
14266                 pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_BT_PAN_DOWNLINK;
14267                 pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_BT_PAN_UPLINK;
14268         }
14269         else
14270         {
14271                 pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_BT_PAN_IDLE;
14272
14273                 if (Ratio_STA)
14274                 {
14275                         // Check if BT PAN (under BT 2.1) is uplink or downlink
14276                         if ((Ratio_Act/Ratio_STA) < 2)
14277                         {
14278                                 // BT PAN Uplink
14279                                 pHalData->bt_coexist.BT21TrafficStatistics.bTxBusyTraffic = _TRUE;
14280                                 pHalData->bt_coexist.CurrentState |= BT_COEX_STATE_BT_PAN_UPLINK;
14281                                 pHalData->bt_coexist.BT21TrafficStatistics.bRxBusyTraffic = _FALSE;
14282                                 pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_BT_PAN_DOWNLINK;
14283                         }
14284                         else
14285                         {
14286                                 // BT PAN downlink
14287                                 pHalData->bt_coexist.BT21TrafficStatistics.bTxBusyTraffic = _FALSE;
14288                                 pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_BT_PAN_UPLINK;
14289                                 pHalData->bt_coexist.BT21TrafficStatistics.bRxBusyTraffic = _TRUE;
14290                                 pHalData->bt_coexist.CurrentState |= BT_COEX_STATE_BT_PAN_DOWNLINK;
14291                         }
14292                 }
14293                 else
14294                 {
14295                         // BT PAN downlink
14296                         pHalData->bt_coexist.BT21TrafficStatistics.bTxBusyTraffic = _FALSE;
14297                         pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_BT_PAN_UPLINK;
14298                         pHalData->bt_coexist.BT21TrafficStatistics.bRxBusyTraffic = _TRUE;
14299                         pHalData->bt_coexist.CurrentState |= BT_COEX_STATE_BT_PAN_DOWNLINK;
14300                 }
14301         }
14302
14303         // Check BT is idle or not
14304         if (pBtMgnt->ExtConfig.NumberOfHandle==0 &&
14305                 pBtMgnt->ExtConfig.NumberOfSCO==0)
14306         {
14307                 pBtMgnt->ExtConfig.bBTBusy = _FALSE;
14308                 pHalData->bt_coexist.CurrentState |= BT_COEX_STATE_BT_IDLE;
14309         }
14310         else
14311         {
14312                 if (Ratio_STA<60)
14313                 {
14314                         pBtMgnt->ExtConfig.bBTBusy = _FALSE;
14315                         pHalData->bt_coexist.CurrentState |= BT_COEX_STATE_BT_IDLE;
14316                 }
14317                 else
14318                 {
14319                         pBtMgnt->ExtConfig.bBTBusy = _TRUE;
14320                         pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_BT_IDLE;
14321                 }
14322         }
14323
14324         if (pBtMgnt->ExtConfig.NumberOfHandle==0 &&
14325                 pBtMgnt->ExtConfig.NumberOfSCO==0)
14326         {
14327                 pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_BT_RSSI_LOW;
14328                 pBtMgnt->ExtConfig.MIN_BT_RSSI = 0;
14329                 BTDM_SetAntenna(padapter, BTDM_ANT_BT_IDLE);
14330         }
14331         else
14332         {
14333                 if (pBtMgnt->ExtConfig.MIN_BT_RSSI <= -5)
14334                 {
14335                         pHalData->bt_coexist.CurrentState |= BT_COEX_STATE_BT_RSSI_LOW;
14336                         RTPRINT(FBT, BT_TRACE, ("[DM][BT], core stack notify bt rssi Low\n"));
14337                 }
14338                 else
14339                 {
14340                         pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_BT_RSSI_LOW;
14341                         RTPRINT(FBT, BT_TRACE, ("[DM][BT], core stack notify bt rssi Normal\n"));
14342                 }
14343         }
14344
14345         if (pHalData->bt_coexist.bBTBusyTraffic !=
14346                 pBtMgnt->ExtConfig.bBTBusy)
14347         {       // BT idle or BT non-idle
14348                 pHalData->bt_coexist.bBTBusyTraffic = pBtMgnt->ExtConfig.bBTBusy;
14349                 stateChange = _TRUE;
14350         }
14351
14352         if (stateChange)
14353         {
14354                 if (!pBtMgnt->ExtConfig.bBTBusy)
14355                 {
14356                         RTPRINT(FBT, BT_TRACE, ("[DM][BT], BT is idle or disable\n"));
14357                 }
14358                 else
14359                 {
14360                         RTPRINT(FBT, BT_TRACE, ("[DM][BT], BT is non-idle\n"));
14361                 }
14362         }
14363         if (!pBtMgnt->ExtConfig.bBTBusy) {
14364                 RTPRINT(FBT, BT_TRACE, ("[DM][BT], BT is idle or disable\n"));
14365                 if (check_fwstate(&padapter->mlmepriv, WIFI_UNDER_LINKING|WIFI_SITE_MONITOR) == _TRUE)
14366                         BTDM_SetAntenna(padapter, BTDM_ANT_WIFI);
14367         }
14368 }
14369
14370 void BTDM_BTCoexistWithProfile1Ant(PADAPTER padapter)
14371 {
14372         PHAL_DATA_TYPE  pHalData = GET_HAL_DATA(padapter);
14373         PBT30Info               pBTInfo = GET_BT_INFO(padapter);
14374         PBT_MGNT                pBtMgnt = &pBTInfo->BtMgnt;
14375
14376         if (pBtMgnt->ExtConfig.bManualControl)
14377         {
14378                 btdm_CheckCounterOnly1Ant(padapter);
14379                 return;
14380         }
14381
14382         RTPRINT(FIOCTL, IOCTL_BT_FLAG_MON, ("CurrentBTConnectionCnt=%d, BtOperationOn=%d, bBTConnectInProgress=%d !!\n",
14383                 pBtMgnt->CurrentBTConnectionCnt, pBtMgnt->BtOperationOn, pBtMgnt->bBTConnectInProgress));
14384
14385         if ((pHalData->bt_coexist.BluetoothCoexist) &&
14386                 (pHalData->bt_coexist.BT_CoexistType == BT_CSR_BC8))
14387         {
14388                 BTHCI_GetProfileNameMoto(padapter);
14389                 BTHCI_GetBTRSSI(padapter);
14390                 BTDM_CheckBTIdleChange1Ant(padapter);
14391                 BTDM_CheckWiFiState(padapter);
14392
14393                 if (btdm_SCOAction1Ant(padapter))
14394                 {
14395                         RTPRINT(FBT, BT_TRACE, ("[DM][BT], Action SCO\n"));
14396                 }
14397                 else if (btdm_HIDAction1Ant(padapter))
14398                 {
14399                         RTPRINT(FBT, BT_TRACE, ("[DM][BT], Action HID\n"));
14400                 }
14401                 else if (btdm_A2DPAction1Ant(padapter))
14402                 {
14403                         RTPRINT(FBT, BT_TRACE, ("[DM][BT], Action A2DP\n"));
14404                 }
14405                 else if (btdm_PANAction1Ant(padapter))
14406                 {
14407                         RTPRINT(FBT, BT_TRACE, ("[DM][BT], Action PAN\n"));
14408                 }
14409                 else if (btdm_HIDA2DPAction1Ant(padapter))
14410                 {
14411                         RTPRINT(FBT, BT_TRACE, ("[DM][BT], Action HID_A2DP\n"));
14412                 }
14413                 else if (btdm_HIDPANAction1Ant(padapter))
14414                 {
14415                         RTPRINT(FBT, BT_TRACE, ("[DM][BT], Action HID_PAN\n"));
14416                 }
14417                 else if (btdm_PANA2DPAction1Ant(padapter))
14418                 {
14419                         RTPRINT(FBT, BT_TRACE, ("[DM][BT], Action PAN_A2DP\n"));
14420                 }
14421                 else
14422                 {
14423                         RTPRINT(FBT, BT_TRACE, ("[DM][BT], No Action case!!!\n"));
14424                 }
14425
14426                 if (!BTDM_IsSameCoexistState(padapter))
14427                 {
14428                         RTPRINT(FBT, BT_TRACE, ("[DM][BT], Coexist State[bitMap] change from 0x%"i64fmt"x to 0x%"i64fmt"x\n",
14429                                 pHalData->bt_coexist.PreviousState,
14430                                 pHalData->bt_coexist.CurrentState));
14431                         pHalData->bt_coexist.PreviousState = pHalData->bt_coexist.CurrentState;
14432
14433                         RTPRINT(FBT, BT_TRACE, ("["));
14434                         if (pHalData->bt_coexist.CurrentState & BT_COEX_STATE_BT30)
14435                                 RTPRINT(FBT, BT_TRACE, ("BT 3.0, "));
14436                         if (pHalData->bt_coexist.CurrentState & BT_COEX_STATE_WIFI_HT20)
14437                                 RTPRINT(FBT, BT_TRACE, ("HT20, "));
14438                         if (pHalData->bt_coexist.CurrentState & BT_COEX_STATE_WIFI_HT40)
14439                                 RTPRINT(FBT, BT_TRACE, ("HT40, "));
14440                         if (pHalData->bt_coexist.CurrentState & BT_COEX_STATE_WIFI_LEGACY)
14441                                 RTPRINT(FBT, BT_TRACE, ("Legacy, "));
14442                         if (pHalData->bt_coexist.CurrentState & BT_COEX_STATE_WIFI_RSSI_LOW)
14443                                 RTPRINT(FBT, BT_TRACE, ("Rssi_Low, "));
14444                         if (pHalData->bt_coexist.CurrentState & BT_COEX_STATE_WIFI_RSSI_MEDIUM)
14445                                 RTPRINT(FBT, BT_TRACE, ("Rssi_Mid, "));
14446                         if (pHalData->bt_coexist.CurrentState & BT_COEX_STATE_WIFI_RSSI_HIGH)
14447                                 RTPRINT(FBT, BT_TRACE, ("Rssi_High, "));
14448                         if (pHalData->bt_coexist.CurrentState & BT_COEX_STATE_WIFI_IDLE)
14449                                 RTPRINT(FBT, BT_TRACE, ("Wifi_Idle, "));
14450                         if (pHalData->bt_coexist.CurrentState & BT_COEX_STATE_WIFI_UPLINK)
14451                                 RTPRINT(FBT, BT_TRACE, ("Wifi_Uplink, "));
14452                         if (pHalData->bt_coexist.CurrentState & BT_COEX_STATE_WIFI_DOWNLINK)
14453                                 RTPRINT(FBT, BT_TRACE, ("Wifi_Downlink, "));
14454                         if (pHalData->bt_coexist.CurrentState & BT_COEX_STATE_BT_IDLE)
14455                                 RTPRINT(FBT, BT_TRACE, ("BT_idle, "));
14456                         if (pHalData->bt_coexist.CurrentState & BT_COEX_STATE_BT_PAN_IDLE)
14457                                 RTPRINT(FBT, BT_TRACE, ("BT_PAN_idle, "));
14458                         if (pHalData->bt_coexist.CurrentState & BT_COEX_STATE_BT_PAN_UPLINK)
14459                                 RTPRINT(FBT, BT_TRACE, ("BT_PAN_uplink, "));
14460                         if (pHalData->bt_coexist.CurrentState & BT_COEX_STATE_BT_PAN_DOWNLINK)
14461                                 RTPRINT(FBT, BT_TRACE, ("BT_PAN_downlink, "));
14462                         if (pHalData->bt_coexist.CurrentState & BT_COEX_STATE_PROFILE_HID)
14463                                 RTPRINT(FBT, BT_TRACE, ("PRO_HID, "));
14464                         if (pHalData->bt_coexist.CurrentState & BT_COEX_STATE_PROFILE_A2DP)
14465                                 RTPRINT(FBT, BT_TRACE, ("PRO_A2DP, "));
14466                         if (pHalData->bt_coexist.CurrentState & BT_COEX_STATE_PROFILE_PAN)
14467                                 RTPRINT(FBT, BT_TRACE, ("PRO_PAN, "));
14468                         if (pHalData->bt_coexist.CurrentState & BT_COEX_STATE_PROFILE_SCO)
14469                                 RTPRINT(FBT, BT_TRACE, ("PRO_SCO, "));
14470                         RTPRINT(FBT, BT_TRACE, ("]\n"));
14471                 }
14472         }
14473 }
14474
14475 // ===== End of sync from SD7 driver HAL/BTCoexist/HalBtcCsr1Ant.c =====
14476 #endif
14477
14478 #ifdef __HALBTCCSR2ANT_C__ // HAL/BTCoexist/HalBtcCsr2Ant.c
14479 // ===== Below this line is sync from SD7 driver HAL/BTCoexist/HalBtcCsr2Ant.c =====
14480
14481 //============================================================
14482 // local function start with btdm_
14483 //============================================================
14484 void
14485 btdm_BtEnableDisableCheck(
14486         PADAPTER        padapter,
14487         u32             BT_Active
14488         )
14489 {
14490         // This function check if 92D bt is disabled
14491         PHAL_DATA_TYPE  pHalData = GET_HAL_DATA(padapter);
14492
14493         if (IS_HARDWARE_TYPE_8192D(padapter))
14494         {
14495                 if (BT_Active)
14496                 {
14497                         pHalData->bt_coexist.btActiveZeroCnt = 0;
14498                         pHalData->bt_coexist.bCurBtDisabled = _FALSE;
14499                         RTPRINT(FBT, BT_TRACE, ("92D Bt is enabled !!\n"));
14500                 }
14501                 else
14502                 {
14503                         pHalData->bt_coexist.btActiveZeroCnt++;
14504                         RTPRINT(FBT, BT_TRACE, ("92D BT_Active = 0, cnt = %d!!\n",
14505                                         pHalData->bt_coexist.btActiveZeroCnt));
14506                         if (pHalData->bt_coexist.btActiveZeroCnt >= 2)
14507                         {
14508                                 pHalData->bt_coexist.bCurBtDisabled = _TRUE;
14509                                 RTPRINT(FBT, BT_TRACE, ("92D Bt is disabled !!\n"));
14510                         }
14511                 }
14512                 if (pHalData->bt_coexist.bPreBtDisabled !=
14513                         pHalData->bt_coexist.bCurBtDisabled )
14514                 {
14515                         RTPRINT(FBT, BT_TRACE, ("92D Bt is from %s to %s!!\n",
14516                                 (pHalData->bt_coexist.bPreBtDisabled ? "disabled":"enabled"),
14517                                 (pHalData->bt_coexist.bCurBtDisabled ? "disabled":"enabled")));
14518                         pHalData->bt_coexist.bNeedToRoamForBtDisableEnable = _TRUE;
14519                         pHalData->bt_coexist.bPreBtDisabled = pHalData->bt_coexist.bCurBtDisabled;
14520                 }
14521         }
14522 }
14523
14524 void btdm_CheckBTState2Ant(PADAPTER padapter)
14525 {
14526         PHAL_DATA_TYPE  pHalData = GET_HAL_DATA(padapter);
14527 //      PMGNT_INFO              pMgntInfo = &padapter->MgntInfo;
14528         PBT30Info               pBTInfo = GET_BT_INFO(padapter);
14529         PBT_MGNT                pBtMgnt = &pBTInfo->BtMgnt;
14530 //      PRT_HIGH_THROUGHPUT     pHTInfo = GET_HT_INFO(pMgntInfo);
14531         u8                      stateChange = _FALSE;
14532         u32                     BT_Polling, Ratio_Act, Ratio_STA;
14533         u32                     BT_Active, BT_State;
14534         u32                     regBTActive = 0, regBTState = 0, regBTPolling=0;
14535         u32                     btBusyThresh = 0;
14536
14537         RTPRINT(FBT, BT_TRACE, ("FirmwareVersion = 0x%x(%d)\n",
14538         pHalData->FirmwareVersion, pHalData->FirmwareVersion));
14539
14540         if (IS_HARDWARE_TYPE_8192C(padapter))
14541         {
14542                 if (pHalData->FirmwareVersion < FW_VER_BT_REG)
14543                 {
14544                         regBTActive = REG_BT_ACTIVE_OLD;
14545                         regBTState = REG_BT_STATE_OLD;
14546                         regBTPolling = REG_BT_POLLING_OLD;
14547                 }
14548                 else
14549                 {
14550                         regBTActive = REG_BT_ACTIVE;
14551                         regBTState = REG_BT_STATE;
14552                         if (pHalData->FirmwareVersion >= FW_VER_BT_REG1)
14553                                 regBTPolling = REG_BT_POLLING1;
14554                         else
14555                                 regBTPolling = REG_BT_POLLING;
14556                 }
14557         }
14558         else if (IS_HARDWARE_TYPE_8192D(padapter))
14559         {
14560                 regBTActive = REG_BT_ACTIVE;
14561                 regBTState = REG_BT_STATE;
14562                 regBTPolling = REG_BT_POLLING1;
14563         }
14564
14565         if (IS_HARDWARE_TYPE_8192D(padapter))
14566         {
14567                 btBusyThresh = 40;
14568         }
14569         else
14570         {
14571                 btBusyThresh = 60;
14572         }
14573
14574         BT_Active = rtw_read32(padapter, regBTActive);
14575         RTPRINT(FBT, BT_TRACE, ("BT_Active(0x%x)=%x\n", regBTActive, BT_Active));
14576         BT_Active = BT_Active & 0x00ffffff;
14577
14578         BT_State = rtw_read32(padapter, regBTState);
14579         RTPRINT(FBT, BT_TRACE, ("BT_State(0x%x)=%x\n", regBTState, BT_State));
14580         BT_State = BT_State & 0x00ffffff;
14581
14582         BT_Polling = rtw_read32(padapter, regBTPolling);
14583         RTPRINT(FBT, BT_TRACE, ("BT_Polling(0x%x)=%x\n", regBTPolling, BT_Polling));
14584
14585         if (BT_Active==0xffffffff && BT_State==0xffffffff && BT_Polling==0xffffffff )
14586                 return;
14587
14588         // 2011/05/04 MH For Slim combo test meet a problem. Surprise remove and WLAN is running
14589         // DHCP process. At the same time, the register read value might be zero. And cause BSOD 0x7f
14590         // EXCEPTION_DIVIDED_BY_ZERO. In This case, the stack content may always be wrong due to
14591         // HW divide trap.
14592         if (BT_Polling==0)
14593                 return;
14594
14595         btdm_BtEnableDisableCheck(padapter, BT_Active);
14596
14597         Ratio_Act = BT_Active*1000/BT_Polling;
14598         Ratio_STA = BT_State*1000/BT_Polling;
14599
14600         pHalData->bt_coexist.Ratio_Tx = Ratio_Act;
14601         pHalData->bt_coexist.Ratio_PRI = Ratio_STA;
14602
14603         RTPRINT(FBT, BT_TRACE, ("Ratio_Act=%d\n", Ratio_Act));
14604         RTPRINT(FBT, BT_TRACE, ("Ratio_STA=%d\n", Ratio_STA));
14605
14606         if (pHalData->bt_coexist.BT_CoexistType == BT_CSR_BC8)
14607         {
14608                 if (Ratio_STA < 60)     // BT PAN idle
14609                 {
14610                         pHalData->bt_coexist.CurrentState |= BT_COEX_STATE_BT_PAN_IDLE;
14611                         pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_BT_PAN_DOWNLINK;
14612                         pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_BT_PAN_UPLINK;
14613                 }
14614                 else
14615                 {
14616                         pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_BT_PAN_IDLE;
14617
14618                         // Check if BT PAN (under BT 2.1) is uplink or downlink
14619                         if ((Ratio_Act/Ratio_STA) < 2)
14620                         {       // BT PAN Uplink
14621                                 pHalData->bt_coexist.BT21TrafficStatistics.bTxBusyTraffic = _TRUE;
14622                                 pHalData->bt_coexist.CurrentState |= BT_COEX_STATE_BT_PAN_UPLINK;
14623                                 pHalData->bt_coexist.BT21TrafficStatistics.bRxBusyTraffic = _FALSE;
14624                                 pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_BT_PAN_DOWNLINK;
14625                         }
14626                         else
14627                         {       // BT PAN downlink
14628                                 pHalData->bt_coexist.BT21TrafficStatistics.bTxBusyTraffic = _FALSE;
14629                                 pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_BT_PAN_UPLINK;
14630                                 pHalData->bt_coexist.BT21TrafficStatistics.bRxBusyTraffic = _TRUE;
14631                                 pHalData->bt_coexist.CurrentState |= BT_COEX_STATE_BT_PAN_DOWNLINK;
14632                         }
14633                 }
14634         }
14635         else
14636         {
14637                 // BC4, doesn't use the following variables.
14638                 pHalData->bt_coexist.CurrentState |= BT_COEX_STATE_BT_PAN_IDLE;
14639                 pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_BT_PAN_DOWNLINK;
14640                 pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_BT_PAN_UPLINK;
14641         }
14642
14643
14644         // Check BT is idle or not
14645         if (pBtMgnt->ExtConfig.NumberOfHandle==0 &&
14646                 pBtMgnt->ExtConfig.NumberOfSCO==0)
14647         {
14648                 pBtMgnt->ExtConfig.bBTBusy = _FALSE;
14649                 pHalData->bt_coexist.CurrentState |= BT_COEX_STATE_BT_IDLE;
14650         }
14651         else
14652         {
14653                 if (pHalData->bt_coexist.BT_CoexistType == BT_CSR_BC4)
14654                 {
14655                         if (Ratio_Act < 20)
14656                         {
14657                                 pBtMgnt->ExtConfig.bBTBusy = _FALSE;
14658                                 pHalData->bt_coexist.CurrentState |= BT_COEX_STATE_BT_IDLE;
14659                         }
14660                         else
14661                         {
14662                                 pBtMgnt->ExtConfig.bBTBusy = _TRUE;
14663                                 pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_BT_IDLE;
14664                         }
14665                 }
14666                 else if (pHalData->bt_coexist.BT_CoexistType == BT_CSR_BC8)
14667                 {
14668                         if (Ratio_STA < btBusyThresh)
14669                         {
14670                                 pBtMgnt->ExtConfig.bBTBusy = _FALSE;
14671                                 pHalData->bt_coexist.CurrentState |= BT_COEX_STATE_BT_IDLE;
14672                         }
14673                         else
14674                         {
14675                                 pBtMgnt->ExtConfig.bBTBusy = _TRUE;
14676                                 pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_BT_IDLE;
14677                         }
14678
14679                         if ((Ratio_STA < btBusyThresh) ||
14680                                 (Ratio_Act<180 && Ratio_STA<130))
14681                         {
14682                                 pBtMgnt->ExtConfig.bBTA2DPBusy = _FALSE;
14683                                 pHalData->bt_coexist.CurrentState |= BT_COEX_STATE_BT_A2DP_IDLE;
14684                         }
14685                         else
14686                         {
14687                                 pBtMgnt->ExtConfig.bBTA2DPBusy =_TRUE;
14688                                 pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_BT_A2DP_IDLE;
14689                         }
14690                 }
14691         }
14692
14693         if (pBtMgnt->ExtConfig.NumberOfHandle==0 &&
14694                 pBtMgnt->ExtConfig.NumberOfSCO==0)
14695         {
14696                 pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_BT_RSSI_LOW;
14697                 pBtMgnt->ExtConfig.MIN_BT_RSSI = 0;
14698         }
14699         else
14700         {
14701                 if (pBtMgnt->ExtConfig.MIN_BT_RSSI <= -5)
14702                 {
14703                         pHalData->bt_coexist.CurrentState |= BT_COEX_STATE_BT_RSSI_LOW;
14704                         RTPRINT(FBT, BT_TRACE, ("[bt rssi], Low\n"));
14705                 }
14706                 else
14707                 {
14708                         pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_BT_RSSI_LOW;
14709                         RTPRINT(FBT, BT_TRACE, ("[bt rssi], Normal\n"));
14710                 }
14711         }
14712
14713         if (pHalData->bt_coexist.bBTBusyTraffic !=
14714                 pBtMgnt->ExtConfig.bBTBusy)
14715         {       // BT idle or BT non-idle
14716                 pHalData->bt_coexist.bBTBusyTraffic = pBtMgnt->ExtConfig.bBTBusy;
14717                 stateChange = _TRUE;
14718         }
14719
14720         if (stateChange)
14721         {
14722                 if (!pBtMgnt->ExtConfig.bBTBusy)
14723                 {
14724                         u8      tempu1Byte;
14725                         RTPRINT(FBT, BT_TRACE, ("[BT] BT is idle or disable\n"));
14726
14727                         tempu1Byte = rtw_read8(padapter, 0x4fd);
14728                         tempu1Byte |= BIT(2);
14729
14730                         rtw_write8(padapter, 0x4fd, tempu1Byte);
14731
14732                         //Resume RF Rx LPF corner
14733                         if (IS_HARDWARE_TYPE_8192D(padapter))
14734                         {
14735                                 PHY_SetRFReg(padapter, PathA, 0x1e, bRFRegOffsetMask, pHalData->bt_coexist.BtRfRegOrigin1E);
14736                         }
14737                         else
14738                         {
14739                                 PHY_SetRFReg(padapter, PathA, 0x1e, 0xf0, pHalData->bt_coexist.BtRfRegOrigin1E);
14740                         }
14741                         BTDM_CoexAllOff(padapter);
14742
14743                         RTPRINT(FBT, BT_TRACE, ("BT_Turn OFF Coexist bt is off \n"));
14744
14745                         rtw_write8(padapter, REG_GPIO_MUXCFG, 0x0);
14746                 }
14747                 else
14748                 {
14749                         u8      tempu1Byte;
14750                         RTPRINT(FBT, BT_TRACE, ("[BT] BT is non-idle\n"));
14751
14752                         tempu1Byte = rtw_read8(padapter, 0x4fd);
14753                         tempu1Byte &=~ BIT(2);
14754                         rtw_write8(padapter, 0x4fd, tempu1Byte);
14755
14756                         //Shrink RF Rx LPF corner
14757                         if (IS_HARDWARE_TYPE_8192D(padapter))
14758                         {
14759                                 PHY_SetRFReg(padapter, PathA, 0x1e, bRFRegOffsetMask, 0xf2ff7);
14760                         }
14761                         else
14762                         {
14763                                 //Shrink RF Rx LPF corner, 0x1e[7:4]=1111
14764                                 PHY_SetRFReg(padapter, PathA, 0x1e, 0xf0, 0xf);
14765                         }
14766                 }
14767         }
14768
14769         if (stateChange)
14770         {
14771                 if (pBtMgnt->ExtConfig.bBTBusy)
14772                 {
14773                         BTDM_RejectAPAggregatedPacket(padapter, _TRUE);
14774                 }
14775                 else
14776                 {
14777                         BTDM_RejectAPAggregatedPacket(padapter, _FALSE);
14778                 }
14779         }
14780 }
14781
14782 void btdm_WLANActOff(PADAPTER padapter)
14783 {
14784         PHAL_DATA_TYPE  pHalData = GET_HAL_DATA(padapter);
14785
14786         //Only used in BC4 setting
14787         rtw_write8(padapter, REG_GPIO_MUXCFG, 0x0);
14788         BTDM_Balance(padapter, _FALSE, 0, 0);
14789         BTDM_DiminishWiFi(padapter, _FALSE, _FALSE, 0x0, BT_FW_NAV_OFF);
14790 }
14791
14792 void btdm_WLANActBTPrecedence(PADAPTER padapter)
14793 {
14794         BTDM_Balance(padapter, _FALSE, 0, 0);
14795         BTDM_DiminishWiFi(padapter, _FALSE, _FALSE, 0x0, BT_FW_NAV_OFF);
14796
14797         rtw_write32(padapter, 0x6c4,0x55555555);
14798         rtw_write32(padapter, 0x6c8,0x000000f0);
14799         rtw_write32(padapter, 0x6cc,0x40000010);
14800         rtw_write8(padapter, REG_GPIO_MUXCFG, 0xa0);
14801 }
14802
14803 //==============================================================
14804 //
14805 // Note:
14806 // In the following, FW should be done before SW mechanism.
14807 // BTDM_Balance(), BTDM_DiminishWiFi(), BT_NAV() should be done
14808 // before BTDM_AGCTable(), BTDM_BBBackOffLevel(), btdm_DacSwing().
14809 //
14810 //==============================================================
14811
14812 void btdm_DacSwing(PADAPTER padapter, u8 type)
14813 {
14814         PHAL_DATA_TYPE  pHalData = GET_HAL_DATA(padapter);
14815
14816         if (pHalData->bt_coexist.BT_Ant_Num != Ant_x2)
14817                 return;
14818
14819         if (type == BT_DACSWING_OFF)
14820         {
14821                 RTPRINT(FBT, BT_TRACE, ("[BT]DACSwing Off!\n"));
14822                 PHY_SetBBReg(padapter, 0x880, 0xfc000000, 0x30);
14823         }
14824         else if (type == BT_DACSWING_M4)
14825         {
14826                 if (pHalData->bt_coexist.CurrentState & BT_COEX_STATE_BT_RSSI_LOW)
14827                 {
14828                         RTPRINT(FBT, BT_TRACE, ("[BT]DACSwing -4 original, but Low RSSI!\n"));
14829                         PHY_SetBBReg(padapter, 0x880, 0xfc000000, 0x18);
14830                 }
14831                 else
14832                 {
14833                         RTPRINT(FBT, BT_TRACE, ("[BT]DACSwing -4!\n"));
14834                         PHY_SetBBReg(padapter, 0x880, 0xfc000000, 0x20);
14835                 }
14836         }
14837         else if (type == BT_DACSWING_M7)
14838         {
14839                 RTPRINT(FBT, BT_TRACE, ("[BT]DACSwing -7!\n"));
14840                 PHY_SetBBReg(padapter, 0x880, 0xfc000000, 0x18);
14841         }
14842         else if (type == BT_DACSWING_M10)
14843         {
14844                 RTPRINT(FBT, BT_TRACE, ("[BT]DACSwing -10!\n"));
14845                 PHY_SetBBReg(padapter, 0x880, 0xfc000000, 0x10);
14846         }
14847
14848         if (type != BT_DACSWING_OFF)
14849                 pHalData->bt_coexist.bSWCoexistAllOff = _FALSE;
14850 }
14851
14852 void btdm_A2DPActionBC42Ant(PADAPTER padapter)
14853 {
14854 //      PMGNT_INFO              pMgntInfo = &padapter->MgntInfo;
14855         struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
14856         PBT30Info               pBTInfo = GET_BT_INFO(padapter);
14857         PBT_MGNT                pBtMgnt = &pBTInfo->BtMgnt;
14858         PHAL_DATA_TYPE  pHalData = GET_HAL_DATA(padapter);
14859         u8                      btRssiState;
14860
14861         rtw_write8(padapter, REG_GPIO_MUXCFG, 0x0);
14862
14863         if (pBtMgnt->ExtConfig.bBTBusy)
14864         {
14865                 RTPRINT(FBT, BT_TRACE, ("BT is non-idle!\n"));
14866
14867                 if (BTDM_IsHT40(padapter))
14868                 {
14869                         RTPRINT(FBT, BT_TRACE, ("HT40\n"));
14870                         if (pHalData->bt_coexist.PreviousState == pHalData->bt_coexist.CurrentState)
14871                                 return;
14872                         // Do the FW mechanism first
14873                         if (pmlmepriv->LinkDetectInfo.bTxBusyTraffic)
14874                         {
14875                                 RTPRINT(FBT, BT_TRACE, ("Wifi Uplink\n"));
14876                                 BTDM_Balance(padapter, _TRUE, 0xc, 0x18);
14877                                 BTDM_DiminishWiFi(padapter, _FALSE, _FALSE, 0x20, BT_FW_NAV_OFF);
14878                         }
14879                         else if (pmlmepriv->LinkDetectInfo.bRxBusyTraffic)
14880                         {
14881                                 RTPRINT(FBT, BT_TRACE, ("Wifi Downlink\n"));
14882                                 BTDM_FWCoexAllOff(padapter);
14883                         }
14884                         // Then do the SW mechanism
14885                         BTDM_AGCTable(padapter, BT_AGCTABLE_OFF);
14886                         BTDM_BBBackOffLevel(padapter, BT_BB_BACKOFF_ON);
14887                         btdm_DacSwing(padapter, BT_DACSWING_M4);
14888                 }
14889                 else
14890                 {
14891                         RTPRINT(FBT, BT_TRACE, ("HT20 or Legacy\n"));
14892                         btRssiState = BTDM_CheckCoexRSSIState(padapter, 2, BT_FW_COEX_THRESH_47, 0);
14893                         if (pHalData->bt_coexist.PreviousState == pHalData->bt_coexist.CurrentState)
14894                                 return;
14895                         if (pmlmepriv->LinkDetectInfo.bTxBusyTraffic)
14896                         {
14897                                 RTPRINT(FBT, BT_TRACE, ("Wifi Uplink\n"));
14898                                 BTDM_Balance(padapter, _TRUE, 0xc, 0x18);
14899                                 BTDM_DiminishWiFi(padapter, _FALSE, _FALSE, 0x20, BT_FW_NAV_OFF);
14900                         }
14901                         else if (pmlmepriv->LinkDetectInfo.bRxBusyTraffic)
14902                         {
14903                                 RTPRINT(FBT, BT_TRACE, ("Wifi Downlink\n"));
14904                                 BTDM_FWCoexAllOff(padapter);
14905                         }
14906                         // Then do the SW mechanism
14907                         if ((btRssiState == BT_RSSI_STATE_HIGH) ||
14908                                 (btRssiState == BT_RSSI_STATE_STAY_HIGH))
14909                         {
14910                                 BTDM_AGCTable(padapter, BT_AGCTABLE_ON);
14911                                 BTDM_BBBackOffLevel(padapter, BT_BB_BACKOFF_ON);
14912                                 btdm_DacSwing(padapter, BT_DACSWING_M4);
14913                         }
14914                         else
14915                         {
14916                                 BTDM_AGCTable(padapter, BT_AGCTABLE_OFF);
14917                                 BTDM_BBBackOffLevel(padapter, BT_BB_BACKOFF_OFF);
14918                                 btdm_DacSwing(padapter, BT_DACSWING_M4);
14919                         }
14920                 }
14921         }
14922         else
14923         {
14924                 RTPRINT(FBT, BT_TRACE, ("BT is idle!\n"));
14925                 BTDM_CoexAllOff(padapter);
14926         }
14927 }
14928
14929 void btdm_A2DPActionBC82Ant(PADAPTER padapter)
14930 {
14931 //      PMGNT_INFO              pMgntInfo = &padapter->MgntInfo;
14932         struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
14933         PBT30Info               pBTInfo = GET_BT_INFO(padapter) ;
14934         PBT_MGNT                pBtMgnt = &pBTInfo->BtMgnt;
14935         PHAL_DATA_TYPE  pHalData = GET_HAL_DATA(padapter);
14936         u8                      btRssiState;
14937
14938         if (pBtMgnt->ExtConfig.bBTA2DPBusy && pmlmepriv->LinkDetectInfo.bBusyTraffic)
14939         {
14940                 RTPRINT(FBT, BT_TRACE, ("BT is non-idle && Wifi is non-idle!\n"));
14941                 btRssiState = BTDM_CheckCoexRSSIState(padapter, 2, BT_FW_COEX_THRESH_47, 0);
14942                 if (pHalData->bt_coexist.PreviousState == pHalData->bt_coexist.CurrentState)
14943                         return;
14944
14945                 // Do the FW mechanism first
14946                 if (pmlmepriv->LinkDetectInfo.bTxBusyTraffic)
14947                 {
14948                         RTPRINT(FBT, BT_TRACE, ("Wifi Uplink\n"));
14949                         BTDM_Balance(padapter, _TRUE, 0xc, 0x18);
14950                         BTDM_DiminishWiFi(padapter, _TRUE, _FALSE, 0x20, BT_FW_NAV_OFF);
14951                 }
14952                 else if (pmlmepriv->LinkDetectInfo.bRxBusyTraffic)
14953                 {
14954                         RTPRINT(FBT, BT_TRACE, ("Wifi Downlink\n"));
14955                         BTDM_Balance(padapter, _TRUE, 0x10, 0x18);
14956                         BTDM_DiminishWiFi(padapter, _TRUE, _FALSE, 0x20, BT_FW_NAV_OFF);
14957                 }
14958
14959                 // Then do the SW mechanism
14960                 if (BTDM_IsHT40(padapter))
14961                 {
14962                         RTPRINT(FBT, BT_TRACE, ("HT40\n"));
14963                         BTDM_AGCTable(padapter, BT_AGCTABLE_OFF);
14964                         BTDM_BBBackOffLevel(padapter, BT_BB_BACKOFF_ON);
14965                         btdm_DacSwing(padapter, BT_DACSWING_OFF);
14966                 }
14967                 else
14968                 {
14969                         RTPRINT(FBT, BT_TRACE, ("HT20 or Legacy\n"));
14970                         if ((btRssiState == BT_RSSI_STATE_HIGH) ||
14971                                 (btRssiState == BT_RSSI_STATE_STAY_HIGH))
14972                         {
14973                                 BTDM_AGCTable(padapter, BT_AGCTABLE_ON);
14974                                 BTDM_BBBackOffLevel(padapter, BT_BB_BACKOFF_ON);
14975                                 btdm_DacSwing(padapter, BT_DACSWING_OFF);
14976                         }
14977                         else
14978                         {
14979                                 BTDM_SWCoexAllOff(padapter);
14980                         }
14981                 }
14982         }
14983         else if (pBtMgnt->ExtConfig.bBTA2DPBusy)
14984         {
14985                 RTPRINT(FBT, BT_TRACE, ("BT is non-idle!\n"));
14986                 if (pHalData->bt_coexist.PreviousState == pHalData->bt_coexist.CurrentState)
14987                         return;
14988
14989                 // Do the FW mechanism first
14990                 BTDM_Balance(padapter, _FALSE, 0, 0);
14991                 BTDM_DiminishWiFi(padapter, _TRUE, _TRUE, 0x18, BT_FW_NAV_OFF);
14992
14993                 // Then do the SW mechanism
14994                 BTDM_SWCoexAllOff(padapter);
14995         }
14996         else
14997         {
14998                 RTPRINT(FBT, BT_TRACE, ("BT is idle and Wifi is idle!\n"));
14999                 BTDM_CoexAllOff(padapter);
15000         }
15001 }
15002
15003 void btdm_A2DPActionBC82Ant92d(PADAPTER padapter)
15004 {
15005 //      PMGNT_INFO              pMgntInfo = &padapter->MgntInfo;
15006         struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
15007         PBT30Info               pBTInfo = GET_BT_INFO(padapter) ;
15008         PBT_MGNT                pBtMgnt = &pBTInfo->BtMgnt;
15009         PHAL_DATA_TYPE  pHalData = GET_HAL_DATA(padapter);
15010         u8                      btRssiState, rssiState1;
15011
15012         if (pBtMgnt->ExtConfig.bBTA2DPBusy && pmlmepriv->LinkDetectInfo.bBusyTraffic)
15013         {
15014                 RTPRINT(FBT, BT_TRACE, ("BT is non-idle && Wifi is non-idle!\n"));
15015                 if (BTDM_IsHT40(padapter))
15016                 {
15017                         RTPRINT(FBT, BT_TRACE, ("HT40\n"));
15018                         rssiState1 = BTDM_CheckCoexRSSIState1(padapter, 2, BT_FW_COEX_THRESH_47, 0);
15019                 }
15020                 else
15021                 {
15022                         RTPRINT(FBT, BT_TRACE, ("HT20 or Legacy\n"));
15023                         if (BTDM_IsWifiUplink(padapter))
15024                         {
15025                                 RTPRINT(FBT, BT_TRACE, ("Wifi Uplink\n"));
15026                                 rssiState1 = BTDM_CheckCoexRSSIState1(padapter, 2, BT_FW_COEX_THRESH_25, 0);
15027                         }
15028                         else if (BTDM_IsWifiDownlink(padapter))
15029                         {
15030                                 RTPRINT(FBT, BT_TRACE, ("Wifi Downlink\n"));
15031                                 rssiState1 = BTDM_CheckCoexRSSIState1(padapter, 2, BT_FW_COEX_THRESH_40, 0);
15032                         }
15033                 }
15034                 btRssiState = BTDM_CheckCoexRSSIState(padapter, 2, BT_FW_COEX_THRESH_47, 0);
15035                 if (!BTDM_IsCoexistStateChanged(padapter))
15036                         return;
15037
15038                 // Do the FW mechanism first
15039                 if (BTDM_IsWifiUplink(padapter))
15040                 {
15041                         BTDM_Balance(padapter, _TRUE, 0xc, 0x18);
15042                         BTDM_DiminishWiFi(padapter, _TRUE, _FALSE, 0x20, BT_FW_NAV_OFF);
15043                 }
15044                 else if (BTDM_IsWifiDownlink(padapter))
15045                 {
15046                         BTDM_Balance(padapter, _TRUE, 0x10, 0x18);
15047                         BTDM_DiminishWiFi(padapter, _TRUE, _FALSE, 0x20, BT_FW_NAV_OFF);
15048                 }
15049
15050                 // Then do the SW mechanism
15051                 if ((rssiState1 == BT_RSSI_STATE_HIGH) ||
15052                         (rssiState1 == BT_RSSI_STATE_STAY_HIGH))
15053                 {
15054                         BTDM_AGCTable(padapter, BT_AGCTABLE_ON);
15055                 }
15056                 else
15057                 {
15058                         BTDM_AGCTable(padapter, BT_AGCTABLE_OFF);
15059                 }
15060
15061                 if (BTDM_IsHT40(padapter))
15062                 {
15063                         BTDM_BBBackOffLevel(padapter, BT_BB_BACKOFF_ON);
15064                         btdm_DacSwing(padapter, BT_DACSWING_OFF);
15065                 }
15066                 else
15067                 {
15068                         if ((btRssiState == BT_RSSI_STATE_HIGH) ||
15069                                 (btRssiState == BT_RSSI_STATE_STAY_HIGH))
15070                         {
15071                                 BTDM_BBBackOffLevel(padapter, BT_BB_BACKOFF_ON);
15072                                 btdm_DacSwing(padapter, BT_DACSWING_OFF);
15073                         }
15074                         else
15075                         {
15076                                 BTDM_BBBackOffLevel(padapter, BT_BB_BACKOFF_OFF);
15077                                 btdm_DacSwing(padapter, BT_DACSWING_OFF);
15078                         }
15079                 }
15080         }
15081         else if (pBtMgnt->ExtConfig.bBTA2DPBusy)
15082         {
15083                 RTPRINT(FBT, BT_TRACE, ("BT is non-idle!\n"));
15084                 if (pHalData->bt_coexist.PreviousState == pHalData->bt_coexist.CurrentState)
15085                         return;
15086
15087                 // Do the FW mechanism first
15088                 BTDM_Balance(padapter, _FALSE, 0, 0);
15089                 BTDM_DiminishWiFi(padapter, _TRUE, _TRUE, 0x18, BT_FW_NAV_OFF);
15090
15091                 // Then do the SW mechanism
15092                 BTDM_SWCoexAllOff(padapter);
15093         }
15094         else
15095         {
15096                 RTPRINT(FBT, BT_TRACE, ("BT is idle and Wifi is idle!\n"));
15097                 BTDM_CoexAllOff(padapter);
15098         }
15099 }
15100
15101 u8 btdm_A2DPAction2Ant(PADAPTER padapter)
15102 {
15103         PHAL_DATA_TYPE  pHalData = GET_HAL_DATA(padapter);
15104         PBT30Info               pBTInfo = GET_BT_INFO(padapter);
15105         PBT_MGNT                pBtMgnt = &pBTInfo->BtMgnt;
15106         PBT_DBG                 pBtDbg = &pBTInfo->BtDbg;
15107         u8                      bEnter = _FALSE;
15108
15109         if (pBtDbg->dbgCtrl == _TRUE )
15110         {
15111                 if (pBtDbg->dbgProfile == BT_DBG_PROFILE_A2DP)
15112                         bEnter = _TRUE;
15113         }
15114         else
15115         {
15116                 if (BTHCI_CheckProfileExist(padapter,BT_PROFILE_A2DP) && pBtMgnt->ExtConfig.NumberOfHandle==1)
15117                         bEnter = _TRUE;
15118         }
15119
15120         if (bEnter)
15121         {
15122                 RTPRINT(FBT, BT_TRACE, ("[DM][BT], btdm_A2DPAction2Ant(), "));
15123                 pHalData->bt_coexist.CurrentState |= BT_COEX_STATE_PROFILE_A2DP;
15124                 pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_PROFILE_HID;
15125                 pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_PROFILE_PAN;
15126
15127                 if (pHalData->bt_coexist.BT_CoexistType == BT_CSR_BC4)
15128                 {
15129                         RTPRINT(FBT, BT_TRACE, ("[BC4]\n"));
15130                         btdm_A2DPActionBC42Ant(padapter);
15131                 }
15132                 else if (pHalData->bt_coexist.BT_CoexistType == BT_CSR_BC8)
15133                 {
15134                         RTPRINT(FBT, BT_TRACE, ("[BC8]\n"));
15135                         if (IS_HARDWARE_TYPE_8192D(padapter))
15136                                 btdm_A2DPActionBC82Ant92d(padapter);
15137                         else
15138                                 btdm_A2DPActionBC82Ant(padapter);
15139                 }
15140                 return _TRUE;
15141         }
15142         else
15143         {
15144                 return _FALSE;
15145         }
15146 }
15147
15148 void btdm_PANActionBC42Ant(PADAPTER padapter)
15149 {
15150 //      PMGNT_INFO              pMgntInfo = &padapter->MgntInfo;
15151         struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
15152         PBT30Info               pBTInfo = GET_BT_INFO(padapter);
15153         PBT_MGNT                pBtMgnt = &pBTInfo->BtMgnt;
15154         PHAL_DATA_TYPE  pHalData = GET_HAL_DATA(padapter);
15155
15156         if (pHalData->bt_coexist.PreviousState == pHalData->bt_coexist.CurrentState)
15157                 return;
15158
15159         rtw_write8(padapter, REG_GPIO_MUXCFG, 0x0);
15160
15161         if (pBtMgnt->BtOperationOn)
15162         {
15163                 RTPRINT(FBT, BT_TRACE, ("[BT 3.0]\n"));
15164                 BTDM_Balance(padapter, _FALSE, 0, 0);
15165                 BTDM_DiminishWiFi(padapter, _FALSE, _FALSE, 0x0, BT_FW_NAV_OFF);
15166         }
15167         else
15168         {
15169                 RTPRINT(FBT, BT_TRACE, ("[BT 2.1]\n"));
15170                 if (pBtMgnt->ExtConfig.bBTBusy && pmlmepriv->LinkDetectInfo.bBusyTraffic)
15171                 {
15172                         RTPRINT(FBT, BT_TRACE, ("BT is non-idle && Wifi is non-idle!\n"));
15173                         BTDM_Balance(padapter, _TRUE, 0x20, 0x10);
15174                         BTDM_DiminishWiFi(padapter, _TRUE, _FALSE, 0x20, BT_FW_NAV_OFF);
15175                 }
15176                 else
15177                 {
15178                         RTPRINT(FBT, BT_TRACE, ("BT is idle or Wifi is idle!\n"));
15179                         BTDM_Balance(padapter, _FALSE, 0, 0);
15180                         BTDM_DiminishWiFi(padapter, _FALSE, _FALSE, 0x0, BT_FW_NAV_OFF);
15181                 }
15182         }
15183         BTDM_SWCoexAllOff(padapter);
15184 }
15185
15186 void btdm_PANActionBC82Ant(PADAPTER padapter)
15187 {
15188 //      PMGNT_INFO              pMgntInfo = &padapter->MgntInfo;
15189         struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
15190         PBT30Info               pBTInfo = GET_BT_INFO(padapter) ;
15191         PBT_MGNT                pBtMgnt = &pBTInfo->BtMgnt;
15192         PHAL_DATA_TYPE  pHalData = GET_HAL_DATA(padapter);
15193         u8                      btRssiState;
15194
15195         if (pBtMgnt->BtOperationOn)
15196         {
15197                 RTPRINT(FBT, BT_TRACE, ("[BT 3.0]\n"));
15198                 if (pHalData->bt_coexist.PreviousState == pHalData->bt_coexist.CurrentState)
15199                         return;
15200
15201                 BTDM_CoexAllOff(padapter);
15202         }
15203         else
15204         {
15205                 RTPRINT(FBT, BT_TRACE, ("[BT 2.1]\n"));
15206                 btRssiState = BTDM_CheckCoexRSSIState(padapter, 3, BT_FW_COEX_THRESH_25, BT_FW_COEX_THRESH_50);
15207                 if (pHalData->bt_coexist.PreviousState == pHalData->bt_coexist.CurrentState)
15208                         return;
15209
15210                 if (pBtMgnt->ExtConfig.bBTBusy && pmlmepriv->LinkDetectInfo.bBusyTraffic)
15211                 {
15212                         RTPRINT(FBT, BT_TRACE, ("BT is non-idle && Wifi is non-idle!\n"));
15213
15214                         if ((btRssiState == BT_RSSI_STATE_HIGH) ||
15215                                 (btRssiState == BT_RSSI_STATE_STAY_HIGH))
15216                         {
15217                                 RTPRINT(FBT, BT_TRACE, ("RSSI stay HIGH or High \n"));
15218                                 // Do the FW mechanism first
15219                                 if (pHalData->bt_coexist.BT21TrafficStatistics.bTxBusyTraffic)
15220                                 {
15221                                         RTPRINT(FBT, BT_TRACE, ("BT Uplink\n"));
15222                                         BTDM_Balance(padapter, _TRUE, 0x20, 0x20);
15223                                         BTDM_DiminishWiFi(padapter, _TRUE, _FALSE, 0x20, BT_FW_NAV_OFF);
15224                                 }
15225                                 else if (pHalData->bt_coexist.BT21TrafficStatistics.bRxBusyTraffic)
15226                                 {
15227                                         RTPRINT(FBT, BT_TRACE, ("BT Downlink\n"));
15228                                         BTDM_FWCoexAllOff(padapter);
15229                                 }
15230                                 // Then do the SW mechanism
15231                                 if (BTDM_IsHT40(padapter))
15232                                 {
15233                                         RTPRINT(FBT, BT_TRACE, ("HT40\n"));
15234                                         BTDM_AGCTable(padapter, BT_AGCTABLE_OFF);
15235                                 }
15236                                 else
15237                                 {
15238                                         RTPRINT(FBT, BT_TRACE, ("HT20 or Legacy\n"));
15239                                         BTDM_AGCTable(padapter, BT_AGCTABLE_ON);
15240                                 }
15241                                 BTDM_BBBackOffLevel(padapter, BT_BB_BACKOFF_ON);
15242                                 if (pHalData->bt_coexist.BT21TrafficStatistics.bTxBusyTraffic)
15243                                 {
15244                                         RTPRINT(FBT, BT_TRACE, ("BT Uplink\n"));
15245                                         btdm_DacSwing(padapter, BT_DACSWING_OFF);
15246                                 }
15247                                 else if (pHalData->bt_coexist.BT21TrafficStatistics.bRxBusyTraffic)
15248                                 {
15249                                         RTPRINT(FBT, BT_TRACE, ("BT Downlink\n"));
15250                                         btdm_DacSwing(padapter, BT_DACSWING_M4);
15251                                 }
15252                         }
15253                         else if ((btRssiState == BT_RSSI_STATE_MEDIUM) ||
15254                                 (btRssiState == BT_RSSI_STATE_STAY_MEDIUM))
15255                         {
15256                                 RTPRINT(FBT, BT_TRACE, ("RSSI stay Medium or Medium \n"));
15257                                 // Do the FW mechanism first
15258                                 BTDM_Balance(padapter, _TRUE, 0x20, 0x20);
15259
15260                                 if (pmlmepriv->LinkDetectInfo.bTxBusyTraffic)
15261                                 {
15262                                         RTPRINT(FBT, BT_TRACE, ("Wifi Uplink\n"));
15263                                         BTDM_DiminishWiFi(padapter, _TRUE, _FALSE, 0x20, BT_FW_NAV_OFF);
15264                                 }
15265                                 else if (pmlmepriv->LinkDetectInfo.bRxBusyTraffic)
15266                                 {
15267                                         RTPRINT(FBT, BT_TRACE, ("Wifi Downlink\n"));
15268                                         if (BTDM_IsHT40(padapter))
15269                                                 BTDM_DiminishWiFi(padapter, _TRUE, _FALSE, 0x20, BT_FW_NAV_OFF);//BT_FW_NAV_ON);
15270                                         else
15271                                                 BTDM_DiminishWiFi(padapter, _TRUE, _FALSE, 0x20, BT_FW_NAV_OFF);
15272                                 }
15273                                 // Then do the SW mechanism
15274                                 if (BTDM_IsHT40(padapter))
15275                                 {
15276                                         RTPRINT(FBT, BT_TRACE, ("HT40\n"));
15277                                         BTDM_AGCTable(padapter, BT_AGCTABLE_OFF);
15278                                 }
15279                                 else
15280                                 {
15281                                         RTPRINT(FBT, BT_TRACE, ("HT20 or Legacy\n"));
15282                                         BTDM_AGCTable(padapter, BT_AGCTABLE_ON);
15283                                 }
15284                                 BTDM_BBBackOffLevel(padapter, BT_BB_BACKOFF_ON);
15285                                 btdm_DacSwing(padapter, BT_DACSWING_OFF);
15286                         }
15287                         else
15288                         {
15289                                 RTPRINT(FBT, BT_TRACE, ("RSSI stay LOW or LOW \n"));
15290                                 // Do the FW mechanism first
15291                                 BTDM_Balance(padapter, _TRUE, 0x20, 0x20);
15292
15293                                 if (pmlmepriv->LinkDetectInfo.bTxBusyTraffic)
15294                                 {
15295                                         RTPRINT(FBT, BT_TRACE, ("Wifi Uplink\n"));
15296                                         BTDM_DiminishWiFi(padapter, _TRUE, _FALSE, 0x20, BT_FW_NAV_OFF);
15297                                 }
15298                                 else if (pmlmepriv->LinkDetectInfo.bRxBusyTraffic)
15299                                 {
15300                                         RTPRINT(FBT, BT_TRACE, ("Wifi Downlink\n"));
15301                                         if (pHalData->bt_coexist.BT21TrafficStatistics.bTxBusyTraffic)
15302                                         {
15303                                                 RTPRINT(FBT, BT_TRACE, ("BT Uplink\n"));
15304                                                 if (BTDM_IsHT40(padapter))
15305                                                 {
15306                                                         RTPRINT(FBT, BT_TRACE, ("HT40\n"));
15307                                                         BTDM_DiminishWiFi(padapter, _TRUE, _FALSE, 0x20, BT_FW_NAV_OFF);//BT_FW_NAV_ON);
15308                                                 }
15309                                                 else
15310                                                 {
15311                                                         RTPRINT(FBT, BT_TRACE, ("HT20 or Legacy\n"));
15312                                                         BTDM_DiminishWiFi(padapter, _TRUE, _FALSE, 0x20, BT_FW_NAV_OFF);
15313                                                 }
15314                                         }
15315                                         else if (pHalData->bt_coexist.BT21TrafficStatistics.bRxBusyTraffic)
15316                                         {
15317                                                 RTPRINT(FBT, BT_TRACE, ("BT Downlink\n"));
15318                                                 BTDM_DiminishWiFi(padapter, _TRUE, _FALSE, 0x20, BT_FW_NAV_OFF);
15319                                         }
15320                                 }
15321                                 // Then do the SW mechanism
15322                                 BTDM_SWCoexAllOff(padapter);
15323                         }
15324                 }
15325                 else if (pBtMgnt->ExtConfig.bBTBusy &&
15326                                 !pmlmepriv->LinkDetectInfo.bBusyTraffic &&
15327                                 (BTDM_GetRxSS(padapter) < 30))
15328                 {
15329                         RTPRINT(FBT, BT_TRACE, ("BT is non-idle && Wifi is idle!\n"));
15330                         RTPRINT(FBT, BT_TRACE, ("RSSI < 30\n"));
15331                         // Do the FW mechanism first
15332                         BTDM_Balance(padapter, _TRUE, 0x0a, 0x20);
15333                         BTDM_DiminishWiFi(padapter, _TRUE, _FALSE, 0x20, BT_FW_NAV_OFF);
15334                         // Then do the SW mechanism
15335                         BTDM_SWCoexAllOff(padapter);
15336                 }
15337                 else
15338                 {
15339                         RTPRINT(FBT, BT_TRACE, ("BT is idle or Wifi is idle!\n"));
15340                         BTDM_CoexAllOff(padapter);
15341                 }
15342         }
15343 }
15344
15345 void btdm_PANActionBC82Ant92d(PADAPTER padapter)
15346 {
15347 //      PMGNT_INFO              pMgntInfo = &padapter->MgntInfo;
15348         struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
15349         PBT30Info               pBTInfo = GET_BT_INFO(padapter) ;
15350         PBT_MGNT                pBtMgnt = &pBTInfo->BtMgnt;
15351         PHAL_DATA_TYPE  pHalData = GET_HAL_DATA(padapter);
15352         u8                      btRssiState, rssiState1;
15353
15354         if (pBtMgnt->BtOperationOn)
15355         {
15356                 RTPRINT(FBT, BT_TRACE, ("[BT 3.0]\n"));
15357                 if (pHalData->bt_coexist.PreviousState == pHalData->bt_coexist.CurrentState)
15358                         return;
15359
15360                 BTDM_CoexAllOff(padapter);
15361         }
15362         else
15363         {
15364                 RTPRINT(FBT, BT_TRACE, ("[BT 2.1]\n"));
15365                 if (BTDM_IsHT40(padapter))
15366                 {
15367                         RTPRINT(FBT, BT_TRACE, ("HT40\n"));
15368                         rssiState1 = BTDM_CheckCoexRSSIState1(padapter, 2, BT_FW_COEX_THRESH_47, 0);
15369                 }
15370                 else
15371                 {
15372                         RTPRINT(FBT, BT_TRACE, ("HT20 or Legacy\n"));
15373                         rssiState1 = BTDM_CheckCoexRSSIState1(padapter, 2, BT_FW_COEX_THRESH_25, 0);
15374                 }
15375                 btRssiState = BTDM_CheckCoexRSSIState(padapter, 3, BT_FW_COEX_THRESH_25, BT_FW_COEX_THRESH_50);
15376                 if (!BTDM_IsCoexistStateChanged(padapter))
15377                         return;
15378
15379                 if (pBtMgnt->ExtConfig.bBTBusy && pmlmepriv->LinkDetectInfo.bBusyTraffic)
15380                 {
15381                         RTPRINT(FBT, BT_TRACE, ("BT is non-idle && Wifi is non-idle!\n"));
15382
15383                         if ((btRssiState == BT_RSSI_STATE_HIGH) ||
15384                                 (btRssiState == BT_RSSI_STATE_STAY_HIGH))
15385                         {
15386                                 RTPRINT(FBT, BT_TRACE, ("RSSI stay HIGH or High \n"));
15387                                 // Do the FW mechanism first
15388                                 if (pHalData->bt_coexist.BT21TrafficStatistics.bTxBusyTraffic)
15389                                 {
15390                                         RTPRINT(FBT, BT_TRACE, ("BT Uplink\n"));
15391                                         BTDM_Balance(padapter, _TRUE, 0x20, 0x20);
15392                                         BTDM_DiminishWiFi(padapter, _TRUE, _FALSE, 0x20, BT_FW_NAV_OFF);
15393                                 }
15394                                 else if (pHalData->bt_coexist.BT21TrafficStatistics.bRxBusyTraffic)
15395                                 {
15396                                         RTPRINT(FBT, BT_TRACE, ("BT Downlink\n"));
15397                                         BTDM_FWCoexAllOff(padapter);
15398                                 }
15399                                 // Then do the SW mechanism
15400                                 if ((rssiState1 == BT_RSSI_STATE_HIGH) ||
15401                                         (rssiState1 == BT_RSSI_STATE_STAY_HIGH))
15402                                 {
15403                                         BTDM_AGCTable(padapter, BT_AGCTABLE_ON);
15404                                 }
15405                                 else
15406                                 {
15407                                         BTDM_AGCTable(padapter, BT_AGCTABLE_OFF);
15408                                 }
15409                                 BTDM_BBBackOffLevel(padapter, BT_BB_BACKOFF_ON);
15410                                 if (pHalData->bt_coexist.BT21TrafficStatistics.bTxBusyTraffic)
15411                                 {
15412                                         RTPRINT(FBT, BT_TRACE, ("BT Uplink\n"));
15413                                         btdm_DacSwing(padapter, BT_DACSWING_OFF);
15414                                 }
15415                                 else if (pHalData->bt_coexist.BT21TrafficStatistics.bRxBusyTraffic)
15416                                 {
15417                                         RTPRINT(FBT, BT_TRACE, ("BT Downlink\n"));
15418                                         btdm_DacSwing(padapter, BT_DACSWING_M4);
15419                                 }
15420                         }
15421                         else if ((btRssiState == BT_RSSI_STATE_MEDIUM) ||
15422                                 (btRssiState == BT_RSSI_STATE_STAY_MEDIUM))
15423                         {
15424                                 RTPRINT(FBT, BT_TRACE, ("RSSI stay Medium or Medium \n"));
15425                                 // Do the FW mechanism first
15426                                 BTDM_Balance(padapter, _TRUE, 0x20, 0x20);
15427
15428                                 if (pmlmepriv->LinkDetectInfo.bTxBusyTraffic)
15429                                 {
15430                                         RTPRINT(FBT, BT_TRACE, ("Wifi Uplink\n"));
15431                                         BTDM_DiminishWiFi(padapter, _TRUE, _FALSE, 0x20, BT_FW_NAV_OFF);
15432                                 }
15433                                 else if (pmlmepriv->LinkDetectInfo.bRxBusyTraffic)
15434                                 {
15435                                         RTPRINT(FBT, BT_TRACE, ("Wifi Downlink\n"));
15436                                         if (BTDM_IsHT40(padapter))
15437                                                 BTDM_DiminishWiFi(padapter, _TRUE, _FALSE, 0x20, BT_FW_NAV_OFF);//BT_FW_NAV_ON);
15438                                         else
15439                                                 BTDM_DiminishWiFi(padapter, _TRUE, _FALSE, 0x20, BT_FW_NAV_OFF);
15440                                 }
15441                                 // Then do the SW mechanism
15442                                 if ((rssiState1 == BT_RSSI_STATE_HIGH) ||
15443                                         (rssiState1 == BT_RSSI_STATE_STAY_HIGH))
15444                                 {
15445                                         BTDM_AGCTable(padapter, BT_AGCTABLE_ON);
15446                                 }
15447                                 else
15448                                 {
15449                                         BTDM_AGCTable(padapter, BT_AGCTABLE_OFF);
15450                                 }
15451                                 BTDM_BBBackOffLevel(padapter, BT_BB_BACKOFF_ON);
15452                                 btdm_DacSwing(padapter, BT_DACSWING_OFF);
15453                         }
15454                         else
15455                         {
15456                                 RTPRINT(FBT, BT_TRACE, ("RSSI stay LOW or LOW \n"));
15457                                 // Do the FW mechanism first
15458                                 BTDM_Balance(padapter, _TRUE, 0x20, 0x20);
15459
15460                                 if (pmlmepriv->LinkDetectInfo.bTxBusyTraffic)
15461                                 {
15462                                         RTPRINT(FBT, BT_TRACE, ("Wifi Uplink\n"));
15463                                         BTDM_DiminishWiFi(padapter, _TRUE, _FALSE, 0x20, BT_FW_NAV_OFF);
15464                                 }
15465                                 else if (pmlmepriv->LinkDetectInfo.bRxBusyTraffic)
15466                                 {
15467                                         RTPRINT(FBT, BT_TRACE, ("Wifi Downlink\n"));
15468                                         if (pHalData->bt_coexist.BT21TrafficStatistics.bTxBusyTraffic)
15469                                         {
15470                                                 RTPRINT(FBT, BT_TRACE, ("BT Uplink\n"));
15471                                                 if (BTDM_IsHT40(padapter))
15472                                                 {
15473                                                         RTPRINT(FBT, BT_TRACE, ("HT40\n"));
15474                                                         BTDM_DiminishWiFi(padapter, _TRUE, _FALSE, 0x20, BT_FW_NAV_OFF);//BT_FW_NAV_ON);
15475                                                 }
15476                                                 else
15477                                                 {
15478                                                         RTPRINT(FBT, BT_TRACE, ("HT20 or Legacy\n"));
15479                                                         BTDM_DiminishWiFi(padapter, _TRUE, _FALSE, 0x20, BT_FW_NAV_OFF);
15480                                                 }
15481                                         }
15482                                         else if (pHalData->bt_coexist.BT21TrafficStatistics.bRxBusyTraffic)
15483                                         {
15484                                                 RTPRINT(FBT, BT_TRACE, ("BT Downlink\n"));
15485                                                 BTDM_DiminishWiFi(padapter, _TRUE, _FALSE, 0x20, BT_FW_NAV_OFF);
15486                                         }
15487                                 }
15488                                 // Then do the SW mechanism
15489                                 if ((rssiState1 == BT_RSSI_STATE_HIGH) ||
15490                                         (rssiState1 == BT_RSSI_STATE_STAY_HIGH))
15491                                 {
15492                                         BTDM_AGCTable(padapter, BT_AGCTABLE_ON);
15493                                 }
15494                                 else
15495                                 {
15496                                         BTDM_AGCTable(padapter, BT_AGCTABLE_OFF);
15497                                 }
15498                                 BTDM_BBBackOffLevel(padapter, BT_BB_BACKOFF_OFF);
15499                                 btdm_DacSwing(padapter, BT_DACSWING_OFF);
15500                         }
15501                 }
15502                 else if (pBtMgnt->ExtConfig.bBTBusy &&
15503                                 !pmlmepriv->LinkDetectInfo.bBusyTraffic &&
15504                                 (BTDM_GetRxSS(padapter) < 30))
15505                 {
15506                         RTPRINT(FBT, BT_TRACE, ("BT is non-idle && Wifi is idle!\n"));
15507                         RTPRINT(FBT, BT_TRACE, ("RSSI < 30\n"));
15508                         // Do the FW mechanism first
15509                         BTDM_Balance(padapter, _TRUE, 0x0a, 0x20);
15510                         BTDM_DiminishWiFi(padapter, _TRUE, _FALSE, 0x20, BT_FW_NAV_OFF);
15511                         // Then do the SW mechanism
15512                         BTDM_SWCoexAllOff(padapter);
15513                 }
15514                 else
15515                 {
15516                         RTPRINT(FBT, BT_TRACE, ("BT is idle or Wifi is idle!\n"));
15517                         BTDM_CoexAllOff(padapter);
15518                 }
15519         }
15520 }
15521
15522 u8 btdm_PANAction2Ant(PADAPTER padapter)
15523 {
15524         PHAL_DATA_TYPE  pHalData = GET_HAL_DATA(padapter);
15525         PBT30Info               pBTInfo = GET_BT_INFO(padapter);
15526         PBT_MGNT                pBtMgnt = &pBTInfo->BtMgnt;
15527         PBT_DBG                 pBtDbg = &pBTInfo->BtDbg;
15528         u8                      bEnter = _FALSE;
15529
15530         if (pBtDbg->dbgCtrl == _TRUE )
15531         {
15532                 if (pBtDbg->dbgProfile == BT_DBG_PROFILE_PAN)
15533                         bEnter = _TRUE;
15534         }
15535         else
15536         {
15537                 if (BTHCI_CheckProfileExist(padapter,BT_PROFILE_PAN) && pBtMgnt->ExtConfig.NumberOfHandle==1)
15538                         bEnter = _TRUE;
15539         }
15540
15541         if (bEnter)
15542         {
15543                 RTPRINT(FBT, BT_TRACE, ("[DM][BT], btdm_PANAction2Ant(), "));
15544                 pHalData->bt_coexist.CurrentState |= BT_COEX_STATE_PROFILE_PAN;
15545                 pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_PROFILE_HID;
15546                 pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_PROFILE_A2DP;
15547
15548                 if (pHalData->bt_coexist.BT_CoexistType == BT_CSR_BC4)
15549                 {
15550                         RTPRINT(FBT, BT_TRACE, ("[BC4]\n"));
15551                         btdm_PANActionBC42Ant(padapter);
15552                 }
15553                 else if (pHalData->bt_coexist.BT_CoexistType == BT_CSR_BC8)
15554                 {
15555                         RTPRINT(FBT, BT_TRACE, ("[BC8]\n"));
15556                         if (IS_HARDWARE_TYPE_8192D(padapter))
15557                                 btdm_PANActionBC82Ant92d(padapter);
15558                         else
15559                         btdm_PANActionBC82Ant(padapter);
15560                 }
15561                 return _TRUE;
15562         }
15563         else
15564         {
15565                 return _FALSE;
15566         }
15567 }
15568
15569 void btdm_HIDActionBC42Ant(PADAPTER padapter)
15570 {
15571 //      PMGNT_INFO              pMgntInfo = &padapter->MgntInfo;
15572         struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
15573         PHAL_DATA_TYPE  pHalData = GET_HAL_DATA(padapter);
15574
15575         if (pHalData->bt_coexist.PreviousState == pHalData->bt_coexist.CurrentState)
15576                 return;
15577
15578         if (BTDM_Legacy(padapter))
15579         {
15580                 RTPRINT(FBT, BT_TRACE, ("Current Wireless Mode is B/G\n"));
15581                 btdm_WLANActBTPrecedence(padapter);
15582         }
15583         else if (pmlmepriv->LinkDetectInfo.bTxBusyTraffic)
15584         {
15585                 RTPRINT(FBT, BT_TRACE, ("Wifi Uplink\n"));
15586                 btdm_WLANActBTPrecedence(padapter);
15587         }
15588         else if (pmlmepriv->LinkDetectInfo.bRxBusyTraffic)
15589         {
15590                 RTPRINT(FBT, BT_TRACE, ("Wifi Downlink\n"));
15591                 btdm_WLANActOff(padapter);
15592         }
15593         else if (!pmlmepriv->LinkDetectInfo.bBusyTraffic)
15594         {
15595                 RTPRINT(FBT, BT_TRACE, ("Wifi Idel \n"));
15596                 btdm_WLANActOff(padapter);
15597         }
15598         BTDM_SWCoexAllOff(padapter);
15599 }
15600
15601 void btdm_HIDActionBC82Ant(PADAPTER padapter)
15602 {
15603 //      PMGNT_INFO              pMgntInfo = &padapter->MgntInfo;
15604         struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
15605         PBT30Info               pBTInfo = GET_BT_INFO(padapter) ;
15606         PBT_MGNT                pBtMgnt = &pBTInfo->BtMgnt;
15607         PHAL_DATA_TYPE  pHalData = GET_HAL_DATA(padapter);
15608         u8                      btRssiState;
15609
15610 #ifdef CONFIG_USB_HCI
15611         if (pHalData->CustomerID == RT_CID_PLANEX)
15612         {
15613                 if (pHalData->bt_coexist.PreviousState == pHalData->bt_coexist.CurrentState)
15614                         return;
15615                 btdm_HIDActionBC42Ant(padapter);
15616                 return;
15617         }
15618 #endif
15619
15620         if (pmlmepriv->LinkDetectInfo.bTxBusyTraffic)
15621         {
15622                 btRssiState = BTDM_CheckCoexRSSIState(padapter, 2, BT_FW_COEX_THRESH_45, 0);
15623         }
15624         else if (pmlmepriv->LinkDetectInfo.bRxBusyTraffic)
15625         {
15626                 btRssiState = BTDM_CheckCoexRSSIState(padapter, 2, BT_FW_COEX_THRESH_20, 0);
15627         }
15628
15629         if (pHalData->bt_coexist.PreviousState == pHalData->bt_coexist.CurrentState)
15630                 return;
15631
15632         if (pBtMgnt->ExtConfig.bBTBusy && pmlmepriv->LinkDetectInfo.bBusyTraffic)
15633         {
15634                 RTPRINT(FBT, BT_TRACE, ("BT is non-idle && Wifi is non-idle!\n"));
15635                 // Do the FW mechanism first
15636                 if ((btRssiState == BT_RSSI_STATE_HIGH) ||
15637                         (btRssiState == BT_RSSI_STATE_STAY_HIGH))
15638                 {
15639                         BTDM_FWCoexAllOff(padapter);
15640                 }
15641                 else
15642                 {
15643                         if (pmlmepriv->LinkDetectInfo.bTxBusyTraffic)
15644                         {
15645                                 RTPRINT(FBT, BT_TRACE, ("Wifi Uplink\n"));
15646                                 BTDM_Balance(padapter, _FALSE, 0, 0);
15647                                 BTDM_DiminishWiFi(padapter, _TRUE, _TRUE, 0x18, BT_FW_NAV_OFF);
15648                         }
15649                         else if (pmlmepriv->LinkDetectInfo.bRxBusyTraffic)
15650                         {
15651                                 RTPRINT(FBT, BT_TRACE, ("Wifi Downlink\n"));
15652                                 BTDM_Balance(padapter, _TRUE, 0x15, 0x15);
15653                                 BTDM_DiminishWiFi(padapter, _TRUE, _FALSE, 0x30, BT_FW_NAV_OFF);
15654                         }
15655                 }
15656                 // Then do the SW mechanism
15657                 BTDM_SWCoexAllOff(padapter);
15658         }
15659         else
15660         {
15661                 RTPRINT(FBT, BT_TRACE, ("BT is idle or Wifi is idle!\n"));
15662                 BTDM_CoexAllOff(padapter);
15663         }
15664 }
15665
15666 void btdm_HIDActionBC82Ant92d(PADAPTER padapter)
15667 {
15668 //      PMGNT_INFO              pMgntInfo = &padapter->MgntInfo;
15669         struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
15670         PBT30Info               pBTInfo = GET_BT_INFO(padapter) ;
15671         PBT_MGNT                pBtMgnt = &pBTInfo->BtMgnt;
15672         PHAL_DATA_TYPE  pHalData = GET_HAL_DATA(padapter);
15673         u8                      btRssiState;
15674
15675         if (pmlmepriv->LinkDetectInfo.bTxBusyTraffic)
15676         {
15677                 btRssiState = BTDM_CheckCoexRSSIState(padapter, 2, BT_FW_COEX_THRESH_45, 0);
15678         }
15679         else if (pmlmepriv->LinkDetectInfo.bRxBusyTraffic)
15680         {
15681                 btRssiState = BTDM_CheckCoexRSSIState(padapter, 2, BT_FW_COEX_THRESH_20, 0);
15682         }
15683
15684         if (pHalData->bt_coexist.PreviousState == pHalData->bt_coexist.CurrentState)
15685                 return;
15686
15687         if (pBtMgnt->ExtConfig.bBTBusy && pmlmepriv->LinkDetectInfo.bBusyTraffic)
15688         {
15689                 RTPRINT(FBT, BT_TRACE, ("BT is non-idle && Wifi is non-idle!\n"));
15690                 if ((btRssiState == BT_RSSI_STATE_HIGH) ||
15691                         (btRssiState == BT_RSSI_STATE_STAY_HIGH))
15692                 {
15693                         // Do the FW mechanism first
15694                         BTDM_FWCoexAllOff(padapter);
15695
15696                         // Then do the SW mechanism
15697                         BTDM_AGCTable(padapter, BT_AGCTABLE_OFF);
15698                         BTDM_BBBackOffLevel(padapter, BT_BB_BACKOFF_OFF);
15699                         btdm_DacSwing(padapter, BT_DACSWING_M4);
15700                 }
15701                 else
15702                 {
15703                         // Do the FW mechanism first
15704                         if (pmlmepriv->LinkDetectInfo.bTxBusyTraffic)
15705                         {
15706                                 RTPRINT(FBT, BT_TRACE, ("Wifi Uplink\n"));
15707                                 BTDM_Balance(padapter, _FALSE, 0, 0);
15708                                 BTDM_DiminishWiFi(padapter, _TRUE, _TRUE, 0x18, BT_FW_NAV_OFF);
15709                         }
15710                         else if (pmlmepriv->LinkDetectInfo.bRxBusyTraffic)
15711                         {
15712                                 RTPRINT(FBT, BT_TRACE, ("Wifi Downlink\n"));
15713                                 BTDM_Balance(padapter, _TRUE, 0x15, 0x15);
15714                                 BTDM_DiminishWiFi(padapter, _TRUE, _FALSE, 0x30, BT_FW_NAV_OFF);
15715                         }
15716                         // Then do the SW mechanism
15717                         BTDM_SWCoexAllOff(padapter);
15718                 }
15719         }
15720         else
15721         {
15722                 RTPRINT(FBT, BT_TRACE, ("BT is idle or Wifi is idle!\n"));
15723                 BTDM_CoexAllOff(padapter);
15724         }
15725 }
15726
15727 u8 btdm_HIDAction2Ant(PADAPTER padapter)
15728 {
15729         PBT30Info               pBTInfo = GET_BT_INFO(padapter) ;
15730         PBT_MGNT                pBtMgnt = &pBTInfo->BtMgnt;
15731         PBT_DBG                 pBtDbg = &pBTInfo->BtDbg;
15732         PHAL_DATA_TYPE  pHalData = GET_HAL_DATA(padapter);
15733         u8                      bEnter = _FALSE;
15734
15735         if (pBtDbg->dbgCtrl == _TRUE )
15736         {
15737                 if (pBtDbg->dbgProfile == BT_DBG_PROFILE_HID)
15738                         bEnter = _TRUE;
15739         }
15740         else
15741         {
15742                 if (BTHCI_CheckProfileExist(padapter,BT_PROFILE_HID) && pBtMgnt->ExtConfig.NumberOfHandle==1)
15743                         bEnter = _TRUE;
15744         }
15745
15746         if (bEnter)
15747         {
15748                 RTPRINT(FBT, BT_TRACE, ("[DM][BT], btdm_HIDAction2Ant(), "));
15749                 pHalData->bt_coexist.CurrentState |= BT_COEX_STATE_PROFILE_HID;
15750                 pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_PROFILE_PAN;
15751                 pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_PROFILE_A2DP;
15752
15753                 if (pHalData->bt_coexist.BT_CoexistType == BT_CSR_BC4)
15754                 {
15755                         RTPRINT(FBT, BT_TRACE, ("[BC4]\n"));
15756                         btdm_HIDActionBC42Ant(padapter);
15757                 }
15758                 else if (pHalData->bt_coexist.BT_CoexistType == BT_CSR_BC8)
15759                 {
15760                         RTPRINT(FBT, BT_TRACE, ("[BC8]\n"));
15761                         if (IS_HARDWARE_TYPE_8192D(padapter))
15762                                 btdm_HIDActionBC82Ant92d(padapter);
15763                         else
15764                         btdm_HIDActionBC42Ant(padapter);
15765                 }
15766                 return _TRUE;
15767         }
15768         else
15769         {
15770                 return _FALSE;
15771         }
15772 }
15773
15774 void btdm_SCOActionBC42Ant(PADAPTER padapter)
15775 {
15776         PHAL_DATA_TYPE  pHalData = GET_HAL_DATA(padapter);
15777
15778         if (pHalData->bt_coexist.PreviousState == pHalData->bt_coexist.CurrentState)
15779                 return;
15780
15781         btdm_WLANActOff(padapter);
15782         BTDM_SWCoexAllOff(padapter);
15783 }
15784
15785 void btdm_SCOActionBC82Ant(PADAPTER padapter)
15786 {
15787         PHAL_DATA_TYPE  pHalData = GET_HAL_DATA(padapter);
15788         u8      btRssiState;
15789
15790         if (BTDM_IsHT40(padapter))
15791         {
15792                 if (pHalData->bt_coexist.PreviousState == pHalData->bt_coexist.CurrentState)
15793                         return;
15794
15795                 RTPRINT(FBT, BT_TRACE, ("HT40\n"));
15796                 // Do the FW mechanism first
15797                 BTDM_Balance(padapter, _FALSE, 0, 0);
15798                 BTDM_DiminishWiFi(padapter, _FALSE, _FALSE, 0, BT_FW_NAV_OFF);
15799
15800                 // Then do the SW mechanism
15801                 BTDM_AGCTable(padapter, BT_AGCTABLE_OFF);
15802                 BTDM_BBBackOffLevel(padapter, BT_BB_BACKOFF_ON);
15803                 btdm_DacSwing(padapter, BT_DACSWING_OFF);
15804         }
15805         else
15806         {
15807                 btRssiState = BTDM_CheckCoexRSSIState(padapter, 2, BT_FW_COEX_THRESH_47, 0);
15808                 if (pHalData->bt_coexist.PreviousState == pHalData->bt_coexist.CurrentState)
15809                         return;
15810
15811                 RTPRINT(FBT, BT_TRACE, ("HT20 or Legacy\n"));
15812                 // Do the FW mechanism first
15813                 BTDM_Balance(padapter, _FALSE, 0, 0);
15814                 BTDM_DiminishWiFi(padapter, _FALSE, _FALSE, 0, BT_FW_NAV_OFF);
15815
15816                 // Then do the SW mechanism
15817                 if ((btRssiState == BT_RSSI_STATE_HIGH) ||
15818                         (btRssiState == BT_RSSI_STATE_STAY_HIGH))
15819                 {
15820                         BTDM_AGCTable(padapter, BT_AGCTABLE_ON);
15821                         BTDM_BBBackOffLevel(padapter, BT_BB_BACKOFF_ON);
15822                         btdm_DacSwing(padapter, BT_DACSWING_OFF);
15823                 }
15824                 else
15825                 {
15826                         BTDM_SWCoexAllOff(padapter);
15827                 }
15828         }
15829 }
15830
15831 void btdm_SCOActionBC82Ant92d(PADAPTER padapter)
15832 {
15833         PHAL_DATA_TYPE  pHalData = GET_HAL_DATA(padapter);
15834         u8      btRssiState, rssiState1;
15835
15836         rssiState1 = BTDM_CheckCoexRSSIState1(padapter, 2, BT_FW_COEX_THRESH_47, 0);
15837         if (BTDM_IsHT40(padapter))
15838         {
15839                 if (pHalData->bt_coexist.PreviousState == pHalData->bt_coexist.CurrentState)
15840                         return;
15841
15842                 RTPRINT(FBT, BT_TRACE, ("HT40\n"));
15843                 // Do the FW mechanism first
15844                 BTDM_Balance(padapter, _FALSE, 0, 0);
15845                 BTDM_DiminishWiFi(padapter, _FALSE, _FALSE, 0, BT_FW_NAV_OFF);
15846
15847                 // Then do the SW mechanism
15848                 BTDM_AGCTable(padapter, BT_AGCTABLE_OFF);
15849                 BTDM_BBBackOffLevel(padapter, BT_BB_BACKOFF_ON);
15850                 btdm_DacSwing(padapter, BT_DACSWING_OFF);
15851         }
15852         else
15853         {
15854                 btRssiState = BTDM_CheckCoexRSSIState(padapter, 2, BT_FW_COEX_THRESH_47, 0);
15855                 if (pHalData->bt_coexist.PreviousState == pHalData->bt_coexist.CurrentState)
15856                         return;
15857
15858                 RTPRINT(FBT, BT_TRACE, ("HT20 or Legacy\n"));
15859                 // Do the FW mechanism first
15860                 BTDM_Balance(padapter, _FALSE, 0, 0);
15861                 BTDM_DiminishWiFi(padapter, _FALSE, _FALSE, 0, BT_FW_NAV_OFF);
15862
15863                 // Then do the SW mechanism
15864                 if ((rssiState1 == BT_RSSI_STATE_HIGH) ||
15865                         (rssiState1 == BT_RSSI_STATE_STAY_HIGH))
15866                 {
15867                         BTDM_AGCTable(padapter, BT_AGCTABLE_ON);
15868                 }
15869                 else
15870                 {
15871                         BTDM_AGCTable(padapter, BT_AGCTABLE_OFF);
15872                 }
15873                 if ((btRssiState == BT_RSSI_STATE_HIGH) ||
15874                         (btRssiState == BT_RSSI_STATE_STAY_HIGH))
15875                 {
15876                         BTDM_BBBackOffLevel(padapter, BT_BB_BACKOFF_ON);
15877                         btdm_DacSwing(padapter, BT_DACSWING_OFF);
15878                 }
15879                 else
15880                 {
15881                         BTDM_BBBackOffLevel(padapter, BT_BB_BACKOFF_OFF);
15882                         btdm_DacSwing(padapter, BT_DACSWING_OFF);
15883                 }
15884         }
15885 }
15886
15887 u8 btdm_SCOAction2Ant(PADAPTER padapter)
15888 {
15889         PHAL_DATA_TYPE  pHalData = GET_HAL_DATA(padapter);
15890         PBT30Info               pBTInfo = GET_BT_INFO(padapter);
15891         PBT_MGNT                pBtMgnt = &pBTInfo->BtMgnt;
15892         PBT_DBG                 pBtDbg = &pBTInfo->BtDbg;
15893         u8                      bEnter = _FALSE;
15894
15895         if (pBtDbg->dbgCtrl == _TRUE )
15896         {
15897                 if (pBtDbg->dbgProfile == BT_DBG_PROFILE_SCO)
15898                         bEnter = _TRUE;
15899         }
15900         else
15901         {
15902                 if (pBtMgnt->ExtConfig.NumberOfSCO > 0)
15903                         bEnter = _TRUE;
15904         }
15905         if (bEnter)
15906         {
15907                 RTPRINT(FBT, BT_TRACE, ("[DM][BT], btdm_SCOAction2Ant(), "));
15908                 pHalData->bt_coexist.CurrentState |= BT_COEX_STATE_PROFILE_SCO;
15909
15910                 if (pHalData->bt_coexist.BT_CoexistType == BT_CSR_BC4)
15911                 {
15912                         RTPRINT(FBT, BT_TRACE, ("[BC4]\n"));
15913                         btdm_SCOActionBC42Ant(padapter);
15914                 }
15915                 else if (pHalData->bt_coexist.BT_CoexistType == BT_CSR_BC8)
15916                 {
15917                         RTPRINT(FBT, BT_TRACE, ("[BC8]\n"));
15918                         if (IS_HARDWARE_TYPE_8192D(padapter))
15919                                 btdm_SCOActionBC82Ant92d(padapter);
15920                         else
15921                         btdm_SCOActionBC82Ant(padapter);
15922                 }
15923                 return _TRUE;
15924         }
15925         else
15926         {
15927                 pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_PROFILE_SCO;
15928                 return _FALSE;
15929         }
15930 }
15931
15932 void btdm_HIDA2DPActionBC42Ant(PADAPTER padapter)
15933 {
15934 //      PMGNT_INFO              pMgntInfo = &padapter->MgntInfo;
15935         struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
15936         PBT30Info               pBTInfo = GET_BT_INFO(padapter);
15937         PBT_MGNT                pBtMgnt = &pBTInfo->BtMgnt;
15938         PHAL_DATA_TYPE  pHalData = GET_HAL_DATA(padapter);
15939         u8                      btRssiState;
15940
15941         if (pBtMgnt->ExtConfig.bBTBusy)
15942         {
15943                 RTPRINT(FBT, BT_TRACE, ("BT is non-idle!\n"));
15944
15945                 if (BTDM_IsHT40(padapter))
15946                 {
15947                         RTPRINT(FBT, BT_TRACE, ("HT40\n"));
15948                         if (pHalData->bt_coexist.PreviousState == pHalData->bt_coexist.CurrentState)
15949                                 return;
15950                         // Do the FW mechanism first
15951                         if (pmlmepriv->LinkDetectInfo.bTxBusyTraffic)
15952                         {
15953                                 RTPRINT(FBT, BT_TRACE, ("Wifi Uplink\n"));
15954                                 BTDM_Balance(padapter, _TRUE, 0x7, 0x20);
15955                                 BTDM_DiminishWiFi(padapter, _FALSE, _FALSE, 0x20, BT_FW_NAV_OFF);
15956                         }
15957                         else if (pmlmepriv->LinkDetectInfo.bRxBusyTraffic)
15958                         {
15959                                 RTPRINT(FBT, BT_TRACE, ("Wifi Downlink\n"));
15960                                 BTDM_FWCoexAllOff(padapter);
15961                         }
15962                         // Then do the SW mechanism
15963                         BTDM_AGCTable(padapter, BT_AGCTABLE_OFF);
15964                         BTDM_BBBackOffLevel(padapter, BT_BB_BACKOFF_ON);
15965                         btdm_DacSwing(padapter, BT_DACSWING_M7);
15966                 }
15967                 else
15968                 {
15969                         RTPRINT(FBT, BT_TRACE, ("HT20 or Legacy\n"));
15970                         btRssiState = BTDM_CheckCoexRSSIState(padapter, 2, BT_FW_COEX_THRESH_47, 0);
15971                         if (pHalData->bt_coexist.PreviousState == pHalData->bt_coexist.CurrentState)
15972                                 return;
15973                         // Do the FW mechanism first
15974                         if (pmlmepriv->LinkDetectInfo.bTxBusyTraffic)
15975                         {
15976                                 RTPRINT(FBT, BT_TRACE, ("Wifi Uplink\n"));
15977                                 BTDM_Balance(padapter, _TRUE, 0x7, 0x20);
15978                                 BTDM_DiminishWiFi(padapter, _FALSE, _FALSE, 0x20, BT_FW_NAV_OFF);
15979                         }
15980                         else if (pmlmepriv->LinkDetectInfo.bRxBusyTraffic)
15981                         {
15982                                 RTPRINT(FBT, BT_TRACE, ("Wifi Downlink\n"));
15983                                 BTDM_FWCoexAllOff(padapter);
15984                         }
15985
15986                         // Then do the SW mechanism
15987                         if ((btRssiState == BT_RSSI_STATE_HIGH) ||
15988                                 (btRssiState == BT_RSSI_STATE_STAY_HIGH))
15989                         {
15990                                 BTDM_AGCTable(padapter, BT_AGCTABLE_ON);
15991                                 BTDM_BBBackOffLevel(padapter, BT_BB_BACKOFF_ON);
15992                                 btdm_DacSwing(padapter, BT_DACSWING_M7);
15993                         }
15994                         else
15995                         {
15996                                 BTDM_AGCTable(padapter, BT_AGCTABLE_OFF);
15997                                 BTDM_BBBackOffLevel(padapter, BT_BB_BACKOFF_OFF);
15998                                 btdm_DacSwing(padapter, BT_DACSWING_M7);
15999                         }
16000                 }
16001         }
16002         else
16003         {
16004                 RTPRINT(FBT, BT_TRACE, ("BT is idle!\n"));
16005                 BTDM_CoexAllOff(padapter);
16006         }
16007 }
16008
16009 void btdm_HIDA2DPActionBC82Ant(PADAPTER padapter)
16010 {
16011         PBT30Info               pBTInfo = GET_BT_INFO(padapter);
16012         PBT_MGNT                pBtMgnt = &pBTInfo->BtMgnt;
16013         PHAL_DATA_TYPE  pHalData = GET_HAL_DATA(padapter);
16014         u8                      btRssiState;
16015
16016         if (pBtMgnt->ExtConfig.bBTBusy)
16017         {
16018                 RTPRINT(FBT, BT_TRACE, ("BT is non-idle!\n"));
16019
16020                 if (BTDM_IsHT40(padapter))
16021                 {
16022                         RTPRINT(FBT, BT_TRACE, ("HT40\n"));
16023                         if (pHalData->bt_coexist.PreviousState == pHalData->bt_coexist.CurrentState)
16024                                 return;
16025
16026                         // Do the FW mechanism first
16027                         BTDM_FWCoexAllOff(padapter);
16028
16029                         // Then do the SW mechanism
16030                         BTDM_AGCTable(padapter, BT_AGCTABLE_OFF);
16031                         BTDM_BBBackOffLevel(padapter, BT_BB_BACKOFF_ON);
16032                         btdm_DacSwing(padapter, BT_DACSWING_M7);
16033                 }
16034                 else
16035                 {
16036                         RTPRINT(FBT, BT_TRACE, ("HT20 or Legacy\n"));
16037                         btRssiState = BTDM_CheckCoexRSSIState(padapter, 2, BT_FW_COEX_THRESH_47, 0);
16038                         if (pHalData->bt_coexist.PreviousState == pHalData->bt_coexist.CurrentState)
16039                                 return;
16040
16041                         BTDM_FWCoexAllOff(padapter);
16042
16043                         // Then do the SW mechanism
16044                         if ((btRssiState == BT_RSSI_STATE_HIGH) ||
16045                                 (btRssiState == BT_RSSI_STATE_STAY_HIGH))
16046                         {
16047                                 BTDM_AGCTable(padapter, BT_AGCTABLE_ON);
16048                                 BTDM_BBBackOffLevel(padapter, BT_BB_BACKOFF_ON);
16049                                 btdm_DacSwing(padapter, BT_DACSWING_M7);
16050                         }
16051                         else
16052                         {
16053                                 BTDM_AGCTable(padapter, BT_AGCTABLE_OFF);
16054                                 BTDM_BBBackOffLevel(padapter, BT_BB_BACKOFF_OFF);
16055                                 btdm_DacSwing(padapter, BT_DACSWING_M7);
16056                         }
16057                 }
16058         }
16059         else
16060         {
16061                 RTPRINT(FBT, BT_TRACE, ("BT is idle!\n"));
16062                 BTDM_CoexAllOff(padapter);
16063         }
16064 }
16065
16066 void btdm_HIDA2DPActionBC82Ant92d(PADAPTER padapter)
16067 {
16068         PBT30Info               pBTInfo = GET_BT_INFO(padapter);
16069         PBT_MGNT                pBtMgnt = &pBTInfo->BtMgnt;
16070         PHAL_DATA_TYPE  pHalData = GET_HAL_DATA(padapter);
16071         u8                      btRssiState, rssiState1;
16072
16073         rssiState1 = BTDM_CheckCoexRSSIState1(padapter, 2, BT_FW_COEX_THRESH_35, 0);
16074         if (pBtMgnt->ExtConfig.bBTBusy)
16075         {
16076                 RTPRINT(FBT, BT_TRACE, ("BT is non-idle!\n"));
16077
16078                 if (BTDM_IsHT40(padapter))
16079                 {
16080                         RTPRINT(FBT, BT_TRACE, ("HT40\n"));
16081                         if (pHalData->bt_coexist.PreviousState == pHalData->bt_coexist.CurrentState)
16082                                 return;
16083
16084                         // Do the FW mechanism first
16085                         BTDM_FWCoexAllOff(padapter);
16086
16087                         // Then do the SW mechanism
16088                         if ((rssiState1 == BT_RSSI_STATE_HIGH) ||
16089                                 (rssiState1 == BT_RSSI_STATE_STAY_HIGH))
16090                         {
16091                                 BTDM_AGCTable(padapter, BT_AGCTABLE_ON);
16092                         }
16093                         else
16094                         {
16095                                 BTDM_AGCTable(padapter, BT_AGCTABLE_OFF);
16096                         }
16097                         BTDM_BBBackOffLevel(padapter, BT_BB_BACKOFF_ON);
16098                         btdm_DacSwing(padapter, BT_DACSWING_M7);
16099                 }
16100                 else
16101                 {
16102                         RTPRINT(FBT, BT_TRACE, ("HT20 or Legacy\n"));
16103                         btRssiState = BTDM_CheckCoexRSSIState(padapter, 2, BT_FW_COEX_THRESH_47, 0);
16104                         if (pHalData->bt_coexist.PreviousState == pHalData->bt_coexist.CurrentState)
16105                                 return;
16106
16107                         BTDM_FWCoexAllOff(padapter);
16108
16109                         // Then do the SW mechanism
16110                         if ((rssiState1 == BT_RSSI_STATE_HIGH) ||
16111                                 (rssiState1 == BT_RSSI_STATE_STAY_HIGH))
16112                         {
16113                                 BTDM_AGCTable(padapter, BT_AGCTABLE_ON);
16114                         }
16115                         else
16116                         {
16117                                 BTDM_AGCTable(padapter, BT_AGCTABLE_OFF);
16118                         }
16119                         if ((btRssiState == BT_RSSI_STATE_HIGH) ||
16120                                 (btRssiState == BT_RSSI_STATE_STAY_HIGH))
16121                         {
16122                                 BTDM_BBBackOffLevel(padapter, BT_BB_BACKOFF_ON);
16123                                 btdm_DacSwing(padapter, BT_DACSWING_M7);
16124                         }
16125                         else
16126                         {
16127                                 BTDM_BBBackOffLevel(padapter, BT_BB_BACKOFF_OFF);
16128                                 btdm_DacSwing(padapter, BT_DACSWING_M7);
16129                         }
16130                 }
16131         }
16132         else
16133         {
16134                 RTPRINT(FBT, BT_TRACE, ("BT is idle!\n"));
16135                 BTDM_CoexAllOff(padapter);
16136         }
16137 }
16138
16139 u8 btdm_HIDA2DPAction2Ant(PADAPTER padapter)
16140 {
16141         PHAL_DATA_TYPE  pHalData = GET_HAL_DATA(padapter);
16142         PBT30Info               pBTInfo = GET_BT_INFO(padapter);
16143         PBT_DBG                 pBtDbg = &pBTInfo->BtDbg;
16144         u8                      bEnter = _FALSE;
16145
16146         if (pBtDbg->dbgCtrl == _TRUE )
16147         {
16148                 if (pBtDbg->dbgProfile == BT_DBG_PROFILE_HID_A2DP)
16149                         bEnter = _TRUE;
16150         }
16151         else
16152         {
16153                 if (BTHCI_CheckProfileExist(padapter,BT_PROFILE_HID) && BTHCI_CheckProfileExist(padapter,BT_PROFILE_A2DP))
16154                         bEnter = _TRUE;
16155         }
16156
16157         if (bEnter)
16158         {
16159                 RTPRINT(FBT, BT_TRACE, ("[DM][BT], btdm_HIDA2DPAction2Ant(), "));
16160                 pHalData->bt_coexist.CurrentState |= (BT_COEX_STATE_PROFILE_HID|BT_COEX_STATE_PROFILE_A2DP);
16161
16162                 if (pHalData->bt_coexist.BT_CoexistType == BT_CSR_BC4)
16163                 {
16164                         RTPRINT(FBT, BT_TRACE, ("[BC4]\n"));
16165                         btdm_HIDA2DPActionBC42Ant(padapter);
16166                 }
16167                 else if (pHalData->bt_coexist.BT_CoexistType == BT_CSR_BC8)
16168                 {
16169                         RTPRINT(FBT, BT_TRACE, ("[BC8]\n"));
16170                         if (IS_HARDWARE_TYPE_8192D(padapter))
16171                                 btdm_HIDA2DPActionBC82Ant92d(padapter);
16172                         else
16173                         btdm_HIDA2DPActionBC82Ant(padapter);
16174                 }
16175                 return _TRUE;
16176         }
16177         else
16178         {
16179                 pHalData->bt_coexist.CurrentState &= ~(BT_COEX_STATE_PROFILE_HID|BT_COEX_STATE_PROFILE_A2DP);
16180                 return _FALSE;
16181         }
16182 }
16183
16184 void btdm_HIDPANActionBC42Ant(PADAPTER padapter)
16185 {
16186 //      PMGNT_INFO              pMgntInfo = &padapter->MgntInfo;
16187         struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
16188         PBT30Info               pBTInfo = GET_BT_INFO(padapter);
16189         PBT_MGNT                pBtMgnt = &pBTInfo->BtMgnt;
16190         PHAL_DATA_TYPE  pHalData = GET_HAL_DATA(padapter);
16191
16192         if (pHalData->bt_coexist.PreviousState == pHalData->bt_coexist.CurrentState)
16193                 return;
16194
16195         if (pBtMgnt->BtOperationOn)
16196         {
16197                 RTPRINT(FBT, BT_TRACE, ("[BT 3.0]\n"));
16198                         btdm_WLANActBTPrecedence(padapter);
16199                 }
16200         else
16201         {
16202                 RTPRINT(FBT, BT_TRACE, ("[BT 2.1]\n"));
16203                 if (BTDM_Legacy(padapter))
16204                 {
16205                         RTPRINT(FBT, BT_TRACE, ("B/G mode \n"));
16206                         btdm_WLANActBTPrecedence(padapter);
16207                 }
16208                 else if (pmlmepriv->LinkDetectInfo.bTxBusyTraffic)
16209                 {
16210                         RTPRINT(FBT, BT_TRACE, ("Wifi Uplink \n"));
16211                         btdm_WLANActBTPrecedence(padapter);
16212                 }
16213                 else if (pmlmepriv->LinkDetectInfo.bRxBusyTraffic)
16214                 {
16215                         RTPRINT(FBT, BT_TRACE, ("Wifi Downlink \n"));
16216                         rtw_write8(padapter, REG_GPIO_MUXCFG, 0x0);
16217                         BTDM_Balance(padapter, _TRUE, 0x20, 0x10);
16218                         BTDM_DiminishWiFi(padapter, _TRUE, _FALSE, 0x20, BT_FW_NAV_OFF);
16219                 }
16220                 else if (!pmlmepriv->LinkDetectInfo.bBusyTraffic)
16221                 {
16222                         RTPRINT(FBT, BT_TRACE, ("Wifi Idel \n"));
16223                         btdm_WLANActOff(padapter);
16224                 }
16225         }
16226         BTDM_SWCoexAllOff(padapter);
16227 }
16228
16229 void btdm_HIDPANActionBC82Ant(PADAPTER padapter)
16230 {
16231 //      PMGNT_INFO              pMgntInfo = &padapter->MgntInfo;
16232         PBT30Info               pBTInfo = GET_BT_INFO(padapter);
16233         PBT_MGNT                pBtMgnt = &pBTInfo->BtMgnt;
16234         PHAL_DATA_TYPE  pHalData = GET_HAL_DATA(padapter);
16235         u8                      btRssiState;
16236
16237         if (!pBtMgnt->BtOperationOn)
16238         {
16239                 RTPRINT(FBT, BT_TRACE, ("[BT 2.1]\n"));
16240
16241                 btRssiState = BTDM_CheckCoexRSSIState(padapter, 2, BT_FW_COEX_THRESH_25, 0);
16242                 if (pHalData->bt_coexist.PreviousState == pHalData->bt_coexist.CurrentState)
16243                         return;
16244
16245                 if ((pBtMgnt->ExtConfig.bBTBusy && padapter->mlmepriv.LinkDetectInfo.bBusyTraffic))
16246                 {
16247                         RTPRINT(FBT, BT_TRACE, ("BT is non-idle && Wifi is non-idle, "));
16248
16249                         // Do the FW mechanism first
16250                         if (pHalData->bt_coexist.BT21TrafficStatistics.bTxBusyTraffic)
16251                         {
16252                                 RTPRINT(FBT, BT_TRACE, ("BT Uplink\n"));
16253                                 BTDM_Balance(padapter, _TRUE, 0x15, 0x20);
16254                         }
16255                         else if (pHalData->bt_coexist.BT21TrafficStatistics.bRxBusyTraffic)
16256                         {
16257                                 RTPRINT(FBT, BT_TRACE, ("BT Downlink\n"));
16258                                 BTDM_Balance(padapter, _TRUE, 0x10, 0x20);
16259                         }
16260                         BTDM_DiminishWiFi(padapter, _TRUE, _FALSE, 0x20, BT_FW_NAV_OFF);
16261
16262                         // Then do the SW mechanism
16263                         if ((btRssiState == BT_RSSI_STATE_HIGH) ||
16264                                 (btRssiState == BT_RSSI_STATE_STAY_HIGH))
16265                         {
16266                                 if (BTDM_IsHT40(padapter))
16267                                 {
16268                                         RTPRINT(FBT, BT_TRACE, ("HT40\n"));
16269                                         BTDM_AGCTable(padapter, BT_AGCTABLE_OFF);
16270                                         BTDM_BBBackOffLevel(padapter, BT_BB_BACKOFF_ON);
16271                                         btdm_DacSwing(padapter, BT_DACSWING_OFF);
16272                                 }
16273                                 else
16274                                 {
16275                                         RTPRINT(FBT, BT_TRACE, ("HT20 or Legacy\n"));
16276                                         BTDM_AGCTable(padapter, BT_AGCTABLE_ON);
16277                                         BTDM_BBBackOffLevel(padapter, BT_BB_BACKOFF_ON);
16278                                         btdm_DacSwing(padapter, BT_DACSWING_OFF);
16279                                 }
16280                         }
16281                         else
16282                         {
16283                                 BTDM_SWCoexAllOff(padapter);
16284                         }
16285                 }
16286                 else
16287                 {
16288                         RTPRINT(FBT, BT_TRACE, ("BT is idle or Wifi is idle!\n"));
16289                         BTDM_CoexAllOff(padapter);
16290                 }
16291         }
16292         else
16293         {
16294                 RTPRINT(FBT, BT_TRACE, ("[BT 3.0]\n"));
16295 #ifdef CONFIG_USB_HCI
16296                 if (BTDM_IsWifiUplink(padapter))
16297                 {
16298                         RTPRINT(FBT, BT_TRACE, ("Wifi Uplink\n"));
16299                         btdm_WLANActBTPrecedence(padapter);
16300                         if (pHalData->CustomerID == RT_CID_PLANEX)
16301                                 btdm_DacSwing(padapter, BT_DACSWING_M10);
16302                         else
16303                                 btdm_DacSwing(padapter, BT_DACSWING_M7);
16304                 }
16305                 else if (BTDM_IsWifiDownlink(padapter))
16306                 {
16307                         RTPRINT(FBT, BT_TRACE, ("Wifi Downlink\n"));
16308                         if (pHalData->CustomerID == RT_CID_PLANEX)
16309                                 btdm_DacSwing(padapter, BT_DACSWING_M10);
16310                         else
16311                                 btdm_DacSwing(padapter, BT_DACSWING_M7);
16312                 }
16313 #elif defined(CONFIG_PCI_HCI)
16314                 if (pBtMgnt->ExtConfig.bBTBusy)
16315                 {
16316                         RTPRINT(FBT, BT_TRACE, ("BT is non-idle\n"));
16317                         BTDM_FWCoexAllOff(padapter);
16318                         BTDM_AGCTable(padapter, BT_AGCTABLE_OFF);
16319                         BTDM_BBBackOffLevel(padapter, BT_BB_BACKOFF_OFF);
16320                         btdm_DacSwing(padapter, BT_DACSWING_M4);
16321                 }
16322                 else
16323                 {
16324                         RTPRINT(FBT, BT_TRACE, ("BT is idle\n"));
16325                         btdm_DacSwing(padapter, BT_DACSWING_OFF);
16326                 }
16327 #endif
16328         }
16329 }
16330
16331 u8 btdm_HIDPANAction2Ant(PADAPTER padapter)
16332 {
16333         PHAL_DATA_TYPE  pHalData = GET_HAL_DATA(padapter);
16334         PBT30Info               pBTInfo = GET_BT_INFO(padapter);
16335         PBT_DBG                 pBtDbg = &pBTInfo->BtDbg;
16336         u8                      bEnter = _FALSE;
16337
16338         if (pBtDbg->dbgCtrl == _TRUE )
16339         {
16340                 if (pBtDbg->dbgProfile == BT_DBG_PROFILE_HID_PAN)
16341                         bEnter = _TRUE;
16342         }
16343         else
16344         {
16345                 if (BTHCI_CheckProfileExist(padapter,BT_PROFILE_HID) && BTHCI_CheckProfileExist(padapter,BT_PROFILE_PAN))
16346                         bEnter = _TRUE;
16347         }
16348
16349         if (bEnter)
16350         {
16351                 RTPRINT(FBT, BT_TRACE, ("[DM][BT], btdm_HIDPANAction2Ant(), "));
16352                 pHalData->bt_coexist.CurrentState |= (BT_COEX_STATE_PROFILE_HID|BT_COEX_STATE_PROFILE_PAN);
16353
16354                 if (pHalData->bt_coexist.BT_CoexistType == BT_CSR_BC4)
16355                 {
16356                         RTPRINT(FBT, BT_TRACE, ("[BC4]\n"));
16357                         btdm_HIDPANActionBC42Ant(padapter);
16358                 }
16359                 else if (pHalData->bt_coexist.BT_CoexistType == BT_CSR_BC8)
16360                 {
16361                         RTPRINT(FBT, BT_TRACE, ("[BC8]\n"));
16362                         btdm_HIDPANActionBC82Ant(padapter);
16363                 }
16364                 return _TRUE;
16365         }
16366         else
16367         {
16368                 pHalData->bt_coexist.CurrentState &= ~(BT_COEX_STATE_PROFILE_HID|BT_COEX_STATE_PROFILE_PAN);
16369                 return _FALSE;
16370         }
16371
16372 }
16373
16374 void btdm_PANA2DPActionBC42Ant(PADAPTER padapter)
16375 {
16376 //      PMGNT_INFO              pMgntInfo = &padapter->MgntInfo;
16377         struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
16378         PBT30Info               pBTInfo = GET_BT_INFO(padapter);
16379         PBT_MGNT                pBtMgnt = &pBTInfo->BtMgnt;
16380         PHAL_DATA_TYPE  pHalData = GET_HAL_DATA(padapter);
16381
16382         if (pHalData->bt_coexist.PreviousState == pHalData->bt_coexist.CurrentState)
16383                 return;
16384
16385         rtw_write8(padapter, REG_GPIO_MUXCFG, 0x0);
16386         if (pBtMgnt->BtOperationOn)
16387         {
16388                 RTPRINT(FBT, BT_TRACE, ("[BT 3.0]\n"));
16389
16390                 if (pBtMgnt->ExtConfig.bBTBusy)
16391                 {
16392                         RTPRINT(FBT, BT_TRACE, ("BT is non-idle\n"));
16393                         BTDM_FWCoexAllOff(padapter);
16394
16395                         BTDM_AGCTable(padapter, BT_AGCTABLE_OFF);
16396                         BTDM_BBBackOffLevel(padapter, BT_BB_BACKOFF_OFF);
16397                         btdm_DacSwing(padapter, BT_DACSWING_M4);
16398                 }
16399                 else
16400                 {
16401                         RTPRINT(FBT, BT_TRACE, ("BT is idle\n"));
16402                         BTDM_CoexAllOff(padapter);
16403                 }
16404         }
16405         else
16406         {
16407                 RTPRINT(FBT, BT_TRACE, ("[BT 2.1]\n"));
16408                 if (pBtMgnt->ExtConfig.bBTBusy && pmlmepriv->LinkDetectInfo.bBusyTraffic)
16409                 {
16410                         RTPRINT(FBT, BT_TRACE, ("BT is non-idle && Wifi is non-idle!\n"));
16411                         BTDM_Balance(padapter, _TRUE, 0x20, 0x10);
16412                         BTDM_DiminishWiFi(padapter, _TRUE, _FALSE, 0x20, BT_FW_NAV_OFF);
16413                 }
16414                 else
16415                 {
16416                         RTPRINT(FBT, BT_TRACE, ("BT is idle or Wifi is idle!\n"));
16417                         BTDM_Balance(padapter, _FALSE, 0, 0);
16418                         BTDM_DiminishWiFi(padapter, _FALSE, _FALSE, 0x0, BT_FW_NAV_OFF);
16419                 }
16420                 BTDM_SWCoexAllOff(padapter);
16421         }
16422 }
16423
16424 void btdm_PANA2DPActionBC82Ant(PADAPTER padapter)
16425 {
16426 //      PMGNT_INFO              pMgntInfo = &padapter->MgntInfo;
16427         struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
16428         PBT30Info               pBTInfo = GET_BT_INFO(padapter);
16429         PBT_MGNT                pBtMgnt = &pBTInfo->BtMgnt;
16430         PHAL_DATA_TYPE  pHalData = GET_HAL_DATA(padapter);
16431         u8                      btRssiState;
16432
16433         if (!pBtMgnt->BtOperationOn)
16434         {
16435                 RTPRINT(FBT, BT_TRACE, ("[BT 2.1]\n"));
16436
16437                 btRssiState = BTDM_CheckCoexRSSIState(padapter, 2, BT_FW_COEX_THRESH_25, 0);
16438                 if (pHalData->bt_coexist.PreviousState == pHalData->bt_coexist.CurrentState)
16439                         return;
16440
16441                 if ((pBtMgnt->ExtConfig.bBTBusy && pmlmepriv->LinkDetectInfo.bBusyTraffic))
16442                 {
16443                         RTPRINT(FBT, BT_TRACE, ("BT is non-idle && Wifi is non-idle, "));
16444
16445                         // Do the FW mechanism first
16446                         if (pHalData->bt_coexist.BT21TrafficStatistics.bTxBusyTraffic)
16447                         {
16448                                 RTPRINT(FBT, BT_TRACE, ("BT Uplink\n"));
16449                                 BTDM_Balance(padapter, _TRUE, 0x15, 0x20);
16450                         }
16451                         else if (pHalData->bt_coexist.BT21TrafficStatistics.bRxBusyTraffic)
16452                         {
16453                                 RTPRINT(FBT, BT_TRACE, ("BT Downlink\n"));
16454                                 BTDM_Balance(padapter, _TRUE, 0x10, 0x20);
16455                         }
16456                         BTDM_DiminishWiFi(padapter, _TRUE, _FALSE, 0x20, BT_FW_NAV_OFF);
16457
16458                         // Then do the SW mechanism
16459                         if ((btRssiState == BT_RSSI_STATE_HIGH) ||
16460                                 (btRssiState == BT_RSSI_STATE_STAY_HIGH))
16461                         {
16462                                 if (BTDM_IsHT40(padapter))
16463                                 {
16464                                         RTPRINT(FBT, BT_TRACE, ("HT40\n"));
16465                                         BTDM_AGCTable(padapter, BT_AGCTABLE_OFF);
16466                                         BTDM_BBBackOffLevel(padapter, BT_BB_BACKOFF_ON);
16467                                         btdm_DacSwing(padapter, BT_DACSWING_OFF);
16468                                 }
16469                                 else
16470                                 {
16471                                         RTPRINT(FBT, BT_TRACE, ("HT20 or Legacy\n"));
16472                                         BTDM_AGCTable(padapter, BT_AGCTABLE_ON);
16473                                         BTDM_BBBackOffLevel(padapter, BT_BB_BACKOFF_ON);
16474                                         btdm_DacSwing(padapter, BT_DACSWING_OFF);
16475                                 }
16476                         }
16477                         else
16478                         {
16479                                 BTDM_SWCoexAllOff(padapter);
16480                         }
16481                 }
16482                 else
16483                 {
16484                         RTPRINT(FBT, BT_TRACE, ("BT is idle or Wifi is idle!\n"));
16485                         BTDM_CoexAllOff(padapter);
16486                 }
16487         }
16488         else
16489         {
16490                 RTPRINT(FBT, BT_TRACE, ("[BT 3.0]\n"));
16491                 if (pBtMgnt->ExtConfig.bBTBusy)
16492                 {
16493                         RTPRINT(FBT, BT_TRACE, ("BT is non-idle\n"));
16494                         BTDM_FWCoexAllOff(padapter);
16495                         BTDM_AGCTable(padapter, BT_AGCTABLE_OFF);
16496                         BTDM_BBBackOffLevel(padapter, BT_BB_BACKOFF_OFF);
16497                         btdm_DacSwing(padapter, BT_DACSWING_M4);
16498                 }
16499                 else
16500                 {
16501                         RTPRINT(FBT, BT_TRACE, ("BT is idle\n"));
16502                         btdm_DacSwing(padapter, BT_DACSWING_OFF);
16503                 }
16504         }
16505 }
16506
16507 u8 btdm_PANA2DPAction2Ant(PADAPTER padapter)
16508 {
16509         PHAL_DATA_TYPE  pHalData = GET_HAL_DATA(padapter);
16510         PBT30Info               pBTInfo = GET_BT_INFO(padapter);
16511         PBT_DBG                 pBtDbg = &pBTInfo->BtDbg;
16512         u8                      bEnter = _FALSE;
16513
16514         if (pBtDbg->dbgCtrl == _TRUE )
16515         {
16516                 if (pBtDbg->dbgProfile == BT_DBG_PROFILE_PAN_A2DP)
16517                         bEnter = _TRUE;
16518         }
16519         else
16520         {
16521                 if (BTHCI_CheckProfileExist(padapter,BT_PROFILE_PAN) && BTHCI_CheckProfileExist(padapter,BT_PROFILE_A2DP))
16522                         bEnter = _TRUE;
16523         }
16524
16525         if (bEnter)
16526         {
16527                 RTPRINT(FBT, BT_TRACE, ("[DM][BT], btdm_PANA2DPAction2Ant(), "));
16528                 pHalData->bt_coexist.CurrentState |= (BT_COEX_STATE_PROFILE_PAN|BT_COEX_STATE_PROFILE_A2DP);
16529
16530                 if (pHalData->bt_coexist.BT_CoexistType == BT_CSR_BC4)
16531                 {
16532                         RTPRINT(FBT, BT_TRACE, ("[BC4]\n"));
16533                         btdm_PANA2DPActionBC42Ant(padapter);
16534                 }
16535                 else if (pHalData->bt_coexist.BT_CoexistType == BT_CSR_BC8)
16536                 {
16537                         RTPRINT(FBT, BT_TRACE, ("[BC8]\n"));
16538                         btdm_PANA2DPActionBC82Ant(padapter);
16539                 }
16540                 return _TRUE;
16541         }
16542         else
16543         {
16544                 pHalData->bt_coexist.CurrentState &= ~(BT_COEX_STATE_PROFILE_PAN|BT_COEX_STATE_PROFILE_A2DP);
16545                 return _FALSE;
16546         }
16547 }
16548
16549 //============================================================
16550 // extern function start with BTDM_
16551 //============================================================
16552
16553 void BTDM_SwCoexAllOff92C(PADAPTER padapter)
16554 {
16555         BTDM_AGCTable(padapter, BT_AGCTABLE_OFF);
16556         BTDM_BBBackOffLevel(padapter, BT_BB_BACKOFF_OFF);
16557         btdm_DacSwing(padapter, BT_DACSWING_OFF);
16558 }
16559
16560 void BTDM_SwCoexAllOff92D(PADAPTER padapter)
16561 {
16562         BTDM_AGCTable(padapter, BT_AGCTABLE_OFF);
16563         BTDM_BBBackOffLevel(padapter, BT_BB_BACKOFF_OFF);
16564         btdm_DacSwing(padapter, BT_DACSWING_OFF);
16565 }
16566
16567 void
16568 BTDM_DiminishWiFi(
16569         PADAPTER        padapter,
16570         u8                      bDACOn,
16571         u8                      bInterruptOn,
16572         u8                      DACSwingLevel,
16573         u8                      bNAVOn
16574         )
16575 {
16576         PHAL_DATA_TYPE  pHalData = GET_HAL_DATA(padapter);
16577         u8                      H2C_Parameter[3] = {0};
16578
16579         if (pHalData->bt_coexist.BT_Ant_Num != Ant_x2)
16580                 return;
16581
16582         if ((pHalData->bt_coexist.CurrentState & BT_COEX_STATE_BT_RSSI_LOW) &&
16583                 (DACSwingLevel == 0x20))
16584         {
16585                 RTPRINT(FBT, BT_TRACE, ("[BT]DiminishWiFi 0x20 original, but set 0x18 for Low RSSI!\n"));
16586                 DACSwingLevel = 0x18;
16587         }
16588
16589         H2C_Parameter[2] = 0;
16590         H2C_Parameter[1] = DACSwingLevel;
16591         H2C_Parameter[0] = 0;
16592         if (bDACOn)
16593         {
16594                 H2C_Parameter[2] |= 0x01;       //BIT0
16595                 if (bInterruptOn)
16596                 {
16597                         H2C_Parameter[2] |= 0x02;       //BIT1
16598                 }
16599                 pHalData->bt_coexist.bFWCoexistAllOff = _FALSE;
16600         }
16601         if (bNAVOn)
16602         {
16603                 H2C_Parameter[2] |= 0x08;       //BIT3
16604                 pHalData->bt_coexist.bFWCoexistAllOff = _FALSE;
16605         }
16606
16607         RTPRINT(FBT, BT_TRACE, ("[DM][BT], bDACOn = %s, bInterruptOn = %s, write 0xe = 0x%x\n",
16608                 bDACOn?"ON":"OFF", bInterruptOn?"ON":"OFF",
16609                 H2C_Parameter[0]<<16|H2C_Parameter[1]<<8|H2C_Parameter[2]));
16610         RTPRINT(FBT, BT_TRACE, ("[DM][BT], bNAVOn = %s\n",
16611                 bNAVOn?"ON":"OFF"));
16612
16613         if (IS_HARDWARE_TYPE_8192C(padapter))
16614         {
16615                 FillH2CCmd(padapter, 0xe, 3, H2C_Parameter);
16616         }
16617         else if (IS_HARDWARE_TYPE_8192D(padapter))
16618         {
16619                 FillH2CCmd(padapter, 0x12, 3, H2C_Parameter);
16620         }
16621 }
16622
16623 void BTDM_BTCoexistWithProfile2Ant(PADAPTER padapter)
16624 {
16625         PHAL_DATA_TYPE  pHalData = GET_HAL_DATA(padapter);
16626         PBT30Info               pBTInfo = GET_BT_INFO(padapter);
16627         PBT_MGNT                pBtMgnt = &pBTInfo->BtMgnt;
16628
16629         if (pBtMgnt->ExtConfig.bManualControl)
16630                 return;
16631
16632         RTPRINT(FIOCTL, IOCTL_BT_FLAG_MON, ("CurrentBTConnectionCnt=%d, BtOperationOn=%d, bBTConnectInProgress=%d !!\n",
16633                 pBtMgnt->CurrentBTConnectionCnt, pBtMgnt->BtOperationOn, pBtMgnt->bBTConnectInProgress));
16634
16635         if ((pHalData->bt_coexist.BluetoothCoexist) &&
16636                 ((pHalData->bt_coexist.BT_CoexistType == BT_CSR_BC4) ||
16637                 (pHalData->bt_coexist.BT_CoexistType == BT_CSR_BC8)))
16638         {
16639                 BTHCI_GetProfileNameMoto(padapter);
16640                 BTHCI_GetBTRSSI(padapter);
16641                 btdm_CheckBTState2Ant(padapter);
16642                 BTDM_CheckWiFiState(padapter);
16643
16644                 if (btdm_SCOAction2Ant(padapter))
16645                 {
16646                         RTPRINT(FBT, BT_TRACE, ("Action SCO\n"));
16647                 }
16648                 else if (btdm_HIDAction2Ant(padapter))
16649                 {
16650                         RTPRINT(FBT, BT_TRACE, ("Action HID\n"));
16651                 }
16652                 else if (btdm_A2DPAction2Ant(padapter))
16653                 {
16654                         RTPRINT(FBT, BT_TRACE, ("Action A2DP\n"));
16655                 }
16656                 else if (btdm_PANAction2Ant(padapter))
16657                 {
16658                         RTPRINT(FBT, BT_TRACE, ("Action PAN\n"));
16659                 }
16660                 else if (btdm_HIDA2DPAction2Ant(padapter))
16661                 {
16662                         RTPRINT(FBT, BT_TRACE, ("Action HID_A2DP\n"));
16663                 }
16664                 else if (btdm_HIDPANAction2Ant(padapter))
16665                 {
16666                         RTPRINT(FBT, BT_TRACE, ("Action HID_PAN\n"));
16667                 }
16668                 else if (btdm_PANA2DPAction2Ant(padapter))
16669                 {
16670                         RTPRINT(FBT, BT_TRACE, ("Action PAN_A2DP\n"));
16671                 }
16672                 else
16673                 {
16674                         RTPRINT(FBT, BT_TRACE, ("No Action Matched \n"));
16675                 }
16676
16677                 if (pHalData->bt_coexist.PreviousState != pHalData->bt_coexist.CurrentState)
16678                 {
16679                         RTPRINT(FBT, BT_TRACE, ("Coexist State change from 0x%"i64fmt"x to 0x%"i64fmt"x\n",
16680                                 pHalData->bt_coexist.PreviousState,
16681                                 pHalData->bt_coexist.CurrentState));
16682                         pHalData->bt_coexist.PreviousState = pHalData->bt_coexist.CurrentState;
16683
16684                         RTPRINT(FBT, BT_TRACE, ("["));
16685                         if (pHalData->bt_coexist.CurrentState & BT_COEX_STATE_BT30)
16686                                 RTPRINT(FBT, BT_TRACE, ("BT 3.0, "));
16687                         if (pHalData->bt_coexist.CurrentState & BT_COEX_STATE_WIFI_HT20)
16688                                 RTPRINT(FBT, BT_TRACE, ("HT20, "));
16689                         if (pHalData->bt_coexist.CurrentState & BT_COEX_STATE_WIFI_HT40)
16690                                 RTPRINT(FBT, BT_TRACE, ("HT40, "));
16691                         if (pHalData->bt_coexist.CurrentState & BT_COEX_STATE_WIFI_LEGACY)
16692                                 RTPRINT(FBT, BT_TRACE, ("Legacy, "));
16693                         if (pHalData->bt_coexist.CurrentState & BT_COEX_STATE_WIFI_RSSI_LOW)
16694                                 RTPRINT(FBT, BT_TRACE, ("Rssi_Low, "));
16695                         if (pHalData->bt_coexist.CurrentState & BT_COEX_STATE_WIFI_RSSI_MEDIUM)
16696                                 RTPRINT(FBT, BT_TRACE, ("Rssi_Mid, "));
16697                         if (pHalData->bt_coexist.CurrentState & BT_COEX_STATE_WIFI_RSSI_HIGH)
16698                                 RTPRINT(FBT, BT_TRACE, ("Rssi_High, "));
16699                         if (pHalData->bt_coexist.CurrentState & BT_COEX_STATE_WIFI_IDLE)
16700                                 RTPRINT(FBT, BT_TRACE, ("Wifi_Idle, "));
16701                         if (pHalData->bt_coexist.CurrentState & BT_COEX_STATE_WIFI_UPLINK)
16702                                 RTPRINT(FBT, BT_TRACE, ("Wifi_Uplink, "));
16703                         if (pHalData->bt_coexist.CurrentState & BT_COEX_STATE_WIFI_DOWNLINK)
16704                                 RTPRINT(FBT, BT_TRACE, ("Wifi_Downlink, "));
16705                         if (pHalData->bt_coexist.CurrentState & BT_COEX_STATE_BT_IDLE)
16706                                 RTPRINT(FBT, BT_TRACE, ("BT_idle, "));
16707                         if (pHalData->bt_coexist.CurrentState & BT_COEX_STATE_BT_PAN_IDLE)
16708                                 RTPRINT(FBT, BT_TRACE, ("BT_PAN_idle, "));
16709                         if (pHalData->bt_coexist.CurrentState & BT_COEX_STATE_BT_PAN_UPLINK)
16710                                 RTPRINT(FBT, BT_TRACE, ("BT_PAN_uplink, "));
16711                         if (pHalData->bt_coexist.CurrentState & BT_COEX_STATE_BT_PAN_DOWNLINK)
16712                                 RTPRINT(FBT, BT_TRACE, ("BT_PAN_downlink, "));
16713                         if (pHalData->bt_coexist.CurrentState & BT_COEX_STATE_PROFILE_HID)
16714                                 RTPRINT(FBT, BT_TRACE, ("PRO_HID, "));
16715                         if (pHalData->bt_coexist.CurrentState & BT_COEX_STATE_PROFILE_A2DP)
16716                                 RTPRINT(FBT, BT_TRACE, ("PRO_A2DP, "));
16717                         if (pHalData->bt_coexist.CurrentState & BT_COEX_STATE_PROFILE_PAN)
16718                                 RTPRINT(FBT, BT_TRACE, ("PRO_PAN, "));
16719                         if (pHalData->bt_coexist.CurrentState & BT_COEX_STATE_PROFILE_SCO)
16720                                 RTPRINT(FBT, BT_TRACE, ("PRO_SCO, "));
16721                         RTPRINT(FBT, BT_TRACE, ("]\n"));
16722                 }
16723         }
16724 }
16725
16726 // ===== End of sync from SD7 driver HAL/BTCoexist/HalBtcCsr2Ant.c =====
16727 #endif
16728
16729 #ifdef __HALBTCOEXIST_C__ // HAL/BTCoexist/HalBtCoexist.c
16730 // ===== Below this line is sync from SD7 driver HAL/BTCoexist/HalBtCoexist.c =====
16731
16732 //============================================================
16733 // local function
16734 //============================================================
16735 void btdm_BTCoexistWithProfile(PADAPTER padapter)
16736 {
16737         PHAL_DATA_TYPE  pHalData = GET_HAL_DATA(padapter);
16738
16739         if (pHalData->bt_coexist.BT_Ant_Num == Ant_x2)
16740         {
16741                 RTPRINT(FBT, BT_TRACE, ("[DM][BT], 2 Ant mechanism\n"));
16742                 BTDM_BTCoexistWithProfile2Ant(padapter);
16743         }
16744         else
16745         {
16746                 RTPRINT(FBT, BT_TRACE, ("[DM][BT], 1 Ant mechanism\n"));
16747                 BTDM_BTCoexistWithProfile1Ant(padapter);
16748         }
16749 }
16750
16751 void btdm_ResetFWCoexState(PADAPTER padapter)
16752 {
16753         PHAL_DATA_TYPE  pHalData = GET_HAL_DATA(padapter);
16754
16755         pHalData->bt_coexist.CurrentState = 0;
16756         pHalData->bt_coexist.PreviousState = 0;
16757 }
16758
16759 void btdm_InitBtCoexistDM(PADAPTER padapter)
16760 {
16761         PHAL_DATA_TYPE pHalData = GET_HAL_DATA(padapter);
16762
16763         // 20100415 Joseph: Restore RF register 0x1E and 0x1F value for further usage.
16764         if (IS_HARDWARE_TYPE_8723A(padapter))
16765         {
16766                 pHalData->bt_coexist.BtRfRegOrigin1E = PHY_QueryRFReg(padapter, PathA, RF_RCK1, bRFRegOffsetMask);
16767         }
16768         else if (IS_HARDWARE_TYPE_8192D(padapter))
16769         {
16770                 pHalData->bt_coexist.BtRfRegOrigin1E = PHY_QueryRFReg(padapter, PathA, RF_RCK1, bRFRegOffsetMask);
16771         }
16772         else
16773         {
16774                 pHalData->bt_coexist.BtRfRegOrigin1E = PHY_QueryRFReg(padapter, PathA, RF_RCK1, 0xf0);
16775         }
16776         pHalData->bt_coexist.BtRfRegOrigin1F = PHY_QueryRFReg(padapter, PathA, RF_RCK2, 0xf0);
16777
16778         pHalData->bt_coexist.CurrentState = 0;
16779         pHalData->bt_coexist.PreviousState = 0;
16780
16781         BTDM_8723AInit(padapter);
16782         pHalData->bt_coexist.bInitlized = _TRUE;
16783 }
16784
16785 //============================================================
16786 // extern function
16787 //============================================================
16788 void BTDM_CheckAntSelMode(PADAPTER padapter)
16789 {
16790 }
16791
16792 u8 BTDM_NeedToRoamForBtEnableDisable(PADAPTER padapter)
16793 {
16794         return _FALSE;
16795 }
16796
16797 void BTDM_FwC2hBtRssi(PADAPTER padapter, u8 *tmpBuf)
16798 {
16799         if (IS_HARDWARE_TYPE_8723A(padapter))
16800                 BTDM_FwC2hBtRssi8723A(padapter, tmpBuf);
16801 }
16802
16803 void BTDM_FwC2hBtInfo(PADAPTER padapter, u8 *tmpBuf, u8 length)
16804 {
16805         if (IS_HARDWARE_TYPE_8723A(padapter))
16806                 BTDM_FwC2hBtInfo8723A(padapter, tmpBuf, length);
16807 }
16808
16809 void BTDM_DisplayBtCoexInfo(PADAPTER padapter)
16810 {
16811         if (IS_HARDWARE_TYPE_8723A(padapter))
16812                 BTDM_Display8723ABtCoexInfo(padapter);
16813 }
16814
16815 void BTDM_RejectAPAggregatedPacket(PADAPTER padapter, u8 bReject)
16816 {
16817 }
16818
16819 u8 BTDM_IsHT40(PADAPTER padapter)
16820 {
16821         u8 isHT40 = _TRUE;
16822         HT_CHANNEL_WIDTH bw;
16823
16824         bw = padapter->mlmeextpriv.cur_bwmode;
16825
16826         if (bw == HT_CHANNEL_WIDTH_20)
16827         {
16828                 isHT40 = _FALSE;
16829         }
16830         else if (bw == HT_CHANNEL_WIDTH_40)
16831         {
16832                 isHT40 = _TRUE;
16833         }
16834
16835         return isHT40;
16836 }
16837
16838 u8 BTDM_Legacy(PADAPTER padapter)
16839 {
16840         struct mlme_ext_priv *pmlmeext;
16841         u8                      isLegacy = _FALSE;
16842
16843         pmlmeext = &padapter->mlmeextpriv;
16844         if ((pmlmeext->cur_wireless_mode == WIRELESS_11B) ||
16845                 (pmlmeext->cur_wireless_mode == WIRELESS_11G) ||
16846                 (pmlmeext->cur_wireless_mode == WIRELESS_11BG))
16847                 isLegacy = _TRUE;
16848
16849         return isLegacy;
16850 }
16851
16852 void BTDM_CheckWiFiState(PADAPTER padapter)
16853 {
16854         PHAL_DATA_TYPE  pHalData;
16855         struct mlme_priv *pmlmepriv;
16856         PBT30Info               pBTInfo;
16857         PBT_MGNT                pBtMgnt;
16858
16859
16860         pHalData = GET_HAL_DATA(padapter);
16861         pmlmepriv = &padapter->mlmepriv;
16862         pBTInfo = GET_BT_INFO(padapter);
16863         pBtMgnt = &pBTInfo->BtMgnt;
16864
16865         if (pmlmepriv->LinkDetectInfo.bBusyTraffic)
16866         {
16867                 pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_WIFI_IDLE;
16868
16869                 if (pmlmepriv->LinkDetectInfo.bTxBusyTraffic)
16870                 {
16871                         pHalData->bt_coexist.CurrentState |= BT_COEX_STATE_WIFI_UPLINK;
16872                 }
16873                 else
16874                 {
16875                         pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_WIFI_UPLINK;
16876                 }
16877
16878                 if (pmlmepriv->LinkDetectInfo.bRxBusyTraffic)
16879                 {
16880                         pHalData->bt_coexist.CurrentState |= BT_COEX_STATE_WIFI_DOWNLINK;
16881                 }
16882                 else
16883                 {
16884                         pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_WIFI_DOWNLINK;
16885                 }
16886         }
16887         else
16888         {
16889                 pHalData->bt_coexist.CurrentState |= BT_COEX_STATE_WIFI_IDLE;
16890                 pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_WIFI_UPLINK;
16891                 pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_WIFI_DOWNLINK;
16892         }
16893
16894         if (BTDM_Legacy(padapter))
16895         {
16896                 pHalData->bt_coexist.CurrentState |= BT_COEX_STATE_WIFI_LEGACY;
16897                 pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_WIFI_HT20;
16898                 pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_WIFI_HT40;
16899         }
16900         else
16901         {
16902                 pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_WIFI_LEGACY;
16903                 if (BTDM_IsHT40(padapter))
16904                 {
16905                         pHalData->bt_coexist.CurrentState |= BT_COEX_STATE_WIFI_HT40;
16906                         pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_WIFI_HT20;
16907                 }
16908                 else
16909                 {
16910                         pHalData->bt_coexist.CurrentState |= BT_COEX_STATE_WIFI_HT20;
16911                         pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_WIFI_HT40;
16912                 }
16913         }
16914
16915         if (pBtMgnt->BtOperationOn)
16916         {
16917                 pHalData->bt_coexist.CurrentState |= BT_COEX_STATE_BT30;
16918         }
16919         else
16920         {
16921                 pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_BT30;
16922         }
16923 }
16924
16925 s32 BTDM_GetRxSS(PADAPTER padapter)
16926 {
16927 //      PMGNT_INFO              pMgntInfo = &padapter->MgntInfo;
16928         struct mlme_priv *pmlmepriv;
16929         PHAL_DATA_TYPE  pHalData;
16930         s32                     UndecoratedSmoothedPWDB = 0;
16931
16932
16933         pmlmepriv = &padapter->mlmepriv;
16934         pHalData = GET_HAL_DATA(padapter);
16935
16936 //      if (pMgntInfo->bMediaConnect)   // Default port
16937         if (check_fwstate(pmlmepriv, _FW_LINKED) == _TRUE)
16938         {
16939                 UndecoratedSmoothedPWDB = GET_UNDECORATED_AVERAGE_RSSI(padapter);
16940         }
16941         else // associated entry pwdb
16942         {
16943                 UndecoratedSmoothedPWDB = pHalData->dmpriv.EntryMinUndecoratedSmoothedPWDB;
16944                 //pHalData->BT_EntryMinUndecoratedSmoothedPWDB
16945         }
16946         RTPRINT(FBT, BT_TRACE, ("BTDM_GetRxSS() = %d\n", UndecoratedSmoothedPWDB));
16947         return UndecoratedSmoothedPWDB;
16948 }
16949
16950 s32 BTDM_GetRxBeaconSS(PADAPTER padapter)
16951 {
16952 //      PMGNT_INFO              pMgntInfo = &padapter->MgntInfo;
16953         struct mlme_priv *pmlmepriv;
16954         PHAL_DATA_TYPE  pHalData;
16955         s32                     pwdbBeacon = 0;
16956
16957
16958         pmlmepriv = &padapter->mlmepriv;
16959         pHalData = GET_HAL_DATA(padapter);
16960
16961 //      if (pMgntInfo->bMediaConnect)   // Default port
16962         if (check_fwstate(pmlmepriv, _FW_LINKED) == _TRUE)
16963         {
16964                 //pwdbBeacon = pHalData->dmpriv.UndecoratedSmoothedBeacon;
16965                 pwdbBeacon= pHalData->dmpriv.EntryMinUndecoratedSmoothedPWDB;
16966         }
16967         RTPRINT(FBT, BT_TRACE, ("BTDM_GetRxBeaconSS() = %d\n", pwdbBeacon));
16968         return pwdbBeacon;
16969 }
16970
16971 // Get beacon rssi state
16972 u8
16973 BTDM_CheckCoexBcnRssiState(
16974         PADAPTER        padapter,
16975         u8                      levelNum,
16976         u8                      RssiThresh,
16977         u8                      RssiThresh1
16978         )
16979 {
16980         PHAL_DATA_TYPE  pHalData = GET_HAL_DATA(padapter);
16981         s32                     pwdbBeacon = 0;
16982         u8                      bcnRssiState;
16983
16984         pwdbBeacon = BTDM_GetRxBeaconSS(padapter);
16985
16986         if (levelNum == 2)
16987         {
16988                 pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_WIFI_RSSI_BEACON_MEDIUM;
16989
16990                 if ((pHalData->bt_coexist.preRssiStateBeacon == BT_RSSI_STATE_LOW) ||
16991                         (pHalData->bt_coexist.preRssiStateBeacon == BT_RSSI_STATE_STAY_LOW))
16992                 {
16993                         if (pwdbBeacon >= (RssiThresh+BT_FW_COEX_THRESH_TOL))
16994                         {
16995                                 bcnRssiState = BT_RSSI_STATE_HIGH;
16996                                 pHalData->bt_coexist.CurrentState |= BT_COEX_STATE_WIFI_RSSI_BEACON_HIGH;
16997                                 pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_WIFI_RSSI_BEACON_LOW;
16998                                 RTPRINT(FBT, BT_TRACE, ("[DM][BT], RSSI_BEACON state switch to High\n"));
16999                         }
17000                         else
17001                         {
17002                                 bcnRssiState = BT_RSSI_STATE_STAY_LOW;
17003                                 RTPRINT(FBT, BT_TRACE, ("[DM][BT], RSSI_BEACON state stay at Low\n"));
17004                         }
17005                 }
17006                 else
17007                 {
17008                         if (pwdbBeacon < RssiThresh)
17009                         {
17010                                 bcnRssiState = BT_RSSI_STATE_LOW;
17011                                 pHalData->bt_coexist.CurrentState |= BT_COEX_STATE_WIFI_RSSI_BEACON_LOW;
17012                                 pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_WIFI_RSSI_BEACON_HIGH;
17013                                 RTPRINT(FBT, BT_TRACE, ("[DM][BT], RSSI_BEACON state switch to Low\n"));
17014                         }
17015                         else
17016                         {
17017                                 bcnRssiState = BT_RSSI_STATE_STAY_HIGH;
17018                                 RTPRINT(FBT, BT_TRACE, ("[DM][BT], RSSI_BEACON state stay at High\n"));
17019                         }
17020                 }
17021         }
17022         else if (levelNum == 3)
17023         {
17024                 if (RssiThresh > RssiThresh1)
17025                 {
17026                         RTPRINT(FBT, BT_TRACE, ("[DM][BT], RSSI_BEACON thresh error!!\n"));
17027                         return pHalData->bt_coexist.preRssiStateBeacon;
17028                 }
17029
17030                 if ((pHalData->bt_coexist.preRssiStateBeacon == BT_RSSI_STATE_LOW) ||
17031                         (pHalData->bt_coexist.preRssiStateBeacon == BT_RSSI_STATE_STAY_LOW))
17032                 {
17033                         if (pwdbBeacon >= (RssiThresh+BT_FW_COEX_THRESH_TOL))
17034                         {
17035                                 bcnRssiState = BT_RSSI_STATE_MEDIUM;
17036                                 pHalData->bt_coexist.CurrentState |= BT_COEX_STATE_WIFI_RSSI_BEACON_MEDIUM;
17037                                 pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_WIFI_RSSI_BEACON_LOW;
17038                                 pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_WIFI_RSSI_BEACON_HIGH;
17039                                 RTPRINT(FBT, BT_TRACE, ("[DM][BT], RSSI_BEACON state switch to Medium\n"));
17040                         }
17041                         else
17042                         {
17043                                 bcnRssiState = BT_RSSI_STATE_STAY_LOW;
17044                                 RTPRINT(FBT, BT_TRACE, ("[DM][BT], RSSI_BEACON state stay at Low\n"));
17045                         }
17046                 }
17047                 else if ((pHalData->bt_coexist.preRssiStateBeacon == BT_RSSI_STATE_MEDIUM) ||
17048                         (pHalData->bt_coexist.preRssiStateBeacon == BT_RSSI_STATE_STAY_MEDIUM))
17049                 {
17050                         if (pwdbBeacon >= (RssiThresh1+BT_FW_COEX_THRESH_TOL))
17051                         {
17052                                 bcnRssiState = BT_RSSI_STATE_HIGH;
17053                                 pHalData->bt_coexist.CurrentState |= BT_COEX_STATE_WIFI_RSSI_BEACON_HIGH;
17054                                 pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_WIFI_RSSI_BEACON_LOW;
17055                                 pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_WIFI_RSSI_BEACON_MEDIUM;
17056                                 RTPRINT(FBT, BT_TRACE, ("[DM][BT], RSSI_BEACON state switch to High\n"));
17057                         }
17058                         else if (pwdbBeacon < RssiThresh)
17059                         {
17060                                 bcnRssiState = BT_RSSI_STATE_LOW;
17061                                 pHalData->bt_coexist.CurrentState |= BT_COEX_STATE_WIFI_RSSI_BEACON_LOW;
17062                                 pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_WIFI_RSSI_BEACON_HIGH;
17063                                 pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_WIFI_RSSI_BEACON_MEDIUM;
17064                                 RTPRINT(FBT, BT_TRACE, ("[DM][BT], RSSI_BEACON state switch to Low\n"));
17065                         }
17066                         else
17067                         {
17068                                 bcnRssiState = BT_RSSI_STATE_STAY_MEDIUM;
17069                                 RTPRINT(FBT, BT_TRACE, ("[DM][BT], RSSI_BEACON state stay at Medium\n"));
17070                         }
17071                 }
17072                 else
17073                 {
17074                         if (pwdbBeacon < RssiThresh1)
17075                         {
17076                                 bcnRssiState = BT_RSSI_STATE_MEDIUM;
17077                                 pHalData->bt_coexist.CurrentState |= BT_COEX_STATE_WIFI_RSSI_BEACON_MEDIUM;
17078                                 pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_WIFI_RSSI_BEACON_HIGH;
17079                                 pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_WIFI_RSSI_BEACON_LOW;
17080                                 RTPRINT(FBT, BT_TRACE, ("[DM][BT], RSSI_BEACON state switch to Medium\n"));
17081                         }
17082                         else
17083                         {
17084                                 bcnRssiState = BT_RSSI_STATE_STAY_HIGH;
17085                                 RTPRINT(FBT, BT_TRACE, ("[DM][BT], RSSI_BEACON state stay at High\n"));
17086                         }
17087                 }
17088         }
17089
17090         pHalData->bt_coexist.preRssiStateBeacon = bcnRssiState;
17091
17092         return bcnRssiState;
17093 }
17094
17095 u8
17096 BTDM_CheckCoexRSSIState1(
17097         PADAPTER        padapter,
17098         u8                      levelNum,
17099         u8                      RssiThresh,
17100         u8                      RssiThresh1
17101         )
17102 {
17103         PHAL_DATA_TYPE  pHalData = GET_HAL_DATA(padapter);
17104         s32                     UndecoratedSmoothedPWDB = 0;
17105         u8                      btRssiState;
17106
17107         UndecoratedSmoothedPWDB = BTDM_GetRxSS(padapter);
17108
17109         if (levelNum == 2)
17110         {
17111                 pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_WIFI_RSSI_1_MEDIUM;
17112
17113                 if ((pHalData->bt_coexist.preRssiState1 == BT_RSSI_STATE_LOW) ||
17114                         (pHalData->bt_coexist.preRssiState1 == BT_RSSI_STATE_STAY_LOW))
17115                 {
17116                         if (UndecoratedSmoothedPWDB >= (RssiThresh+BT_FW_COEX_THRESH_TOL))
17117                         {
17118                                 btRssiState = BT_RSSI_STATE_HIGH;
17119                                 pHalData->bt_coexist.CurrentState |= BT_COEX_STATE_WIFI_RSSI_1_HIGH;
17120                                 pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_WIFI_RSSI_1_LOW;
17121                                 RTPRINT(FBT, BT_TRACE, ("[DM][BT], RSSI_1 state switch to High\n"));
17122                         }
17123                         else
17124                         {
17125                                 btRssiState = BT_RSSI_STATE_STAY_LOW;
17126                                 RTPRINT(FBT, BT_TRACE, ("[DM][BT], RSSI_1 state stay at Low\n"));
17127                         }
17128                 }
17129                 else
17130                 {
17131                         if (UndecoratedSmoothedPWDB < RssiThresh)
17132                         {
17133                                 btRssiState = BT_RSSI_STATE_LOW;
17134                                 pHalData->bt_coexist.CurrentState |= BT_COEX_STATE_WIFI_RSSI_1_LOW;
17135                                 pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_WIFI_RSSI_1_HIGH;
17136                                 RTPRINT(FBT, BT_TRACE, ("[DM][BT], RSSI_1 state switch to Low\n"));
17137                         }
17138                         else
17139                         {
17140                                 btRssiState = BT_RSSI_STATE_STAY_HIGH;
17141                                 RTPRINT(FBT, BT_TRACE, ("[DM][BT], RSSI_1 state stay at High\n"));
17142                         }
17143                 }
17144         }
17145         else if (levelNum == 3)
17146         {
17147                 if (RssiThresh > RssiThresh1)
17148                 {
17149                         RTPRINT(FBT, BT_TRACE, ("[DM][BT], RSSI_1 thresh error!!\n"));
17150                         return pHalData->bt_coexist.preRssiState1;
17151                 }
17152
17153                 if ((pHalData->bt_coexist.preRssiState1 == BT_RSSI_STATE_LOW) ||
17154                         (pHalData->bt_coexist.preRssiState1 == BT_RSSI_STATE_STAY_LOW))
17155                 {
17156                         if (UndecoratedSmoothedPWDB >= (RssiThresh+BT_FW_COEX_THRESH_TOL))
17157                         {
17158                                 btRssiState = BT_RSSI_STATE_MEDIUM;
17159                                 pHalData->bt_coexist.CurrentState |= BT_COEX_STATE_WIFI_RSSI_1_MEDIUM;
17160                                 pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_WIFI_RSSI_1_LOW;
17161                                 pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_WIFI_RSSI_1_HIGH;
17162                                 RTPRINT(FBT, BT_TRACE, ("[DM][BT], RSSI_1 state switch to Medium\n"));
17163                         }
17164                         else
17165                         {
17166                                 btRssiState = BT_RSSI_STATE_STAY_LOW;
17167                                 RTPRINT(FBT, BT_TRACE, ("[DM][BT], RSSI_1 state stay at Low\n"));
17168                         }
17169                 }
17170                 else if ((pHalData->bt_coexist.preRssiState1 == BT_RSSI_STATE_MEDIUM) ||
17171                         (pHalData->bt_coexist.preRssiState1 == BT_RSSI_STATE_STAY_MEDIUM))
17172                 {
17173                         if (UndecoratedSmoothedPWDB >= (RssiThresh1+BT_FW_COEX_THRESH_TOL))
17174                         {
17175                                 btRssiState = BT_RSSI_STATE_HIGH;
17176                                 pHalData->bt_coexist.CurrentState |= BT_COEX_STATE_WIFI_RSSI_1_HIGH;
17177                                 pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_WIFI_RSSI_1_LOW;
17178                                 pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_WIFI_RSSI_1_MEDIUM;
17179                                 RTPRINT(FBT, BT_TRACE, ("[DM][BT], RSSI_1 state switch to High\n"));
17180                         }
17181                         else if (UndecoratedSmoothedPWDB < RssiThresh)
17182                         {
17183                                 btRssiState = BT_RSSI_STATE_LOW;
17184                                 pHalData->bt_coexist.CurrentState |= BT_COEX_STATE_WIFI_RSSI_1_LOW;
17185                                 pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_WIFI_RSSI_1_HIGH;
17186                                 pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_WIFI_RSSI_1_MEDIUM;
17187                                 RTPRINT(FBT, BT_TRACE, ("[DM][BT], RSSI_1 state switch to Low\n"));
17188                         }
17189                         else
17190                         {
17191                                 btRssiState = BT_RSSI_STATE_STAY_MEDIUM;
17192                                 RTPRINT(FBT, BT_TRACE, ("[DM][BT], RSSI_1 state stay at Medium\n"));
17193                         }
17194                 }
17195                 else
17196                 {
17197                         if (UndecoratedSmoothedPWDB < RssiThresh1)
17198                         {
17199                                 btRssiState = BT_RSSI_STATE_MEDIUM;
17200                                 pHalData->bt_coexist.CurrentState |= BT_COEX_STATE_WIFI_RSSI_1_MEDIUM;
17201                                 pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_WIFI_RSSI_1_HIGH;
17202                                 pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_WIFI_RSSI_1_LOW;
17203                                 RTPRINT(FBT, BT_TRACE, ("[DM][BT], RSSI_1 state switch to Medium\n"));
17204                         }
17205                         else
17206                         {
17207                                 btRssiState = BT_RSSI_STATE_STAY_HIGH;
17208                                 RTPRINT(FBT, BT_TRACE, ("[DM][BT], RSSI_1 state stay at High\n"));
17209                         }
17210                 }
17211         }
17212
17213         pHalData->bt_coexist.preRssiState1 = btRssiState;
17214
17215         return btRssiState;
17216 }
17217
17218 u8
17219 BTDM_CheckCoexRSSIState(
17220         PADAPTER        padapter,
17221         u8                      levelNum,
17222         u8                      RssiThresh,
17223         u8                      RssiThresh1
17224         )
17225 {
17226         PHAL_DATA_TYPE  pHalData = GET_HAL_DATA(padapter);
17227         s32                     UndecoratedSmoothedPWDB = 0;
17228         u8                      btRssiState;
17229
17230         UndecoratedSmoothedPWDB = BTDM_GetRxSS(padapter);
17231
17232         if (levelNum == 2)
17233         {
17234                 pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_WIFI_RSSI_MEDIUM;
17235
17236                 if ((pHalData->bt_coexist.preRssiState == BT_RSSI_STATE_LOW) ||
17237                         (pHalData->bt_coexist.preRssiState == BT_RSSI_STATE_STAY_LOW))
17238                 {
17239                         if (UndecoratedSmoothedPWDB >= (RssiThresh+BT_FW_COEX_THRESH_TOL))
17240                         {
17241                                 btRssiState = BT_RSSI_STATE_HIGH;
17242                                 pHalData->bt_coexist.CurrentState |= BT_COEX_STATE_WIFI_RSSI_HIGH;
17243                                 pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_WIFI_RSSI_LOW;
17244                                 RTPRINT(FBT, BT_TRACE, ("[DM][BT], RSSI state switch to High\n"));
17245                         }
17246                         else
17247                         {
17248                                 btRssiState = BT_RSSI_STATE_STAY_LOW;
17249                                 RTPRINT(FBT, BT_TRACE, ("[DM][BT], RSSI state stay at Low\n"));
17250                         }
17251                 }
17252                 else
17253                 {
17254                         if (UndecoratedSmoothedPWDB < RssiThresh)
17255                         {
17256                                 btRssiState = BT_RSSI_STATE_LOW;
17257                                 pHalData->bt_coexist.CurrentState |= BT_COEX_STATE_WIFI_RSSI_LOW;
17258                                 pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_WIFI_RSSI_HIGH;
17259                                 RTPRINT(FBT, BT_TRACE, ("[DM][BT], RSSI state switch to Low\n"));
17260                         }
17261                         else
17262                         {
17263                                 btRssiState = BT_RSSI_STATE_STAY_HIGH;
17264                                 RTPRINT(FBT, BT_TRACE, ("[DM][BT], RSSI state stay at High\n"));
17265                         }
17266                 }
17267         }
17268         else if (levelNum == 3)
17269         {
17270                 if (RssiThresh > RssiThresh1)
17271                 {
17272                         RTPRINT(FBT, BT_TRACE, ("[DM][BT], RSSI thresh error!!\n"));
17273                         return pHalData->bt_coexist.preRssiState;
17274                 }
17275
17276                 if ((pHalData->bt_coexist.preRssiState == BT_RSSI_STATE_LOW) ||
17277                         (pHalData->bt_coexist.preRssiState == BT_RSSI_STATE_STAY_LOW))
17278                 {
17279                         if (UndecoratedSmoothedPWDB >= (RssiThresh+BT_FW_COEX_THRESH_TOL))
17280                         {
17281                                 btRssiState = BT_RSSI_STATE_MEDIUM;
17282                                 pHalData->bt_coexist.CurrentState |= BT_COEX_STATE_WIFI_RSSI_MEDIUM;
17283                                 pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_WIFI_RSSI_LOW;
17284                                 pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_WIFI_RSSI_HIGH;
17285                                 RTPRINT(FBT, BT_TRACE, ("[DM][BT], RSSI state switch to Medium\n"));
17286                         }
17287                         else
17288                         {
17289                                 btRssiState = BT_RSSI_STATE_STAY_LOW;
17290                                 RTPRINT(FBT, BT_TRACE, ("[DM][BT], RSSI state stay at Low\n"));
17291                         }
17292                 }
17293                 else if ((pHalData->bt_coexist.preRssiState == BT_RSSI_STATE_MEDIUM) ||
17294                         (pHalData->bt_coexist.preRssiState == BT_RSSI_STATE_STAY_MEDIUM))
17295                 {
17296                         if (UndecoratedSmoothedPWDB >= (RssiThresh1+BT_FW_COEX_THRESH_TOL))
17297                         {
17298                                 btRssiState = BT_RSSI_STATE_HIGH;
17299                                 pHalData->bt_coexist.CurrentState |= BT_COEX_STATE_WIFI_RSSI_HIGH;
17300                                 pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_WIFI_RSSI_LOW;
17301                                 pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_WIFI_RSSI_MEDIUM;
17302                                 RTPRINT(FBT, BT_TRACE, ("[DM][BT], RSSI state switch to High\n"));
17303                         }
17304                         else if (UndecoratedSmoothedPWDB < RssiThresh)
17305                         {
17306                                 btRssiState = BT_RSSI_STATE_LOW;
17307                                 pHalData->bt_coexist.CurrentState |= BT_COEX_STATE_WIFI_RSSI_LOW;
17308                                 pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_WIFI_RSSI_HIGH;
17309                                 pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_WIFI_RSSI_MEDIUM;
17310                         RTPRINT(FBT, BT_TRACE, ("[DM][BT], RSSI state switch to Low\n"));
17311                         }
17312                         else
17313                         {
17314                                 btRssiState = BT_RSSI_STATE_STAY_MEDIUM;
17315                                 RTPRINT(FBT, BT_TRACE, ("[DM][BT], RSSI state stay at Medium\n"));
17316                         }
17317                 }
17318                 else
17319                 {
17320                         if (UndecoratedSmoothedPWDB < RssiThresh1)
17321                         {
17322                                 btRssiState = BT_RSSI_STATE_MEDIUM;
17323                                 pHalData->bt_coexist.CurrentState |= BT_COEX_STATE_WIFI_RSSI_MEDIUM;
17324                                 pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_WIFI_RSSI_HIGH;
17325                                 pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_WIFI_RSSI_LOW;
17326                                 RTPRINT(FBT, BT_TRACE, ("[DM][BT], RSSI state switch to Medium\n"));
17327                         }
17328                         else
17329                         {
17330                                 btRssiState = BT_RSSI_STATE_STAY_HIGH;
17331                                 RTPRINT(FBT, BT_TRACE, ("[DM][BT], RSSI state stay at High\n"));
17332                         }
17333                 }
17334         }
17335
17336         pHalData->bt_coexist.preRssiState = btRssiState;
17337
17338         return btRssiState;
17339 }
17340
17341 u8 BTDM_DisableEDCATurbo(PADAPTER padapter)
17342 {
17343 //      PMGNT_INFO              pMgntInfo = &padapter->MgntInfo;
17344         PBT_MGNT                pBtMgnt;
17345         PHAL_DATA_TYPE  pHalData;
17346         u8                      bBtChangeEDCA = _FALSE;
17347         u32                     EDCA_BT_BE = 0x5ea42b, cur_EDCA_reg;
17348         u16                     aggr_num;
17349         u8                      bRet = _FALSE;
17350
17351
17352         pHalData = GET_HAL_DATA(padapter);
17353         pBtMgnt = &pHalData->BtInfo.BtMgnt;
17354
17355         if (!pHalData->bt_coexist.BluetoothCoexist)
17356         {
17357                 bRet = _FALSE;
17358                 pHalData->bt_coexist.lastBtEdca = 0;
17359                 return bRet;
17360         }
17361         if (!((pBtMgnt->bSupportProfile) ||
17362                 (pHalData->bt_coexist.BT_CoexistType == BT_CSR_BC8)))
17363         {
17364                 bRet = _FALSE;
17365                 pHalData->bt_coexist.lastBtEdca = 0;
17366                 return bRet;
17367         }
17368
17369         if (BT_1Ant(padapter))
17370         {
17371                 bRet = _FALSE;
17372                 pHalData->bt_coexist.lastBtEdca = 0;
17373                 return bRet;
17374         }
17375
17376         if (pHalData->bt_coexist.exec_cnt < 3)
17377                 pHalData->bt_coexist.exec_cnt++;
17378         else
17379                 pHalData->bt_coexist.bEDCAInitialized = _TRUE;
17380
17381         // When BT is non idle
17382         if (!(pHalData->bt_coexist.CurrentState & BT_COEX_STATE_BT_IDLE))
17383         {
17384                 RTPRINT(FBT, BT_TRACE, ("BT state non idle, set bt EDCA\n"));
17385
17386                 //aggr_num = 0x0909;
17387                 if (pHalData->odmpriv.DM_EDCA_Table.bCurrentTurboEDCA == _TRUE)
17388                 {
17389                         bBtChangeEDCA = _TRUE;
17390                         pHalData->odmpriv.DM_EDCA_Table.bCurrentTurboEDCA = _FALSE;
17391 //                      pHalData->bIsCurRDLState = _FALSE;
17392                         pHalData->dmpriv.prv_traffic_idx = 3;
17393                 }
17394                 cur_EDCA_reg = rtw_read32(padapter, REG_EDCA_BE_PARAM);
17395
17396                 if (cur_EDCA_reg != EDCA_BT_BE)
17397                 {
17398                         bBtChangeEDCA = _TRUE;
17399                 }
17400                 if (bBtChangeEDCA || !pHalData->bt_coexist.bEDCAInitialized)
17401                 {
17402                         rtw_write32(padapter, REG_EDCA_BE_PARAM, EDCA_BT_BE);
17403                         pHalData->bt_coexist.lastBtEdca = EDCA_BT_BE;
17404                 }
17405                 bRet = _TRUE;
17406         }
17407         else
17408         {
17409                 RTPRINT(FBT, BT_TRACE, ("BT state idle, set original EDCA\n"));
17410                 pHalData->bt_coexist.lastBtEdca = 0;
17411                 bRet = _FALSE;
17412         }
17413
17414 #ifdef CONFIG_PCI_HCI
17415         if (IS_HARDWARE_TYPE_8192C(padapter))
17416         {
17417                 // When BT is non idle
17418                 if (!(pHalData->bt_coexist.CurrentState & BT_COEX_STATE_BT_IDLE))
17419                 {
17420                         aggr_num = 0x0909;
17421                 }
17422                 else
17423                 {
17424                         aggr_num = 0x0A0A;
17425                 }
17426
17427                 if ((pHalData->bt_coexist.last_aggr_num != aggr_num) || !pHalData->bt_coexist.bEDCAInitialized)
17428                 {
17429                         RTPRINT(FBT, BT_TRACE, ("BT write AGGR NUM = 0x%x\n", aggr_num));
17430                         rtw_write16(padapter, REG_MAX_AGGR_NUM, aggr_num);
17431                         pHalData->bt_coexist.last_aggr_num = aggr_num;
17432                 }
17433         }
17434 #endif
17435
17436         return bRet;
17437 }
17438
17439 void
17440 BTDM_Balance(
17441         PADAPTER        padapter,
17442         u8                      bBalanceOn,
17443         u8                      ms0,
17444         u8                      ms1
17445         )
17446 {
17447         PHAL_DATA_TYPE  pHalData = GET_HAL_DATA(padapter);
17448         u8      H2C_Parameter[3] = {0};
17449
17450         if (bBalanceOn)
17451         {
17452                 H2C_Parameter[2] = 1;
17453                 H2C_Parameter[1] = ms1;
17454                 H2C_Parameter[0] = ms0;
17455                 pHalData->bt_coexist.bFWCoexistAllOff = _FALSE;
17456         }
17457         else
17458         {
17459                 H2C_Parameter[2] = 0;
17460                 H2C_Parameter[1] = 0;
17461                 H2C_Parameter[0] = 0;
17462         }
17463         pHalData->bt_coexist.bBalanceOn = bBalanceOn;
17464
17465         RTPRINT(FBT, BT_TRACE, ("[DM][BT], Balance=[%s:%dms:%dms], write 0xc=0x%x\n",
17466                 bBalanceOn?"ON":"OFF", ms0, ms1,
17467                 H2C_Parameter[0]<<16|H2C_Parameter[1]<<8|H2C_Parameter[2]));
17468
17469         FillH2CCmd(padapter, 0xc, 3, H2C_Parameter);
17470 }
17471
17472 void BTDM_AGCTable(PADAPTER padapter, u8 type)
17473 {
17474         PHAL_DATA_TYPE pHalData = GET_HAL_DATA(padapter);
17475         if (type == BT_AGCTABLE_OFF)
17476         {
17477                 RTPRINT(FBT, BT_TRACE, ("[BT]AGCTable Off!\n"));
17478                 rtw_write32(padapter, 0xc78,0x641c0001);
17479                 rtw_write32(padapter, 0xc78,0x631d0001);
17480                 rtw_write32(padapter, 0xc78,0x621e0001);
17481                 rtw_write32(padapter, 0xc78,0x611f0001);
17482                 rtw_write32(padapter, 0xc78,0x60200001);
17483
17484                 PHY_SetRFReg(padapter, PathA, RF_RX_AGC_HP, bRFRegOffsetMask, 0x32000);
17485                 PHY_SetRFReg(padapter, PathA, RF_RX_AGC_HP, bRFRegOffsetMask, 0x71000);
17486                 PHY_SetRFReg(padapter, PathA, RF_RX_AGC_HP, bRFRegOffsetMask, 0xb0000);
17487                 PHY_SetRFReg(padapter, PathA, RF_RX_AGC_HP, bRFRegOffsetMask, 0xfc000);
17488                 if (IS_HARDWARE_TYPE_8723A(padapter))
17489                         PHY_SetRFReg(padapter, PathA, RF_RX_G1, bRFRegOffsetMask, 0x30355);
17490                 else
17491                         PHY_SetRFReg(padapter, PathA, RF_RX_G1, bRFRegOffsetMask, 0x10255);
17492
17493                 if (IS_HARDWARE_TYPE_8723A(padapter))
17494                         pHalData->bt_coexist.b8723aAgcTableOn = _FALSE;
17495         }
17496         else if (type == BT_AGCTABLE_ON)
17497         {
17498                 RTPRINT(FBT, BT_TRACE, ("[BT]AGCTable On!\n"));
17499                 rtw_write32(padapter, 0xc78,0x4e1c0001);
17500                 rtw_write32(padapter, 0xc78,0x4d1d0001);
17501                 rtw_write32(padapter, 0xc78,0x4c1e0001);
17502                 rtw_write32(padapter, 0xc78,0x4b1f0001);
17503                 rtw_write32(padapter, 0xc78,0x4a200001);
17504
17505                 PHY_SetRFReg(padapter, PathA, RF_RX_AGC_HP, bRFRegOffsetMask, 0xdc000);
17506                 PHY_SetRFReg(padapter, PathA, RF_RX_AGC_HP, bRFRegOffsetMask, 0x90000);
17507                 PHY_SetRFReg(padapter, PathA, RF_RX_AGC_HP, bRFRegOffsetMask, 0x51000);
17508                 PHY_SetRFReg(padapter, PathA, RF_RX_AGC_HP, bRFRegOffsetMask, 0x12000);
17509                 if (IS_HARDWARE_TYPE_8723A(padapter))
17510                         PHY_SetRFReg(padapter, PathA, RF_RX_G1, bRFRegOffsetMask, 0x00355);
17511                 else
17512                         PHY_SetRFReg(padapter, PathA, RF_RX_G1, bRFRegOffsetMask, 0x00255);
17513
17514                 if (IS_HARDWARE_TYPE_8723A(padapter))
17515                         pHalData->bt_coexist.b8723aAgcTableOn = _TRUE;
17516
17517                 pHalData->bt_coexist.bSWCoexistAllOff = _FALSE;
17518         }
17519 }
17520
17521 void BTDM_BBBackOffLevel(PADAPTER padapter, u8 type)
17522 {
17523         PHAL_DATA_TYPE  pHalData = GET_HAL_DATA(padapter);
17524
17525         if (type == BT_BB_BACKOFF_OFF)
17526         {
17527                 RTPRINT(FBT, BT_TRACE, ("[BT]BBBackOffLevel Off!\n"));
17528                 rtw_write32(padapter, 0xc04,0x3a05611);
17529         }
17530         else if (type == BT_BB_BACKOFF_ON)
17531         {
17532                 RTPRINT(FBT, BT_TRACE, ("[BT]BBBackOffLevel On!\n"));
17533                 rtw_write32(padapter, 0xc04,0x3a07611);
17534                 pHalData->bt_coexist.bSWCoexistAllOff = _FALSE;
17535         }
17536 }
17537
17538 void BTDM_FWCoexAllOff(PADAPTER padapter)
17539 {
17540         PBT30Info               pBTInfo = GET_BT_INFO(padapter);
17541         PBT_MGNT                pBtMgnt = &pBTInfo->BtMgnt;
17542         PHAL_DATA_TYPE  pHalData = GET_HAL_DATA(padapter);;
17543
17544
17545         RTPRINT(FBT, BT_TRACE, ("BTDM_FWCoexAllOff()\n"));
17546         if (pHalData->bt_coexist.bFWCoexistAllOff)
17547                 return;
17548         RTPRINT(FBT, BT_TRACE, ("BTDM_FWCoexAllOff(), real Do\n"));
17549
17550         BTDM_FWCoexAllOff8723A(padapter);
17551
17552         pHalData->bt_coexist.bFWCoexistAllOff = _TRUE;
17553 }
17554
17555 void BTDM_SWCoexAllOff(PADAPTER padapter)
17556 {
17557         PBT30Info               pBTInfo = GET_BT_INFO(padapter);
17558         PBT_MGNT                pBtMgnt = &pBTInfo->BtMgnt;
17559         PHAL_DATA_TYPE  pHalData = GET_HAL_DATA(padapter);;
17560
17561
17562         RTPRINT(FBT, BT_TRACE, ("BTDM_SWCoexAllOff()\n"));
17563         if (pHalData->bt_coexist.bSWCoexistAllOff)
17564                 return;
17565         RTPRINT(FBT, BT_TRACE, ("BTDM_SWCoexAllOff(), real Do\n"));
17566         BTDM_SWCoexAllOff8723A(padapter);
17567
17568         pHalData->bt_coexist.bSWCoexistAllOff = _TRUE;
17569 }
17570
17571 void BTDM_HWCoexAllOff(PADAPTER padapter)
17572 {
17573         PBT30Info               pBTInfo = GET_BT_INFO(padapter);
17574         PBT_MGNT                pBtMgnt = &pBTInfo->BtMgnt;
17575         PHAL_DATA_TYPE  pHalData = GET_HAL_DATA(padapter);;
17576
17577
17578         RTPRINT(FBT, BT_TRACE, ("BTDM_HWCoexAllOff()\n"));
17579         if (pHalData->bt_coexist.bHWCoexistAllOff)
17580                 return;
17581         RTPRINT(FBT, BT_TRACE, ("BTDM_HWCoexAllOff(), real Do\n"));
17582
17583         if (IS_HARDWARE_TYPE_8723A(padapter))
17584         {
17585                 BTDM_HWCoexAllOff8723A(padapter);
17586         }
17587
17588         pHalData->bt_coexist.bHWCoexistAllOff = _TRUE;
17589 }
17590
17591 void BTDM_CoexAllOff(PADAPTER padapter)
17592 {
17593         BTDM_FWCoexAllOff(padapter);
17594         BTDM_SWCoexAllOff(padapter);
17595         BTDM_HWCoexAllOff(padapter);
17596 }
17597
17598 void BTDM_TurnOffBtCoexistBeforeEnterLPS(PADAPTER padapter)
17599 {
17600         PBT30Info               pBTInfo = GET_BT_INFO(padapter);
17601         PBT_MGNT                pBtMgnt = &pBTInfo->BtMgnt;
17602         PHAL_DATA_TYPE  pHalData = GET_HAL_DATA(padapter);
17603         struct pwrctrl_priv *ppwrctrl = &padapter->pwrctrlpriv;
17604
17605
17606         // Add temporarily.
17607         if ((!pHalData->bt_coexist.BluetoothCoexist) ||(!pBtMgnt->bSupportProfile))
17608                 return;
17609
17610         // 8723 1Ant doesn't need to turn off bt coexist mechanism.
17611         if (BTDM_1Ant8723A(padapter))
17612                 return;
17613
17614         if (IS_HARDWARE_TYPE_8192C(padapter) ||
17615                 IS_HARDWARE_TYPE_8192D(padapter) ||
17616                 IS_HARDWARE_TYPE_8723A(padapter))
17617         {
17618                 //
17619                 // Before enter LPS, turn off FW BT Co-exist mechanism
17620                 //
17621                 if (ppwrctrl->bLeisurePs)
17622                 {
17623                         RTPRINT(FBT, BT_TRACE, ("[BT][DM], Before enter LPS, turn off all Coexist DM\n"));
17624                         btdm_ResetFWCoexState(padapter);
17625                         BTDM_CoexAllOff(padapter);
17626                         BTDM_SetAntenna(padapter, BTDM_ANT_BT);
17627                 }
17628         }
17629 }
17630
17631 void BTDM_TurnOffBtCoexistBeforeEnterIPS(PADAPTER padapter)
17632 {
17633 //      PMGNT_INFO              pMgntInfo = &padapter->MgntInfo;
17634         PBT30Info               pBTInfo = GET_BT_INFO(padapter);
17635         PBT_MGNT                pBtMgnt = &pBTInfo->BtMgnt;
17636         PHAL_DATA_TYPE  pHalData = GET_HAL_DATA(padapter);
17637 //      PRT_POWER_SAVE_CONTROL  pPSC = GET_POWER_SAVE_CONTROL(pMgntInfo);
17638         struct pwrctrl_priv *ppwrctrl = &padapter->pwrctrlpriv;
17639
17640         if (!pHalData->bt_coexist.BluetoothCoexist)
17641                 return;
17642
17643         // 8723 1Ant doesn't need to turn off bt coexist mechanism.
17644         if (BTDM_1Ant8723A(padapter))
17645                 return;
17646
17647         if (IS_HARDWARE_TYPE_8192C(padapter) ||
17648                 IS_HARDWARE_TYPE_8192D(padapter) ||
17649                 IS_HARDWARE_TYPE_8723A(padapter))
17650         {
17651                 //
17652                 // Before enter IPS, turn off FW BT Co-exist mechanism
17653                 //
17654 //              if (pPSC->bInactivePs)
17655                 if (ppwrctrl->reg_rfoff == rf_on)
17656                 {
17657                         RTPRINT(FBT, BT_TRACE, ("[BT][DM], Before enter IPS, turn off all Coexist DM\n"));
17658                         btdm_ResetFWCoexState(padapter);
17659                         BTDM_CoexAllOff(padapter);
17660                         BTDM_SetAntenna(padapter, BTDM_ANT_BT);
17661                 }
17662         }
17663 }
17664
17665 void BTDM_SignalCompensation(PADAPTER padapter, u8 *rssi_wifi, u8 *rssi_bt)
17666 {
17667         if (IS_HARDWARE_TYPE_8723A(padapter))
17668         {
17669                 BTDM_8723ASignalCompensation(padapter, rssi_wifi, rssi_bt);
17670         }
17671 }
17672 #if defined(CONFIG_CHECK_BT_HANG) && defined(CONFIG_BT_COEXIST)
17673 /*
17674 0. write 0xa3 = 0x05
17675
17676 1. 0xa0 == 0x04
17677         write 0xF6?1:0] = 0x01
17678         write 0x3A[7:0] = 0x31
17679
17680 2. read 0xC0[31:0] == 0
17681         write 0xcc{2]= 1
17682
17683 3. read X=0x6b[4]
17684         if X== 1
17685         {
17686                 write 0x6b[4] = 0
17687                 write 0xcc{2]= 0
17688         }
17689         else if X == 0
17690         {
17691                 write 0x6b[4] = 1
17692                 write 0xcc{2]= 0
17693         }
17694
17695 */
17696 void dm_CheckBTState(_adapter *pAdapter)
17697 {
17698         u8 value=0,regValue8=0;
17699         u32 regvalue32=0;
17700         //_adapter *pAdapter = (_adapter*)context;
17701
17702 //      if (pAdapter->drv_in_test == CMCC_TEST)
17703 //              return;
17704
17705         rtw_write8(pAdapter, 0xa3, 5);
17706
17707         //DBG_8723A("------>%s,get 0xa3=%0x\n",__func__,rtw_read8(pAdapter, 0xa3));
17708
17709         regValue8 = rtw_read8(pAdapter, 0xa0);
17710         //DBG_8723A("Get 0xa0 = 0x%x\n",regValue8);
17711         if(regValue8 == 0x4){
17712                 value = rtw_read8(pAdapter, 0xf6);
17713                 value &= ~3;
17714                 value |= 1;
17715                 rtw_write8(pAdapter, 0xf6, value);
17716                 rtw_write8(pAdapter, 0x3A, 0x31);
17717         }
17718
17719         regvalue32 = rtw_read32(pAdapter, 0xc0);
17720         //DBG_8723A("Get 0xc0 = 0x%x\n",regvalue32);
17721         if(rtw_read32(pAdapter, 0xc0) == 0x0){
17722                 value = rtw_read8(pAdapter, 0xcc);
17723                 value |= 0x4;
17724                 rtw_write8(pAdapter, 0xcc, value);
17725         }
17726
17727         regValue8 = rtw_read8(pAdapter, 0x6b); //0x6b[28]
17728         //DBG_8723A("Get 0x6b = 0x%x\n",regValue8);
17729
17730         if((regValue8 & 0x10) == 0x10){
17731                 regValue8 &= 0xEF;
17732                 rtw_write8(pAdapter, 0x6b, regValue8);
17733                 value = rtw_read8(pAdapter, 0xcc);
17734                 value &= 0xfb;
17735                 rtw_write8(pAdapter, 0xcc, value);
17736         }
17737         else if ((regValue8 & 0x10) == 0){
17738                 regValue8 |= 0x10;
17739                 rtw_write8(pAdapter, 0x6b, regValue8);
17740                 value = rtw_read8(pAdapter, 0xcc);
17741                 value &= 0xfb;
17742                 rtw_write8(pAdapter, 0xcc, value);
17743         }
17744
17745         //DBG_8723A("<------%s,get 0x6b=0x%0x,0xcc=0x%x\n",__func__,rtw_read8(pAdapter, 0x6b),rtw_read8(pAdapter, 0xcc));
17746 }
17747
17748 void check_bt_status_work(void *data)
17749 {
17750         struct delayed_work *dwork;
17751         PADAPTER padapter;
17752
17753         dwork = container_of(data, struct delayed_work, work);
17754         padapter = container_of(dwork, struct _ADAPTER, checkbt_work);
17755         if(!padapter)
17756         {
17757                 DBG_8723A("%s padapter == NULL\n", __func__);
17758                 return;
17759         };
17760
17761         dm_CheckBTState(padapter);
17762 }
17763 #endif
17764 void BTDM_Coexist(PADAPTER padapter)
17765 {
17766         PHAL_DATA_TYPE pHalData = GET_HAL_DATA(padapter);
17767
17768 #if defined(CONFIG_CONCURRENT_MODE)
17769         if (padapter->adapter_type != PRIMARY_ADAPTER)
17770         {
17771                 RTPRINT(FBT, BT_TRACE, ("[DM][BT], CONFIG_CONCURRENT_MODE  !!\n"));
17772                 RTPRINT(FBT, BT_TRACE, ("[DM][BT], padapter->adapter_type != PRIMARY_ADAPTER  !!\n"));
17773                 return;
17774         }
17775 #endif
17776
17777         if (!pHalData->bt_coexist.BluetoothCoexist)
17778         {
17779                 RTPRINT(FBT, BT_TRACE, ("[DM][BT], BT not exists!!\n"));
17780                 return;
17781         }
17782
17783         if (!pHalData->bt_coexist.bInitlized)
17784         {
17785                 RTPRINT(FBT, BT_TRACE, ("[DM][BT], btdm_InitBtCoexistDM()\n"));
17786                 btdm_InitBtCoexistDM(padapter);
17787         }
17788
17789         RTPRINT(FBT, BT_TRACE, ("\n\n[DM][BT], BTDM start!!\n"));
17790
17791         BTDM_PWDBMonitor(padapter);
17792
17793         if (IS_HARDWARE_TYPE_8723A(padapter))
17794         {
17795                 RTPRINT(FBT, BT_TRACE, ("[DM][BT], HW type is 8723\n"));
17796                 BTDM_BTCoexist8723A(padapter);
17797         }
17798         RTPRINT(FBT, BT_TRACE, ("[DM][BT], BTDM end!!\n\n"));
17799 }
17800
17801 void BTDM_UpdateCoexState(PADAPTER padapter)
17802 {
17803         PHAL_DATA_TYPE pHalData = GET_HAL_DATA(padapter);
17804
17805         if (!BTDM_IsSameCoexistState(padapter))
17806         {
17807                 RTPRINT(FBT, BT_TRACE, ("[BTCoex], Coexist State[bitMap] change from 0x%"i64fmt"x to 0x%"i64fmt"x,  changeBits=0x%"i64fmt"x\n",
17808                         pHalData->bt_coexist.PreviousState,
17809                         pHalData->bt_coexist.CurrentState,
17810                         (pHalData->bt_coexist.PreviousState^pHalData->bt_coexist.CurrentState)));
17811                 pHalData->bt_coexist.PreviousState = pHalData->bt_coexist.CurrentState;
17812         }
17813 }
17814
17815 u8 BTDM_IsSameCoexistState(PADAPTER padapter)
17816 {
17817         PHAL_DATA_TYPE pHalData = GET_HAL_DATA(padapter);
17818
17819         if (pHalData->bt_coexist.PreviousState == pHalData->bt_coexist.CurrentState)
17820         {
17821                 return _TRUE;
17822         }
17823         else
17824         {
17825                 RTPRINT(FBT, BT_TRACE, ("[DM][BT], Coexist state changed!!\n"));
17826                 return _FALSE;
17827         }
17828 }
17829
17830 void BTDM_PWDBMonitor(PADAPTER padapter)
17831 {
17832 //      PMGNT_INFO              pMgntInfo = &(GetDefaultAdapter(padapter)->MgntInfo);
17833         PBT30Info               pBTInfo = GET_BT_INFO(GetDefaultAdapter(padapter));
17834         PBT_MGNT                pBtMgnt = &pBTInfo->BtMgnt;
17835         PHAL_DATA_TYPE  pHalData = GET_HAL_DATA(padapter);
17836         u8                      H2C_Parameter[3] = {0};
17837         s32                     tmpBTEntryMaxPWDB=0, tmpBTEntryMinPWDB=0xff;
17838         u8                      i;
17839
17840         if (pBtMgnt->BtOperationOn)
17841         {
17842                 for (i = 0; i < MAX_BT_ASOC_ENTRY_NUM; i++)
17843                 {
17844                         if (pBTInfo->BtAsocEntry[i].bUsed)
17845                         {
17846                                 if (pBTInfo->BtAsocEntry[i].UndecoratedSmoothedPWDB < tmpBTEntryMinPWDB)
17847                                         tmpBTEntryMinPWDB = pBTInfo->BtAsocEntry[i].UndecoratedSmoothedPWDB;
17848                                 if (pBTInfo->BtAsocEntry[i].UndecoratedSmoothedPWDB > tmpBTEntryMaxPWDB)
17849                                         tmpBTEntryMaxPWDB = pBTInfo->BtAsocEntry[i].UndecoratedSmoothedPWDB;
17850
17851                                 //
17852                                 // Report every BT connection (HS mode) RSSI to FW
17853                                 //
17854                                 H2C_Parameter[2] = (u8)(pBTInfo->BtAsocEntry[i].UndecoratedSmoothedPWDB & 0xFF);
17855                                 H2C_Parameter[0] = (MAX_FW_SUPPORT_MACID_NUM-1-i);
17856                                 RTPRINT(FDM, DM_BT30, ("RSSI report for BT[%d], H2C_Par = 0x%x\n", i, H2C_Parameter[0]));
17857                                 FillH2CCmd(padapter, RSSI_SETTING_EID, 3, H2C_Parameter);
17858                                 RTPRINT_ADDR(FDM, (DM_PWDB|DM_BT30), ("BT_Entry Mac :"), pBTInfo->BtAsocEntry[i].BTRemoteMACAddr)
17859                                 RTPRINT(FDM, (DM_PWDB|DM_BT30), ("BT rx pwdb[%d] = 0x%x(%d)\n", i, pBTInfo->BtAsocEntry[i].UndecoratedSmoothedPWDB,
17860                                         pBTInfo->BtAsocEntry[i].UndecoratedSmoothedPWDB));
17861                         }
17862                 }
17863                 if (tmpBTEntryMaxPWDB != 0)     // If associated entry is found
17864                 {
17865                         pHalData->dmpriv.BT_EntryMaxUndecoratedSmoothedPWDB = tmpBTEntryMaxPWDB;
17866                         RTPRINT(FDM, (DM_PWDB|DM_BT30), ("BT_EntryMaxPWDB = 0x%x(%d)\n",
17867                                 tmpBTEntryMaxPWDB, tmpBTEntryMaxPWDB));
17868                 }
17869                 else
17870                 {
17871                         pHalData->dmpriv.BT_EntryMaxUndecoratedSmoothedPWDB = 0;
17872                 }
17873                 if (tmpBTEntryMinPWDB != 0xff) // If associated entry is found
17874                 {
17875                         pHalData->dmpriv.BT_EntryMinUndecoratedSmoothedPWDB = tmpBTEntryMinPWDB;
17876                         RTPRINT(FDM, (DM_PWDB|DM_BT30), ("BT_EntryMinPWDB = 0x%x(%d)\n",
17877                                 tmpBTEntryMinPWDB, tmpBTEntryMinPWDB));
17878                 }
17879                 else
17880                 {
17881                         pHalData->dmpriv.BT_EntryMinUndecoratedSmoothedPWDB = 0;
17882                 }
17883         }
17884 }
17885
17886 u8 BTDM_DigByBtRssi(PADAPTER padapter)
17887 {
17888 //      PMGNT_INFO              pMgntInfo = &(GetDefaultAdapter(padapter)->MgntInfo);
17889         PBT30Info               pBTInfo = GET_BT_INFO(GetDefaultAdapter(padapter));
17890         PBT_MGNT                pBtMgnt = &pBTInfo->BtMgnt;
17891         PHAL_DATA_TYPE  pHalData = GET_HAL_DATA(padapter);
17892         u8                              bRet = _FALSE;
17893         PDM_ODM_T               pDM_OutSrc = &pHalData->odmpriv;
17894         u8                              digForBtHs=0, cckCcaThres=0;
17895
17896
17897         //
17898         // When running under HS mode, use bt related Dig and cck threshold.
17899         //
17900         if (pBtMgnt->BtOperationOn)
17901         {
17902                 if (pBtMgnt->bBTConnectInProgress)
17903                 {
17904                         if (IS_HARDWARE_TYPE_8723A(padapter))
17905                                 digForBtHs = 0x28;
17906                         else
17907                                 digForBtHs = 0x22;
17908                 }
17909                 else
17910                 {
17911                         //
17912                         // Decide DIG value by BT RSSI.
17913                         //
17914                         digForBtHs = (u8)pHalData->dmpriv.BT_EntryMinUndecoratedSmoothedPWDB;
17915
17916                         if (IS_HARDWARE_TYPE_8723A(padapter))
17917                                 digForBtHs += 0x04;
17918
17919                         if (digForBtHs > DM_DIG_MAX_NIC)
17920                                 digForBtHs = DM_DIG_MAX_NIC;
17921                         if (digForBtHs < DM_DIG_MIN_NIC)
17922                                 digForBtHs = DM_DIG_MIN_NIC;
17923
17924                         RTPRINT(FDM, DM_BT30, ("BTDM_DigByBtRssi(), digForBtHs=0x%x\n",
17925                                         digForBtHs));
17926                 }
17927                 ODM_Write_DIG(pDM_OutSrc, digForBtHs);
17928
17929                 //
17930                 // Decide cck packet threshold
17931                 //
17932                 cckCcaThres = 0xcd;
17933                 ODM_Write_CCK_CCA_Thres(pDM_OutSrc, cckCcaThres);
17934
17935                 bRet = _TRUE;
17936         }
17937
17938         return bRet;
17939 }
17940
17941 u8 BTDM_IsBTBusy(PADAPTER padapter)
17942 {
17943         PBT30Info               pBTInfo = GET_BT_INFO(padapter);
17944         PBT_MGNT                pBtMgnt = &pBTInfo->BtMgnt;
17945
17946         if (pBtMgnt->ExtConfig.bBTBusy)
17947                 return _TRUE;
17948         else
17949                 return _FALSE;
17950 }
17951
17952 u8 BTDM_IsWifiBusy(PADAPTER padapter)
17953 {
17954 //      PMGNT_INFO              pMgntInfo = &(GetDefaultAdapter(padapter)->MgntInfo);
17955         struct mlme_priv *pmlmepriv = &(GetDefaultAdapter(padapter)->mlmepriv);
17956         PBT30Info               pBTInfo = GET_BT_INFO(padapter);
17957         PBT_TRAFFIC     pBtTraffic = &pBTInfo->BtTraffic;
17958
17959
17960         if (pmlmepriv->LinkDetectInfo.bBusyTraffic ||
17961                 pBtTraffic->Bt30TrafficStatistics.bTxBusyTraffic ||
17962                 pBtTraffic->Bt30TrafficStatistics.bRxBusyTraffic)
17963                 return _TRUE;
17964         else
17965                 return _FALSE;
17966 }
17967
17968 u8 BTDM_IsCoexistStateChanged(PADAPTER padapter)
17969 {
17970         PHAL_DATA_TYPE  pHalData = GET_HAL_DATA(padapter);
17971
17972         if (pHalData->bt_coexist.PreviousState == pHalData->bt_coexist.CurrentState)
17973                 return _FALSE;
17974         else
17975                 return _TRUE;
17976 }
17977
17978 u8 BTDM_IsWifiUplink(PADAPTER padapter)
17979 {
17980 //      PMGNT_INFO              pMgntInfo = &(GetDefaultAdapter(padapter)->MgntInfo);
17981         struct mlme_priv *pmlmepriv;
17982         PBT30Info               pBTInfo;
17983         PBT_TRAFFIC             pBtTraffic;
17984
17985
17986         pmlmepriv = &padapter->mlmepriv;
17987         pBTInfo = GET_BT_INFO(padapter);
17988         pBtTraffic = &pBTInfo->BtTraffic;
17989
17990         if ((pmlmepriv->LinkDetectInfo.bTxBusyTraffic) ||
17991                 (pBtTraffic->Bt30TrafficStatistics.bTxBusyTraffic))
17992                 return _TRUE;
17993         else
17994                 return _FALSE;
17995 }
17996
17997 u8 BTDM_IsWifiDownlink(PADAPTER padapter)
17998 {
17999 //      PMGNT_INFO              pMgntInfo = &(GetDefaultAdapter(padapter)->MgntInfo);
18000         struct mlme_priv *pmlmepriv;
18001         PBT30Info               pBTInfo;
18002         PBT_TRAFFIC             pBtTraffic;
18003
18004
18005         pmlmepriv = &padapter->mlmepriv;
18006         pBTInfo = GET_BT_INFO(padapter);
18007         pBtTraffic = &pBTInfo->BtTraffic;
18008
18009         if ((pmlmepriv->LinkDetectInfo.bRxBusyTraffic) ||
18010                 (pBtTraffic->Bt30TrafficStatistics.bRxBusyTraffic))
18011                 return _TRUE;
18012         else
18013                 return _FALSE;
18014 }
18015
18016 u8 BTDM_IsBTHSMode(PADAPTER padapter)
18017 {
18018 //      PMGNT_INFO              pMgntInfo = &(GetDefaultAdapter(padapter)->MgntInfo);
18019         PHAL_DATA_TYPE  pHalData;
18020         PBT_MGNT                pBtMgnt;
18021
18022
18023         pHalData = GET_HAL_DATA(padapter);
18024         pBtMgnt = &pHalData->BtInfo.BtMgnt;
18025
18026         if (pBtMgnt->BtOperationOn)
18027                 return _TRUE;
18028         else
18029                 return _FALSE;
18030 }
18031
18032 u8 BTDM_IsBTUplink(PADAPTER padapter)
18033 {
18034         PHAL_DATA_TYPE  pHalData = GET_HAL_DATA(padapter);
18035
18036         if (pHalData->bt_coexist.BT21TrafficStatistics.bTxBusyTraffic)
18037                 return _TRUE;
18038         else
18039                 return _FALSE;
18040 }
18041
18042 u8 BTDM_IsBTDownlink(PADAPTER padapter)
18043 {
18044         PHAL_DATA_TYPE  pHalData = GET_HAL_DATA(padapter);
18045
18046         if (pHalData->bt_coexist.BT21TrafficStatistics.bRxBusyTraffic)
18047                 return _TRUE;
18048         else
18049                 return _FALSE;
18050 }
18051
18052 void BTDM_AdjustForBtOperation(PADAPTER padapter)
18053 {
18054         RTPRINT(FBT, BT_TRACE, ("[BT][DM], BTDM_AdjustForBtOperation()\n"));
18055         if (IS_HARDWARE_TYPE_8723A(padapter))
18056         {
18057                 BTDM_AdjustForBtOperation8723A(padapter);
18058         }
18059 }
18060
18061 u8 BTDM_AdjustRssiForAgcTableOn(PADAPTER padapter)
18062 {
18063         PHAL_DATA_TYPE  pHalData = GET_HAL_DATA(padapter);
18064
18065         if (!IS_HARDWARE_TYPE_8192D(padapter) &&
18066                 !IS_HARDWARE_TYPE_8723A(padapter))
18067                 return 0;
18068
18069         if (pHalData->bt_coexist.b92DAgcTableOn)
18070                 return 12;
18071
18072         if (pHalData->bt_coexist.b8723aAgcTableOn)
18073                 return 6;
18074
18075         return 0;
18076 }
18077
18078 void BTDM_SetBtCoexCurrAntNum(PADAPTER padapter, u8 antNum)
18079 {
18080         if (IS_HARDWARE_TYPE_8723A(padapter))
18081                 BTDM_Set8723ABtCoexCurrAntNum(padapter, antNum);
18082 }
18083
18084 void BTDM_ForHalt(PADAPTER padapter)
18085 {
18086         PHAL_DATA_TYPE  pHalData = GET_HAL_DATA(padapter);
18087
18088         if (!pHalData->bt_coexist.BluetoothCoexist)
18089         {
18090                 return;
18091         }
18092
18093         if (IS_HARDWARE_TYPE_8723A(padapter))
18094         {
18095                 BTDM_ForHalt8723A(padapter);
18096                 GET_HAL_DATA(padapter)->bt_coexist.bInitlized = _FALSE;
18097         }
18098 }
18099
18100 void BTDM_WifiScanNotify(PADAPTER padapter, u8 scanType)
18101 {
18102         PHAL_DATA_TYPE  pHalData = GET_HAL_DATA(padapter);
18103
18104         if (!pHalData->bt_coexist.BluetoothCoexist)
18105         {
18106                 return;
18107         }
18108
18109         if (IS_HARDWARE_TYPE_8723A(padapter))
18110                 BTDM_WifiScanNotify8723A(padapter, scanType);
18111 }
18112
18113 void BTDM_WifiAssociateNotify(PADAPTER padapter, u8 action)
18114 {
18115         PHAL_DATA_TYPE  pHalData = GET_HAL_DATA(padapter);
18116
18117         if (!pHalData->bt_coexist.BluetoothCoexist)
18118         {
18119                 return;
18120         }
18121
18122         if (IS_HARDWARE_TYPE_8723A(padapter))
18123                 BTDM_WifiAssociateNotify8723A(padapter, action);
18124 }
18125
18126 void BTDM_MediaStatusNotify(PADAPTER padapter, RT_MEDIA_STATUS mstatus)
18127 {
18128         PHAL_DATA_TYPE  pHalData = GET_HAL_DATA(padapter);
18129
18130         if (!pHalData->bt_coexist.BluetoothCoexist)
18131         {
18132                 return;
18133         }
18134
18135         if (IS_HARDWARE_TYPE_8723A(padapter))
18136                 BTDM_MediaStatusNotify8723A(padapter, mstatus);
18137 }
18138
18139 void BTDM_ForDhcp(PADAPTER padapter)
18140 {
18141         PHAL_DATA_TYPE  pHalData = GET_HAL_DATA(padapter);
18142
18143         if (!pHalData->bt_coexist.BluetoothCoexist)
18144         {
18145                 return;
18146         }
18147
18148         if (IS_HARDWARE_TYPE_8723A(padapter))
18149                 BTDM_ForDhcp8723A(padapter);
18150 }
18151
18152 void BTDM_ResetActionProfileState(PADAPTER padapter)
18153 {
18154         PHAL_DATA_TYPE  pHalData = GET_HAL_DATA(padapter);
18155
18156         pHalData->bt_coexist.CurrentState &= ~\
18157                 (BT_COEX_STATE_PROFILE_HID|BT_COEX_STATE_PROFILE_A2DP|
18158                 BT_COEX_STATE_PROFILE_PAN|BT_COEX_STATE_PROFILE_SCO);
18159 }
18160
18161 u8 BTDM_IsActionSCO(PADAPTER padapter)
18162 {
18163         PHAL_DATA_TYPE  pHalData;
18164         PBT30Info               pBTInfo;
18165         PBT_MGNT                pBtMgnt;
18166         PBT_DBG                 pBtDbg;
18167         u8                      bRet;
18168
18169
18170         pHalData = GET_HAL_DATA(padapter);
18171         pBTInfo = GET_BT_INFO(padapter);
18172         pBtMgnt = &pBTInfo->BtMgnt;
18173         pBtDbg = &pBTInfo->BtDbg;
18174         bRet = _FALSE;
18175
18176         if (pBtDbg->dbgCtrl == _TRUE)
18177         {
18178                 if (pBtDbg->dbgProfile == BT_DBG_PROFILE_SCO)
18179                 {
18180                         pHalData->bt_coexist.CurrentState |= BT_COEX_STATE_PROFILE_SCO;
18181                         bRet = _TRUE;
18182                 }
18183         }
18184         else
18185         {
18186                 if (pBtMgnt->ExtConfig.NumberOfSCO > 0)
18187                 {
18188                         pHalData->bt_coexist.CurrentState |= BT_COEX_STATE_PROFILE_SCO;
18189                         bRet = _TRUE;
18190                 }
18191         }
18192         return bRet;
18193 }
18194
18195 u8 BTDM_IsActionHID(PADAPTER padapter)
18196 {
18197         PBT30Info               pBTInfo;
18198         PHAL_DATA_TYPE  pHalData;
18199         PBT_MGNT                pBtMgnt;
18200         PBT_DBG                 pBtDbg;
18201         u8                      bRet;
18202
18203
18204         pHalData = GET_HAL_DATA(padapter);
18205         pBTInfo = GET_BT_INFO(padapter);
18206         pBtMgnt = &pBTInfo->BtMgnt;
18207         pBtDbg = &pBTInfo->BtDbg;
18208         bRet = _FALSE;
18209
18210         if (pBtDbg->dbgCtrl == _TRUE )
18211         {
18212                 if (pBtDbg->dbgProfile == BT_DBG_PROFILE_HID)
18213                 {
18214                         pHalData->bt_coexist.CurrentState |= BT_COEX_STATE_PROFILE_HID;
18215                         bRet = _TRUE;
18216                 }
18217         }
18218         else
18219         {
18220                 if (BTHCI_CheckProfileExist(padapter,BT_PROFILE_HID) && pBtMgnt->ExtConfig.NumberOfHandle==1)
18221                 {
18222                         pHalData->bt_coexist.CurrentState |= BT_COEX_STATE_PROFILE_HID;
18223                         bRet = _TRUE;
18224                 }
18225         }
18226         return bRet;
18227 }
18228
18229 u8 BTDM_IsActionA2DP(PADAPTER padapter)
18230 {
18231         PHAL_DATA_TYPE  pHalData;
18232         PBT30Info               pBTInfo;
18233         PBT_MGNT                pBtMgnt;
18234         PBT_DBG                 pBtDbg;
18235         u8                      bRet;
18236
18237
18238         pHalData = GET_HAL_DATA(padapter);
18239         pBTInfo = GET_BT_INFO(padapter);
18240         pBtMgnt = &pBTInfo->BtMgnt;
18241         pBtDbg = &pBTInfo->BtDbg;
18242         bRet = _FALSE;
18243
18244         if (pBtDbg->dbgCtrl == _TRUE )
18245         {
18246                 if (pBtDbg->dbgProfile == BT_DBG_PROFILE_A2DP)
18247                 {
18248                         pHalData->bt_coexist.CurrentState |= BT_COEX_STATE_PROFILE_A2DP;
18249                         bRet = _TRUE;
18250                 }
18251         }
18252         else
18253         {
18254                 if (BTHCI_CheckProfileExist(padapter,BT_PROFILE_A2DP) && pBtMgnt->ExtConfig.NumberOfHandle==1)
18255                 {
18256                         pHalData->bt_coexist.CurrentState |= BT_COEX_STATE_PROFILE_A2DP;
18257                         bRet = _TRUE;
18258                 }
18259         }
18260         return bRet;
18261 }
18262
18263 u8 BTDM_IsActionPAN(PADAPTER padapter)
18264 {
18265         PHAL_DATA_TYPE  pHalData;
18266         PBT30Info               pBTInfo;
18267         PBT_MGNT                pBtMgnt;
18268         PBT_DBG                 pBtDbg;
18269         u8                      bRet;
18270
18271
18272         pHalData = GET_HAL_DATA(padapter);
18273         pBTInfo = GET_BT_INFO(padapter);
18274         pBtMgnt = &pBTInfo->BtMgnt;
18275         pBtDbg = &pBTInfo->BtDbg;
18276         bRet = _FALSE;
18277
18278         if (pBtDbg->dbgCtrl == _TRUE)
18279         {
18280                 if (pBtDbg->dbgProfile == BT_DBG_PROFILE_PAN)
18281                 {
18282                         pHalData->bt_coexist.CurrentState |= BT_COEX_STATE_PROFILE_PAN;
18283                         bRet = _TRUE;
18284                 }
18285         }
18286         else
18287         {
18288                 if (BTHCI_CheckProfileExist(padapter,BT_PROFILE_PAN) && pBtMgnt->ExtConfig.NumberOfHandle==1)
18289                 {
18290                         pHalData->bt_coexist.CurrentState |= BT_COEX_STATE_PROFILE_PAN;
18291                         bRet = _TRUE;
18292                 }
18293         }
18294         return bRet;
18295 }
18296
18297 u8 BTDM_IsActionHIDA2DP(PADAPTER padapter)
18298 {
18299         PHAL_DATA_TYPE  pHalData;
18300         PBT30Info               pBTInfo;
18301         PBT_MGNT                pBtMgnt;
18302         PBT_DBG                 pBtDbg;
18303         u8                      bRet;
18304
18305
18306         pHalData = GET_HAL_DATA(padapter);
18307         pBTInfo = GET_BT_INFO(padapter);
18308         pBtMgnt = &pBTInfo->BtMgnt;
18309         pBtDbg = &pBTInfo->BtDbg;
18310         bRet = _FALSE;
18311
18312         if (pBtDbg->dbgCtrl == _TRUE)
18313         {
18314                 if (pBtDbg->dbgProfile == BT_DBG_PROFILE_HID_A2DP)
18315                 {
18316                         pHalData->bt_coexist.CurrentState |= (BT_COEX_STATE_PROFILE_HID|BT_COEX_STATE_PROFILE_A2DP);
18317                         bRet = _TRUE;
18318                 }
18319         }
18320         else
18321         {
18322                 if (BTHCI_CheckProfileExist(padapter,BT_PROFILE_HID) && BTHCI_CheckProfileExist(padapter,BT_PROFILE_A2DP))
18323                 {
18324                         pHalData->bt_coexist.CurrentState |= (BT_COEX_STATE_PROFILE_HID|BT_COEX_STATE_PROFILE_A2DP);
18325                         bRet = _TRUE;
18326                 }
18327         }
18328         return bRet;
18329 }
18330
18331 u8 BTDM_IsActionHIDPAN(PADAPTER padapter)
18332 {
18333         PHAL_DATA_TYPE  pHalData;
18334         PBT30Info               pBTInfo;
18335         PBT_DBG                 pBtDbg;
18336         u8                      bRet;
18337
18338
18339         pHalData = GET_HAL_DATA(padapter);
18340         pBTInfo = GET_BT_INFO(padapter);
18341         pBtDbg = &pBTInfo->BtDbg;
18342         bRet = _FALSE;
18343
18344         if (pBtDbg->dbgCtrl == _TRUE )
18345         {
18346                 if (pBtDbg->dbgProfile == BT_DBG_PROFILE_HID_PAN)
18347                 {
18348                         pHalData->bt_coexist.CurrentState |= (BT_COEX_STATE_PROFILE_HID|BT_COEX_STATE_PROFILE_PAN);
18349                         bRet = _TRUE;
18350                 }
18351         }
18352         else
18353         {
18354                 if (BTHCI_CheckProfileExist(padapter,BT_PROFILE_HID) && BTHCI_CheckProfileExist(padapter,BT_PROFILE_PAN))
18355                 {
18356                         pHalData->bt_coexist.CurrentState |= (BT_COEX_STATE_PROFILE_HID|BT_COEX_STATE_PROFILE_PAN);
18357                         bRet = _TRUE;
18358                 }
18359         }
18360         return bRet;
18361 }
18362
18363 u8 BTDM_IsActionPANA2DP(PADAPTER padapter)
18364 {
18365         PHAL_DATA_TYPE  pHalData;
18366         PBT30Info               pBTInfo;
18367         PBT_DBG                 pBtDbg;
18368         u8                      bRet;
18369
18370
18371         pHalData = GET_HAL_DATA(padapter);
18372         pBTInfo = GET_BT_INFO(padapter);
18373         pBtDbg = &pBTInfo->BtDbg;
18374         bRet = _FALSE;
18375
18376         if (pBtDbg->dbgCtrl == _TRUE )
18377         {
18378                 if (pBtDbg->dbgProfile == BT_DBG_PROFILE_PAN_A2DP)
18379                 {
18380                         pHalData->bt_coexist.CurrentState |= (BT_COEX_STATE_PROFILE_PAN|BT_COEX_STATE_PROFILE_A2DP);
18381                         bRet = _TRUE;
18382                 }
18383         }
18384         else
18385         {
18386                 if (BTHCI_CheckProfileExist(padapter,BT_PROFILE_PAN) && BTHCI_CheckProfileExist(padapter,BT_PROFILE_A2DP))
18387                 {
18388                         pHalData->bt_coexist.CurrentState |= (BT_COEX_STATE_PROFILE_PAN|BT_COEX_STATE_PROFILE_A2DP);
18389                         bRet = _TRUE;
18390                 }
18391         }
18392         return bRet;
18393 }
18394
18395 u8 BTDM_IsBtDisabled(PADAPTER padapter)
18396 {
18397         PHAL_DATA_TYPE  pHalData = GET_HAL_DATA(padapter);
18398
18399         if (pHalData->bt_coexist.bCurBtDisabled)
18400                 return _TRUE;
18401         else
18402                 return _FALSE;
18403 }
18404
18405 //============================================
18406 // Started with "WA_" means this is a work around function.
18407 // Because fw need to count bt HW counters
18408 //(BT_ACTIVE/BT_STATE/BT_POLLING)
18409 // in beacon related interrupt, so we have to write beacon control
18410 // register now.
18411 //============================================
18412 void WA_BTDM_EnableBTFwCounterPolling(PADAPTER padapter)
18413 {
18414         PHAL_DATA_TYPE  pHalData = GET_HAL_DATA(padapter);
18415
18416         // Currently, only 88cu and 92de need to enter the function
18417         if (!IS_HARDWARE_TYPE_8192CU(padapter) &&
18418                 !IS_HARDWARE_TYPE_8192DE(padapter))
18419                 return;
18420
18421         if (!pHalData->bt_coexist.BluetoothCoexist)
18422         {
18423                 return;
18424         }
18425         else
18426         {
18427                 //
18428                 // Enable BT firmware counter statistics.
18429                 // We have to set 0x550[3]=1 to enable it.
18430                 // Advised by Scott.
18431                 //
18432                 u8      u1val = 0;
18433                 u1val = rtw_read8(padapter, REG_BCN_CTRL);
18434                 u1val |= BIT3;
18435                 rtw_write8(padapter, REG_BCN_CTRL, u1val);
18436         }
18437 }
18438
18439 // ===== End of sync from SD7 driver HAL/BTCoexist/HalBtCoexist.c =====
18440 #endif
18441
18442 #ifdef __HALBT_C__ // HAL/HalBT.c
18443 // ===== Below this line is sync from SD7 driver HAL/HalBT.c =====
18444
18445 //==================================================
18446 //      local function
18447 //==================================================
18448
18449 static void halbt_InitHwConfig8723A(PADAPTER padapter)
18450 {
18451 }
18452
18453 //==================================================
18454 //      extern function
18455 //==================================================
18456 u8 HALBT_GetPGAntNum(PADAPTER padapter)
18457 {
18458         PHAL_DATA_TYPE  pHalData = GET_HAL_DATA(padapter);
18459
18460         return pHalData->bt_coexist.BT_Ant_Num;
18461 }
18462
18463 void HALBT_SetKey(PADAPTER padapter, u8 EntryNum)
18464 {
18465         PBT30Info               pBTinfo;
18466         PBT_ASOC_ENTRY  pBtAssocEntry;
18467         u16                             usConfig = 0;
18468
18469
18470         pBTinfo = GET_BT_INFO(padapter);
18471         pBtAssocEntry = &(pBTinfo->BtAsocEntry[EntryNum]);
18472
18473         pBtAssocEntry->HwCAMIndex = BT_HWCAM_STAR + EntryNum;
18474
18475         usConfig = CAM_VALID | (CAM_AES << 2);
18476         write_cam(padapter, pBtAssocEntry->HwCAMIndex, usConfig, pBtAssocEntry->BTRemoteMACAddr, pBtAssocEntry->PTK + TKIP_ENC_KEY_POS);
18477 }
18478
18479 void HALBT_RemoveKey(PADAPTER padapter, u8 EntryNum)
18480 {
18481         PBT30Info               pBTinfo;
18482         PBT_ASOC_ENTRY  pBtAssocEntry;
18483
18484         pBTinfo = GET_BT_INFO(padapter);
18485         pBtAssocEntry = &(pBTinfo->BtAsocEntry[EntryNum]);
18486
18487         if (pBTinfo->BtAsocEntry[EntryNum].HwCAMIndex != 0) {
18488                 // ToDo : add New HALBT_RemoveKey function !!
18489                 if (pBtAssocEntry->HwCAMIndex >= BT_HWCAM_STAR && pBtAssocEntry->HwCAMIndex < HALF_CAM_ENTRY)
18490                         CAM_empty_entry(padapter, pBtAssocEntry->HwCAMIndex);
18491                 pBTinfo->BtAsocEntry[EntryNum].HwCAMIndex = 0;
18492         }
18493 }
18494
18495 void HALBT_InitBTVars8723A(PADAPTER padapter)
18496 {
18497         PHAL_DATA_TYPE  pHalData;
18498
18499
18500         pHalData = GET_HAL_DATA(padapter);
18501
18502         pHalData->bt_coexist.BluetoothCoexist = pHalData->EEPROMBluetoothCoexist;
18503         pHalData->bt_coexist.BT_Ant_Num = pHalData->EEPROMBluetoothAntNum;
18504         pHalData->bt_coexist.BT_CoexistType = pHalData->EEPROMBluetoothType;
18505         pHalData->bt_coexist.BT_Ant_isolation = pHalData->EEPROMBluetoothAntIsolation;
18506         pHalData->bt_coexist.BT_RadioSharedType = pHalData->EEPROMBluetoothRadioShared;
18507
18508         RT_TRACE(_module_hal_init_c_, _drv_info_, ("BT Coexistance = 0x%x\n", pHalData->bt_coexist.BluetoothCoexist));
18509         if (pHalData->bt_coexist.BluetoothCoexist)
18510         {
18511                 if (pHalData->bt_coexist.BT_Ant_Num == Ant_x2)
18512                 {
18513                         BTDM_SetBtCoexCurrAntNum(padapter, 2);
18514                         RT_TRACE(_module_hal_init_c_, _drv_info_,("BlueTooth BT_Ant_Num = Antx2\n"));
18515 //                      DBG_8723A("%s WiFi BT coexist Ant_Num = Antx2\n",__func__);
18516                 }
18517                 else if (pHalData->bt_coexist.BT_Ant_Num == Ant_x1)
18518                 {
18519                         BTDM_SetBtCoexCurrAntNum(padapter, 1);
18520                         RT_TRACE(_module_hal_init_c_, _drv_info_,("BlueTooth BT_Ant_Num = Antx1\n"));
18521 //                      DBG_8723A("%s WiFi BT coexist Ant_Num Ant_Num = Antx1\n",__func__);
18522                 }
18523                 pHalData->bt_coexist.bBTBusyTraffic = _FALSE;
18524                 pHalData->bt_coexist.bBTTrafficModeSet = _FALSE;
18525                 pHalData->bt_coexist.bBTNonTrafficModeSet = _FALSE;
18526                 pHalData->bt_coexist.CurrentState = 0;
18527                 pHalData->bt_coexist.PreviousState = 0;
18528
18529                 RT_TRACE(_module_hal_init_c_, _drv_info_,("BT_RadioSharedType = 0x%x\n", pHalData->bt_coexist.BT_RadioSharedType));
18530         }
18531 }
18532
18533 u8 HALBT_IsBTExist(PADAPTER padapter)
18534 {
18535         PHAL_DATA_TYPE  pHalData = GET_HAL_DATA(padapter);
18536
18537         if (pHalData->bt_coexist.BluetoothCoexist)
18538                 return _TRUE;
18539         else
18540                 return _FALSE;
18541 }
18542
18543 u8 HALBT_BTChipType(PADAPTER padapter)
18544 {
18545         PHAL_DATA_TYPE  pHalData = GET_HAL_DATA(padapter);
18546
18547         return pHalData->bt_coexist.BT_CoexistType;
18548 }
18549
18550 void HALBT_InitHwConfig(PADAPTER padapter)
18551 {
18552         halbt_InitHwConfig8723A(padapter);
18553         BTDM_Coexist(padapter);
18554 }
18555
18556 void HALBT_IPSRFOffCheck(PADAPTER padapter)
18557 {
18558         PBT30Info               pBTinfo;
18559         PBT_MGNT                pBtMgnt;
18560         PHAL_DATA_TYPE  pHalData;
18561
18562
18563         pBTinfo = GET_BT_INFO(padapter);
18564         pBtMgnt = &pBTinfo->BtMgnt;
18565         pHalData = GET_HAL_DATA(padapter);
18566
18567         if (IS_HARDWARE_TYPE_8192C(padapter) ||
18568                 IS_HARDWARE_TYPE_8192D(padapter) ||
18569                 IS_HARDWARE_TYPE_8723A(padapter))
18570         {
18571                 if ((pHalData->bt_coexist.BluetoothCoexist) &&
18572                         (pBtMgnt->bSupportProfile))
18573                 {
18574                         RTPRINT(FBT, BT_TRACE, ("[BT][DM], HALBT_IPSRFOffCheck(), turn off all Coexist DM\n"));
18575                         BTDM_CoexAllOff(padapter);
18576                 }
18577         }
18578 }
18579
18580 void HALBT_LPSRFOffCheck(PADAPTER padapter)
18581 {
18582         PBT30Info               pBTinfo;
18583         PBT_MGNT                pBtMgnt;
18584         PHAL_DATA_TYPE  pHalData;
18585
18586
18587         pBTinfo = GET_BT_INFO(padapter);
18588         pBtMgnt = &pBTinfo->BtMgnt;
18589         pHalData = GET_HAL_DATA(padapter);
18590
18591         if (IS_HARDWARE_TYPE_8192C(padapter) ||
18592                 IS_HARDWARE_TYPE_8192D(padapter) ||
18593                 IS_HARDWARE_TYPE_8723A(padapter))
18594         {
18595                 if ((pHalData->bt_coexist.BluetoothCoexist) &&
18596                         (pBtMgnt->bSupportProfile))
18597                 {
18598                         RTPRINT(FBT, BT_TRACE, ("[BT][DM], HALBT_LPSRFOffCheck(), turn off all Coexist DM\n"));
18599                         BTDM_CoexAllOff(padapter);
18600                 }
18601         }
18602 }
18603
18604 void HALBT_SetRtsCtsNoLenLimit(PADAPTER padapter)
18605 {
18606 #if (RTS_CTS_NO_LEN_LIMIT == 1)
18607         rtw_write32(padapter, 0x4c8, 0xc140402);
18608 #endif
18609 }
18610
18611 u8 HALBT_OnlySupport1T(PADAPTER padapter)
18612 {
18613         return _FALSE;
18614 }
18615
18616 u8
18617 HALBT_BtRegAccess(
18618         PADAPTER        padapter,
18619         u32                     accessType,
18620         u32                     regType,
18621         u32                     regOffset,
18622         u32                     wValue,
18623         u32                     *pRetVal
18624         )
18625 {
18626         u8      H2C_Parameter[5] = {0};
18627
18628         if (IS_HARDWARE_TYPE_8723A(padapter))
18629         {
18630                 *pRetVal = 0x223;
18631                 //FillH2CCmd(padapter, 0xaf, 5, H2C_Parameter);
18632         }
18633         else
18634         {
18635                 *pRetVal = 0xffffffff;
18636                 return _FALSE;
18637         }
18638
18639         return _TRUE;
18640 }
18641
18642 void HALBT_SwitchWirelessMode(PADAPTER padapter, u8 targetWirelessMode)
18643 {
18644 }
18645
18646 // ===== End of sync from SD7 driver HAL/HalBT.c =====
18647 #endif