drivers/staging/rtl8723bs/hal/HalBtc8723b2Ant.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /******************************************************************************
   3  *
   4  * Copyright(c) 2007 - 2012 Realtek Corporation. All rights reserved.
   5  *
   6  ******************************************************************************/
   7
   8 #include "Mp_Precomp.h"
   9
  10 /*  Global variables, these are static variables */
  11 static COEX_DM_8723B_2ANT GLCoexDm8723b2Ant;
  12 static PCOEX_DM_8723B_2ANT pCoexDm = &GLCoexDm8723b2Ant;
  13 static COEX_STA_8723B_2ANT GLCoexSta8723b2Ant;
  14 static PCOEX_STA_8723B_2ANT pCoexSta = &GLCoexSta8723b2Ant;
  15
  16 static const char *const GLBtInfoSrc8723b2Ant[] = {
  17         "BT Info[wifi fw]",
  18         "BT Info[bt rsp]",
  19         "BT Info[bt auto report]",
  20 };
  21
  22 static u32 GLCoexVerDate8723b2Ant = 20131211;
  23 static u32 GLCoexVer8723b2Ant = 0x40;
  24
  25 /*  local function start with halbtc8723b2ant_ */
  26 static u8 halbtc8723b2ant_BtRssiState(
  27         u8 levelNum, u8 rssiThresh, u8 rssiThresh1
  28 )
  29 {
  30         s32 btRssi = 0;
  31         u8 btRssiState = pCoexSta->preBtRssiState;
  32
  33         btRssi = pCoexSta->btRssi;
  34
  35         if (levelNum == 2) {
  36                 if (
  37                         (pCoexSta->preBtRssiState == BTC_RSSI_STATE_LOW) ||
  38                         (pCoexSta->preBtRssiState == BTC_RSSI_STATE_STAY_LOW)
  39                 ) {
  40                         if (btRssi >= (rssiThresh+BTC_RSSI_COEX_THRESH_TOL_8723B_2ANT)) {
  41                                 btRssiState = BTC_RSSI_STATE_HIGH;
  42                                 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE, ("[BTCoex], BT Rssi state switch to High\n"));
  43                         } else {
  44                                 btRssiState = BTC_RSSI_STATE_STAY_LOW;
  45                                 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE, ("[BTCoex], BT Rssi state stay at Low\n"));
  46                         }
  47                 } else {
  48                         if (btRssi < rssiThresh) {
  49                                 btRssiState = BTC_RSSI_STATE_LOW;
  50                                 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE, ("[BTCoex], BT Rssi state switch to Low\n"));
  51                         } else {
  52                                 btRssiState = BTC_RSSI_STATE_STAY_HIGH;
  53                                 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE, ("[BTCoex], BT Rssi state stay at High\n"));
  54                         }
  55                 }
  56         } else if (levelNum == 3) {
  57                 if (rssiThresh > rssiThresh1) {
  58                         BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE, ("[BTCoex], BT Rssi thresh error!!\n"));
  59                         return pCoexSta->preBtRssiState;
  60                 }
  61
  62                 if (
  63                         (pCoexSta->preBtRssiState == BTC_RSSI_STATE_LOW) ||
  64                         (pCoexSta->preBtRssiState == BTC_RSSI_STATE_STAY_LOW)
  65                 ) {
  66                         if (btRssi >= (rssiThresh+BTC_RSSI_COEX_THRESH_TOL_8723B_2ANT)) {
  67                                 btRssiState = BTC_RSSI_STATE_MEDIUM;
  68                                 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE, ("[BTCoex], BT Rssi state switch to Medium\n"));
  69                         } else {
  70                                 btRssiState = BTC_RSSI_STATE_STAY_LOW;
  71                                 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE, ("[BTCoex], BT Rssi state stay at Low\n"));
  72                         }
  73                 } else if (
  74                         (pCoexSta->preBtRssiState == BTC_RSSI_STATE_MEDIUM) ||
  75                         (pCoexSta->preBtRssiState == BTC_RSSI_STATE_STAY_MEDIUM)
  76                 ) {
  77                         if (btRssi >= (rssiThresh1+BTC_RSSI_COEX_THRESH_TOL_8723B_2ANT)) {
  78                                 btRssiState = BTC_RSSI_STATE_HIGH;
  79                                 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE, ("[BTCoex], BT Rssi state switch to High\n"));
  80                         } else if (btRssi < rssiThresh) {
  81                                 btRssiState = BTC_RSSI_STATE_LOW;
  82                                 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE, ("[BTCoex], BT Rssi state switch to Low\n"));
  83                         } else {
  84                                 btRssiState = BTC_RSSI_STATE_STAY_MEDIUM;
  85                                 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE, ("[BTCoex], BT Rssi state stay at Medium\n"));
  86                         }
  87                 } else {
  88                         if (btRssi < rssiThresh1) {
  89                                 btRssiState = BTC_RSSI_STATE_MEDIUM;
  90                                 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE, ("[BTCoex], BT Rssi state switch to Medium\n"));
  91                         } else {
  92                                 btRssiState = BTC_RSSI_STATE_STAY_HIGH;
  93                                 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE, ("[BTCoex], BT Rssi state stay at High\n"));
  94                         }
  95                 }
  96         }
  97
  98         pCoexSta->preBtRssiState = btRssiState;
  99
 100         return btRssiState;
 101 }
 102
 103 static u8 halbtc8723b2ant_WifiRssiState(
 104         PBTC_COEXIST pBtCoexist,
 105         u8 index,
 106         u8 levelNum,
 107         u8 rssiThresh,
 108         u8 rssiThresh1
 109 )
 110 {
 111         s32 wifiRssi = 0;
 112         u8 wifiRssiState = pCoexSta->preWifiRssiState[index];
 113
 114         pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_S4_WIFI_RSSI, &wifiRssi);
 115
 116         if (levelNum == 2) {
 117                 if (
 118                         (pCoexSta->preWifiRssiState[index] == BTC_RSSI_STATE_LOW) ||
 119                         (pCoexSta->preWifiRssiState[index] == BTC_RSSI_STATE_STAY_LOW)
 120                 ) {
 121                         if (wifiRssi >= (rssiThresh+BTC_RSSI_COEX_THRESH_TOL_8723B_2ANT)) {
 122                                 wifiRssiState = BTC_RSSI_STATE_HIGH;
 123                                 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_WIFI_RSSI_STATE, ("[BTCoex], wifi RSSI state switch to High\n"));
 124                         } else {
 125                                 wifiRssiState = BTC_RSSI_STATE_STAY_LOW;
 126                                 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_WIFI_RSSI_STATE, ("[BTCoex], wifi RSSI state stay at Low\n"));
 127                         }
 128                 } else {
 129                         if (wifiRssi < rssiThresh) {
 130                                 wifiRssiState = BTC_RSSI_STATE_LOW;
 131                                 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_WIFI_RSSI_STATE, ("[BTCoex], wifi RSSI state switch to Low\n"));
 132                         } else {
 133                                 wifiRssiState = BTC_RSSI_STATE_STAY_HIGH;
 134                                 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_WIFI_RSSI_STATE, ("[BTCoex], wifi RSSI state stay at High\n"));
 135                         }
 136                 }
 137         } else if (levelNum == 3) {
 138                 if (rssiThresh > rssiThresh1) {
 139                         BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_WIFI_RSSI_STATE, ("[BTCoex], wifi RSSI thresh error!!\n"));
 140                         return pCoexSta->preWifiRssiState[index];
 141                 }
 142
 143                 if (
 144                         (pCoexSta->preWifiRssiState[index] == BTC_RSSI_STATE_LOW) ||
 145                         (pCoexSta->preWifiRssiState[index] == BTC_RSSI_STATE_STAY_LOW)
 146                 ) {
 147                         if (wifiRssi >= (rssiThresh+BTC_RSSI_COEX_THRESH_TOL_8723B_2ANT)) {
 148                                 wifiRssiState = BTC_RSSI_STATE_MEDIUM;
 149                                 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_WIFI_RSSI_STATE, ("[BTCoex], wifi RSSI state switch to Medium\n"));
 150                         } else {
 151                                 wifiRssiState = BTC_RSSI_STATE_STAY_LOW;
 152                                 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_WIFI_RSSI_STATE, ("[BTCoex], wifi RSSI state stay at Low\n"));
 153                         }
 154                 } else if (
 155                         (pCoexSta->preWifiRssiState[index] == BTC_RSSI_STATE_MEDIUM) ||
 156                         (pCoexSta->preWifiRssiState[index] == BTC_RSSI_STATE_STAY_MEDIUM)
 157                 ) {
 158                         if (wifiRssi >= (rssiThresh1+BTC_RSSI_COEX_THRESH_TOL_8723B_2ANT)) {
 159                                 wifiRssiState = BTC_RSSI_STATE_HIGH;
 160                                 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_WIFI_RSSI_STATE, ("[BTCoex], wifi RSSI state switch to High\n"));
 161                         } else if (wifiRssi < rssiThresh) {
 162                                 wifiRssiState = BTC_RSSI_STATE_LOW;
 163                                 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_WIFI_RSSI_STATE, ("[BTCoex], wifi RSSI state switch to Low\n"));
 164                         } else {
 165                                 wifiRssiState = BTC_RSSI_STATE_STAY_MEDIUM;
 166                                 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_WIFI_RSSI_STATE, ("[BTCoex], wifi RSSI state stay at Medium\n"));
 167                         }
 168                 } else {
 169                         if (wifiRssi < rssiThresh1) {
 170                                 wifiRssiState = BTC_RSSI_STATE_MEDIUM;
 171                                 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_WIFI_RSSI_STATE, ("[BTCoex], wifi RSSI state switch to Medium\n"));
 172                         } else {
 173                                 wifiRssiState = BTC_RSSI_STATE_STAY_HIGH;
 174                                 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_WIFI_RSSI_STATE, ("[BTCoex], wifi RSSI state stay at High\n"));
 175                         }
 176                 }
 177         }
 178
 179         pCoexSta->preWifiRssiState[index] = wifiRssiState;
 180
 181         return wifiRssiState;
 182 }
 183
 184 static void halbtc8723b2ant_LimitedRx(
 185         PBTC_COEXIST pBtCoexist,
 186         bool bForceExec,
 187         bool bRejApAggPkt,
 188         bool bBtCtrlAggBufSize,
 189         u8 aggBufSize
 190 )
 191 {
 192         bool bRejectRxAgg = bRejApAggPkt;
 193         bool bBtCtrlRxAggSize = bBtCtrlAggBufSize;
 194         u8 rxAggSize = aggBufSize;
 195
 196         /*  */
 197         /*      Rx Aggregation related setting */
 198         /*  */
 199         pBtCoexist->fBtcSet(pBtCoexist, BTC_SET_BL_TO_REJ_AP_AGG_PKT, &bRejectRxAgg);
 200         /*  decide BT control aggregation buf size or not */
 201         pBtCoexist->fBtcSet(pBtCoexist, BTC_SET_BL_BT_CTRL_AGG_SIZE, &bBtCtrlRxAggSize);
 202         /*  aggregation buf size, only work when BT control Rx aggregation size. */
 203         pBtCoexist->fBtcSet(pBtCoexist, BTC_SET_U1_AGG_BUF_SIZE, &rxAggSize);
 204         /*  real update aggregation setting */
 205         pBtCoexist->fBtcSet(pBtCoexist, BTC_SET_ACT_AGGREGATE_CTRL, NULL);
 206 }
 207
 208 static void halbtc8723b2ant_MonitorBtCtr(PBTC_COEXIST pBtCoexist)
 209 {
 210         u32 regHPTxRx, regLPTxRx, u4Tmp;
 211         u32 regHPTx = 0, regHPRx = 0, regLPTx = 0, regLPRx = 0;
 212
 213         regHPTxRx = 0x770;
 214         regLPTxRx = 0x774;
 215
 216         u4Tmp = pBtCoexist->fBtcRead4Byte(pBtCoexist, regHPTxRx);
 217         regHPTx = u4Tmp & bMaskLWord;
 218         regHPRx = (u4Tmp & bMaskHWord)>>16;
 219
 220         u4Tmp = pBtCoexist->fBtcRead4Byte(pBtCoexist, regLPTxRx);
 221         regLPTx = u4Tmp & bMaskLWord;
 222         regLPRx = (u4Tmp & bMaskHWord)>>16;
 223
 224         pCoexSta->highPriorityTx = regHPTx;
 225         pCoexSta->highPriorityRx = regHPRx;
 226         pCoexSta->lowPriorityTx = regLPTx;
 227         pCoexSta->lowPriorityRx = regLPRx;
 228
 229         BTC_PRINT(
 230                 BTC_MSG_ALGORITHM,
 231                 ALGO_BT_MONITOR,
 232                 (
 233                         "[BTCoex], High Priority Tx/Rx (reg 0x%x) = 0x%x(%d)/0x%x(%d)\n",
 234                         regHPTxRx,
 235                         regHPTx,
 236                         regHPTx,
 237                         regHPRx,
 238                         regHPRx
 239                 )
 240         );
 241         BTC_PRINT(
 242                 BTC_MSG_ALGORITHM,
 243                 ALGO_BT_MONITOR,
 244                 (
 245                         "[BTCoex], Low Priority Tx/Rx (reg 0x%x) = 0x%x(%d)/0x%x(%d)\n",
 246                         regLPTxRx,
 247                         regLPTx,
 248                         regLPTx,
 249                         regLPRx,
 250                         regLPRx
 251                 )
 252         );
 253
 254         /*  reset counter */
 255         pBtCoexist->fBtcWrite1Byte(pBtCoexist, 0x76e, 0xc);
 256 }
 257
 258 static void halbtc8723b2ant_QueryBtInfo(PBTC_COEXIST pBtCoexist)
 259 {
 260         u8      H2C_Parameter[1] = {0};
 261
 262         pCoexSta->bC2hBtInfoReqSent = true;
 263
 264         H2C_Parameter[0] |= BIT0;       /*  trigger */
 265
 266         BTC_PRINT(
 267                 BTC_MSG_ALGORITHM,
 268                 ALGO_TRACE_FW_EXEC,
 269                 ("[BTCoex], Query Bt Info, FW write 0x61 = 0x%x\n", H2C_Parameter[0])
 270         );
 271
 272         pBtCoexist->fBtcFillH2c(pBtCoexist, 0x61, 1, H2C_Parameter);
 273 }
 274
 275 static bool halbtc8723b2ant_IsWifiStatusChanged(PBTC_COEXIST pBtCoexist)
 276 {
 277         static bool     bPreWifiBusy, bPreUnder4way, bPreBtHsOn;
 278         bool bWifiBusy = false, bUnder4way = false, bBtHsOn = false;
 279         bool bWifiConnected = false;
 280
 281         pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_WIFI_CONNECTED, &bWifiConnected);
 282         pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_WIFI_BUSY, &bWifiBusy);
 283         pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_HS_OPERATION, &bBtHsOn);
 284         pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_WIFI_4_WAY_PROGRESS, &bUnder4way);
 285
 286         if (bWifiConnected) {
 287                 if (bWifiBusy != bPreWifiBusy) {
 288                         bPreWifiBusy = bWifiBusy;
 289                         return true;
 290                 }
 291
 292                 if (bUnder4way != bPreUnder4way) {
 293                         bPreUnder4way = bUnder4way;
 294                         return true;
 295                 }
 296
 297                 if (bBtHsOn != bPreBtHsOn) {
 298                         bPreBtHsOn = bBtHsOn;
 299                         return true;
 300                 }
 301         }
 302
 303         return false;
 304 }
 305
 306 static void halbtc8723b2ant_UpdateBtLinkInfo(PBTC_COEXIST pBtCoexist)
 307 {
 308         PBTC_BT_LINK_INFO pBtLinkInfo = &pBtCoexist->btLinkInfo;
 309         bool bBtHsOn = false;
 310
 311         pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_HS_OPERATION, &bBtHsOn);
 312
 313         pBtLinkInfo->bBtLinkExist = pCoexSta->bBtLinkExist;
 314         pBtLinkInfo->bScoExist = pCoexSta->bScoExist;
 315         pBtLinkInfo->bA2dpExist = pCoexSta->bA2dpExist;
 316         pBtLinkInfo->bPanExist = pCoexSta->bPanExist;
 317         pBtLinkInfo->bHidExist = pCoexSta->bHidExist;
 318
 319         /*  work around for HS mode. */
 320         if (bBtHsOn) {
 321                 pBtLinkInfo->bPanExist = true;
 322                 pBtLinkInfo->bBtLinkExist = true;
 323         }
 324
 325         /*  check if Sco only */
 326         if (
 327                 pBtLinkInfo->bScoExist &&
 328                 !pBtLinkInfo->bA2dpExist &&
 329                 !pBtLinkInfo->bPanExist &&
 330                 !pBtLinkInfo->bHidExist
 331         )
 332                 pBtLinkInfo->bScoOnly = true;
 333         else
 334                 pBtLinkInfo->bScoOnly = false;
 335
 336         /*  check if A2dp only */
 337         if (
 338                 !pBtLinkInfo->bScoExist &&
 339                 pBtLinkInfo->bA2dpExist &&
 340                 !pBtLinkInfo->bPanExist &&
 341                 !pBtLinkInfo->bHidExist
 342         )
 343                 pBtLinkInfo->bA2dpOnly = true;
 344         else
 345                 pBtLinkInfo->bA2dpOnly = false;
 346
 347         /*  check if Pan only */
 348         if (
 349                 !pBtLinkInfo->bScoExist &&
 350                 !pBtLinkInfo->bA2dpExist &&
 351                 pBtLinkInfo->bPanExist &&
 352                 !pBtLinkInfo->bHidExist
 353         )
 354                 pBtLinkInfo->bPanOnly = true;
 355         else
 356                 pBtLinkInfo->bPanOnly = false;
 357
 358         /*  check if Hid only */
 359         if (
 360                 !pBtLinkInfo->bScoExist &&
 361                 !pBtLinkInfo->bA2dpExist &&
 362                 !pBtLinkInfo->bPanExist &&
 363                 pBtLinkInfo->bHidExist
 364         )
 365                 pBtLinkInfo->bHidOnly = true;
 366         else
 367                 pBtLinkInfo->bHidOnly = false;
 368 }
 369
 370 static u8 halbtc8723b2ant_ActionAlgorithm(PBTC_COEXIST pBtCoexist)
 371 {
 372         PBTC_BT_LINK_INFO pBtLinkInfo = &pBtCoexist->btLinkInfo;
 373         bool bBtHsOn = false;
 374         u8 algorithm = BT_8723B_2ANT_COEX_ALGO_UNDEFINED;
 375         u8 numOfDiffProfile = 0;
 376
 377         pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_HS_OPERATION, &bBtHsOn);
 378
 379         if (!pBtLinkInfo->bBtLinkExist) {
 380                 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], No BT link exists!!!\n"));
 381                 return algorithm;
 382         }
 383
 384         if (pBtLinkInfo->bScoExist)
 385                 numOfDiffProfile++;
 386
 387         if (pBtLinkInfo->bHidExist)
 388                 numOfDiffProfile++;
 389
 390         if (pBtLinkInfo->bPanExist)
 391                 numOfDiffProfile++;
 392
 393         if (pBtLinkInfo->bA2dpExist)
 394                 numOfDiffProfile++;
 395
 396         if (numOfDiffProfile == 1) {
 397                 if (pBtLinkInfo->bScoExist) {
 398                         BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], SCO only\n"));
 399                         algorithm = BT_8723B_2ANT_COEX_ALGO_SCO;
 400                 } else {
 401                         if (pBtLinkInfo->bHidExist) {
 402                                 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], HID only\n"));
 403                                 algorithm = BT_8723B_2ANT_COEX_ALGO_HID;
 404                         } else if (pBtLinkInfo->bA2dpExist) {
 405                                 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], A2DP only\n"));
 406                                 algorithm = BT_8723B_2ANT_COEX_ALGO_A2DP;
 407                         } else if (pBtLinkInfo->bPanExist) {
 408                                 if (bBtHsOn) {
 409                                         BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], PAN(HS) only\n"));
 410                                         algorithm = BT_8723B_2ANT_COEX_ALGO_PANHS;
 411                                 } else {
 412                                         BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], PAN(EDR) only\n"));
 413                                         algorithm = BT_8723B_2ANT_COEX_ALGO_PANEDR;
 414                                 }
 415                         }
 416                 }
 417         } else if (numOfDiffProfile == 2) {
 418                 if (pBtLinkInfo->bScoExist) {
 419                         if (pBtLinkInfo->bHidExist) {
 420                                 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], SCO + HID\n"));
 421                                 algorithm = BT_8723B_2ANT_COEX_ALGO_PANEDR_HID;
 422                         } else if (pBtLinkInfo->bA2dpExist) {
 423                                 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], SCO + A2DP ==> SCO\n"));
 424                                 algorithm = BT_8723B_2ANT_COEX_ALGO_PANEDR_HID;
 425                         } else if (pBtLinkInfo->bPanExist) {
 426                                 if (bBtHsOn) {
 427                                         BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], SCO + PAN(HS)\n"));
 428                                         algorithm = BT_8723B_2ANT_COEX_ALGO_SCO;
 429                                 } else {
 430                                         BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], SCO + PAN(EDR)\n"));
 431                                         algorithm = BT_8723B_2ANT_COEX_ALGO_PANEDR_HID;
 432                                 }
 433                         }
 434                 } else {
 435                         if (
 436                                 pBtLinkInfo->bHidExist &&
 437                                 pBtLinkInfo->bA2dpExist
 438                         ) {
 439                                 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], HID + A2DP\n"));
 440                                 algorithm = BT_8723B_2ANT_COEX_ALGO_HID_A2DP;
 441                         } else if (
 442                                 pBtLinkInfo->bHidExist &&
 443                                 pBtLinkInfo->bPanExist
 444                         ) {
 445                                 if (bBtHsOn) {
 446                                         BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], HID + PAN(HS)\n"));
 447                                         algorithm = BT_8723B_2ANT_COEX_ALGO_HID;
 448                                 } else {
 449                                         BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], HID + PAN(EDR)\n"));
 450                                         algorithm = BT_8723B_2ANT_COEX_ALGO_PANEDR_HID;
 451                                 }
 452                         } else if (
 453                                 pBtLinkInfo->bPanExist &&
 454                                 pBtLinkInfo->bA2dpExist
 455                         ) {
 456                                 if (bBtHsOn) {
 457                                         BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], A2DP + PAN(HS)\n"));
 458                                         algorithm = BT_8723B_2ANT_COEX_ALGO_A2DP_PANHS;
 459                                 } else {
 460                                         BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], A2DP + PAN(EDR)\n"));
 461                                         algorithm = BT_8723B_2ANT_COEX_ALGO_PANEDR_A2DP;
 462                                 }
 463                         }
 464                 }
 465         } else if (numOfDiffProfile == 3) {
 466                 if (pBtLinkInfo->bScoExist) {
 467                         if (
 468                                 pBtLinkInfo->bHidExist &&
 469                                 pBtLinkInfo->bA2dpExist
 470                         ) {
 471                                 BTC_PRINT(
 472                                         BTC_MSG_ALGORITHM,
 473                                         ALGO_TRACE,
 474                                         ("[BTCoex], SCO + HID + A2DP ==> HID\n")
 475                                 );
 476                                 algorithm = BT_8723B_2ANT_COEX_ALGO_PANEDR_HID;
 477                         } else if (
 478                                 pBtLinkInfo->bHidExist &&
 479                                 pBtLinkInfo->bPanExist
 480                         ) {
 481                                 if (bBtHsOn) {
 482                                         BTC_PRINT(
 483                                                 BTC_MSG_ALGORITHM,
 484                                                 ALGO_TRACE,
 485                                                 ("[BTCoex], SCO + HID + PAN(HS)\n")
 486                                         );
 487                                         algorithm = BT_8723B_2ANT_COEX_ALGO_PANEDR_HID;
 488                                 } else {
 489                                         BTC_PRINT(
 490                                                 BTC_MSG_ALGORITHM,
 491                                                 ALGO_TRACE,
 492                                                 ("[BTCoex], SCO + HID + PAN(EDR)\n")
 493                                         );
 494                                         algorithm = BT_8723B_2ANT_COEX_ALGO_PANEDR_HID;
 495                                 }
 496                         } else if (
 497                                 pBtLinkInfo->bPanExist &&
 498                                 pBtLinkInfo->bA2dpExist
 499                         ) {
 500                                 if (bBtHsOn) {
 501                                         BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], SCO + A2DP + PAN(HS)\n"));
 502                                         algorithm = BT_8723B_2ANT_COEX_ALGO_PANEDR_HID;
 503                                 } else {
 504                                         BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], SCO + A2DP + PAN(EDR) ==> HID\n"));
 505                                         algorithm = BT_8723B_2ANT_COEX_ALGO_PANEDR_HID;
 506                                 }
 507                         }
 508                 } else {
 509                         if (
 510                                 pBtLinkInfo->bHidExist &&
 511                                 pBtLinkInfo->bPanExist &&
 512                                 pBtLinkInfo->bA2dpExist
 513                         ) {
 514                                 if (bBtHsOn) {
 515                                         BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], HID + A2DP + PAN(HS)\n"));
 516                                         algorithm = BT_8723B_2ANT_COEX_ALGO_HID_A2DP;
 517                                 } else {
 518                                         BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], HID + A2DP + PAN(EDR)\n"));
 519                                         algorithm = BT_8723B_2ANT_COEX_ALGO_HID_A2DP_PANEDR;
 520                                 }
 521                         }
 522                 }
 523         } else if (numOfDiffProfile >= 3) {
 524                 if (pBtLinkInfo->bScoExist) {
 525                         if (
 526                                 pBtLinkInfo->bHidExist &&
 527                                 pBtLinkInfo->bPanExist &&
 528                                 pBtLinkInfo->bA2dpExist
 529                         ) {
 530                                 if (bBtHsOn) {
 531                                         BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], Error!!! SCO + HID + A2DP + PAN(HS)\n"));
 532
 533                                 } else {
 534                                         BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], SCO + HID + A2DP + PAN(EDR) ==>PAN(EDR)+HID\n"));
 535                                         algorithm = BT_8723B_2ANT_COEX_ALGO_PANEDR_HID;
 536                                 }
 537                         }
 538                 }
 539         }
 540
 541         return algorithm;
 542 }
 543
 544 static void halbtc8723b2ant_SetFwDacSwingLevel(
 545         PBTC_COEXIST pBtCoexist, u8 dacSwingLvl
 546 )
 547 {
 548         u8      H2C_Parameter[1] = {0};
 549
 550         /*  There are several type of dacswing */
 551         /*  0x18/ 0x10/ 0xc/ 0x8/ 0x4/ 0x6 */
 552         H2C_Parameter[0] = dacSwingLvl;
 553
 554         BTC_PRINT(
 555                 BTC_MSG_ALGORITHM,
 556                 ALGO_TRACE_FW_EXEC,
 557                 ("[BTCoex], Set Dac Swing Level = 0x%x\n", dacSwingLvl)
 558         );
 559         BTC_PRINT(
 560                 BTC_MSG_ALGORITHM,
 561                 ALGO_TRACE_FW_EXEC,
 562                 ("[BTCoex], FW write 0x64 = 0x%x\n", H2C_Parameter[0])
 563         );
 564
 565         pBtCoexist->fBtcFillH2c(pBtCoexist, 0x64, 1, H2C_Parameter);
 566 }
 567
 568 static void halbtc8723b2ant_SetFwDecBtPwr(
 569         PBTC_COEXIST pBtCoexist, u8 decBtPwrLvl
 570 )
 571 {
 572         u8      H2C_Parameter[1] = {0};
 573
 574         H2C_Parameter[0] = decBtPwrLvl;
 575
 576         BTC_PRINT(
 577                 BTC_MSG_ALGORITHM,
 578                 ALGO_TRACE_FW_EXEC,
 579                 (
 580                         "[BTCoex], decrease Bt Power level = %d, FW write 0x62 = 0x%x\n",
 581                         decBtPwrLvl,
 582                         H2C_Parameter[0]
 583                 )
 584         );
 585
 586         pBtCoexist->fBtcFillH2c(pBtCoexist, 0x62, 1, H2C_Parameter);
 587 }
 588
 589 static void halbtc8723b2ant_DecBtPwr(
 590         PBTC_COEXIST pBtCoexist, bool bForceExec, u8 decBtPwrLvl
 591 )
 592 {
 593         BTC_PRINT(
 594                 BTC_MSG_ALGORITHM,
 595                 ALGO_TRACE_FW,
 596                 (
 597                         "[BTCoex], %s Dec BT power level = %d\n",
 598                         (bForceExec ? "force to" : ""),
 599                         decBtPwrLvl
 600                 )
 601         );
 602         pCoexDm->curBtDecPwrLvl = decBtPwrLvl;
 603
 604         if (!bForceExec) {
 605                 BTC_PRINT(
 606                         BTC_MSG_ALGORITHM,
 607                         ALGO_TRACE_FW_DETAIL,
 608                         (
 609                                 "[BTCoex], preBtDecPwrLvl =%d, curBtDecPwrLvl =%d\n",
 610                                 pCoexDm->preBtDecPwrLvl,
 611                                 pCoexDm->curBtDecPwrLvl
 612                         )
 613                 );
 614
 615                 if (pCoexDm->preBtDecPwrLvl == pCoexDm->curBtDecPwrLvl)
 616                         return;
 617         }
 618         halbtc8723b2ant_SetFwDecBtPwr(pBtCoexist, pCoexDm->curBtDecPwrLvl);
 619
 620         pCoexDm->preBtDecPwrLvl = pCoexDm->curBtDecPwrLvl;
 621 }
 622
 623 static void halbtc8723b2ant_FwDacSwingLvl(
 624         PBTC_COEXIST pBtCoexist, bool bForceExec, u8 fwDacSwingLvl
 625 )
 626 {
 627         BTC_PRINT(
 628                 BTC_MSG_ALGORITHM,
 629                 ALGO_TRACE_FW,
 630                 (
 631                         "[BTCoex], %s set FW Dac Swing level = %d\n",
 632                         (bForceExec ? "force to" : ""),
 633                         fwDacSwingLvl
 634                 )
 635         );
 636         pCoexDm->curFwDacSwingLvl = fwDacSwingLvl;
 637
 638         if (!bForceExec) {
 639                 BTC_PRINT(
 640                         BTC_MSG_ALGORITHM,
 641                         ALGO_TRACE_FW_DETAIL,
 642                         (
 643                                 "[BTCoex], preFwDacSwingLvl =%d, curFwDacSwingLvl =%d\n",
 644                                 pCoexDm->preFwDacSwingLvl,
 645                                 pCoexDm->curFwDacSwingLvl
 646                         )
 647                 );
 648
 649                 if (pCoexDm->preFwDacSwingLvl == pCoexDm->curFwDacSwingLvl)
 650                         return;
 651         }
 652
 653         halbtc8723b2ant_SetFwDacSwingLevel(pBtCoexist, pCoexDm->curFwDacSwingLvl);
 654
 655         pCoexDm->preFwDacSwingLvl = pCoexDm->curFwDacSwingLvl;
 656 }
 657
 658 static void halbtc8723b2ant_SetSwRfRxLpfCorner(
 659         PBTC_COEXIST pBtCoexist,
 660         bool bRxRfShrinkOn
 661 )
 662 {
 663         if (bRxRfShrinkOn) {
 664                 /* Shrink RF Rx LPF corner */
 665                 BTC_PRINT(
 666                         BTC_MSG_ALGORITHM,
 667                         ALGO_TRACE_SW_EXEC,
 668                         ("[BTCoex], Shrink RF Rx LPF corner!!\n")
 669                 );
 670                 pBtCoexist->fBtcSetRfReg(pBtCoexist, BTC_RF_A, 0x1e, 0xfffff, 0xffffc);
 671         } else {
 672                 /* Resume RF Rx LPF corner */
 673                 /*  After initialized, we can use pCoexDm->btRf0x1eBackup */
 674                 if (pBtCoexist->bInitilized) {
 675                         BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_EXEC, ("[BTCoex], Resume RF Rx LPF corner!!\n"));
 676                         pBtCoexist->fBtcSetRfReg(pBtCoexist, BTC_RF_A, 0x1e, 0xfffff, pCoexDm->btRf0x1eBackup);
 677                 }
 678         }
 679 }
 680
 681 static void halbtc8723b2ant_RfShrink(
 682         PBTC_COEXIST pBtCoexist, bool bForceExec, bool bRxRfShrinkOn
 683 )
 684 {
 685         BTC_PRINT(
 686                 BTC_MSG_ALGORITHM,
 687                 ALGO_TRACE_SW,
 688                 (
 689                         "[BTCoex], %s turn Rx RF Shrink = %s\n",
 690                         (bForceExec ? "force to" : ""),
 691                         (bRxRfShrinkOn ? "ON" : "OFF")
 692                 )
 693         );
 694         pCoexDm->bCurRfRxLpfShrink = bRxRfShrinkOn;
 695
 696         if (!bForceExec) {
 697                 BTC_PRINT(
 698                         BTC_MSG_ALGORITHM,
 699                         ALGO_TRACE_SW_DETAIL,
 700                         (
 701                                 "[BTCoex], bPreRfRxLpfShrink =%d, bCurRfRxLpfShrink =%d\n",
 702                                 pCoexDm->bPreRfRxLpfShrink,
 703                                 pCoexDm->bCurRfRxLpfShrink
 704                         )
 705                 );
 706
 707                 if (pCoexDm->bPreRfRxLpfShrink == pCoexDm->bCurRfRxLpfShrink)
 708                         return;
 709         }
 710         halbtc8723b2ant_SetSwRfRxLpfCorner(pBtCoexist, pCoexDm->bCurRfRxLpfShrink);
 711
 712         pCoexDm->bPreRfRxLpfShrink = pCoexDm->bCurRfRxLpfShrink;
 713 }
 714
 715 static void halbtc8723b2ant_SetSwPenaltyTxRateAdaptive(
 716         PBTC_COEXIST pBtCoexist, bool bLowPenaltyRa
 717 )
 718 {
 719         u8      H2C_Parameter[6] = {0};
 720
 721         H2C_Parameter[0] = 0x6; /*  opCode, 0x6 = Retry_Penalty */
 722
 723         if (bLowPenaltyRa) {
 724                 H2C_Parameter[1] |= BIT0;
 725                 H2C_Parameter[2] = 0x00;  /* normal rate except MCS7/6/5, OFDM54/48/36 */
 726                 H2C_Parameter[3] = 0xf7;  /* MCS7 or OFDM54 */
 727                 H2C_Parameter[4] = 0xf8;  /* MCS6 or OFDM48 */
 728                 H2C_Parameter[5] = 0xf9;        /* MCS5 or OFDM36 */
 729         }
 730
 731         BTC_PRINT(
 732                 BTC_MSG_ALGORITHM,
 733                 ALGO_TRACE_FW_EXEC,
 734                 (
 735                         "[BTCoex], set WiFi Low-Penalty Retry: %s",
 736                         (bLowPenaltyRa ? "ON!!" : "OFF!!")
 737                 )
 738         );
 739
 740         pBtCoexist->fBtcFillH2c(pBtCoexist, 0x69, 6, H2C_Parameter);
 741 }
 742
 743 static void halbtc8723b2ant_LowPenaltyRa(
 744         PBTC_COEXIST pBtCoexist, bool bForceExec, bool bLowPenaltyRa
 745 )
 746 {
 747         /* return; */
 748         BTC_PRINT(
 749                 BTC_MSG_ALGORITHM,
 750                 ALGO_TRACE_SW,
 751                 (
 752                         "[BTCoex], %s turn LowPenaltyRA = %s\n",
 753                         (bForceExec ? "force to" : ""),
 754                         (bLowPenaltyRa ? "ON" : "OFF")
 755                 )
 756         );
 757         pCoexDm->bCurLowPenaltyRa = bLowPenaltyRa;
 758
 759         if (!bForceExec) {
 760                 BTC_PRINT(
 761                         BTC_MSG_ALGORITHM,
 762                         ALGO_TRACE_SW_DETAIL,
 763                         (
 764                                 "[BTCoex], bPreLowPenaltyRa =%d, bCurLowPenaltyRa =%d\n",
 765                                 pCoexDm->bPreLowPenaltyRa,
 766                                 pCoexDm->bCurLowPenaltyRa
 767                         )
 768                 );
 769
 770                 if (pCoexDm->bPreLowPenaltyRa == pCoexDm->bCurLowPenaltyRa)
 771                         return;
 772         }
 773         halbtc8723b2ant_SetSwPenaltyTxRateAdaptive(pBtCoexist, pCoexDm->bCurLowPenaltyRa);
 774
 775         pCoexDm->bPreLowPenaltyRa = pCoexDm->bCurLowPenaltyRa;
 776 }
 777
 778 static void halbtc8723b2ant_SetDacSwingReg(PBTC_COEXIST pBtCoexist, u32 level)
 779 {
 780         u8 val = (u8)level;
 781
 782         BTC_PRINT(
 783                 BTC_MSG_ALGORITHM,
 784                 ALGO_TRACE_SW_EXEC,
 785                 ("[BTCoex], Write SwDacSwing = 0x%x\n", level)
 786         );
 787         pBtCoexist->fBtcWrite1ByteBitMask(pBtCoexist, 0x883, 0x3e, val);
 788 }
 789
 790 static void halbtc8723b2ant_SetSwFullTimeDacSwing(
 791         PBTC_COEXIST pBtCoexist, bool bSwDacSwingOn, u32 swDacSwingLvl
 792 )
 793 {
 794         if (bSwDacSwingOn)
 795                 halbtc8723b2ant_SetDacSwingReg(pBtCoexist, swDacSwingLvl);
 796         else
 797                 halbtc8723b2ant_SetDacSwingReg(pBtCoexist, 0x18);
 798 }
 799
 800
 801 static void halbtc8723b2ant_DacSwing(
 802         PBTC_COEXIST pBtCoexist,
 803         bool bForceExec,
 804         bool bDacSwingOn,
 805         u32 dacSwingLvl
 806 )
 807 {
 808         BTC_PRINT(
 809                 BTC_MSG_ALGORITHM,
 810                 ALGO_TRACE_SW,
 811                 (
 812                         "[BTCoex], %s turn DacSwing =%s, dacSwingLvl = 0x%x\n",
 813                         (bForceExec ? "force to" : ""),
 814                         (bDacSwingOn ? "ON" : "OFF"),
 815                         dacSwingLvl
 816                 )
 817         );
 818         pCoexDm->bCurDacSwingOn = bDacSwingOn;
 819         pCoexDm->curDacSwingLvl = dacSwingLvl;
 820
 821         if (!bForceExec) {
 822                 BTC_PRINT(
 823                         BTC_MSG_ALGORITHM,
 824                         ALGO_TRACE_SW_DETAIL,
 825                         (
 826                                 "[BTCoex], bPreDacSwingOn =%d, preDacSwingLvl = 0x%x, bCurDacSwingOn =%d, curDacSwingLvl = 0x%x\n",
 827                                 pCoexDm->bPreDacSwingOn,
 828                                 pCoexDm->preDacSwingLvl,
 829                                 pCoexDm->bCurDacSwingOn,
 830                                 pCoexDm->curDacSwingLvl
 831                         )
 832                 );
 833
 834                 if ((pCoexDm->bPreDacSwingOn == pCoexDm->bCurDacSwingOn) &&
 835                         (pCoexDm->preDacSwingLvl == pCoexDm->curDacSwingLvl))
 836                         return;
 837         }
 838         mdelay(30);
 839         halbtc8723b2ant_SetSwFullTimeDacSwing(pBtCoexist, bDacSwingOn, dacSwingLvl);
 840
 841         pCoexDm->bPreDacSwingOn = pCoexDm->bCurDacSwingOn;
 842         pCoexDm->preDacSwingLvl = pCoexDm->curDacSwingLvl;
 843 }
 844
 845 static void halbtc8723b2ant_SetAgcTable(
 846         PBTC_COEXIST pBtCoexist, bool bAgcTableEn
 847 )
 848 {
 849         u8 rssiAdjustVal = 0;
 850
 851         /* BB AGC Gain Table */
 852         if (bAgcTableEn) {
 853                 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_EXEC, ("[BTCoex], BB Agc Table On!\n"));
 854                 pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0xc78, 0x6e1A0001);
 855                 pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0xc78, 0x6d1B0001);
 856                 pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0xc78, 0x6c1C0001);
 857                 pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0xc78, 0x6b1D0001);
 858                 pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0xc78, 0x6a1E0001);
 859                 pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0xc78, 0x691F0001);
 860                 pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0xc78, 0x68200001);
 861         } else {
 862                 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_EXEC, ("[BTCoex], BB Agc Table Off!\n"));
 863                 pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0xc78, 0xaa1A0001);
 864                 pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0xc78, 0xa91B0001);
 865                 pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0xc78, 0xa81C0001);
 866                 pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0xc78, 0xa71D0001);
 867                 pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0xc78, 0xa61E0001);
 868                 pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0xc78, 0xa51F0001);
 869                 pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0xc78, 0xa4200001);
 870         }
 871
 872
 873         /* RF Gain */
 874         pBtCoexist->fBtcSetRfReg(pBtCoexist, BTC_RF_A, 0xef, 0xfffff, 0x02000);
 875         if (bAgcTableEn) {
 876                 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_EXEC, ("[BTCoex], Agc Table On!\n"));
 877                 pBtCoexist->fBtcSetRfReg(pBtCoexist, BTC_RF_A, 0x3b, 0xfffff, 0x38fff);
 878                 pBtCoexist->fBtcSetRfReg(pBtCoexist, BTC_RF_A, 0x3b, 0xfffff, 0x38ffe);
 879         } else {
 880                 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_EXEC, ("[BTCoex], Agc Table Off!\n"));
 881                 pBtCoexist->fBtcSetRfReg(pBtCoexist, BTC_RF_A, 0x3b, 0xfffff, 0x380c3);
 882                 pBtCoexist->fBtcSetRfReg(pBtCoexist, BTC_RF_A, 0x3b, 0xfffff, 0x28ce6);
 883         }
 884         pBtCoexist->fBtcSetRfReg(pBtCoexist, BTC_RF_A, 0xef, 0xfffff, 0x0);
 885
 886         pBtCoexist->fBtcSetRfReg(pBtCoexist, BTC_RF_A, 0xed, 0xfffff, 0x1);
 887         if (bAgcTableEn) {
 888                 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_EXEC, ("[BTCoex], Agc Table On!\n"));
 889                 pBtCoexist->fBtcSetRfReg(pBtCoexist, BTC_RF_A, 0x40, 0xfffff, 0x38fff);
 890                 pBtCoexist->fBtcSetRfReg(pBtCoexist, BTC_RF_A, 0x40, 0xfffff, 0x38ffe);
 891         } else {
 892                 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_EXEC, ("[BTCoex], Agc Table Off!\n"));
 893                 pBtCoexist->fBtcSetRfReg(pBtCoexist, BTC_RF_A, 0x40, 0xfffff, 0x380c3);
 894                 pBtCoexist->fBtcSetRfReg(pBtCoexist, BTC_RF_A, 0x40, 0xfffff, 0x28ce6);
 895         }
 896         pBtCoexist->fBtcSetRfReg(pBtCoexist, BTC_RF_A, 0xed, 0xfffff, 0x0);
 897
 898         /*  set rssiAdjustVal for wifi module. */
 899         if (bAgcTableEn)
 900                 rssiAdjustVal = 8;
 901
 902         pBtCoexist->fBtcSet(pBtCoexist, BTC_SET_U1_RSSI_ADJ_VAL_FOR_AGC_TABLE_ON, &rssiAdjustVal);
 903 }
 904
 905 static void halbtc8723b2ant_AgcTable(
 906         PBTC_COEXIST pBtCoexist, bool bForceExec, bool bAgcTableEn
 907 )
 908 {
 909         BTC_PRINT(
 910                 BTC_MSG_ALGORITHM,
 911                 ALGO_TRACE_SW,
 912                 (
 913                         "[BTCoex], %s %s Agc Table\n",
 914                         (bForceExec ? "force to" : ""),
 915                         (bAgcTableEn ? "Enable" : "Disable")
 916                 )
 917         );
 918         pCoexDm->bCurAgcTableEn = bAgcTableEn;
 919
 920         if (!bForceExec) {
 921                 BTC_PRINT(
 922                         BTC_MSG_ALGORITHM,
 923                         ALGO_TRACE_SW_DETAIL,
 924                         (
 925                                 "[BTCoex], bPreAgcTableEn =%d, bCurAgcTableEn =%d\n",
 926                                 pCoexDm->bPreAgcTableEn,
 927                                 pCoexDm->bCurAgcTableEn
 928                         )
 929                 );
 930
 931                 if (pCoexDm->bPreAgcTableEn == pCoexDm->bCurAgcTableEn)
 932                         return;
 933         }
 934         halbtc8723b2ant_SetAgcTable(pBtCoexist, bAgcTableEn);
 935
 936         pCoexDm->bPreAgcTableEn = pCoexDm->bCurAgcTableEn;
 937 }
 938
 939 static void halbtc8723b2ant_SetCoexTable(
 940         PBTC_COEXIST pBtCoexist,
 941         u32 val0x6c0,
 942         u32 val0x6c4,
 943         u32 val0x6c8,
 944         u8 val0x6cc
 945 )
 946 {
 947         BTC_PRINT(
 948                 BTC_MSG_ALGORITHM,
 949                 ALGO_TRACE_SW_EXEC,
 950                 ("[BTCoex], set coex table, set 0x6c0 = 0x%x\n", val0x6c0)
 951         );
 952         pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0x6c0, val0x6c0);
 953
 954         BTC_PRINT(
 955                 BTC_MSG_ALGORITHM,
 956                 ALGO_TRACE_SW_EXEC,
 957                 ("[BTCoex], set coex table, set 0x6c4 = 0x%x\n", val0x6c4)
 958         );
 959         pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0x6c4, val0x6c4);
 960
 961         BTC_PRINT(
 962                 BTC_MSG_ALGORITHM,
 963                 ALGO_TRACE_SW_EXEC,
 964                 ("[BTCoex], set coex table, set 0x6c8 = 0x%x\n", val0x6c8)
 965         );
 966         pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0x6c8, val0x6c8);
 967
 968         BTC_PRINT(
 969                 BTC_MSG_ALGORITHM,
 970                 ALGO_TRACE_SW_EXEC,
 971                 ("[BTCoex], set coex table, set 0x6cc = 0x%x\n", val0x6cc)
 972         );
 973         pBtCoexist->fBtcWrite1Byte(pBtCoexist, 0x6cc, val0x6cc);
 974 }
 975
 976 static void halbtc8723b2ant_CoexTable(
 977         PBTC_COEXIST pBtCoexist,
 978         bool bForceExec,
 979         u32 val0x6c0,
 980         u32 val0x6c4,
 981         u32 val0x6c8,
 982         u8 val0x6cc
 983 )
 984 {
 985         BTC_PRINT(
 986                 BTC_MSG_ALGORITHM,
 987                 ALGO_TRACE_SW,
 988                 (
 989                         "[BTCoex], %s write Coex Table 0x6c0 = 0x%x, 0x6c4 = 0x%x, 0x6c8 = 0x%x, 0x6cc = 0x%x\n",
 990                         (bForceExec ? "force to" : ""),
 991                         val0x6c0,
 992                         val0x6c4,
 993                         val0x6c8,
 994                         val0x6cc
 995                 )
 996         );
 997         pCoexDm->curVal0x6c0 = val0x6c0;
 998         pCoexDm->curVal0x6c4 = val0x6c4;
 999         pCoexDm->curVal0x6c8 = val0x6c8;
1000         pCoexDm->curVal0x6cc = val0x6cc;
1001
1002         if (!bForceExec) {
1003                 BTC_PRINT(
1004                         BTC_MSG_ALGORITHM,
1005                         ALGO_TRACE_SW_DETAIL,
1006                         (
1007                                 "[BTCoex], preVal0x6c0 = 0x%x, preVal0x6c4 = 0x%x, preVal0x6c8 = 0x%x, preVal0x6cc = 0x%x !!\n",
1008                                 pCoexDm->preVal0x6c0,
1009                                 pCoexDm->preVal0x6c4,
1010                                 pCoexDm->preVal0x6c8,
1011                                 pCoexDm->preVal0x6cc
1012                         )
1013                 );
1014                 BTC_PRINT(
1015                         BTC_MSG_ALGORITHM,
1016                         ALGO_TRACE_SW_DETAIL,
1017                         (
1018                                 "[BTCoex], curVal0x6c0 = 0x%x, curVal0x6c4 = 0x%x, curVal0x6c8 = 0x%x, curVal0x6cc = 0x%x !!\n",
1019                                 pCoexDm->curVal0x6c0,
1020                                 pCoexDm->curVal0x6c4,
1021                                 pCoexDm->curVal0x6c8,
1022                                 pCoexDm->curVal0x6cc
1023                         )
1024                 );
1025
1026                 if (
1027                         (pCoexDm->preVal0x6c0 == pCoexDm->curVal0x6c0) &&
1028                         (pCoexDm->preVal0x6c4 == pCoexDm->curVal0x6c4) &&
1029                         (pCoexDm->preVal0x6c8 == pCoexDm->curVal0x6c8) &&
1030                         (pCoexDm->preVal0x6cc == pCoexDm->curVal0x6cc)
1031                 )
1032                         return;
1033         }
1034         halbtc8723b2ant_SetCoexTable(pBtCoexist, val0x6c0, val0x6c4, val0x6c8, val0x6cc);
1035
1036         pCoexDm->preVal0x6c0 = pCoexDm->curVal0x6c0;
1037         pCoexDm->preVal0x6c4 = pCoexDm->curVal0x6c4;
1038         pCoexDm->preVal0x6c8 = pCoexDm->curVal0x6c8;
1039         pCoexDm->preVal0x6cc = pCoexDm->curVal0x6cc;
1040 }
1041
1042 static void halbtc8723b2ant_CoexTableWithType(
1043         PBTC_COEXIST pBtCoexist, bool bForceExec, u8 type
1044 )
1045 {
1046         switch (type) {
1047         case 0:
1048                 halbtc8723b2ant_CoexTable(pBtCoexist, bForceExec, 0x55555555, 0x55555555, 0xffff, 0x3);
1049                 break;
1050         case 1:
1051                 halbtc8723b2ant_CoexTable(pBtCoexist, bForceExec, 0x55555555, 0x5afa5afa, 0xffff, 0x3);
1052                 break;
1053         case 2:
1054                 halbtc8723b2ant_CoexTable(pBtCoexist, bForceExec, 0x5a5a5a5a, 0x5a5a5a5a, 0xffff, 0x3);
1055                 break;
1056         case 3:
1057                 halbtc8723b2ant_CoexTable(pBtCoexist, bForceExec, 0xaaaaaaaa, 0xaaaaaaaa, 0xffff, 0x3);
1058                 break;
1059         case 4:
1060                 halbtc8723b2ant_CoexTable(pBtCoexist, bForceExec, 0xffffffff, 0xffffffff, 0xffff, 0x3);
1061                 break;
1062         case 5:
1063                 halbtc8723b2ant_CoexTable(pBtCoexist, bForceExec, 0x5fff5fff, 0x5fff5fff, 0xffff, 0x3);
1064                 break;
1065         case 6:
1066                 halbtc8723b2ant_CoexTable(pBtCoexist, bForceExec, 0x55ff55ff, 0x5a5a5a5a, 0xffff, 0x3);
1067                 break;
1068         case 7:
1069                 halbtc8723b2ant_CoexTable(pBtCoexist, bForceExec, 0x55ff55ff, 0xfafafafa, 0xffff, 0x3);
1070                 break;
1071         case 8:
1072                 halbtc8723b2ant_CoexTable(pBtCoexist, bForceExec, 0x5aea5aea, 0x5aea5aea, 0xffff, 0x3);
1073                 break;
1074         case 9:
1075                 halbtc8723b2ant_CoexTable(pBtCoexist, bForceExec, 0x55ff55ff, 0x5aea5aea, 0xffff, 0x3);
1076                 break;
1077         case 10:
1078                 halbtc8723b2ant_CoexTable(pBtCoexist, bForceExec, 0x55ff55ff, 0x5aff5aff, 0xffff, 0x3);
1079                 break;
1080         case 11:
1081                 halbtc8723b2ant_CoexTable(pBtCoexist, bForceExec, 0x55ff55ff, 0x5a5f5a5f, 0xffff, 0x3);
1082                 break;
1083         case 12:
1084                 halbtc8723b2ant_CoexTable(pBtCoexist, bForceExec, 0x55ff55ff, 0x5f5f5f5f, 0xffff, 0x3);
1085                 break;
1086         default:
1087                 break;
1088         }
1089 }
1090
1091 static void halbtc8723b2ant_SetFwIgnoreWlanAct(
1092         PBTC_COEXIST pBtCoexist, bool bEnable
1093 )
1094 {
1095         u8      H2C_Parameter[1] = {0};
1096
1097         if (bEnable)
1098                 H2C_Parameter[0] |= BIT0;               /*  function enable */
1099
1100         BTC_PRINT(
1101                 BTC_MSG_ALGORITHM,
1102                 ALGO_TRACE_FW_EXEC,
1103                 (
1104                         "[BTCoex], set FW for BT Ignore Wlan_Act, FW write 0x63 = 0x%x\n",
1105                         H2C_Parameter[0]
1106                 )
1107         );
1108
1109         pBtCoexist->fBtcFillH2c(pBtCoexist, 0x63, 1, H2C_Parameter);
1110 }
1111
1112 static void halbtc8723b2ant_IgnoreWlanAct(
1113         PBTC_COEXIST pBtCoexist, bool bForceExec, bool bEnable
1114 )
1115 {
1116         BTC_PRINT(
1117                 BTC_MSG_ALGORITHM,
1118                 ALGO_TRACE_FW,
1119                 (
1120                         "[BTCoex], %s turn Ignore WlanAct %s\n",
1121                         (bForceExec ? "force to" : ""),
1122                         (bEnable ? "ON" : "OFF")
1123                 )
1124         );
1125
1126         pCoexDm->bCurIgnoreWlanAct = bEnable;
1127
1128         if (!bForceExec) {
1129                 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL, ("[BTCoex], bPreIgnoreWlanAct = %d, bCurIgnoreWlanAct = %d!!\n",
1130                         pCoexDm->bPreIgnoreWlanAct, pCoexDm->bCurIgnoreWlanAct));
1131
1132                 if (pCoexDm->bPreIgnoreWlanAct == pCoexDm->bCurIgnoreWlanAct)
1133                         return;
1134         }
1135         halbtc8723b2ant_SetFwIgnoreWlanAct(pBtCoexist, bEnable);
1136
1137         pCoexDm->bPreIgnoreWlanAct = pCoexDm->bCurIgnoreWlanAct;
1138 }
1139
1140 static void halbtc8723b2ant_SetFwPstdma(
1141         PBTC_COEXIST pBtCoexist,
1142         u8 byte1,
1143         u8 byte2,
1144         u8 byte3,
1145         u8 byte4,
1146         u8 byte5
1147 )
1148 {
1149         u8      H2C_Parameter[5] = {0};
1150
1151         H2C_Parameter[0] = byte1;
1152         H2C_Parameter[1] = byte2;
1153         H2C_Parameter[2] = byte3;
1154         H2C_Parameter[3] = byte4;
1155         H2C_Parameter[4] = byte5;
1156
1157         pCoexDm->psTdmaPara[0] = byte1;
1158         pCoexDm->psTdmaPara[1] = byte2;
1159         pCoexDm->psTdmaPara[2] = byte3;
1160         pCoexDm->psTdmaPara[3] = byte4;
1161         pCoexDm->psTdmaPara[4] = byte5;
1162
1163         BTC_PRINT(
1164                 BTC_MSG_ALGORITHM,
1165                 ALGO_TRACE_FW_EXEC,
1166                 (
1167                         "[BTCoex], FW write 0x60(5bytes) = 0x%x%08x\n",
1168                         H2C_Parameter[0],
1169                         H2C_Parameter[1]<<24|
1170                         H2C_Parameter[2]<<16|
1171                         H2C_Parameter[3]<<8|
1172                         H2C_Parameter[4]
1173                 )
1174         );
1175
1176         pBtCoexist->fBtcFillH2c(pBtCoexist, 0x60, 5, H2C_Parameter);
1177 }
1178
1179 static void halbtc8723b2ant_SwMechanism1(
1180         PBTC_COEXIST pBtCoexist,
1181         bool bShrinkRxLPF,
1182         bool bLowPenaltyRA,
1183         bool bLimitedDIG,
1184         bool bBTLNAConstrain
1185 )
1186 {
1187         halbtc8723b2ant_RfShrink(pBtCoexist, NORMAL_EXEC, bShrinkRxLPF);
1188         halbtc8723b2ant_LowPenaltyRa(pBtCoexist, NORMAL_EXEC, bLowPenaltyRA);
1189 }
1190
1191 static void halbtc8723b2ant_SwMechanism2(
1192         PBTC_COEXIST pBtCoexist,
1193         bool bAGCTableShift,
1194         bool bADCBackOff,
1195         bool bSWDACSwing,
1196         u32 dacSwingLvl
1197 )
1198 {
1199         halbtc8723b2ant_AgcTable(pBtCoexist, NORMAL_EXEC, bAGCTableShift);
1200         halbtc8723b2ant_DacSwing(pBtCoexist, NORMAL_EXEC, bSWDACSwing, dacSwingLvl);
1201 }
1202
1203 static void halbtc8723b2ant_SetAntPath(
1204         PBTC_COEXIST pBtCoexist, u8 antPosType, bool bInitHwCfg, bool bWifiOff
1205 )
1206 {
1207         PBTC_BOARD_INFO pBoardInfo = &pBtCoexist->boardInfo;
1208         u32 fwVer = 0, u4Tmp = 0;
1209         bool bPgExtSwitch = false;
1210         bool bUseExtSwitch = false;
1211         u8      H2C_Parameter[2] = {0};
1212
1213         pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_EXT_SWITCH, &bPgExtSwitch);
1214         pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_U4_WIFI_FW_VER, &fwVer);        /*  [31:16]=fw ver, [15:0]=fw sub ver */
1215
1216         if ((fwVer > 0 && fwVer < 0xc0000) || bPgExtSwitch)
1217                 bUseExtSwitch = true;
1218
1219         if (bInitHwCfg) {
1220                 pBtCoexist->fBtcWrite1ByteBitMask(pBtCoexist, 0x39, 0x8, 0x1);
1221                 pBtCoexist->fBtcWrite1Byte(pBtCoexist, 0x974, 0xff);
1222                 pBtCoexist->fBtcWrite1ByteBitMask(pBtCoexist, 0x944, 0x3, 0x3);
1223                 pBtCoexist->fBtcWrite1Byte(pBtCoexist, 0x930, 0x77);
1224                 pBtCoexist->fBtcWrite1ByteBitMask(pBtCoexist, 0x67, 0x20, 0x1);
1225
1226                 if (fwVer >= 0x180000) {
1227                         /* Use H2C to set GNT_BT to LOW */
1228                         H2C_Parameter[0] = 0;
1229                         pBtCoexist->fBtcFillH2c(pBtCoexist, 0x6E, 1, H2C_Parameter);
1230                 } else {
1231                         pBtCoexist->fBtcWrite1Byte(pBtCoexist, 0x765, 0x0);
1232                 }
1233
1234                 pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0x948, 0x0);
1235
1236                 pBtCoexist->fBtcSetRfReg(pBtCoexist, BTC_RF_A, 0x1, 0xfffff, 0x0); /* WiFi TRx Mask off */
1237                 pBtCoexist->fBtcSetBtReg(pBtCoexist, BTC_BT_REG_RF, 0x3c, 0x01); /* BT TRx Mask off */
1238
1239                 if (pBoardInfo->btdmAntPos == BTC_ANTENNA_AT_MAIN_PORT) {
1240                         /* tell firmware "no antenna inverse" */
1241                         H2C_Parameter[0] = 0;
1242                 } else {
1243                         /* tell firmware "antenna inverse" */
1244                         H2C_Parameter[0] = 1;
1245                 }
1246
1247                 if (bUseExtSwitch) {
1248                         /* ext switch type */
1249                         H2C_Parameter[1] = 1;
1250                 } else {
1251                         /* int switch type */
1252                         H2C_Parameter[1] = 0;
1253                 }
1254                 pBtCoexist->fBtcFillH2c(pBtCoexist, 0x65, 2, H2C_Parameter);
1255         }
1256
1257         /*  ext switch setting */
1258         if (bUseExtSwitch) {
1259                 if (bInitHwCfg) {
1260                         /*  0x4c[23]= 0, 0x4c[24]= 1  Antenna control by WL/BT */
1261                         u4Tmp = pBtCoexist->fBtcRead4Byte(pBtCoexist, 0x4c);
1262                         u4Tmp &= ~BIT23;
1263                         u4Tmp |= BIT24;
1264                         pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0x4c, u4Tmp);
1265                 }
1266
1267                 pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0x948, 0x0); /*  fixed internal switch S1->WiFi, S0->BT */
1268                 switch (antPosType) {
1269                 case BTC_ANT_WIFI_AT_MAIN:
1270                         pBtCoexist->fBtcWrite1ByteBitMask(pBtCoexist, 0x92c, 0x3, 0x1); /*  ext switch main at wifi */
1271                         break;
1272                 case BTC_ANT_WIFI_AT_AUX:
1273                         pBtCoexist->fBtcWrite1ByteBitMask(pBtCoexist, 0x92c, 0x3, 0x2); /*  ext switch aux at wifi */
1274                         break;
1275                 }
1276         } else { /*  internal switch */
1277                 if (bInitHwCfg) {
1278                         /*  0x4c[23]= 0, 0x4c[24]= 1  Antenna control by WL/BT */
1279                         u4Tmp = pBtCoexist->fBtcRead4Byte(pBtCoexist, 0x4c);
1280                         u4Tmp |= BIT23;
1281                         u4Tmp &= ~BIT24;
1282                         pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0x4c, u4Tmp);
1283                 }
1284
1285                 pBtCoexist->fBtcWrite1ByteBitMask(pBtCoexist, 0x64, 0x1, 0x0); /* fixed external switch S1->Main, S0->Aux */
1286                 switch (antPosType) {
1287                 case BTC_ANT_WIFI_AT_MAIN:
1288                         pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0x948, 0x0); /*  fixed internal switch S1->WiFi, S0->BT */
1289                         break;
1290                 case BTC_ANT_WIFI_AT_AUX:
1291                         pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0x948, 0x280); /*  fixed internal switch S0->WiFi, S1->BT */
1292                         break;
1293                 }
1294         }
1295 }
1296
1297 static void halbtc8723b2ant_PsTdma(
1298         PBTC_COEXIST pBtCoexist, bool bForceExec, bool bTurnOn, u8 type
1299 )
1300 {
1301         BTC_PRINT(
1302                 BTC_MSG_ALGORITHM,
1303                 ALGO_TRACE_FW,
1304                 (
1305                         "[BTCoex], %s turn %s PS TDMA, type =%d\n",
1306                         (bForceExec ? "force to" : ""),
1307                         (bTurnOn ? "ON" : "OFF"),
1308                         type
1309                 )
1310         );
1311         pCoexDm->bCurPsTdmaOn = bTurnOn;
1312         pCoexDm->curPsTdma = type;
1313
1314         if (!bForceExec) {
1315                 BTC_PRINT(
1316                         BTC_MSG_ALGORITHM,
1317                         ALGO_TRACE_FW_DETAIL,
1318                         (
1319                                 "[BTCoex], bPrePsTdmaOn = %d, bCurPsTdmaOn = %d!!\n",
1320                                 pCoexDm->bPrePsTdmaOn,
1321                                 pCoexDm->bCurPsTdmaOn
1322                         )
1323                 );
1324                 BTC_PRINT(
1325                         BTC_MSG_ALGORITHM,
1326                         ALGO_TRACE_FW_DETAIL,
1327                         (
1328                                 "[BTCoex], prePsTdma = %d, curPsTdma = %d!!\n",
1329                                 pCoexDm->prePsTdma, pCoexDm->curPsTdma
1330                         )
1331                 );
1332
1333                 if (
1334                         (pCoexDm->bPrePsTdmaOn == pCoexDm->bCurPsTdmaOn) &&
1335                         (pCoexDm->prePsTdma == pCoexDm->curPsTdma)
1336                 )
1337                         return;
1338         }
1339
1340         if (bTurnOn) {
1341                 switch (type) {
1342                 case 1:
1343                 default:
1344                         halbtc8723b2ant_SetFwPstdma(pBtCoexist, 0xe3, 0x1a, 0x1a, 0xe1, 0x90);
1345                         break;
1346                 case 2:
1347                         halbtc8723b2ant_SetFwPstdma(pBtCoexist, 0xe3, 0x12, 0x12, 0xe1, 0x90);
1348                         break;
1349                 case 3:
1350                         halbtc8723b2ant_SetFwPstdma(pBtCoexist, 0xe3, 0x1c, 0x3, 0xf1, 0x90);
1351                         break;
1352                 case 4:
1353                         halbtc8723b2ant_SetFwPstdma(pBtCoexist, 0xe3, 0x10, 0x03, 0xf1, 0x90);
1354                         break;
1355                 case 5:
1356                         halbtc8723b2ant_SetFwPstdma(pBtCoexist, 0xe3, 0x1a, 0x1a, 0x60, 0x90);
1357                         break;
1358                 case 6:
1359                         halbtc8723b2ant_SetFwPstdma(pBtCoexist, 0xe3, 0x12, 0x12, 0x60, 0x90);
1360                         break;
1361                 case 7:
1362                         halbtc8723b2ant_SetFwPstdma(pBtCoexist, 0xe3, 0x1c, 0x3, 0x70, 0x90);
1363                         break;
1364                 case 8:
1365                         halbtc8723b2ant_SetFwPstdma(pBtCoexist, 0xa3, 0x10, 0x3, 0x70, 0x90);
1366                         break;
1367                 case 9:
1368                         halbtc8723b2ant_SetFwPstdma(pBtCoexist, 0xe3, 0x1a, 0x1a, 0xe1, 0x90);
1369                         break;
1370                 case 10:
1371                         halbtc8723b2ant_SetFwPstdma(pBtCoexist, 0xe3, 0x12, 0x12, 0xe1, 0x90);
1372                         break;
1373                 case 11:
1374                         halbtc8723b2ant_SetFwPstdma(pBtCoexist, 0xe3, 0xa, 0xa, 0xe1, 0x90);
1375                         break;
1376                 case 12:
1377                         halbtc8723b2ant_SetFwPstdma(pBtCoexist, 0xe3, 0x5, 0x5, 0xe1, 0x90);
1378                         break;
1379                 case 13:
1380                         halbtc8723b2ant_SetFwPstdma(pBtCoexist, 0xe3, 0x1a, 0x1a, 0x60, 0x90);
1381                         break;
1382                 case 14:
1383                         halbtc8723b2ant_SetFwPstdma(pBtCoexist, 0xe3, 0x12, 0x12, 0x60, 0x90);
1384                         break;
1385                 case 15:
1386                         halbtc8723b2ant_SetFwPstdma(pBtCoexist, 0xe3, 0xa, 0xa, 0x60, 0x90);
1387                         break;
1388                 case 16:
1389                         halbtc8723b2ant_SetFwPstdma(pBtCoexist, 0xe3, 0x5, 0x5, 0x60, 0x90);
1390                         break;
1391                 case 17:
1392                         halbtc8723b2ant_SetFwPstdma(pBtCoexist, 0xa3, 0x2f, 0x2f, 0x60, 0x90);
1393                         break;
1394                 case 18:
1395                         halbtc8723b2ant_SetFwPstdma(pBtCoexist, 0xe3, 0x5, 0x5, 0xe1, 0x90);
1396                         break;
1397                 case 19:
1398                         halbtc8723b2ant_SetFwPstdma(pBtCoexist, 0xe3, 0x25, 0x25, 0xe1, 0x90);
1399                         break;
1400                 case 20:
1401                         halbtc8723b2ant_SetFwPstdma(pBtCoexist, 0xe3, 0x25, 0x25, 0x60, 0x90);
1402                         break;
1403                 case 21:
1404                         halbtc8723b2ant_SetFwPstdma(pBtCoexist, 0xe3, 0x15, 0x03, 0x70, 0x90);
1405                         break;
1406                 case 71:
1407                         halbtc8723b2ant_SetFwPstdma(pBtCoexist, 0xe3, 0x1a, 0x1a, 0xe1, 0x90);
1408                         break;
1409                 }
1410         } else {
1411                 /*  disable PS tdma */
1412                 switch (type) {
1413                 case 0:
1414                         halbtc8723b2ant_SetFwPstdma(pBtCoexist, 0x0, 0x0, 0x0, 0x40, 0x0);
1415                         break;
1416                 case 1:
1417                         halbtc8723b2ant_SetFwPstdma(pBtCoexist, 0x0, 0x0, 0x0, 0x48, 0x0);
1418                         break;
1419                 default:
1420                         halbtc8723b2ant_SetFwPstdma(pBtCoexist, 0x0, 0x0, 0x0, 0x40, 0x0);
1421                         break;
1422                 }
1423         }
1424
1425         /*  update pre state */
1426         pCoexDm->bPrePsTdmaOn = pCoexDm->bCurPsTdmaOn;
1427         pCoexDm->prePsTdma = pCoexDm->curPsTdma;
1428 }
1429
1430 static void halbtc8723b2ant_CoexAllOff(PBTC_COEXIST pBtCoexist)
1431 {
1432         /*  fw all off */
1433         halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, false, 1);
1434         halbtc8723b2ant_FwDacSwingLvl(pBtCoexist, NORMAL_EXEC, 6);
1435         halbtc8723b2ant_DecBtPwr(pBtCoexist, NORMAL_EXEC, 0);
1436
1437         /*  sw all off */
1438         halbtc8723b2ant_SwMechanism1(pBtCoexist, false, false, false, false);
1439         halbtc8723b2ant_SwMechanism2(pBtCoexist, false, false, false, 0x18);
1440
1441         /*  hw all off */
1442         /* pBtCoexist->fBtcSetRfReg(pBtCoexist, BTC_RF_A, 0x1, 0xfffff, 0x0); */
1443         halbtc8723b2ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 0);
1444 }
1445
1446 static void halbtc8723b2ant_InitCoexDm(PBTC_COEXIST pBtCoexist)
1447 {
1448         /*  force to reset coex mechanism */
1449
1450         halbtc8723b2ant_PsTdma(pBtCoexist, FORCE_EXEC, false, 1);
1451         halbtc8723b2ant_FwDacSwingLvl(pBtCoexist, FORCE_EXEC, 6);
1452         halbtc8723b2ant_DecBtPwr(pBtCoexist, FORCE_EXEC, 0);
1453
1454         halbtc8723b2ant_SwMechanism1(pBtCoexist, false, false, false, false);
1455         halbtc8723b2ant_SwMechanism2(pBtCoexist, false, false, false, 0x18);
1456 }
1457
1458 static void halbtc8723b2ant_ActionBtInquiry(PBTC_COEXIST pBtCoexist)
1459 {
1460         bool bWifiConnected = false;
1461         bool bLowPwrDisable = true;
1462
1463         pBtCoexist->fBtcSet(pBtCoexist, BTC_SET_ACT_DISABLE_LOW_POWER, &bLowPwrDisable);
1464         pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_WIFI_CONNECTED, &bWifiConnected);
1465
1466         if (bWifiConnected) {
1467                 halbtc8723b2ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 7);
1468                 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 3);
1469         } else {
1470                 halbtc8723b2ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 0);
1471                 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, false, 1);
1472         }
1473
1474         halbtc8723b2ant_FwDacSwingLvl(pBtCoexist, FORCE_EXEC, 6);
1475         halbtc8723b2ant_DecBtPwr(pBtCoexist, NORMAL_EXEC, 0);
1476
1477         halbtc8723b2ant_SwMechanism1(pBtCoexist, false, false, false, false);
1478         halbtc8723b2ant_SwMechanism2(pBtCoexist, false, false, false, 0x18);
1479
1480         pCoexDm->bNeedRecover0x948 = true;
1481         pCoexDm->backup0x948 = pBtCoexist->fBtcRead4Byte(pBtCoexist, 0x948);
1482
1483         halbtc8723b2ant_SetAntPath(pBtCoexist, BTC_ANT_WIFI_AT_AUX, false, false);
1484 }
1485
1486 static bool halbtc8723b2ant_IsCommonAction(PBTC_COEXIST pBtCoexist)
1487 {
1488         u8 btRssiState = BTC_RSSI_STATE_HIGH;
1489         bool bCommon = false, bWifiConnected = false, bWifiBusy = false;
1490         bool bBtHsOn = false, bLowPwrDisable = false;
1491
1492         pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_HS_OPERATION, &bBtHsOn);
1493         pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_WIFI_CONNECTED, &bWifiConnected);
1494         pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_WIFI_BUSY, &bWifiBusy);
1495
1496         if (!bWifiConnected) {
1497                 bLowPwrDisable = false;
1498                 pBtCoexist->fBtcSet(pBtCoexist, BTC_SET_ACT_DISABLE_LOW_POWER, &bLowPwrDisable);
1499                 halbtc8723b2ant_LimitedRx(pBtCoexist, NORMAL_EXEC, false, false, 0x8);
1500
1501                 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], Wifi non-connected idle!!\n"));
1502
1503                 pBtCoexist->fBtcSetRfReg(pBtCoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
1504                 halbtc8723b2ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 0);
1505                 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, false, 1);
1506                 halbtc8723b2ant_FwDacSwingLvl(pBtCoexist, NORMAL_EXEC, 6);
1507                 halbtc8723b2ant_DecBtPwr(pBtCoexist, NORMAL_EXEC, 0);
1508
1509                 halbtc8723b2ant_SwMechanism1(pBtCoexist, false, false, false, false);
1510                 halbtc8723b2ant_SwMechanism2(pBtCoexist, false, false, false, 0x18);
1511
1512                 bCommon = true;
1513         } else {
1514                 if (BT_8723B_2ANT_BT_STATUS_NON_CONNECTED_IDLE == pCoexDm->btStatus) {
1515                         bLowPwrDisable = false;
1516                         pBtCoexist->fBtcSet(pBtCoexist, BTC_SET_ACT_DISABLE_LOW_POWER, &bLowPwrDisable);
1517                         halbtc8723b2ant_LimitedRx(pBtCoexist, NORMAL_EXEC, false, false, 0x8);
1518
1519                         BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], Wifi connected + BT non connected-idle!!\n"));
1520
1521                         pBtCoexist->fBtcSetRfReg(pBtCoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
1522                         halbtc8723b2ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 0);
1523                         halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, false, 1);
1524                         halbtc8723b2ant_FwDacSwingLvl(pBtCoexist, NORMAL_EXEC, 0xb);
1525                         halbtc8723b2ant_DecBtPwr(pBtCoexist, NORMAL_EXEC, 0);
1526
1527                         halbtc8723b2ant_SwMechanism1(pBtCoexist, false, false, false, false);
1528                         halbtc8723b2ant_SwMechanism2(pBtCoexist, false, false, false, 0x18);
1529
1530                         bCommon = true;
1531                 } else if (BT_8723B_2ANT_BT_STATUS_CONNECTED_IDLE == pCoexDm->btStatus) {
1532                         bLowPwrDisable = true;
1533                         pBtCoexist->fBtcSet(pBtCoexist, BTC_SET_ACT_DISABLE_LOW_POWER, &bLowPwrDisable);
1534
1535                         if (bBtHsOn)
1536                                 return false;
1537
1538                         BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], Wifi connected + BT connected-idle!!\n"));
1539                         halbtc8723b2ant_LimitedRx(pBtCoexist, NORMAL_EXEC, false, false, 0x8);
1540
1541                         pBtCoexist->fBtcSetRfReg(pBtCoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
1542                         halbtc8723b2ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 0);
1543                         halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, false, 1);
1544                         halbtc8723b2ant_FwDacSwingLvl(pBtCoexist, NORMAL_EXEC, 0xb);
1545                         halbtc8723b2ant_DecBtPwr(pBtCoexist, NORMAL_EXEC, 0);
1546
1547                         halbtc8723b2ant_SwMechanism1(pBtCoexist, true, false, false, false);
1548                         halbtc8723b2ant_SwMechanism2(pBtCoexist, false, false, false, 0x18);
1549
1550                         bCommon = true;
1551                 } else {
1552                         bLowPwrDisable = true;
1553                         pBtCoexist->fBtcSet(pBtCoexist, BTC_SET_ACT_DISABLE_LOW_POWER, &bLowPwrDisable);
1554
1555                         if (bWifiBusy) {
1556                                 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], Wifi Connected-Busy + BT Busy!!\n"));
1557                                 bCommon = false;
1558                         } else {
1559                                 if (bBtHsOn)
1560                                         return false;
1561
1562                                 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], Wifi Connected-Idle + BT Busy!!\n"));
1563                                 btRssiState = halbtc8723b2ant_BtRssiState(2, 29, 0);
1564                                 halbtc8723b2ant_LimitedRx(pBtCoexist, NORMAL_EXEC, false, false, 0x8);
1565
1566                                 pBtCoexist->fBtcSetRfReg(pBtCoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
1567                                 halbtc8723b2ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 7);
1568                                 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 21);
1569                                 halbtc8723b2ant_FwDacSwingLvl(pBtCoexist, NORMAL_EXEC, 0xb);
1570
1571                                 if (BTC_RSSI_HIGH(btRssiState))
1572                                         halbtc8723b2ant_DecBtPwr(pBtCoexist, NORMAL_EXEC, 2);
1573                                 else
1574                                         halbtc8723b2ant_DecBtPwr(pBtCoexist, NORMAL_EXEC, 0);
1575
1576                                 halbtc8723b2ant_SwMechanism1(pBtCoexist, false, false, false, false);
1577                                 halbtc8723b2ant_SwMechanism2(pBtCoexist, false, false, false, 0x18);
1578                                 bCommon = true;
1579                         }
1580                 }
1581         }
1582
1583         return bCommon;
1584 }
1585
1586 static void halbtc8723b2ant_TdmaDurationAdjust(
1587         PBTC_COEXIST pBtCoexist, bool bScoHid, bool bTxPause, u8 maxInterval
1588 )
1589 {
1590         static s32 up, dn, m, n, WaitCount;
1591         s32 result;   /* 0: no change, +1: increase WiFi duration, -1: decrease WiFi duration */
1592         u8 retryCount = 0;
1593
1594         BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW, ("[BTCoex], TdmaDurationAdjust()\n"));
1595
1596         if (!pCoexDm->bAutoTdmaAdjust) {
1597                 pCoexDm->bAutoTdmaAdjust = true;
1598                 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL, ("[BTCoex], first run TdmaDurationAdjust()!!\n"));
1599                 {
1600                         if (bScoHid) {
1601                                 if (bTxPause) {
1602                                         if (maxInterval == 1) {
1603                                                 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 13);
1604                                                 pCoexDm->psTdmaDuAdjType = 13;
1605                                         } else if (maxInterval == 2) {
1606                                                 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 14);
1607                                                 pCoexDm->psTdmaDuAdjType = 14;
1608                                         } else if (maxInterval == 3) {
1609                                                 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 15);
1610                                                 pCoexDm->psTdmaDuAdjType = 15;
1611                                         } else {
1612                                                 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 15);
1613                                                 pCoexDm->psTdmaDuAdjType = 15;
1614                                         }
1615                                 } else {
1616                                         if (maxInterval == 1) {
1617                                                 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 9);
1618                                                 pCoexDm->psTdmaDuAdjType = 9;
1619                                         } else if (maxInterval == 2) {
1620                                                 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 10);
1621                                                 pCoexDm->psTdmaDuAdjType = 10;
1622                                         } else if (maxInterval == 3) {
1623                                                 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 11);
1624                                                 pCoexDm->psTdmaDuAdjType = 11;
1625                                         } else {
1626                                                 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 11);
1627                                                 pCoexDm->psTdmaDuAdjType = 11;
1628                                         }
1629                                 }
1630                         } else {
1631                                 if (bTxPause) {
1632                                         if (maxInterval == 1) {
1633                                                 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 5);
1634                                                 pCoexDm->psTdmaDuAdjType = 5;
1635                                         } else if (maxInterval == 2) {
1636                                                 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 6);
1637                                                 pCoexDm->psTdmaDuAdjType = 6;
1638                                         } else if (maxInterval == 3) {
1639                                                 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 7);
1640                                                 pCoexDm->psTdmaDuAdjType = 7;
1641                                         } else {
1642                                                 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 7);
1643                                                 pCoexDm->psTdmaDuAdjType = 7;
1644                                         }
1645                                 } else {
1646                                         if (maxInterval == 1) {
1647                                                 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 1);
1648                                                 pCoexDm->psTdmaDuAdjType = 1;
1649                                         } else if (maxInterval == 2) {
1650                                                 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 2);
1651                                                 pCoexDm->psTdmaDuAdjType = 2;
1652                                         } else if (maxInterval == 3) {
1653                                                 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 3);
1654                                                 pCoexDm->psTdmaDuAdjType = 3;
1655                                         } else {
1656                                                 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 3);
1657                                                 pCoexDm->psTdmaDuAdjType = 3;
1658                                         }
1659                                 }
1660                         }
1661                 }
1662                 /*  */
1663                 up = 0;
1664                 dn = 0;
1665                 m = 1;
1666                 n = 3;
1667                 result = 0;
1668                 WaitCount = 0;
1669         } else {
1670                 /* accquire the BT TRx retry count from BT_Info byte2 */
1671                 retryCount = pCoexSta->btRetryCnt;
1672                 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL, ("[BTCoex], retryCount = %d\n", retryCount));
1673                 BTC_PRINT(
1674                         BTC_MSG_ALGORITHM,
1675                         ALGO_TRACE_FW_DETAIL,
1676                         (
1677                                 "[BTCoex], up =%d, dn =%d, m =%d, n =%d, WaitCount =%d\n",
1678                                 up, dn, m, n, WaitCount
1679                         )
1680                 );
1681                 result = 0;
1682                 WaitCount++;
1683
1684                 if (retryCount == 0) { /*  no retry in the last 2-second duration */
1685                         up++;
1686                         dn--;
1687
1688                         if (dn <= 0)
1689                                 dn = 0;
1690
1691                         if (up >= n) { /*  if 連續 n 個2秒 retry count為0, 則調寬WiFi duration */
1692                                 WaitCount = 0;
1693                                 n = 3;
1694                                 up = 0;
1695                                 dn = 0;
1696                                 result = 1;
1697                                 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL, ("[BTCoex], Increase wifi duration!!\n"));
1698                         }
1699                 } else if (retryCount <= 3) { /*  <=3 retry in the last 2-second duration */
1700                         up--;
1701                         dn++;
1702
1703                         if (up <= 0)
1704                                 up = 0;
1705
1706                         if (dn == 2) { /*  if 連續 2 個2秒 retry count< 3, 則調窄WiFi duration */
1707                                 if (WaitCount <= 2)
1708                                         m++; /*  避免一直在兩個level中來回 */
1709                                 else
1710                                         m = 1;
1711
1712                                 if (m >= 20) /* m 最大值 = 20 ' 最大120秒 recheck是否調整 WiFi duration. */
1713                                         m = 20;
1714
1715                                 n = 3*m;
1716                                 up = 0;
1717                                 dn = 0;
1718                                 WaitCount = 0;
1719                                 result = -1;
1720                                 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL, ("[BTCoex], Decrease wifi duration for retryCounter<3!!\n"));
1721                         }
1722                 } else { /* retry count > 3, 只要1次 retry count > 3, 則調窄WiFi duration */
1723                         if (WaitCount == 1)
1724                                 m++; /*  避免一直在兩個level中來回 */
1725                         else
1726                                 m = 1;
1727
1728                         if (m >= 20) /* m 最大值 = 20 ' 最大120秒 recheck是否調整 WiFi duration. */
1729                                 m = 20;
1730
1731                         n = 3*m;
1732                         up = 0;
1733                         dn = 0;
1734                         WaitCount = 0;
1735                         result = -1;
1736                         BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL, ("[BTCoex], Decrease wifi duration for retryCounter>3!!\n"));
1737                 }
1738
1739                 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL, ("[BTCoex], max Interval = %d\n", maxInterval));
1740                 if (maxInterval == 1) {
1741                         if (bTxPause) {
1742                                 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL, ("[BTCoex], TxPause = 1\n"));
1743
1744                                 if (pCoexDm->curPsTdma == 71) {
1745                                         halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 5);
1746                                         pCoexDm->psTdmaDuAdjType = 5;
1747                                 } else if (pCoexDm->curPsTdma == 1) {
1748                                         halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 5);
1749                                         pCoexDm->psTdmaDuAdjType = 5;
1750                                 } else if (pCoexDm->curPsTdma == 2) {
1751                                         halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 6);
1752                                         pCoexDm->psTdmaDuAdjType = 6;
1753                                 } else if (pCoexDm->curPsTdma == 3) {
1754                                         halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 7);
1755                                         pCoexDm->psTdmaDuAdjType = 7;
1756                                 } else if (pCoexDm->curPsTdma == 4) {
1757                                         halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 8);
1758                                         pCoexDm->psTdmaDuAdjType = 8;
1759                                 }
1760
1761                                 if (pCoexDm->curPsTdma == 9) {
1762                                         halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 13);
1763                                         pCoexDm->psTdmaDuAdjType = 13;
1764                                 } else if (pCoexDm->curPsTdma == 10) {
1765                                         halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 14);
1766                                         pCoexDm->psTdmaDuAdjType = 14;
1767                                 } else if (pCoexDm->curPsTdma == 11) {
1768                                         halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 15);
1769                                         pCoexDm->psTdmaDuAdjType = 15;
1770                                 } else if (pCoexDm->curPsTdma == 12) {
1771                                         halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 16);
1772                                         pCoexDm->psTdmaDuAdjType = 16;
1773                                 }
1774
1775                                 if (result == -1) {
1776                                         if (pCoexDm->curPsTdma == 5) {
1777                                                 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 6);
1778                                                 pCoexDm->psTdmaDuAdjType = 6;
1779                                         } else if (pCoexDm->curPsTdma == 6) {
1780                                                 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 7);
1781                                                 pCoexDm->psTdmaDuAdjType = 7;
1782                                         } else if (pCoexDm->curPsTdma == 7) {
1783                                                 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 8);
1784                                                 pCoexDm->psTdmaDuAdjType = 8;
1785                                         } else if (pCoexDm->curPsTdma == 13) {
1786                                                 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 14);
1787                                                 pCoexDm->psTdmaDuAdjType = 14;
1788                                         } else if (pCoexDm->curPsTdma == 14) {
1789                                                 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 15);
1790                                                 pCoexDm->psTdmaDuAdjType = 15;
1791                                         } else if (pCoexDm->curPsTdma == 15) {
1792                                                 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 16);
1793                                                 pCoexDm->psTdmaDuAdjType = 16;
1794                                         }
1795                                 } else if (result == 1) {
1796                                         if (pCoexDm->curPsTdma == 8) {
1797                                                 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 7);
1798                                                 pCoexDm->psTdmaDuAdjType = 7;
1799                                         } else if (pCoexDm->curPsTdma == 7) {
1800                                                 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 6);
1801                                                 pCoexDm->psTdmaDuAdjType = 6;
1802                                         } else if (pCoexDm->curPsTdma == 6) {
1803                                                 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 5);
1804                                                 pCoexDm->psTdmaDuAdjType = 5;
1805                                         } else if (pCoexDm->curPsTdma == 16) {
1806                                                 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 15);
1807                                                 pCoexDm->psTdmaDuAdjType = 15;
1808                                         } else if (pCoexDm->curPsTdma == 15) {
1809                                                 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 14);
1810                                                 pCoexDm->psTdmaDuAdjType = 14;
1811                                         } else if (pCoexDm->curPsTdma == 14) {
1812                                                 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 13);
1813                                                 pCoexDm->psTdmaDuAdjType = 13;
1814                                         }
1815                                 }
1816                         } else {
1817                                 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL, ("[BTCoex], TxPause = 0\n"));
1818                                 if (pCoexDm->curPsTdma == 5) {
1819                                         halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 71);
1820                                         pCoexDm->psTdmaDuAdjType = 71;
1821                                 } else if (pCoexDm->curPsTdma == 6) {
1822                                         halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 2);
1823                                         pCoexDm->psTdmaDuAdjType = 2;
1824                                 } else if (pCoexDm->curPsTdma == 7) {
1825                                         halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 3);
1826                                         pCoexDm->psTdmaDuAdjType = 3;
1827                                 } else if (pCoexDm->curPsTdma == 8) {
1828                                         halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 4);
1829                                         pCoexDm->psTdmaDuAdjType = 4;
1830                                 }
1831
1832                                 if (pCoexDm->curPsTdma == 13) {
1833                                         halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 9);
1834                                         pCoexDm->psTdmaDuAdjType = 9;
1835                                 } else if (pCoexDm->curPsTdma == 14) {
1836                                         halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 10);
1837                                         pCoexDm->psTdmaDuAdjType = 10;
1838                                 } else if (pCoexDm->curPsTdma == 15) {
1839                                         halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 11);
1840                                         pCoexDm->psTdmaDuAdjType = 11;
1841                                 } else if (pCoexDm->curPsTdma == 16) {
1842                                         halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 12);
1843                                         pCoexDm->psTdmaDuAdjType = 12;
1844                                 }
1845
1846                                 if (result == -1) {
1847                                         if (pCoexDm->curPsTdma == 71) {
1848                                                 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 1);
1849                                                 pCoexDm->psTdmaDuAdjType = 1;
1850                                         } else if (pCoexDm->curPsTdma == 1) {
1851                                                 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 2);
1852                                                 pCoexDm->psTdmaDuAdjType = 2;
1853                                         } else if (pCoexDm->curPsTdma == 2) {
1854                                                 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 3);
1855                                                 pCoexDm->psTdmaDuAdjType = 3;
1856                                         } else if (pCoexDm->curPsTdma == 3) {
1857                                                 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 4);
1858                                                 pCoexDm->psTdmaDuAdjType = 4;
1859                                         } else if (pCoexDm->curPsTdma == 9) {
1860                                                 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 10);
1861                                                 pCoexDm->psTdmaDuAdjType = 10;
1862                                         } else if (pCoexDm->curPsTdma == 10) {
1863                                                 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 11);
1864                                                 pCoexDm->psTdmaDuAdjType = 11;
1865                                         } else if (pCoexDm->curPsTdma == 11) {
1866                                                 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 12);
1867                                                 pCoexDm->psTdmaDuAdjType = 12;
1868                                         }
1869                                 } else if (result == 1) {
1870                                         if (pCoexDm->curPsTdma == 4) {
1871                                                 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 3);
1872                                                 pCoexDm->psTdmaDuAdjType = 3;
1873                                         } else if (pCoexDm->curPsTdma == 3) {
1874                                                 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 2);
1875                                                 pCoexDm->psTdmaDuAdjType = 2;
1876                                         } else if (pCoexDm->curPsTdma == 2) {
1877                                                 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 1);
1878                                                 pCoexDm->psTdmaDuAdjType = 1;
1879                                         } else if (pCoexDm->curPsTdma == 1) {
1880                                                 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 71);
1881                                                 pCoexDm->psTdmaDuAdjType = 71;
1882                                         } else if (pCoexDm->curPsTdma == 12) {
1883                                                 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 11);
1884                                                 pCoexDm->psTdmaDuAdjType = 11;
1885                                         } else if (pCoexDm->curPsTdma == 11) {
1886                                                 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 10);
1887                                                 pCoexDm->psTdmaDuAdjType = 10;
1888                                         } else if (pCoexDm->curPsTdma == 10) {
1889                                                 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 9);
1890                                                 pCoexDm->psTdmaDuAdjType = 9;
1891                                         }
1892                                 }
1893                         }
1894                 } else if (maxInterval == 2) {
1895                         if (bTxPause) {
1896                                 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL, ("[BTCoex], TxPause = 1\n"));
1897                                 if (pCoexDm->curPsTdma == 1) {
1898                                         halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 6);
1899                                         pCoexDm->psTdmaDuAdjType = 6;
1900                                 } else if (pCoexDm->curPsTdma == 2) {
1901                                         halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 6);
1902                                         pCoexDm->psTdmaDuAdjType = 6;
1903                                 } else if (pCoexDm->curPsTdma == 3) {
1904                                         halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 7);
1905                                         pCoexDm->psTdmaDuAdjType = 7;
1906                                 } else if (pCoexDm->curPsTdma == 4) {
1907                                         halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 8);
1908                                         pCoexDm->psTdmaDuAdjType = 8;
1909                                 }
1910
1911                                 if (pCoexDm->curPsTdma == 9) {
1912                                         halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 14);
1913                                         pCoexDm->psTdmaDuAdjType = 14;
1914                                 } else if (pCoexDm->curPsTdma == 10) {
1915                                         halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 14);
1916                                         pCoexDm->psTdmaDuAdjType = 14;
1917                                 } else if (pCoexDm->curPsTdma == 11) {
1918                                         halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 15);
1919                                         pCoexDm->psTdmaDuAdjType = 15;
1920                                 } else if (pCoexDm->curPsTdma == 12) {
1921                                         halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 16);
1922                                         pCoexDm->psTdmaDuAdjType = 16;
1923                                 }
1924
1925                                 if (result == -1) {
1926                                         if (pCoexDm->curPsTdma == 5) {
1927                                                 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 6);
1928                                                 pCoexDm->psTdmaDuAdjType = 6;
1929                                         } else if (pCoexDm->curPsTdma == 6) {
1930                                                 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 7);
1931                                                 pCoexDm->psTdmaDuAdjType = 7;
1932                                         } else if (pCoexDm->curPsTdma == 7) {
1933                                                 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 8);
1934                                                 pCoexDm->psTdmaDuAdjType = 8;
1935                                         } else if (pCoexDm->curPsTdma == 13) {
1936                                                 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 14);
1937                                                 pCoexDm->psTdmaDuAdjType = 14;
1938                                         } else if (pCoexDm->curPsTdma == 14) {
1939                                                 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 15);
1940                                                 pCoexDm->psTdmaDuAdjType = 15;
1941                                         } else if (pCoexDm->curPsTdma == 15) {
1942                                                 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 16);
1943                                                 pCoexDm->psTdmaDuAdjType = 16;
1944                                         }
1945                                 } else if (result == 1) {
1946                                         if (pCoexDm->curPsTdma == 8) {
1947                                                 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 7);
1948                                                 pCoexDm->psTdmaDuAdjType = 7;
1949                                         } else if (pCoexDm->curPsTdma == 7) {
1950                                                 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 6);
1951                                                 pCoexDm->psTdmaDuAdjType = 6;
1952                                         } else if (pCoexDm->curPsTdma == 6) {
1953                                                 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 6);
1954                                                 pCoexDm->psTdmaDuAdjType = 6;
1955                                         } else if (pCoexDm->curPsTdma == 16) {
1956                                                 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 15);
1957                                                 pCoexDm->psTdmaDuAdjType = 15;
1958                                         } else if (pCoexDm->curPsTdma == 15) {
1959                                                 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 14);
1960                                                 pCoexDm->psTdmaDuAdjType = 14;
1961                                         } else if (pCoexDm->curPsTdma == 14) {
1962                                                 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 14);
1963                                                 pCoexDm->psTdmaDuAdjType = 14;
1964                                         }
1965                                 }
1966                         } else {
1967                                 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL, ("[BTCoex], TxPause = 0\n"));
1968                                 if (pCoexDm->curPsTdma == 5) {
1969                                         halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 2);
1970                                         pCoexDm->psTdmaDuAdjType = 2;
1971                                 } else if (pCoexDm->curPsTdma == 6) {
1972                                         halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 2);
1973                                         pCoexDm->psTdmaDuAdjType = 2;
1974                                 } else if (pCoexDm->curPsTdma == 7) {
1975                                         halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 3);
1976                                         pCoexDm->psTdmaDuAdjType = 3;
1977                                 } else if (pCoexDm->curPsTdma == 8) {
1978                                         halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 4);
1979                                         pCoexDm->psTdmaDuAdjType = 4;
1980                                 }
1981
1982                                 if (pCoexDm->curPsTdma == 13) {
1983                                         halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 10);
1984                                         pCoexDm->psTdmaDuAdjType = 10;
1985                                 } else if (pCoexDm->curPsTdma == 14) {
1986                                         halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 10);
1987                                         pCoexDm->psTdmaDuAdjType = 10;
1988                                 } else if (pCoexDm->curPsTdma == 15) {
1989                                         halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 11);
1990                                         pCoexDm->psTdmaDuAdjType = 11;
1991                                 } else if (pCoexDm->curPsTdma == 16) {
1992                                         halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 12);
1993                                         pCoexDm->psTdmaDuAdjType = 12;
1994                                 }
1995
1996                                 if (result == -1) {
1997                                         if (pCoexDm->curPsTdma == 1) {
1998                                                 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 2);
1999                                                 pCoexDm->psTdmaDuAdjType = 2;
2000                                         } else if (pCoexDm->curPsTdma == 2) {
2001                                                 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 3);
2002                                                 pCoexDm->psTdmaDuAdjType = 3;
2003                                         } else if (pCoexDm->curPsTdma == 3) {
2004                                                 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 4);
2005                                                 pCoexDm->psTdmaDuAdjType = 4;
2006                                         } else if (pCoexDm->curPsTdma == 9) {
2007                                                 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 10);
2008                                                 pCoexDm->psTdmaDuAdjType = 10;
2009                                         } else if (pCoexDm->curPsTdma == 10) {
2010                                                 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 11);
2011                                                 pCoexDm->psTdmaDuAdjType = 11;
2012                                         } else if (pCoexDm->curPsTdma == 11) {
2013                                                 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 12);
2014                                                 pCoexDm->psTdmaDuAdjType = 12;
2015                                         }
2016                                 } else if (result == 1) {
2017                                         if (pCoexDm->curPsTdma == 4) {
2018                                                 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 3);
2019                                                 pCoexDm->psTdmaDuAdjType = 3;
2020                                         } else if (pCoexDm->curPsTdma == 3) {
2021                                                 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 2);
2022                                                 pCoexDm->psTdmaDuAdjType = 2;
2023                                         } else if (pCoexDm->curPsTdma == 2) {
2024                                                 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 2);
2025                                                 pCoexDm->psTdmaDuAdjType = 2;
2026                                         } else if (pCoexDm->curPsTdma == 12) {
2027                                                 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 11);
2028                                                 pCoexDm->psTdmaDuAdjType = 11;
2029                                         } else if (pCoexDm->curPsTdma == 11) {
2030                                                 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 10);
2031                                                 pCoexDm->psTdmaDuAdjType = 10;
2032                                         } else if (pCoexDm->curPsTdma == 10) {
2033                                                 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 10);
2034                                                 pCoexDm->psTdmaDuAdjType = 10;
2035                                         }
2036                                 }
2037                         }
2038                 } else if (maxInterval == 3) {
2039                         if (bTxPause) {
2040                                 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL, ("[BTCoex], TxPause = 1\n"));
2041                                 if (pCoexDm->curPsTdma == 1) {
2042                                         halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 7);
2043                                         pCoexDm->psTdmaDuAdjType = 7;
2044                                 } else if (pCoexDm->curPsTdma == 2) {
2045                                         halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 7);
2046                                         pCoexDm->psTdmaDuAdjType = 7;
2047                                 } else if (pCoexDm->curPsTdma == 3) {
2048                                         halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 7);
2049                                         pCoexDm->psTdmaDuAdjType = 7;
2050                                 } else if (pCoexDm->curPsTdma == 4) {
2051                                         halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 8);
2052                                         pCoexDm->psTdmaDuAdjType = 8;
2053                                 }
2054
2055                                 if (pCoexDm->curPsTdma == 9) {
2056                                         halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 15);
2057                                         pCoexDm->psTdmaDuAdjType = 15;
2058                                 } else if (pCoexDm->curPsTdma == 10) {
2059                                         halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 15);
2060                                         pCoexDm->psTdmaDuAdjType = 15;
2061                                 } else if (pCoexDm->curPsTdma == 11) {
2062                                         halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 15);
2063                                         pCoexDm->psTdmaDuAdjType = 15;
2064                                 } else if (pCoexDm->curPsTdma == 12) {
2065                                         halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 16);
2066                                         pCoexDm->psTdmaDuAdjType = 16;
2067                                 }
2068
2069                                 if (result == -1) {
2070                                         if (pCoexDm->curPsTdma == 5) {
2071                                                 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 7);
2072                                                 pCoexDm->psTdmaDuAdjType = 7;
2073                                         } else if (pCoexDm->curPsTdma == 6) {
2074                                                 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 7);
2075                                                 pCoexDm->psTdmaDuAdjType = 7;
2076                                         } else if (pCoexDm->curPsTdma == 7) {
2077                                                 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 8);
2078                                                 pCoexDm->psTdmaDuAdjType = 8;
2079                                         } else if (pCoexDm->curPsTdma == 13) {
2080                                                 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 15);
2081                                                 pCoexDm->psTdmaDuAdjType = 15;
2082                                         } else if (pCoexDm->curPsTdma == 14) {
2083                                                 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 15);
2084                                                 pCoexDm->psTdmaDuAdjType = 15;
2085                                         } else if (pCoexDm->curPsTdma == 15) {
2086                                                 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 16);
2087                                                 pCoexDm->psTdmaDuAdjType = 16;
2088                                         }
2089                                 } else if (result == 1) {
2090                                         if (pCoexDm->curPsTdma == 8) {
2091                                                 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 7);
2092                                                 pCoexDm->psTdmaDuAdjType = 7;
2093                                         } else if (pCoexDm->curPsTdma == 7) {
2094                                                 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 7);
2095                                                 pCoexDm->psTdmaDuAdjType = 7;
2096                                         } else if (pCoexDm->curPsTdma == 6) {
2097                                                 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 7);
2098                                                 pCoexDm->psTdmaDuAdjType = 7;
2099                                         } else if (pCoexDm->curPsTdma == 16) {
2100                                                 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 15);
2101                                                 pCoexDm->psTdmaDuAdjType = 15;
2102                                         } else if (pCoexDm->curPsTdma == 15) {
2103                                                 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 15);
2104                                                 pCoexDm->psTdmaDuAdjType = 15;
2105                                         } else if (pCoexDm->curPsTdma == 14) {
2106                                                 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 15);
2107                                                 pCoexDm->psTdmaDuAdjType = 15;
2108                                         }
2109                                 }
2110                         } else {
2111                                 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL, ("[BTCoex], TxPause = 0\n"));
2112                                 if (pCoexDm->curPsTdma == 5) {
2113                                         halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 3);
2114                                         pCoexDm->psTdmaDuAdjType = 3;
2115                                 } else if (pCoexDm->curPsTdma == 6) {
2116                                         halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 3);
2117                                         pCoexDm->psTdmaDuAdjType = 3;
2118                                 } else if (pCoexDm->curPsTdma == 7) {
2119                                         halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 3);
2120                                         pCoexDm->psTdmaDuAdjType = 3;
2121                                 } else if (pCoexDm->curPsTdma == 8) {
2122                                         halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 4);
2123                                         pCoexDm->psTdmaDuAdjType = 4;
2124                                 }
2125
2126                                 if (pCoexDm->curPsTdma == 13) {
2127                                         halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 11);
2128                                         pCoexDm->psTdmaDuAdjType = 11;
2129                                 } else if (pCoexDm->curPsTdma == 14) {
2130                                         halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 11);
2131                                         pCoexDm->psTdmaDuAdjType = 11;
2132                                 } else if (pCoexDm->curPsTdma == 15) {
2133                                         halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 11);
2134                                         pCoexDm->psTdmaDuAdjType = 11;
2135                                 } else if (pCoexDm->curPsTdma == 16) {
2136                                         halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 12);
2137                                         pCoexDm->psTdmaDuAdjType = 12;
2138                                 }
2139
2140                                 if (result == -1) {
2141                                         if (pCoexDm->curPsTdma == 1) {
2142                                                 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 3);
2143                                                 pCoexDm->psTdmaDuAdjType = 3;
2144                                         } else if (pCoexDm->curPsTdma == 2) {
2145                                                 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 3);
2146                                                 pCoexDm->psTdmaDuAdjType = 3;
2147                                         } else if (pCoexDm->curPsTdma == 3) {
2148                                                 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 4);
2149                                                 pCoexDm->psTdmaDuAdjType = 4;
2150                                         } else if (pCoexDm->curPsTdma == 9) {
2151                                                 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 11);
2152                                                 pCoexDm->psTdmaDuAdjType = 11;
2153                                         } else if (pCoexDm->curPsTdma == 10) {
2154                                                 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 11);
2155                                                 pCoexDm->psTdmaDuAdjType = 11;
2156                                         } else if (pCoexDm->curPsTdma == 11) {
2157                                                 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 12);
2158                                                 pCoexDm->psTdmaDuAdjType = 12;
2159                                         }
2160                                 } else if (result == 1) {
2161                                         if (pCoexDm->curPsTdma == 4) {
2162                                                 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 3);
2163                                                 pCoexDm->psTdmaDuAdjType = 3;
2164                                         } else if (pCoexDm->curPsTdma == 3) {
2165                                                 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 3);
2166                                                 pCoexDm->psTdmaDuAdjType = 3;
2167                                         } else if (pCoexDm->curPsTdma == 2) {
2168                                                 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 3);
2169                                                 pCoexDm->psTdmaDuAdjType = 3;
2170                                         } else if (pCoexDm->curPsTdma == 12) {
2171                                                 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 11);
2172                                                 pCoexDm->psTdmaDuAdjType = 11;
2173                                         } else if (pCoexDm->curPsTdma == 11) {
2174                                                 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 11);
2175                                                 pCoexDm->psTdmaDuAdjType = 11;
2176                                         } else if (pCoexDm->curPsTdma == 10) {
2177                                                 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 11);
2178                                                 pCoexDm->psTdmaDuAdjType = 11;
2179                                         }
2180                                 }
2181                         }
2182                 }
2183         }
2184
2185         /*  if current PsTdma not match with the recorded one (when scan, dhcp...), */
2186         /*  then we have to adjust it back to the previous record one. */
2187         if (pCoexDm->curPsTdma != pCoexDm->psTdmaDuAdjType) {
2188                 bool bScan = false, bLink = false, bRoam = false;
2189                 BTC_PRINT(
2190                         BTC_MSG_ALGORITHM,
2191                         ALGO_TRACE_FW_DETAIL,
2192                         (
2193                                 "[BTCoex], PsTdma type mismatch!!!, curPsTdma =%d, recordPsTdma =%d\n",
2194                                 pCoexDm->curPsTdma,
2195                                 pCoexDm->psTdmaDuAdjType
2196                         )
2197                 );
2198
2199                 pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_WIFI_SCAN, &bScan);
2200                 pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_WIFI_LINK, &bLink);
2201                 pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_WIFI_ROAM, &bRoam);
2202
2203                 if (!bScan && !bLink && !bRoam)
2204                         halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, pCoexDm->psTdmaDuAdjType);
2205                 else {
2206                         BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL, ("[BTCoex], roaming/link/scan is under progress, will adjust next time!!!\n"));
2207                 }
2208         }
2209 }
2210
2211 /*  SCO only or SCO+PAN(HS) */
2212 static void halbtc8723b2ant_ActionSco(PBTC_COEXIST pBtCoexist)
2213 {
2214         u8 wifiRssiState, btRssiState;
2215         u32 wifiBw;
2216
2217         wifiRssiState = halbtc8723b2ant_WifiRssiState(pBtCoexist, 0, 2, 15, 0);
2218         btRssiState = halbtc8723b2ant_BtRssiState(2, 29, 0);
2219
2220         pBtCoexist->fBtcSetRfReg(pBtCoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
2221
2222         halbtc8723b2ant_LimitedRx(pBtCoexist, NORMAL_EXEC, false, false, 0x8);
2223
2224         halbtc8723b2ant_FwDacSwingLvl(pBtCoexist, NORMAL_EXEC, 4);
2225
2226         if (BTC_RSSI_HIGH(btRssiState))
2227                 halbtc8723b2ant_DecBtPwr(pBtCoexist, NORMAL_EXEC, 2);
2228         else
2229                 halbtc8723b2ant_DecBtPwr(pBtCoexist, NORMAL_EXEC, 0);
2230
2231         pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_U4_WIFI_BW, &wifiBw);
2232
2233         if (BTC_WIFI_BW_LEGACY == wifiBw) /* for SCO quality at 11b/g mode */
2234                 halbtc8723b2ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 2);
2235         else  /* for SCO quality & wifi performance balance at 11n mode */
2236                 halbtc8723b2ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 8);
2237
2238         halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, false, 0); /* for voice quality */
2239
2240         /*  sw mechanism */
2241         if (BTC_WIFI_BW_HT40 == wifiBw) {
2242                 if (
2243                         (wifiRssiState == BTC_RSSI_STATE_HIGH) ||
2244                         (wifiRssiState == BTC_RSSI_STATE_STAY_HIGH)
2245                 ) {
2246                         halbtc8723b2ant_SwMechanism1(pBtCoexist, true, true, false, false);
2247                         halbtc8723b2ant_SwMechanism2(pBtCoexist, true, false, true, 0x4);
2248                 } else {
2249                         halbtc8723b2ant_SwMechanism1(pBtCoexist, true, true, false, false);
2250                         halbtc8723b2ant_SwMechanism2(pBtCoexist, false, false, true, 0x4);
2251                 }
2252         } else {
2253                 if (
2254                         (wifiRssiState == BTC_RSSI_STATE_HIGH) ||
2255                         (wifiRssiState == BTC_RSSI_STATE_STAY_HIGH)
2256                 ) {
2257                         halbtc8723b2ant_SwMechanism1(pBtCoexist, false, true, false, false);
2258                         halbtc8723b2ant_SwMechanism2(pBtCoexist, true, false, true, 0x4);
2259                 } else {
2260                         halbtc8723b2ant_SwMechanism1(pBtCoexist, false, true, false, false);
2261                         halbtc8723b2ant_SwMechanism2(pBtCoexist, false, false, true, 0x4);
2262                 }
2263         }
2264 }
2265
2266
2267 static void halbtc8723b2ant_ActionHid(PBTC_COEXIST pBtCoexist)
2268 {
2269         u8 wifiRssiState, btRssiState;
2270         u32 wifiBw;
2271
2272         wifiRssiState = halbtc8723b2ant_WifiRssiState(pBtCoexist, 0, 2, 15, 0);
2273         btRssiState = halbtc8723b2ant_BtRssiState(2, 29, 0);
2274
2275         pBtCoexist->fBtcSetRfReg(pBtCoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
2276
2277         halbtc8723b2ant_LimitedRx(pBtCoexist, NORMAL_EXEC, false, false, 0x8);
2278
2279         halbtc8723b2ant_FwDacSwingLvl(pBtCoexist, NORMAL_EXEC, 6);
2280
2281         if (BTC_RSSI_HIGH(btRssiState))
2282                 halbtc8723b2ant_DecBtPwr(pBtCoexist, NORMAL_EXEC, 2);
2283         else
2284                 halbtc8723b2ant_DecBtPwr(pBtCoexist, NORMAL_EXEC, 0);
2285
2286         pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_U4_WIFI_BW, &wifiBw);
2287
2288         if (BTC_WIFI_BW_LEGACY == wifiBw) /* for HID at 11b/g mode */
2289                 halbtc8723b2ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 7);
2290         else  /* for HID quality & wifi performance balance at 11n mode */
2291                 halbtc8723b2ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 9);
2292
2293         if (
2294                 (btRssiState == BTC_RSSI_STATE_HIGH) ||
2295                 (btRssiState == BTC_RSSI_STATE_STAY_HIGH)
2296         )
2297                 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 9);
2298         else
2299                 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 13);
2300
2301         /*  sw mechanism */
2302         if (BTC_WIFI_BW_HT40 == wifiBw) {
2303                 if (
2304                         (wifiRssiState == BTC_RSSI_STATE_HIGH) ||
2305                         (wifiRssiState == BTC_RSSI_STATE_STAY_HIGH)
2306                 ) {
2307                         halbtc8723b2ant_SwMechanism1(pBtCoexist, true, true, false, false);
2308                         halbtc8723b2ant_SwMechanism2(pBtCoexist, true, false, false, 0x18);
2309                 } else {
2310                         halbtc8723b2ant_SwMechanism1(pBtCoexist, true, true, false, false);
2311                         halbtc8723b2ant_SwMechanism2(pBtCoexist, false, false, false, 0x18);
2312                 }
2313         } else {
2314                 if (
2315                         (wifiRssiState == BTC_RSSI_STATE_HIGH) ||
2316                         (wifiRssiState == BTC_RSSI_STATE_STAY_HIGH)
2317                 ) {
2318                         halbtc8723b2ant_SwMechanism1(pBtCoexist, false, true, false, false);
2319                         halbtc8723b2ant_SwMechanism2(pBtCoexist, true, false, false, 0x18);
2320                 } else {
2321                         halbtc8723b2ant_SwMechanism1(pBtCoexist, false, true, false, false);
2322                         halbtc8723b2ant_SwMechanism2(pBtCoexist, false, false, false, 0x18);
2323                 }
2324         }
2325 }
2326
2327 /* A2DP only / PAN(EDR) only/ A2DP+PAN(HS) */
2328 static void halbtc8723b2ant_ActionA2dp(PBTC_COEXIST pBtCoexist)
2329 {
2330         u8 wifiRssiState, wifiRssiState1, btRssiState;
2331         u32 wifiBw;
2332         u8 apNum = 0;
2333
2334         wifiRssiState = halbtc8723b2ant_WifiRssiState(pBtCoexist, 0, 2, 15, 0);
2335         wifiRssiState1 = halbtc8723b2ant_WifiRssiState(pBtCoexist, 1, 2, 40, 0);
2336         btRssiState = halbtc8723b2ant_BtRssiState(2, 29, 0);
2337
2338         pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_U1_AP_NUM, &apNum);
2339
2340         /*  define the office environment */
2341         if (apNum >= 10 && BTC_RSSI_HIGH(wifiRssiState1)) {
2342                 /* DbgPrint(" AP#>10(%d)\n", apNum); */
2343                 pBtCoexist->fBtcSetRfReg(pBtCoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
2344                 halbtc8723b2ant_LimitedRx(pBtCoexist, NORMAL_EXEC, false, false, 0x8);
2345                 halbtc8723b2ant_FwDacSwingLvl(pBtCoexist, NORMAL_EXEC, 6);
2346                 halbtc8723b2ant_DecBtPwr(pBtCoexist, NORMAL_EXEC, 0);
2347                 halbtc8723b2ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 0);
2348                 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, false, 1);
2349
2350                 /*  sw mechanism */
2351                 pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_U4_WIFI_BW, &wifiBw);
2352                 if (BTC_WIFI_BW_HT40 == wifiBw) {
2353                         halbtc8723b2ant_SwMechanism1(pBtCoexist, true, false, false, false);
2354                         halbtc8723b2ant_SwMechanism2(pBtCoexist, true, false, true, 0x18);
2355                 } else {
2356                         halbtc8723b2ant_SwMechanism1(pBtCoexist, false, false, false, false);
2357                         halbtc8723b2ant_SwMechanism2(pBtCoexist, true, false, true, 0x18);
2358                 }
2359                 return;
2360         }
2361
2362         pBtCoexist->fBtcSetRfReg(pBtCoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
2363         halbtc8723b2ant_LimitedRx(pBtCoexist, NORMAL_EXEC, false, false, 0x8);
2364
2365         halbtc8723b2ant_FwDacSwingLvl(pBtCoexist, NORMAL_EXEC, 6);
2366
2367         if (BTC_RSSI_HIGH(btRssiState))
2368                 halbtc8723b2ant_DecBtPwr(pBtCoexist, NORMAL_EXEC, 2);
2369         else
2370                 halbtc8723b2ant_DecBtPwr(pBtCoexist, NORMAL_EXEC, 0);
2371
2372         halbtc8723b2ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 7);
2373
2374         if (
2375                 (btRssiState == BTC_RSSI_STATE_HIGH) ||
2376                 (btRssiState == BTC_RSSI_STATE_STAY_HIGH)
2377         )
2378                 halbtc8723b2ant_TdmaDurationAdjust(pBtCoexist, false, false, 1);
2379         else
2380                 halbtc8723b2ant_TdmaDurationAdjust(pBtCoexist, false, true, 1);
2381
2382         /*  sw mechanism */
2383         pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_U4_WIFI_BW, &wifiBw);
2384         if (BTC_WIFI_BW_HT40 == wifiBw) {
2385                 if (
2386                         (wifiRssiState == BTC_RSSI_STATE_HIGH) ||
2387                         (wifiRssiState == BTC_RSSI_STATE_STAY_HIGH)
2388                 ) {
2389                         halbtc8723b2ant_SwMechanism1(pBtCoexist, true, false, false, false);
2390                         halbtc8723b2ant_SwMechanism2(pBtCoexist, true, false, false, 0x18);
2391                 } else {
2392                         halbtc8723b2ant_SwMechanism1(pBtCoexist, true, false, false, false);
2393                         halbtc8723b2ant_SwMechanism2(pBtCoexist, false, false, false, 0x18);
2394                 }
2395         } else {
2396                 if (
2397                         (wifiRssiState == BTC_RSSI_STATE_HIGH) ||
2398                         (wifiRssiState == BTC_RSSI_STATE_STAY_HIGH)
2399                 ) {
2400                         halbtc8723b2ant_SwMechanism1(pBtCoexist, false, false, false, false);
2401                         halbtc8723b2ant_SwMechanism2(pBtCoexist, true, false, false, 0x18);
2402                 } else {
2403                         halbtc8723b2ant_SwMechanism1(pBtCoexist, false, false, false, false);
2404                         halbtc8723b2ant_SwMechanism2(pBtCoexist, false, false, false, 0x18);
2405                 }
2406         }
2407 }
2408
2409 static void halbtc8723b2ant_ActionA2dpPanHs(PBTC_COEXIST pBtCoexist)
2410 {
2411         u8 wifiRssiState, btRssiState;
2412         u32 wifiBw;
2413
2414         wifiRssiState = halbtc8723b2ant_WifiRssiState(pBtCoexist, 0, 2, 15, 0);
2415         btRssiState = halbtc8723b2ant_BtRssiState(2, 29, 0);
2416
2417         pBtCoexist->fBtcSetRfReg(pBtCoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
2418
2419         halbtc8723b2ant_LimitedRx(pBtCoexist, NORMAL_EXEC, false, false, 0x8);
2420
2421         halbtc8723b2ant_FwDacSwingLvl(pBtCoexist, NORMAL_EXEC, 6);
2422
2423         if (BTC_RSSI_HIGH(btRssiState))
2424                 halbtc8723b2ant_DecBtPwr(pBtCoexist, NORMAL_EXEC, 2);
2425         else
2426                 halbtc8723b2ant_DecBtPwr(pBtCoexist, NORMAL_EXEC, 0);
2427
2428         halbtc8723b2ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 7);
2429
2430         halbtc8723b2ant_TdmaDurationAdjust(pBtCoexist, false, true, 2);
2431
2432         /*  sw mechanism */
2433         pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_U4_WIFI_BW, &wifiBw);
2434         if (BTC_WIFI_BW_HT40 == wifiBw) {
2435                 if (
2436                         (wifiRssiState == BTC_RSSI_STATE_HIGH) ||
2437                         (wifiRssiState == BTC_RSSI_STATE_STAY_HIGH)
2438                 ) {
2439                         halbtc8723b2ant_SwMechanism1(pBtCoexist, true, false, false, false);
2440                         halbtc8723b2ant_SwMechanism2(pBtCoexist, true, false, false, 0x18);
2441                 } else {
2442                         halbtc8723b2ant_SwMechanism1(pBtCoexist, true, false, false, false);
2443                         halbtc8723b2ant_SwMechanism2(pBtCoexist, false, false, false, 0x18);
2444                 }
2445         } else {
2446                 if (
2447                         (wifiRssiState == BTC_RSSI_STATE_HIGH) ||
2448                         (wifiRssiState == BTC_RSSI_STATE_STAY_HIGH)
2449                 ) {
2450                         halbtc8723b2ant_SwMechanism1(pBtCoexist, false, false, false, false);
2451                         halbtc8723b2ant_SwMechanism2(pBtCoexist, true, false, false, 0x18);
2452                 } else {
2453                         halbtc8723b2ant_SwMechanism1(pBtCoexist, false, false, false, false);
2454                         halbtc8723b2ant_SwMechanism2(pBtCoexist, false, false, false, 0x18);
2455                 }
2456         }
2457 }
2458
2459 static void halbtc8723b2ant_ActionPanEdr(PBTC_COEXIST pBtCoexist)
2460 {
2461         u8 wifiRssiState, btRssiState;
2462         u32 wifiBw;
2463
2464         wifiRssiState = halbtc8723b2ant_WifiRssiState(pBtCoexist, 0, 2, 15, 0);
2465         btRssiState = halbtc8723b2ant_BtRssiState(2, 29, 0);
2466
2467         pBtCoexist->fBtcSetRfReg(pBtCoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
2468
2469         halbtc8723b2ant_LimitedRx(pBtCoexist, NORMAL_EXEC, false, false, 0x8);
2470
2471         halbtc8723b2ant_FwDacSwingLvl(pBtCoexist, NORMAL_EXEC, 6);
2472
2473         if (BTC_RSSI_HIGH(btRssiState))
2474                 halbtc8723b2ant_DecBtPwr(pBtCoexist, NORMAL_EXEC, 2);
2475         else
2476                 halbtc8723b2ant_DecBtPwr(pBtCoexist, NORMAL_EXEC, 0);
2477
2478         halbtc8723b2ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 10);
2479
2480         if (
2481                 (btRssiState == BTC_RSSI_STATE_HIGH) ||
2482                 (btRssiState == BTC_RSSI_STATE_STAY_HIGH)
2483         )
2484                 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 1);
2485         else
2486                 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 5);
2487
2488         /*  sw mechanism */
2489         pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_U4_WIFI_BW, &wifiBw);
2490         if (BTC_WIFI_BW_HT40 == wifiBw) {
2491                 if (
2492                         (wifiRssiState == BTC_RSSI_STATE_HIGH) ||
2493                         (wifiRssiState == BTC_RSSI_STATE_STAY_HIGH)
2494                 ) {
2495                         halbtc8723b2ant_SwMechanism1(pBtCoexist, true, false, false, false);
2496                         halbtc8723b2ant_SwMechanism2(pBtCoexist, true, false, false, 0x18);
2497                 } else {
2498                         halbtc8723b2ant_SwMechanism1(pBtCoexist, true, false, false, false);
2499                         halbtc8723b2ant_SwMechanism2(pBtCoexist, false, false, false, 0x18);
2500                 }
2501         } else {
2502                 if (
2503                         (wifiRssiState == BTC_RSSI_STATE_HIGH) ||
2504                         (wifiRssiState == BTC_RSSI_STATE_STAY_HIGH)
2505                 ) {
2506                         halbtc8723b2ant_SwMechanism1(pBtCoexist, false, false, false, false);
2507                         halbtc8723b2ant_SwMechanism2(pBtCoexist, true, false, false, 0x18);
2508                 } else {
2509                         halbtc8723b2ant_SwMechanism1(pBtCoexist, false, false, false, false);
2510                         halbtc8723b2ant_SwMechanism2(pBtCoexist, false, false, false, 0x18);
2511                 }
2512         }
2513 }
2514
2515
2516 /* PAN(HS) only */
2517 static void halbtc8723b2ant_ActionPanHs(PBTC_COEXIST pBtCoexist)
2518 {
2519         u8 wifiRssiState, btRssiState;
2520         u32 wifiBw;
2521
2522         wifiRssiState = halbtc8723b2ant_WifiRssiState(pBtCoexist, 0, 2, 15, 0);
2523         btRssiState = halbtc8723b2ant_BtRssiState(2, 29, 0);
2524
2525         pBtCoexist->fBtcSetRfReg(pBtCoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
2526
2527         halbtc8723b2ant_LimitedRx(pBtCoexist, NORMAL_EXEC, false, false, 0x8);
2528
2529         halbtc8723b2ant_FwDacSwingLvl(pBtCoexist, NORMAL_EXEC, 6);
2530
2531         if (BTC_RSSI_HIGH(btRssiState))
2532                 halbtc8723b2ant_DecBtPwr(pBtCoexist, NORMAL_EXEC, 2);
2533         else
2534                 halbtc8723b2ant_DecBtPwr(pBtCoexist, NORMAL_EXEC, 0);
2535
2536         halbtc8723b2ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 7);
2537
2538         halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, false, 1);
2539
2540         pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_U4_WIFI_BW, &wifiBw);
2541         if (BTC_WIFI_BW_HT40 == wifiBw) {
2542                 if (
2543                         (wifiRssiState == BTC_RSSI_STATE_HIGH) ||
2544                         (wifiRssiState == BTC_RSSI_STATE_STAY_HIGH)
2545                 ) {
2546                         halbtc8723b2ant_SwMechanism1(pBtCoexist, true, false, false, false);
2547                         halbtc8723b2ant_SwMechanism2(pBtCoexist, true, false, false, 0x18);
2548                 } else {
2549                         halbtc8723b2ant_SwMechanism1(pBtCoexist, true, false, false, false);
2550                         halbtc8723b2ant_SwMechanism2(pBtCoexist, false, false, false, 0x18);
2551                 }
2552         } else {
2553                 if (
2554                         (wifiRssiState == BTC_RSSI_STATE_HIGH) ||
2555                         (wifiRssiState == BTC_RSSI_STATE_STAY_HIGH)
2556                 ) {
2557                         halbtc8723b2ant_SwMechanism1(pBtCoexist, false, false, false, false);
2558                         halbtc8723b2ant_SwMechanism2(pBtCoexist, true, false, false, 0x18);
2559                 } else {
2560                         halbtc8723b2ant_SwMechanism1(pBtCoexist, false, false, false, false);
2561                         halbtc8723b2ant_SwMechanism2(pBtCoexist, false, false, false, 0x18);
2562                 }
2563         }
2564 }
2565
2566 /* PAN(EDR)+A2DP */
2567 static void halbtc8723b2ant_ActionPanEdrA2dp(PBTC_COEXIST pBtCoexist)
2568 {
2569         u8 wifiRssiState, btRssiState;
2570         u32 wifiBw;
2571
2572         wifiRssiState = halbtc8723b2ant_WifiRssiState(pBtCoexist, 0, 2, 15, 0);
2573         btRssiState = halbtc8723b2ant_BtRssiState(2, 29, 0);
2574
2575         pBtCoexist->fBtcSetRfReg(pBtCoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
2576
2577         halbtc8723b2ant_LimitedRx(pBtCoexist, NORMAL_EXEC, false, false, 0x8);
2578
2579         halbtc8723b2ant_FwDacSwingLvl(pBtCoexist, NORMAL_EXEC, 6);
2580
2581         if (BTC_RSSI_HIGH(btRssiState))
2582                 halbtc8723b2ant_DecBtPwr(pBtCoexist, NORMAL_EXEC, 2);
2583         else
2584                 halbtc8723b2ant_DecBtPwr(pBtCoexist, NORMAL_EXEC, 0);
2585
2586         pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_U4_WIFI_BW, &wifiBw);
2587
2588         if (
2589                 (btRssiState == BTC_RSSI_STATE_HIGH) ||
2590                 (btRssiState == BTC_RSSI_STATE_STAY_HIGH)
2591         ) {
2592                 halbtc8723b2ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 12);
2593                 if (BTC_WIFI_BW_HT40 == wifiBw)
2594                         halbtc8723b2ant_TdmaDurationAdjust(pBtCoexist, false, true, 3);
2595                 else
2596                         halbtc8723b2ant_TdmaDurationAdjust(pBtCoexist, false, false, 3);
2597         } else {
2598                 halbtc8723b2ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 7);
2599                 halbtc8723b2ant_TdmaDurationAdjust(pBtCoexist, false, true, 3);
2600         }
2601
2602         /*  sw mechanism */
2603         if (BTC_WIFI_BW_HT40 == wifiBw) {
2604                 if (
2605                         (wifiRssiState == BTC_RSSI_STATE_HIGH) ||
2606                         (wifiRssiState == BTC_RSSI_STATE_STAY_HIGH)
2607                 ) {
2608                         halbtc8723b2ant_SwMechanism1(pBtCoexist, true, false, false, false);
2609                         halbtc8723b2ant_SwMechanism2(pBtCoexist, true, false, false, 0x18);
2610                 } else {
2611                         halbtc8723b2ant_SwMechanism1(pBtCoexist, true, false, false, false);
2612                         halbtc8723b2ant_SwMechanism2(pBtCoexist, false, false, false, 0x18);
2613                 }
2614         } else {
2615                 if (
2616                         (wifiRssiState == BTC_RSSI_STATE_HIGH) ||
2617                         (wifiRssiState == BTC_RSSI_STATE_STAY_HIGH)
2618                 ) {
2619                         halbtc8723b2ant_SwMechanism1(pBtCoexist, false, false, false, false);
2620                         halbtc8723b2ant_SwMechanism2(pBtCoexist, true, false, false, 0x18);
2621                 } else {
2622                         halbtc8723b2ant_SwMechanism1(pBtCoexist, false, false, false, false);
2623                         halbtc8723b2ant_SwMechanism2(pBtCoexist, false, false, false, 0x18);
2624                 }
2625         }
2626 }
2627
2628 static void halbtc8723b2ant_ActionPanEdrHid(PBTC_COEXIST pBtCoexist)
2629 {
2630         u8 wifiRssiState, btRssiState;
2631         u32 wifiBw;
2632
2633         wifiRssiState = halbtc8723b2ant_WifiRssiState(pBtCoexist, 0, 2, 15, 0);
2634         btRssiState = halbtc8723b2ant_BtRssiState(2, 29, 0);
2635         pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_U4_WIFI_BW, &wifiBw);
2636
2637         halbtc8723b2ant_LimitedRx(pBtCoexist, NORMAL_EXEC, false, false, 0x8);
2638
2639         if (BTC_RSSI_HIGH(btRssiState))
2640                 halbtc8723b2ant_DecBtPwr(pBtCoexist, NORMAL_EXEC, 2);
2641         else
2642                 halbtc8723b2ant_DecBtPwr(pBtCoexist, NORMAL_EXEC, 0);
2643
2644         if (
2645                 (btRssiState == BTC_RSSI_STATE_HIGH) ||
2646                 (btRssiState == BTC_RSSI_STATE_STAY_HIGH)
2647         ) {
2648                 if (BTC_WIFI_BW_HT40 == wifiBw) {
2649                         halbtc8723b2ant_FwDacSwingLvl(pBtCoexist, NORMAL_EXEC, 3);
2650                         halbtc8723b2ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 11);
2651                         pBtCoexist->fBtcSetRfReg(pBtCoexist, BTC_RF_A, 0x1, 0xfffff, 0x780);
2652                 } else {
2653                         halbtc8723b2ant_FwDacSwingLvl(pBtCoexist, NORMAL_EXEC, 6);
2654                         halbtc8723b2ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 7);
2655                         pBtCoexist->fBtcSetRfReg(pBtCoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
2656                 }
2657                 halbtc8723b2ant_TdmaDurationAdjust(pBtCoexist, true, false, 2);
2658         } else {
2659                 halbtc8723b2ant_FwDacSwingLvl(pBtCoexist, NORMAL_EXEC, 6);
2660                 halbtc8723b2ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 11);
2661                 pBtCoexist->fBtcSetRfReg(pBtCoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
2662                 halbtc8723b2ant_TdmaDurationAdjust(pBtCoexist, true, true, 2);
2663         }
2664
2665         /*  sw mechanism */
2666         if (BTC_WIFI_BW_HT40 == wifiBw) {
2667                 if (
2668                         (wifiRssiState == BTC_RSSI_STATE_HIGH) ||
2669                         (wifiRssiState == BTC_RSSI_STATE_STAY_HIGH)
2670                 ) {
2671                         halbtc8723b2ant_SwMechanism1(pBtCoexist, true, true, false, false);
2672                         halbtc8723b2ant_SwMechanism2(pBtCoexist, true, false, false, 0x18);
2673                 } else {
2674                         halbtc8723b2ant_SwMechanism1(pBtCoexist, true, true, false, false);
2675                         halbtc8723b2ant_SwMechanism2(pBtCoexist, false, false, false, 0x18);
2676                 }
2677         } else {
2678                 if (
2679                         (wifiRssiState == BTC_RSSI_STATE_HIGH) ||
2680                         (wifiRssiState == BTC_RSSI_STATE_STAY_HIGH)
2681                 ) {
2682                         halbtc8723b2ant_SwMechanism1(pBtCoexist, false, true, false, false);
2683                         halbtc8723b2ant_SwMechanism2(pBtCoexist, true, false, false, 0x18);
2684                 } else {
2685                         halbtc8723b2ant_SwMechanism1(pBtCoexist, false, true, false, false);
2686                         halbtc8723b2ant_SwMechanism2(pBtCoexist, false, false, false, 0x18);
2687                 }
2688         }
2689 }
2690
2691 /*  HID+A2DP+PAN(EDR) */
2692 static void halbtc8723b2ant_ActionHidA2dpPanEdr(PBTC_COEXIST pBtCoexist)
2693 {
2694         u8 wifiRssiState, btRssiState;
2695         u32 wifiBw;
2696
2697         wifiRssiState = halbtc8723b2ant_WifiRssiState(pBtCoexist, 0, 2, 15, 0);
2698         btRssiState = halbtc8723b2ant_BtRssiState(2, 29, 0);
2699
2700         pBtCoexist->fBtcSetRfReg(pBtCoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
2701
2702         halbtc8723b2ant_LimitedRx(pBtCoexist, NORMAL_EXEC, false, false, 0x8);
2703
2704         halbtc8723b2ant_FwDacSwingLvl(pBtCoexist, NORMAL_EXEC, 6);
2705
2706         if (BTC_RSSI_HIGH(btRssiState))
2707                 halbtc8723b2ant_DecBtPwr(pBtCoexist, NORMAL_EXEC, 2);
2708         else
2709                 halbtc8723b2ant_DecBtPwr(pBtCoexist, NORMAL_EXEC, 0);
2710
2711         pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_U4_WIFI_BW, &wifiBw);
2712
2713         halbtc8723b2ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 7);
2714
2715         if (
2716                 (btRssiState == BTC_RSSI_STATE_HIGH) ||
2717                 (btRssiState == BTC_RSSI_STATE_STAY_HIGH)
2718         ) {
2719                 if (BTC_WIFI_BW_HT40 == wifiBw)
2720                         halbtc8723b2ant_TdmaDurationAdjust(pBtCoexist, true, true, 2);
2721                 else
2722                         halbtc8723b2ant_TdmaDurationAdjust(pBtCoexist, true, false, 3);
2723         } else
2724                 halbtc8723b2ant_TdmaDurationAdjust(pBtCoexist, true, true, 3);
2725
2726         /*  sw mechanism */
2727         if (BTC_WIFI_BW_HT40 == wifiBw) {
2728                 if (
2729                         (wifiRssiState == BTC_RSSI_STATE_HIGH) ||
2730                         (wifiRssiState == BTC_RSSI_STATE_STAY_HIGH)
2731                 ) {
2732                         halbtc8723b2ant_SwMechanism1(pBtCoexist, true, true, false, false);
2733                         halbtc8723b2ant_SwMechanism2(pBtCoexist, true, false, false, 0x18);
2734                 } else {
2735                         halbtc8723b2ant_SwMechanism1(pBtCoexist, true, true, false, false);
2736                         halbtc8723b2ant_SwMechanism2(pBtCoexist, false, false, false, 0x18);
2737                 }
2738         } else {
2739                 if (
2740                         (wifiRssiState == BTC_RSSI_STATE_HIGH) ||
2741                         (wifiRssiState == BTC_RSSI_STATE_STAY_HIGH)
2742                 ) {
2743                         halbtc8723b2ant_SwMechanism1(pBtCoexist, false, true, false, false);
2744                         halbtc8723b2ant_SwMechanism2(pBtCoexist, true, false, false, 0x18);
2745                 } else {
2746                         halbtc8723b2ant_SwMechanism1(pBtCoexist, false, true, false, false);
2747                         halbtc8723b2ant_SwMechanism2(pBtCoexist, false, false, false, 0x18);
2748                 }
2749         }
2750 }
2751
2752 static void halbtc8723b2ant_ActionHidA2dp(PBTC_COEXIST pBtCoexist)
2753 {
2754         u8 wifiRssiState, btRssiState;
2755         u32 wifiBw;
2756         u8 apNum = 0;
2757
2758         wifiRssiState = halbtc8723b2ant_WifiRssiState(pBtCoexist, 0, 2, 15, 0);
2759         /* btRssiState = halbtc8723b2ant_BtRssiState(2, 29, 0); */
2760         btRssiState = halbtc8723b2ant_BtRssiState(3, 29, 37);
2761
2762         pBtCoexist->fBtcSetRfReg(pBtCoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
2763
2764         halbtc8723b2ant_LimitedRx(pBtCoexist, NORMAL_EXEC, false, true, 0x5);
2765
2766         halbtc8723b2ant_FwDacSwingLvl(pBtCoexist, NORMAL_EXEC, 6);
2767
2768         pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_U4_WIFI_BW, &wifiBw);
2769         if (BTC_WIFI_BW_LEGACY == wifiBw) {
2770                 if (BTC_RSSI_HIGH(btRssiState))
2771                         halbtc8723b2ant_DecBtPwr(pBtCoexist, NORMAL_EXEC, 2);
2772                 else if (BTC_RSSI_MEDIUM(btRssiState))
2773                         halbtc8723b2ant_DecBtPwr(pBtCoexist, NORMAL_EXEC, 2);
2774                 else
2775                         halbtc8723b2ant_DecBtPwr(pBtCoexist, NORMAL_EXEC, 0);
2776         } else {
2777                 /*  only 802.11N mode we have to dec bt power to 4 degree */
2778                 if (BTC_RSSI_HIGH(btRssiState)) {
2779                         pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_U1_AP_NUM, &apNum);
2780                         /*  need to check ap Number of Not */
2781                         if (apNum < 10)
2782                                 halbtc8723b2ant_DecBtPwr(pBtCoexist, NORMAL_EXEC, 4);
2783                         else
2784                                 halbtc8723b2ant_DecBtPwr(pBtCoexist, NORMAL_EXEC, 2);
2785                 } else if (BTC_RSSI_MEDIUM(btRssiState))
2786                         halbtc8723b2ant_DecBtPwr(pBtCoexist, NORMAL_EXEC, 2);
2787                 else
2788                         halbtc8723b2ant_DecBtPwr(pBtCoexist, NORMAL_EXEC, 0);
2789         }
2790
2791         halbtc8723b2ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 7);
2792
2793         if (
2794                 (btRssiState == BTC_RSSI_STATE_HIGH) ||
2795                 (btRssiState == BTC_RSSI_STATE_STAY_HIGH)
2796         )
2797                 halbtc8723b2ant_TdmaDurationAdjust(pBtCoexist, true, false, 2);
2798         else
2799                 halbtc8723b2ant_TdmaDurationAdjust(pBtCoexist, true, true, 2);
2800
2801         /*  sw mechanism */
2802         if (BTC_WIFI_BW_HT40 == wifiBw) {
2803                 if (
2804                         (wifiRssiState == BTC_RSSI_STATE_HIGH) ||
2805                         (wifiRssiState == BTC_RSSI_STATE_STAY_HIGH)
2806                 ) {
2807                         halbtc8723b2ant_SwMechanism1(pBtCoexist, true, true, false, false);
2808                         halbtc8723b2ant_SwMechanism2(pBtCoexist, true, false, false, 0x18);
2809                 } else {
2810                         halbtc8723b2ant_SwMechanism1(pBtCoexist, true, true, false, false);
2811                         halbtc8723b2ant_SwMechanism2(pBtCoexist, false, false, false, 0x18);
2812                 }
2813         } else {
2814                 if (
2815                         (wifiRssiState == BTC_RSSI_STATE_HIGH) ||
2816                         (wifiRssiState == BTC_RSSI_STATE_STAY_HIGH)
2817                 ) {
2818                         halbtc8723b2ant_SwMechanism1(pBtCoexist, false, true, false, false);
2819                         halbtc8723b2ant_SwMechanism2(pBtCoexist, true, false, false, 0x18);
2820                 } else {
2821                         halbtc8723b2ant_SwMechanism1(pBtCoexist, false, true, false, false);
2822                         halbtc8723b2ant_SwMechanism2(pBtCoexist, false, false, false, 0x18);
2823                 }
2824         }
2825 }
2826
2827 static void halbtc8723b2ant_RunCoexistMechanism(PBTC_COEXIST pBtCoexist)
2828 {
2829         u8 algorithm = 0;
2830
2831         BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], RunCoexistMechanism() ===>\n"));
2832
2833         if (pBtCoexist->bManualControl) {
2834                 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], RunCoexistMechanism(), return for Manual CTRL <===\n"));
2835                 return;
2836         }
2837
2838         if (pCoexSta->bUnderIps) {
2839                 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], wifi is under IPS !!!\n"));
2840                 return;
2841         }
2842
2843         algorithm = halbtc8723b2ant_ActionAlgorithm(pBtCoexist);
2844         if (pCoexSta->bC2hBtInquiryPage && (BT_8723B_2ANT_COEX_ALGO_PANHS != algorithm)) {
2845                 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], BT is under inquiry/page scan !!\n"));
2846                 halbtc8723b2ant_ActionBtInquiry(pBtCoexist);
2847                 return;
2848         } else {
2849                 if (pCoexDm->bNeedRecover0x948) {
2850                         pCoexDm->bNeedRecover0x948 = false;
2851                         pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0x948, pCoexDm->backup0x948);
2852                 }
2853         }
2854
2855         pCoexDm->curAlgorithm = algorithm;
2856         BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], Algorithm = %d\n", pCoexDm->curAlgorithm));
2857
2858         if (halbtc8723b2ant_IsCommonAction(pBtCoexist)) {
2859                 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], Action 2-Ant common.\n"));
2860                 pCoexDm->bAutoTdmaAdjust = false;
2861         } else {
2862                 if (pCoexDm->curAlgorithm != pCoexDm->preAlgorithm) {
2863                         BTC_PRINT(
2864                                 BTC_MSG_ALGORITHM,
2865                                 ALGO_TRACE,
2866                                 (
2867                                         "[BTCoex], preAlgorithm =%d, curAlgorithm =%d\n",
2868                                         pCoexDm->preAlgorithm,
2869                                         pCoexDm->curAlgorithm
2870                                 )
2871                         );
2872                         pCoexDm->bAutoTdmaAdjust = false;
2873                 }
2874
2875
2876                 switch (pCoexDm->curAlgorithm) {
2877                 case BT_8723B_2ANT_COEX_ALGO_SCO:
2878                         BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], Action 2-Ant, algorithm = SCO.\n"));
2879                         halbtc8723b2ant_ActionSco(pBtCoexist);
2880                         break;
2881                 case BT_8723B_2ANT_COEX_ALGO_HID:
2882                         BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], Action 2-Ant, algorithm = HID.\n"));
2883                         halbtc8723b2ant_ActionHid(pBtCoexist);
2884                         break;
2885                 case BT_8723B_2ANT_COEX_ALGO_A2DP:
2886                         BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], Action 2-Ant, algorithm = A2DP.\n"));
2887                         halbtc8723b2ant_ActionA2dp(pBtCoexist);
2888                         break;
2889                 case BT_8723B_2ANT_COEX_ALGO_A2DP_PANHS:
2890                         BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], Action 2-Ant, algorithm = A2DP+PAN(HS).\n"));
2891                         halbtc8723b2ant_ActionA2dpPanHs(pBtCoexist);
2892                         break;
2893                 case BT_8723B_2ANT_COEX_ALGO_PANEDR:
2894                         BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], Action 2-Ant, algorithm = PAN(EDR).\n"));
2895                         halbtc8723b2ant_ActionPanEdr(pBtCoexist);
2896                         break;
2897                 case BT_8723B_2ANT_COEX_ALGO_PANHS:
2898                         BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], Action 2-Ant, algorithm = HS mode.\n"));
2899                         halbtc8723b2ant_ActionPanHs(pBtCoexist);
2900                         break;
2901                 case BT_8723B_2ANT_COEX_ALGO_PANEDR_A2DP:
2902                         BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], Action 2-Ant, algorithm = PAN+A2DP.\n"));
2903                         halbtc8723b2ant_ActionPanEdrA2dp(pBtCoexist);
2904                         break;
2905                 case BT_8723B_2ANT_COEX_ALGO_PANEDR_HID:
2906                         BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], Action 2-Ant, algorithm = PAN(EDR)+HID.\n"));
2907                         halbtc8723b2ant_ActionPanEdrHid(pBtCoexist);
2908                         break;
2909                 case BT_8723B_2ANT_COEX_ALGO_HID_A2DP_PANEDR:
2910                         BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], Action 2-Ant, algorithm = HID+A2DP+PAN.\n"));
2911                         halbtc8723b2ant_ActionHidA2dpPanEdr(pBtCoexist);
2912                         break;
2913                 case BT_8723B_2ANT_COEX_ALGO_HID_A2DP:
2914                         BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], Action 2-Ant, algorithm = HID+A2DP.\n"));
2915                         halbtc8723b2ant_ActionHidA2dp(pBtCoexist);
2916                         break;
2917                 default:
2918                         BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], Action 2-Ant, algorithm = coexist All Off!!\n"));
2919                         halbtc8723b2ant_CoexAllOff(pBtCoexist);
2920                         break;
2921                 }
2922                 pCoexDm->preAlgorithm = pCoexDm->curAlgorithm;
2923         }
2924 }
2925
2926 static void halbtc8723b2ant_WifiOffHwCfg(PBTC_COEXIST pBtCoexist)
2927 {
2928         bool bIsInMpMode = false;
2929         u8 H2C_Parameter[2] = {0};
2930         u32 fwVer = 0;
2931
2932         /*  set wlan_act to low */
2933         pBtCoexist->fBtcWrite1Byte(pBtCoexist, 0x76e, 0x4);
2934
2935         pBtCoexist->fBtcSetRfReg(pBtCoexist, BTC_RF_A, 0x1, 0xfffff, 0x780); /* WiFi goto standby while GNT_BT 0-->1 */
2936         pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_U4_WIFI_FW_VER, &fwVer);
2937         if (fwVer >= 0x180000) {
2938                 /* Use H2C to set GNT_BT to HIGH */
2939                 H2C_Parameter[0] = 1;
2940                 pBtCoexist->fBtcFillH2c(pBtCoexist, 0x6E, 1, H2C_Parameter);
2941         } else
2942                 pBtCoexist->fBtcWrite1Byte(pBtCoexist, 0x765, 0x18);
2943
2944         pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_WIFI_IS_IN_MP_MODE, &bIsInMpMode);
2945         if (!bIsInMpMode)
2946                 pBtCoexist->fBtcWrite1ByteBitMask(pBtCoexist, 0x67, 0x20, 0x0); /* BT select s0/s1 is controlled by BT */
2947         else
2948                 pBtCoexist->fBtcWrite1ByteBitMask(pBtCoexist, 0x67, 0x20, 0x1); /* BT select s0/s1 is controlled by WiFi */
2949 }
2950
2951 static void halbtc8723b2ant_InitHwConfig(PBTC_COEXIST pBtCoexist, bool bBackUp)
2952 {
2953         u8 u1Tmp = 0;
2954
2955         BTC_PRINT(BTC_MSG_INTERFACE, INTF_INIT, ("[BTCoex], 2Ant Init HW Config!!\n"));
2956
2957         /*  backup rf 0x1e value */
2958         pCoexDm->btRf0x1eBackup =
2959                 pBtCoexist->fBtcGetRfReg(pBtCoexist, BTC_RF_A, 0x1e, 0xfffff);
2960
2961         /*  0x790[5:0]= 0x5 */
2962         u1Tmp = pBtCoexist->fBtcRead1Byte(pBtCoexist, 0x790);
2963         u1Tmp &= 0xc0;
2964         u1Tmp |= 0x5;
2965         pBtCoexist->fBtcWrite1Byte(pBtCoexist, 0x790, u1Tmp);
2966
2967         /* Antenna config */
2968         halbtc8723b2ant_SetAntPath(pBtCoexist, BTC_ANT_WIFI_AT_MAIN, true, false);
2969
2970         /*  PTA parameter */
2971         halbtc8723b2ant_CoexTableWithType(pBtCoexist, FORCE_EXEC, 0);
2972
2973         /*  Enable counter statistics */
2974         pBtCoexist->fBtcWrite1Byte(pBtCoexist, 0x76e, 0xc); /* 0x76e[3] = 1, WLAN_Act control by PTA */
2975         pBtCoexist->fBtcWrite1Byte(pBtCoexist, 0x778, 0x3);
2976         pBtCoexist->fBtcWrite1ByteBitMask(pBtCoexist, 0x40, 0x20, 0x1);
2977 }
2978
2979 /*  */
2980 /*  work around function start with wa_halbtc8723b2ant_ */
2981 /*  */
2982 /*  */
2983 /*  extern function start with EXhalbtc8723b2ant_ */
2984 /*  */
2985 void EXhalbtc8723b2ant_PowerOnSetting(PBTC_COEXIST pBtCoexist)
2986 {
2987         PBTC_BOARD_INFO pBoardInfo = &pBtCoexist->boardInfo;
2988         u8 u1Tmp = 0x4; /* Set BIT2 by default since it's 2ant case */
2989         u16 u2Tmp = 0x0;
2990
2991         pBtCoexist->fBtcWrite1Byte(pBtCoexist, 0x67, 0x20);
2992
2993         /*  enable BB, REG_SYS_FUNC_EN such that we can write 0x948 correctly. */
2994         u2Tmp = pBtCoexist->fBtcRead2Byte(pBtCoexist, 0x2);
2995         pBtCoexist->fBtcWrite2Byte(pBtCoexist, 0x2, u2Tmp|BIT0|BIT1);
2996
2997         /*  set GRAN_BT = 1 */
2998         pBtCoexist->fBtcWrite1Byte(pBtCoexist, 0x765, 0x18);
2999         /*  set WLAN_ACT = 0 */
3000         pBtCoexist->fBtcWrite1Byte(pBtCoexist, 0x76e, 0x4);
3001
3002         /*  */
3003         /*  S0 or S1 setting and Local register setting(By the setting fw can get ant number, S0/S1, ... info) */
3004         /*  Local setting bit define */
3005         /*      BIT0: "0" for no antenna inverse; "1" for antenna inverse */
3006         /*      BIT1: "0" for internal switch; "1" for external switch */
3007         /*      BIT2: "0" for one antenna; "1" for two antenna */
3008         /*  NOTE: here default all internal switch and 1-antenna ==> BIT1 = 0 and BIT2 = 0 */
3009         if (pBtCoexist->chipInterface == BTC_INTF_USB) {
3010                 /*  fixed at S0 for USB interface */
3011                 pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0x948, 0x0);
3012
3013                 u1Tmp |= 0x1;   /*  antenna inverse */
3014                 pBtCoexist->fBtcWriteLocalReg1Byte(pBtCoexist, 0xfe08, u1Tmp);
3015
3016                 pBoardInfo->btdmAntPos = BTC_ANTENNA_AT_AUX_PORT;
3017         } else {
3018                 /*  for PCIE and SDIO interface, we check efuse 0xc3[6] */
3019                 if (pBoardInfo->singleAntPath == 0) {
3020                         /*  set to S1 */
3021                         pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0x948, 0x280);
3022                         pBoardInfo->btdmAntPos = BTC_ANTENNA_AT_MAIN_PORT;
3023                 } else if (pBoardInfo->singleAntPath == 1) {
3024                         /*  set to S0 */
3025                         pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0x948, 0x0);
3026                         u1Tmp |= 0x1;   /*  antenna inverse */
3027                         pBoardInfo->btdmAntPos = BTC_ANTENNA_AT_AUX_PORT;
3028                 }
3029
3030                 if (pBtCoexist->chipInterface == BTC_INTF_PCI)
3031                         pBtCoexist->fBtcWriteLocalReg1Byte(pBtCoexist, 0x384, u1Tmp);
3032                 else if (pBtCoexist->chipInterface == BTC_INTF_SDIO)
3033                         pBtCoexist->fBtcWriteLocalReg1Byte(pBtCoexist, 0x60, u1Tmp);
3034         }
3035 }
3036
3037 void EXhalbtc8723b2ant_InitHwConfig(PBTC_COEXIST pBtCoexist, bool bWifiOnly)
3038 {
3039         halbtc8723b2ant_InitHwConfig(pBtCoexist, true);
3040 }
3041
3042 void EXhalbtc8723b2ant_InitCoexDm(PBTC_COEXIST pBtCoexist)
3043 {
3044         BTC_PRINT(BTC_MSG_INTERFACE, INTF_INIT, ("[BTCoex], Coex Mechanism Init!!\n"));
3045
3046         halbtc8723b2ant_InitCoexDm(pBtCoexist);
3047 }
3048
3049 void EXhalbtc8723b2ant_DisplayCoexInfo(PBTC_COEXIST pBtCoexist)
3050 {
3051         PBTC_BOARD_INFO pBoardInfo = &pBtCoexist->boardInfo;
3052         PBTC_STACK_INFO pStackInfo = &pBtCoexist->stackInfo;
3053         PBTC_BT_LINK_INFO pBtLinkInfo = &pBtCoexist->btLinkInfo;
3054         u8 *cliBuf = pBtCoexist->cliBuf;
3055         u8 u1Tmp[4], i, btInfoExt, psTdmaCase = 0;
3056         u32 u4Tmp[4];
3057         bool bRoam = false, bScan = false, bLink = false, bWifiUnder5G = false;
3058         bool bBtHsOn = false, bWifiBusy = false;
3059         s32 wifiRssi = 0, btHsRssi = 0;
3060         u32 wifiBw, wifiTrafficDir, faOfdm, faCck;
3061         u8 wifiDot11Chnl, wifiHsChnl;
3062         u32 fwVer = 0, btPatchVer = 0;
3063         u8 apNum = 0;
3064
3065         CL_SPRINTF(cliBuf, BT_TMP_BUF_SIZE, "\r\n ============[BT Coexist info]============");
3066         CL_PRINTF(cliBuf);
3067
3068         if (pBtCoexist->bManualControl) {
3069                 CL_SPRINTF(cliBuf, BT_TMP_BUF_SIZE, "\r\n ============[Under Manual Control]============");
3070                 CL_PRINTF(cliBuf);
3071                 CL_SPRINTF(cliBuf, BT_TMP_BUF_SIZE, "\r\n ==========================================");
3072                 CL_PRINTF(cliBuf);
3073         }
3074
3075         CL_SPRINTF(
3076                 cliBuf,
3077                 BT_TMP_BUF_SIZE,
3078                 "\r\n %-35s = %d/ %d ", "Ant PG number/ Ant mechanism:", \
3079                 pBoardInfo->pgAntNum,
3080                 pBoardInfo->btdmAntNum
3081         );
3082         CL_PRINTF(cliBuf);
3083
3084         CL_SPRINTF(
3085                 cliBuf,
3086                 BT_TMP_BUF_SIZE,
3087                 "\r\n %-35s = %s / %d", "BT stack/ hci ext ver", \
3088                 (pStackInfo->bProfileNotified ? "Yes" : "No"),
3089                 pStackInfo->hciVersion
3090         );
3091         CL_PRINTF(cliBuf);
3092
3093         pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_U4_BT_PATCH_VER, &btPatchVer);
3094         pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_U4_WIFI_FW_VER, &fwVer);
3095         CL_SPRINTF(cliBuf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d_%x/ 0x%x/ 0x%x(%d)", "CoexVer/ FwVer/ PatchVer", \
3096                 GLCoexVerDate8723b2Ant, GLCoexVer8723b2Ant, fwVer, btPatchVer, btPatchVer);
3097         CL_PRINTF(cliBuf);
3098
3099         pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_HS_OPERATION, &bBtHsOn);
3100         pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_U1_WIFI_DOT11_CHNL, &wifiDot11Chnl);
3101         pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_U1_WIFI_HS_CHNL, &wifiHsChnl);
3102         CL_SPRINTF(
3103                 cliBuf,
3104                 BT_TMP_BUF_SIZE,
3105                 "\r\n %-35s = %d / %d(%d)", "Dot11 channel / HsChnl(HsMode)", \
3106                 wifiDot11Chnl,
3107                 wifiHsChnl,
3108                 bBtHsOn
3109         );
3110         CL_PRINTF(cliBuf);
3111
3112         CL_SPRINTF(
3113                 cliBuf,
3114                 BT_TMP_BUF_SIZE,
3115                 "\r\n %-35s = %02x %02x %02x ", "H2C Wifi inform bt chnl Info", \
3116                 pCoexDm->wifiChnlInfo[0],
3117                 pCoexDm->wifiChnlInfo[1],
3118                 pCoexDm->wifiChnlInfo[2]
3119         );
3120         CL_PRINTF(cliBuf);
3121
3122         pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_S4_WIFI_RSSI, &wifiRssi);
3123         pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_S4_HS_RSSI, &btHsRssi);
3124         pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_U1_AP_NUM, &apNum);
3125         CL_SPRINTF(
3126                 cliBuf,
3127                 BT_TMP_BUF_SIZE,
3128                 "\r\n %-35s = %d/ %d/ %d", "Wifi rssi/ HS rssi/ AP#", \
3129                 wifiRssi,
3130                 btHsRssi,
3131                 apNum
3132         );
3133         CL_PRINTF(cliBuf);
3134
3135         pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_WIFI_SCAN, &bScan);
3136         pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_WIFI_LINK, &bLink);
3137         pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_WIFI_ROAM, &bRoam);
3138         CL_SPRINTF(
3139                 cliBuf,
3140                 BT_TMP_BUF_SIZE,
3141                 "\r\n %-35s = %d/ %d/ %d ", "Wifi bLink/ bRoam/ bScan", \
3142                 bLink,
3143                 bRoam,
3144                 bScan
3145         );
3146         CL_PRINTF(cliBuf);
3147
3148         pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_WIFI_UNDER_5G, &bWifiUnder5G);
3149         pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_U4_WIFI_BW, &wifiBw);
3150         pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_WIFI_BUSY, &bWifiBusy);
3151         pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_U4_WIFI_TRAFFIC_DIRECTION, &wifiTrafficDir);
3152         CL_SPRINTF(
3153                 cliBuf,
3154                 BT_TMP_BUF_SIZE,
3155                 "\r\n %-35s = %s / %s/ %s ", "Wifi status", \
3156                 (bWifiUnder5G ? "5G" : "2.4G"),
3157                 ((BTC_WIFI_BW_LEGACY == wifiBw) ? "Legacy" : (((BTC_WIFI_BW_HT40 == wifiBw) ? "HT40" : "HT20"))),
3158                 ((!bWifiBusy) ? "idle" : ((BTC_WIFI_TRAFFIC_TX == wifiTrafficDir) ? "uplink" : "downlink"))
3159         );
3160         CL_PRINTF(cliBuf);
3161
3162         CL_SPRINTF(
3163                 cliBuf,
3164                 BT_TMP_BUF_SIZE,
3165                 "\r\n %-35s = [%s/ %d/ %d] ", "BT [status/ rssi/ retryCnt]", \
3166                 ((pBtCoexist->btInfo.bBtDisabled) ? ("disabled") : ((pCoexSta->bC2hBtInquiryPage) ? ("inquiry/page scan") : ((BT_8723B_2ANT_BT_STATUS_NON_CONNECTED_IDLE == pCoexDm->btStatus) ? "non-connected idle" :
3167                 ((BT_8723B_2ANT_BT_STATUS_CONNECTED_IDLE == pCoexDm->btStatus) ? "connected-idle" : "busy")))),
3168                 pCoexSta->btRssi,
3169                 pCoexSta->btRetryCnt
3170         );
3171         CL_PRINTF(cliBuf);
3172
3173         CL_SPRINTF(
3174                 cliBuf,
3175                 BT_TMP_BUF_SIZE,
3176                 "\r\n %-35s = %d / %d / %d / %d", "SCO/HID/PAN/A2DP", \
3177                 pBtLinkInfo->bScoExist,
3178                 pBtLinkInfo->bHidExist,
3179                 pBtLinkInfo->bPanExist,
3180                 pBtLinkInfo->bA2dpExist
3181         );
3182         CL_PRINTF(cliBuf);
3183         pBtCoexist->fBtcDispDbgMsg(pBtCoexist, BTC_DBG_DISP_BT_LINK_INFO);
3184
3185         btInfoExt = pCoexSta->btInfoExt;
3186         CL_SPRINTF(
3187                 cliBuf,
3188                 BT_TMP_BUF_SIZE,
3189                 "\r\n %-35s = %s", "BT Info A2DP rate", \
3190                 (btInfoExt&BIT0) ? "Basic rate" : "EDR rate"
3191         );
3192         CL_PRINTF(cliBuf);
3193
3194         for (i = 0; i < BT_INFO_SRC_8723B_2ANT_MAX; i++) {
3195                 if (pCoexSta->btInfoC2hCnt[i]) {
3196                         CL_SPRINTF(
3197                                 cliBuf,
3198                                 BT_TMP_BUF_SIZE,
3199                                 "\r\n %-35s = %02x %02x %02x %02x %02x %02x %02x(%d)", GLBtInfoSrc8723b2Ant[i], \
3200                                 pCoexSta->btInfoC2h[i][0],
3201                                 pCoexSta->btInfoC2h[i][1],
3202                                 pCoexSta->btInfoC2h[i][2],
3203                                 pCoexSta->btInfoC2h[i][3],
3204                                 pCoexSta->btInfoC2h[i][4],
3205                                 pCoexSta->btInfoC2h[i][5],
3206                                 pCoexSta->btInfoC2h[i][6],
3207                                 pCoexSta->btInfoC2hCnt[i]
3208                         );
3209                         CL_PRINTF(cliBuf);
3210                 }
3211         }
3212
3213         CL_SPRINTF(
3214                 cliBuf,
3215                 BT_TMP_BUF_SIZE,
3216                 "\r\n %-35s = %s/%s", "PS state, IPS/LPS", \
3217                 ((pCoexSta->bUnderIps ? "IPS ON" : "IPS OFF")),
3218                 ((pCoexSta->bUnderLps ? "LPS ON" : "LPS OFF"))
3219         );
3220         CL_PRINTF(cliBuf);
3221         pBtCoexist->fBtcDispDbgMsg(pBtCoexist, BTC_DBG_DISP_FW_PWR_MODE_CMD);
3222
3223         /*  Sw mechanism */
3224         CL_SPRINTF(
3225                 cliBuf,
3226                 BT_TMP_BUF_SIZE,
3227                 "\r\n %-35s", "============[Sw mechanism]============"
3228         );
3229         CL_PRINTF(cliBuf);
3230         CL_SPRINTF(
3231                 cliBuf,
3232                 BT_TMP_BUF_SIZE,
3233                 "\r\n %-35s = %d/ %d/ %d ", "SM1[ShRf/ LpRA/ LimDig]", \
3234                 pCoexDm->bCurRfRxLpfShrink,
3235                 pCoexDm->bCurLowPenaltyRa,
3236                 pCoexDm->bLimitedDig
3237         );
3238         CL_PRINTF(cliBuf);
3239         CL_SPRINTF(
3240                 cliBuf,
3241                 BT_TMP_BUF_SIZE,
3242                 "\r\n %-35s = %d/ %d/ %d(0x%x) ",
3243                 "SM2[AgcT/ AdcB/ SwDacSwing(lvl)]", \
3244                 pCoexDm->bCurAgcTableEn,
3245                 pCoexDm->bCurAdcBackOff,
3246                 pCoexDm->bCurDacSwingOn,
3247                 pCoexDm->curDacSwingLvl
3248         );
3249         CL_PRINTF(cliBuf);
3250
3251         /*  Fw mechanism */
3252         CL_SPRINTF(cliBuf, BT_TMP_BUF_SIZE, "\r\n %-35s", "============[Fw mechanism]============");
3253         CL_PRINTF(cliBuf);
3254
3255         psTdmaCase = pCoexDm->curPsTdma;
3256         CL_SPRINTF(
3257                 cliBuf,
3258                 BT_TMP_BUF_SIZE,
3259                 "\r\n %-35s = %02x %02x %02x %02x %02x case-%d (auto:%d)", "PS TDMA", \
3260                 pCoexDm->psTdmaPara[0],
3261                 pCoexDm->psTdmaPara[1],
3262                 pCoexDm->psTdmaPara[2],
3263                 pCoexDm->psTdmaPara[3],
3264                 pCoexDm->psTdmaPara[4],
3265                 psTdmaCase, pCoexDm->bAutoTdmaAdjust
3266         );
3267         CL_PRINTF(cliBuf);
3268
3269         CL_SPRINTF(
3270                 cliBuf,
3271                 BT_TMP_BUF_SIZE,
3272                 "\r\n %-35s = %d/ %d ", "DecBtPwr/ IgnWlanAct", \
3273                 pCoexDm->curBtDecPwrLvl,
3274                 pCoexDm->bCurIgnoreWlanAct
3275         );
3276         CL_PRINTF(cliBuf);
3277
3278         /*  Hw setting */
3279         CL_SPRINTF(cliBuf, BT_TMP_BUF_SIZE, "\r\n %-35s", "============[Hw setting]============");
3280         CL_PRINTF(cliBuf);
3281
3282         CL_SPRINTF(
3283                 cliBuf,
3284                 BT_TMP_BUF_SIZE,
3285                 "\r\n %-35s = 0x%x", "RF-A, 0x1e initVal", \
3286                 pCoexDm->btRf0x1eBackup
3287         );
3288         CL_PRINTF(cliBuf);
3289
3290         u1Tmp[0] = pBtCoexist->fBtcRead1Byte(pBtCoexist, 0x778);
3291         u4Tmp[0] = pBtCoexist->fBtcRead4Byte(pBtCoexist, 0x880);
3292         CL_SPRINTF(
3293                 cliBuf,
3294                 BT_TMP_BUF_SIZE,
3295                 "\r\n %-35s = 0x%x/ 0x%x", "0x778/0x880[29:25]", \
3296                 u1Tmp[0],
3297                 (u4Tmp[0]&0x3e000000) >> 25
3298         );
3299         CL_PRINTF(cliBuf);
3300
3301
3302         u4Tmp[0] = pBtCoexist->fBtcRead4Byte(pBtCoexist, 0x948);
3303         u1Tmp[0] = pBtCoexist->fBtcRead1Byte(pBtCoexist, 0x67);
3304         u1Tmp[1] = pBtCoexist->fBtcRead1Byte(pBtCoexist, 0x765);
3305         CL_SPRINTF(
3306                 cliBuf,
3307                 BT_TMP_BUF_SIZE,
3308                 "\r\n %-35s = 0x%x/ 0x%x/ 0x%x", "0x948/ 0x67[5] / 0x765", \
3309                 u4Tmp[0],
3310                 ((u1Tmp[0]&0x20)>>5),
3311                 u1Tmp[1]
3312         );
3313         CL_PRINTF(cliBuf);
3314
3315         u4Tmp[0] = pBtCoexist->fBtcRead4Byte(pBtCoexist, 0x92c);
3316         u4Tmp[1] = pBtCoexist->fBtcRead4Byte(pBtCoexist, 0x930);
3317         u4Tmp[2] = pBtCoexist->fBtcRead4Byte(pBtCoexist, 0x944);
3318         CL_SPRINTF(
3319                 cliBuf,
3320                 BT_TMP_BUF_SIZE,
3321                 "\r\n %-35s = 0x%x/ 0x%x/ 0x%x", "0x92c[1:0]/ 0x930[7:0]/0x944[1:0]", \
3322                 u4Tmp[0]&0x3,
3323                 u4Tmp[1]&0xff,
3324                 u4Tmp[2]&0x3
3325         );
3326         CL_PRINTF(cliBuf);
3327
3328
3329         u1Tmp[0] = pBtCoexist->fBtcRead1Byte(pBtCoexist, 0x39);
3330         u1Tmp[1] = pBtCoexist->fBtcRead1Byte(pBtCoexist, 0x40);
3331         u4Tmp[0] = pBtCoexist->fBtcRead4Byte(pBtCoexist, 0x4c);
3332         u1Tmp[2] = pBtCoexist->fBtcRead1Byte(pBtCoexist, 0x64);
3333         CL_SPRINTF(
3334                 cliBuf,
3335                 BT_TMP_BUF_SIZE,
3336                 "\r\n %-35s = 0x%x/ 0x%x/ 0x%x/ 0x%x", "0x38[11]/0x40/0x4c[24:23]/0x64[0]", \
3337                 ((u1Tmp[0] & 0x8)>>3),
3338                 u1Tmp[1],
3339                 ((u4Tmp[0]&0x01800000)>>23),
3340                 u1Tmp[2]&0x1
3341         );
3342         CL_PRINTF(cliBuf);
3343
3344         u4Tmp[0] = pBtCoexist->fBtcRead4Byte(pBtCoexist, 0x550);
3345         u1Tmp[0] = pBtCoexist->fBtcRead1Byte(pBtCoexist, 0x522);
3346         CL_SPRINTF(
3347                 cliBuf,
3348                 BT_TMP_BUF_SIZE,
3349                 "\r\n %-35s = 0x%x/ 0x%x", "0x550(bcn ctrl)/0x522", \
3350                 u4Tmp[0],
3351                 u1Tmp[0]
3352         );
3353         CL_PRINTF(cliBuf);
3354
3355         u4Tmp[0] = pBtCoexist->fBtcRead4Byte(pBtCoexist, 0xc50);
3356         u1Tmp[0] = pBtCoexist->fBtcRead1Byte(pBtCoexist, 0x49c);
3357         CL_SPRINTF(
3358                 cliBuf,
3359                 BT_TMP_BUF_SIZE,
3360                 "\r\n %-35s = 0x%x/ 0x%x", "0xc50(dig)/0x49c(null-drop)", \
3361                 u4Tmp[0]&0xff,
3362                 u1Tmp[0]
3363         );
3364         CL_PRINTF(cliBuf);
3365
3366         u4Tmp[0] = pBtCoexist->fBtcRead4Byte(pBtCoexist, 0xda0);
3367         u4Tmp[1] = pBtCoexist->fBtcRead4Byte(pBtCoexist, 0xda4);
3368         u4Tmp[2] = pBtCoexist->fBtcRead4Byte(pBtCoexist, 0xda8);
3369         u4Tmp[3] = pBtCoexist->fBtcRead4Byte(pBtCoexist, 0xcf0);
3370
3371         u1Tmp[0] = pBtCoexist->fBtcRead1Byte(pBtCoexist, 0xa5b);
3372         u1Tmp[1] = pBtCoexist->fBtcRead1Byte(pBtCoexist, 0xa5c);
3373
3374         faOfdm =
3375                 ((u4Tmp[0]&0xffff0000) >> 16) +
3376                 ((u4Tmp[1]&0xffff0000) >> 16) +
3377                 (u4Tmp[1] & 0xffff) +  (u4Tmp[2] & 0xffff) + \
3378                 ((u4Tmp[3]&0xffff0000) >> 16) +
3379                 (u4Tmp[3] & 0xffff);
3380
3381         faCck = (u1Tmp[0] << 8) + u1Tmp[1];
3382
3383         CL_SPRINTF(
3384                 cliBuf,
3385                 BT_TMP_BUF_SIZE,
3386                 "\r\n %-35s = 0x%x/ 0x%x/ 0x%x", "OFDM-CCA/OFDM-FA/CCK-FA", \
3387                 u4Tmp[0]&0xffff,
3388                 faOfdm,
3389                 faCck
3390         );
3391         CL_PRINTF(cliBuf);
3392
3393         u4Tmp[0] = pBtCoexist->fBtcRead4Byte(pBtCoexist, 0x6c0);
3394         u4Tmp[1] = pBtCoexist->fBtcRead4Byte(pBtCoexist, 0x6c4);
3395         u4Tmp[2] = pBtCoexist->fBtcRead4Byte(pBtCoexist, 0x6c8);
3396         u1Tmp[0] = pBtCoexist->fBtcRead1Byte(pBtCoexist, 0x6cc);
3397         CL_SPRINTF(
3398                 cliBuf,
3399                 BT_TMP_BUF_SIZE,
3400                 "\r\n %-35s = 0x%x/ 0x%x/ 0x%x/ 0x%x", "0x6c0/0x6c4/0x6c8/0x6cc(coexTable)", \
3401                 u4Tmp[0],
3402                 u4Tmp[1],
3403                 u4Tmp[2],
3404                 u1Tmp[0]
3405         );
3406         CL_PRINTF(cliBuf);
3407
3408         CL_SPRINTF(
3409                 cliBuf,
3410                 BT_TMP_BUF_SIZE,
3411                 "\r\n %-35s = %d/ %d", "0x770(high-pri rx/tx)", \
3412                 pCoexSta->highPriorityRx,
3413                 pCoexSta->highPriorityTx
3414         );
3415         CL_PRINTF(cliBuf);
3416         CL_SPRINTF(
3417                 cliBuf,
3418                 BT_TMP_BUF_SIZE,
3419                 "\r\n %-35s = %d/ %d", "0x774(low-pri rx/tx)", \
3420                 pCoexSta->lowPriorityRx,
3421                 pCoexSta->lowPriorityTx
3422         );
3423         CL_PRINTF(cliBuf);
3424
3425         halbtc8723b2ant_MonitorBtCtr(pBtCoexist);
3426         pBtCoexist->fBtcDispDbgMsg(pBtCoexist, BTC_DBG_DISP_COEX_STATISTICS);
3427 }
3428
3429
3430 void EXhalbtc8723b2ant_IpsNotify(PBTC_COEXIST pBtCoexist, u8 type)
3431 {
3432         if (BTC_IPS_ENTER == type) {
3433                 BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY, ("[BTCoex], IPS ENTER notify\n"));
3434                 pCoexSta->bUnderIps = true;
3435                 halbtc8723b2ant_WifiOffHwCfg(pBtCoexist);
3436                 halbtc8723b2ant_IgnoreWlanAct(pBtCoexist, FORCE_EXEC, true);
3437                 halbtc8723b2ant_CoexAllOff(pBtCoexist);
3438         } else if (BTC_IPS_LEAVE == type) {
3439                 BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY, ("[BTCoex], IPS LEAVE notify\n"));
3440                 pCoexSta->bUnderIps = false;
3441                 halbtc8723b2ant_InitHwConfig(pBtCoexist, false);
3442                 halbtc8723b2ant_InitCoexDm(pBtCoexist);
3443                 halbtc8723b2ant_QueryBtInfo(pBtCoexist);
3444         }
3445 }
3446
3447 void EXhalbtc8723b2ant_LpsNotify(PBTC_COEXIST pBtCoexist, u8 type)
3448 {
3449         if (BTC_LPS_ENABLE == type) {
3450                 BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY, ("[BTCoex], LPS ENABLE notify\n"));
3451                 pCoexSta->bUnderLps = true;
3452         } else if (BTC_LPS_DISABLE == type) {
3453                 BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY, ("[BTCoex], LPS DISABLE notify\n"));
3454                 pCoexSta->bUnderLps = false;
3455         }
3456 }
3457
3458 void EXhalbtc8723b2ant_ScanNotify(PBTC_COEXIST pBtCoexist, u8 type)
3459 {
3460         if (BTC_SCAN_START == type) {
3461                 BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY, ("[BTCoex], SCAN START notify\n"));
3462         } else if (BTC_SCAN_FINISH == type) {
3463                 BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY, ("[BTCoex], SCAN FINISH notify\n"));
3464         }
3465 }
3466
3467 void EXhalbtc8723b2ant_ConnectNotify(PBTC_COEXIST pBtCoexist, u8 type)
3468 {
3469         if (BTC_ASSOCIATE_START == type) {
3470                 BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY, ("[BTCoex], CONNECT START notify\n"));
3471         } else if (BTC_ASSOCIATE_FINISH == type) {
3472                 BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY, ("[BTCoex], CONNECT FINISH notify\n"));
3473         }
3474 }
3475
3476 void EXhalbtc8723b2ant_MediaStatusNotify(PBTC_COEXIST pBtCoexist, u8 type)
3477 {
3478         u8 H2C_Parameter[3] = {0};
3479         u32 wifiBw;
3480         u8 wifiCentralChnl;
3481         u8 apNum = 0;
3482
3483         if (BTC_MEDIA_CONNECT == type) {
3484                 BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY, ("[BTCoex], MEDIA connect notify\n"));
3485         } else {
3486                 BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY, ("[BTCoex], MEDIA disconnect notify\n"));
3487         }
3488
3489         /*  only 2.4G we need to inform bt the chnl mask */
3490         pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_U1_WIFI_CENTRAL_CHNL, &wifiCentralChnl);
3491         if ((BTC_MEDIA_CONNECT == type) && (wifiCentralChnl <= 14)) {
3492                 H2C_Parameter[0] = 0x1;
3493                 H2C_Parameter[1] = wifiCentralChnl;
3494                 pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_U4_WIFI_BW, &wifiBw);
3495                 if (BTC_WIFI_BW_HT40 == wifiBw)
3496                         H2C_Parameter[2] = 0x30;
3497                 else {
3498                         pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_U1_AP_NUM, &apNum);
3499                         if (apNum < 10)
3500                                 H2C_Parameter[2] = 0x30;
3501                         else
3502                                 H2C_Parameter[2] = 0x20;
3503                 }
3504         }
3505
3506         pCoexDm->wifiChnlInfo[0] = H2C_Parameter[0];
3507         pCoexDm->wifiChnlInfo[1] = H2C_Parameter[1];
3508         pCoexDm->wifiChnlInfo[2] = H2C_Parameter[2];
3509
3510         BTC_PRINT(
3511                 BTC_MSG_ALGORITHM,
3512                 ALGO_TRACE_FW_EXEC,
3513                 (
3514                         "[BTCoex], FW write 0x66 = 0x%x\n",
3515                         H2C_Parameter[0]<<16|H2C_Parameter[1]<<8|H2C_Parameter[2]
3516                 )
3517         );
3518
3519         pBtCoexist->fBtcFillH2c(pBtCoexist, 0x66, 3, H2C_Parameter);
3520 }
3521
3522 void EXhalbtc8723b2ant_SpecialPacketNotify(PBTC_COEXIST pBtCoexist, u8 type)
3523 {
3524         if (type == BTC_PACKET_DHCP) {
3525                 BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY, ("[BTCoex], DHCP Packet notify\n"));
3526         }
3527 }
3528
3529 void EXhalbtc8723b2ant_BtInfoNotify(
3530         PBTC_COEXIST pBtCoexist, u8 *tmpBuf, u8 length
3531 )
3532 {
3533         u8      btInfo = 0;
3534         u8      i, rspSource = 0;
3535         bool bBtBusy = false, bLimitedDig = false;
3536         bool bWifiConnected = false;
3537
3538         pCoexSta->bC2hBtInfoReqSent = false;
3539
3540         rspSource = tmpBuf[0]&0xf;
3541         if (rspSource >= BT_INFO_SRC_8723B_2ANT_MAX)
3542                 rspSource = BT_INFO_SRC_8723B_2ANT_WIFI_FW;
3543
3544         pCoexSta->btInfoC2hCnt[rspSource]++;
3545
3546         BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY, ("[BTCoex], Bt info[%d], length =%d, hex data =[", rspSource, length));
3547         for (i = 0; i < length; i++) {
3548                 pCoexSta->btInfoC2h[rspSource][i] = tmpBuf[i];
3549                 if (i == 1)
3550                         btInfo = tmpBuf[i];
3551
3552                 if (i == length-1) {
3553                         BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY, ("0x%02x]\n", tmpBuf[i]));
3554                 } else {
3555                         BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY, ("0x%02x, ", tmpBuf[i]));
3556                 }
3557         }
3558
3559         if (pBtCoexist->bManualControl) {
3560                 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], BtInfoNotify(), return for Manual CTRL<===\n"));
3561                 return;
3562         }
3563
3564         if (BT_INFO_SRC_8723B_2ANT_WIFI_FW != rspSource) {
3565                 pCoexSta->btRetryCnt = pCoexSta->btInfoC2h[rspSource][2]&0xf; /* [3:0] */
3566
3567                 pCoexSta->btRssi = pCoexSta->btInfoC2h[rspSource][3]*2+10;
3568
3569                 pCoexSta->btInfoExt = pCoexSta->btInfoC2h[rspSource][4];
3570
3571                 pCoexSta->bBtTxRxMask = (pCoexSta->btInfoC2h[rspSource][2]&0x40);
3572                 pBtCoexist->fBtcSet(pBtCoexist, BTC_SET_BL_BT_TX_RX_MASK, &pCoexSta->bBtTxRxMask);
3573                 if (pCoexSta->bBtTxRxMask) {
3574                         /* BT into is responded by BT FW and BT RF REG 0x3C != 0x01 => Need to switch BT TRx Mask */
3575                         BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], Switch BT TRx Mask since BT RF REG 0x3C != 0x01\n"));
3576                         pBtCoexist->fBtcSetBtReg(pBtCoexist, BTC_BT_REG_RF, 0x3c, 0x01);
3577                 }
3578
3579                 /*  Here we need to resend some wifi info to BT */
3580                 /*  because bt is reset and loss of the info. */
3581                 if ((pCoexSta->btInfoExt & BIT1)) {
3582                         BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], BT ext info bit1 check, send wifi BW&Chnl to BT!!\n"));
3583                         pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_WIFI_CONNECTED, &bWifiConnected);
3584
3585                         if (bWifiConnected)
3586                                 EXhalbtc8723b2ant_MediaStatusNotify(pBtCoexist, BTC_MEDIA_CONNECT);
3587                         else
3588                                 EXhalbtc8723b2ant_MediaStatusNotify(pBtCoexist, BTC_MEDIA_DISCONNECT);
3589                 }
3590
3591                 if ((pCoexSta->btInfoExt & BIT3)) {
3592                         BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], BT ext info bit3 check, set BT NOT to ignore Wlan active!!\n"));
3593                         halbtc8723b2ant_IgnoreWlanAct(pBtCoexist, FORCE_EXEC, false);
3594                 } else {
3595                         /*  BT already NOT ignore Wlan active, do nothing here. */
3596                 }
3597         }
3598
3599         /*  check BIT2 first ==> check if bt is under inquiry or page scan */
3600         if (btInfo & BT_INFO_8723B_2ANT_B_INQ_PAGE)
3601                 pCoexSta->bC2hBtInquiryPage = true;
3602         else
3603                 pCoexSta->bC2hBtInquiryPage = false;
3604
3605         /*  set link exist status */
3606         if (!(btInfo&BT_INFO_8723B_2ANT_B_CONNECTION)) {
3607                 pCoexSta->bBtLinkExist = false;
3608                 pCoexSta->bPanExist = false;
3609                 pCoexSta->bA2dpExist = false;
3610                 pCoexSta->bHidExist = false;
3611                 pCoexSta->bScoExist = false;
3612         } else { /*  connection exists */
3613                 pCoexSta->bBtLinkExist = true;
3614                 if (btInfo & BT_INFO_8723B_2ANT_B_FTP)
3615                         pCoexSta->bPanExist = true;
3616                 else
3617                         pCoexSta->bPanExist = false;
3618                 if (btInfo & BT_INFO_8723B_2ANT_B_A2DP)
3619                         pCoexSta->bA2dpExist = true;
3620                 else
3621                         pCoexSta->bA2dpExist = false;
3622                 if (btInfo & BT_INFO_8723B_2ANT_B_HID)
3623                         pCoexSta->bHidExist = true;
3624                 else
3625                         pCoexSta->bHidExist = false;
3626                 if (btInfo & BT_INFO_8723B_2ANT_B_SCO_ESCO)
3627                         pCoexSta->bScoExist = true;
3628                 else
3629                         pCoexSta->bScoExist = false;
3630         }
3631
3632         halbtc8723b2ant_UpdateBtLinkInfo(pBtCoexist);
3633
3634         if (!(btInfo&BT_INFO_8723B_2ANT_B_CONNECTION)) {
3635                 pCoexDm->btStatus = BT_8723B_2ANT_BT_STATUS_NON_CONNECTED_IDLE;
3636                 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], BtInfoNotify(), BT Non-Connected idle!!!\n"));
3637         } else if (btInfo == BT_INFO_8723B_2ANT_B_CONNECTION)   { /*  connection exists but no busy */
3638                 pCoexDm->btStatus = BT_8723B_2ANT_BT_STATUS_CONNECTED_IDLE;
3639                 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], BtInfoNotify(), BT Connected-idle!!!\n"));
3640         } else if (
3641                 (btInfo&BT_INFO_8723B_2ANT_B_SCO_ESCO) ||
3642                 (btInfo&BT_INFO_8723B_2ANT_B_SCO_BUSY)
3643         ) {
3644                 pCoexDm->btStatus = BT_8723B_2ANT_BT_STATUS_SCO_BUSY;
3645                 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], BtInfoNotify(), BT SCO busy!!!\n"));
3646         } else if (btInfo&BT_INFO_8723B_2ANT_B_ACL_BUSY) {
3647                 pCoexDm->btStatus = BT_8723B_2ANT_BT_STATUS_ACL_BUSY;
3648                 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], BtInfoNotify(), BT ACL busy!!!\n"));
3649         } else {
3650                 pCoexDm->btStatus = BT_8723B_2ANT_BT_STATUS_MAX;
3651                 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], BtInfoNotify(), BT Non-Defined state!!!\n"));
3652         }
3653
3654         if (
3655                 (BT_8723B_2ANT_BT_STATUS_ACL_BUSY == pCoexDm->btStatus) ||
3656                 (BT_8723B_2ANT_BT_STATUS_SCO_BUSY == pCoexDm->btStatus) ||
3657                 (BT_8723B_2ANT_BT_STATUS_ACL_SCO_BUSY == pCoexDm->btStatus)
3658         ) {
3659                 bBtBusy = true;
3660                 bLimitedDig = true;
3661         } else {
3662                 bBtBusy = false;
3663                 bLimitedDig = false;
3664         }
3665
3666         pBtCoexist->fBtcSet(pBtCoexist, BTC_SET_BL_BT_TRAFFIC_BUSY, &bBtBusy);
3667
3668         pCoexDm->bLimitedDig = bLimitedDig;
3669         pBtCoexist->fBtcSet(pBtCoexist, BTC_SET_BL_BT_LIMITED_DIG, &bLimitedDig);
3670
3671         halbtc8723b2ant_RunCoexistMechanism(pBtCoexist);
3672 }
3673
3674 void EXhalbtc8723b2ant_HaltNotify(PBTC_COEXIST pBtCoexist)
3675 {
3676         BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY, ("[BTCoex], Halt notify\n"));
3677
3678         halbtc8723b2ant_WifiOffHwCfg(pBtCoexist);
3679         pBtCoexist->fBtcSetBtReg(pBtCoexist, BTC_BT_REG_RF, 0x3c, 0x15); /* BT goto standby while GNT_BT 1-->0 */
3680         halbtc8723b2ant_IgnoreWlanAct(pBtCoexist, FORCE_EXEC, true);
3681
3682         EXhalbtc8723b2ant_MediaStatusNotify(pBtCoexist, BTC_MEDIA_DISCONNECT);
3683 }
3684
3685 void EXhalbtc8723b2ant_PnpNotify(PBTC_COEXIST pBtCoexist, u8 pnpState)
3686 {
3687         BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY, ("[BTCoex], Pnp notify\n"));
3688
3689         if (BTC_WIFI_PNP_SLEEP == pnpState) {
3690                 BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY, ("[BTCoex], Pnp notify to SLEEP\n"));
3691         } else if (BTC_WIFI_PNP_WAKE_UP == pnpState) {
3692                 BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY, ("[BTCoex], Pnp notify to WAKE UP\n"));
3693                 halbtc8723b2ant_InitHwConfig(pBtCoexist, false);
3694                 halbtc8723b2ant_InitCoexDm(pBtCoexist);
3695                 halbtc8723b2ant_QueryBtInfo(pBtCoexist);
3696         }
3697 }
3698
3699 void EXhalbtc8723b2ant_Periodical(PBTC_COEXIST pBtCoexist)
3700 {
3701         static u8 disVerInfoCnt;
3702         u32 fwVer = 0, btPatchVer = 0;
3703
3704         BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], ==========================Periodical ===========================\n"));
3705
3706         if (disVerInfoCnt <= 5) {
3707                 disVerInfoCnt += 1;
3708                 BTC_PRINT(BTC_MSG_INTERFACE, INTF_INIT, ("[BTCoex], ****************************************************************\n"));
3709                 pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_U4_BT_PATCH_VER, &btPatchVer);
3710                 pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_U4_WIFI_FW_VER, &fwVer);
3711                 BTC_PRINT(BTC_MSG_INTERFACE, INTF_INIT, ("[BTCoex], CoexVer/ FwVer/ PatchVer = %d_%x/ 0x%x/ 0x%x(%d)\n", \
3712                         GLCoexVerDate8723b2Ant, GLCoexVer8723b2Ant, fwVer, btPatchVer, btPatchVer));
3713                 BTC_PRINT(BTC_MSG_INTERFACE, INTF_INIT, ("[BTCoex], ****************************************************************\n"));
3714         }
3715
3716         if (
3717                 halbtc8723b2ant_IsWifiStatusChanged(pBtCoexist) ||
3718                 pCoexDm->bAutoTdmaAdjust
3719         )
3720                 halbtc8723b2ant_RunCoexistMechanism(pBtCoexist);
3721 }