drivers/staging/rtl8723bs/hal/HalBtc8723b1Ant.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 struct coex_dm_8723b_1ant GLCoexDm8723b1Ant;
  12 static struct coex_dm_8723b_1ant *pCoexDm = &GLCoexDm8723b1Ant;
  13 static struct coex_sta_8723b_1ant GLCoexSta8723b1Ant;
  14 static struct coex_sta_8723b_1ant *pCoexSta = &GLCoexSta8723b1Ant;
  15
  16 /*  local function proto type if needed */
  17 /*  local function start with halbtc8723b1ant_ */
  18 static u8 halbtc8723b1ant_BtRssiState(
  19         u8 levelNum, u8 rssiThresh, u8 rssiThresh1
  20 )
  21 {
  22         s32 btRssi = 0;
  23         u8 btRssiState = pCoexSta->preBtRssiState;
  24
  25         btRssi = pCoexSta->btRssi;
  26
  27         if (levelNum == 2) {
  28                 if (
  29                         (pCoexSta->preBtRssiState == BTC_RSSI_STATE_LOW) ||
  30                         (pCoexSta->preBtRssiState == BTC_RSSI_STATE_STAY_LOW)
  31                 ) {
  32                         if (btRssi >= (rssiThresh + BTC_RSSI_COEX_THRESH_TOL_8723B_1ANT))
  33
  34                                 btRssiState = BTC_RSSI_STATE_HIGH;
  35                         else
  36                                 btRssiState = BTC_RSSI_STATE_STAY_LOW;
  37                 } else {
  38                         if (btRssi < rssiThresh)
  39                                 btRssiState = BTC_RSSI_STATE_LOW;
  40                         else
  41                                 btRssiState = BTC_RSSI_STATE_STAY_HIGH;
  42                 }
  43         } else if (levelNum == 3) {
  44                 if (rssiThresh > rssiThresh1)
  45                         return pCoexSta->preBtRssiState;
  46
  47                 if (
  48                         (pCoexSta->preBtRssiState == BTC_RSSI_STATE_LOW) ||
  49                         (pCoexSta->preBtRssiState == BTC_RSSI_STATE_STAY_LOW)
  50                 ) {
  51                         if (btRssi >= (rssiThresh + BTC_RSSI_COEX_THRESH_TOL_8723B_1ANT))
  52                                 btRssiState = BTC_RSSI_STATE_MEDIUM;
  53                         else
  54                                 btRssiState = BTC_RSSI_STATE_STAY_LOW;
  55                 } else if (
  56                         (pCoexSta->preBtRssiState == BTC_RSSI_STATE_MEDIUM) ||
  57                         (pCoexSta->preBtRssiState == BTC_RSSI_STATE_STAY_MEDIUM)
  58                 ) {
  59                         if (btRssi >= (rssiThresh1 + BTC_RSSI_COEX_THRESH_TOL_8723B_1ANT))
  60                                 btRssiState = BTC_RSSI_STATE_HIGH;
  61                         else if (btRssi < rssiThresh)
  62                                 btRssiState = BTC_RSSI_STATE_LOW;
  63                         else
  64                                 btRssiState = BTC_RSSI_STATE_STAY_MEDIUM;
  65                 } else {
  66                         if (btRssi < rssiThresh1)
  67                                 btRssiState = BTC_RSSI_STATE_MEDIUM;
  68                         else
  69                                 btRssiState = BTC_RSSI_STATE_STAY_HIGH;
  70                 }
  71         }
  72
  73         pCoexSta->preBtRssiState = btRssiState;
  74
  75         return btRssiState;
  76 }
  77
  78 static void halbtc8723b1ant_UpdateRaMask(
  79         struct btc_coexist *pBtCoexist, bool bForceExec, u32 disRateMask
  80 )
  81 {
  82         pCoexDm->curRaMask = disRateMask;
  83
  84         if (bForceExec || (pCoexDm->preRaMask != pCoexDm->curRaMask))
  85                 pBtCoexist->fBtcSet(
  86                         pBtCoexist,
  87                         BTC_SET_ACT_UPDATE_RAMASK,
  88                         &pCoexDm->curRaMask
  89                 );
  90         pCoexDm->preRaMask = pCoexDm->curRaMask;
  91 }
  92
  93 static void halbtc8723b1ant_AutoRateFallbackRetry(
  94         struct btc_coexist *pBtCoexist, bool bForceExec, u8 type
  95 )
  96 {
  97         bool bWifiUnderBMode = false;
  98
  99         pCoexDm->curArfrType = type;
 100
 101         if (bForceExec || (pCoexDm->preArfrType != pCoexDm->curArfrType)) {
 102                 switch (pCoexDm->curArfrType) {
 103                 case 0: /*  normal mode */
 104                         pBtCoexist->fBtcWrite4Byte(
 105                                 pBtCoexist, 0x430, pCoexDm->backupArfrCnt1
 106                         );
 107                         pBtCoexist->fBtcWrite4Byte(
 108                                 pBtCoexist, 0x434, pCoexDm->backupArfrCnt2
 109                         );
 110                         break;
 111                 case 1:
 112                         pBtCoexist->fBtcGet(
 113                                 pBtCoexist, BTC_GET_BL_WIFI_UNDER_B_MODE, &bWifiUnderBMode
 114                         );
 115                         if (bWifiUnderBMode) {
 116                                 pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0x430, 0x0);
 117                                 pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0x434, 0x01010101);
 118                         } else {
 119                                 pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0x430, 0x0);
 120                                 pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0x434, 0x04030201);
 121                         }
 122                         break;
 123                 default:
 124                         break;
 125                 }
 126         }
 127
 128         pCoexDm->preArfrType = pCoexDm->curArfrType;
 129 }
 130
 131 static void halbtc8723b1ant_RetryLimit(
 132         struct btc_coexist *pBtCoexist, bool bForceExec, u8 type
 133 )
 134 {
 135         pCoexDm->curRetryLimitType = type;
 136
 137         if (
 138                 bForceExec ||
 139                 (pCoexDm->preRetryLimitType != pCoexDm->curRetryLimitType)
 140         ) {
 141                 switch (pCoexDm->curRetryLimitType) {
 142                 case 0: /*  normal mode */
 143                         pBtCoexist->fBtcWrite2Byte(
 144                                 pBtCoexist, 0x42a, pCoexDm->backupRetryLimit
 145                         );
 146                         break;
 147                 case 1: /*  retry limit =8 */
 148                         pBtCoexist->fBtcWrite2Byte(pBtCoexist, 0x42a, 0x0808);
 149                         break;
 150                 default:
 151                         break;
 152                 }
 153         }
 154
 155         pCoexDm->preRetryLimitType = pCoexDm->curRetryLimitType;
 156 }
 157
 158 static void halbtc8723b1ant_AmpduMaxTime(
 159         struct btc_coexist *pBtCoexist, bool bForceExec, u8 type
 160 )
 161 {
 162         pCoexDm->curAmpduTimeType = type;
 163
 164         if (
 165                 bForceExec || (pCoexDm->preAmpduTimeType != pCoexDm->curAmpduTimeType)
 166         ) {
 167                 switch (pCoexDm->curAmpduTimeType) {
 168                 case 0: /*  normal mode */
 169                         pBtCoexist->fBtcWrite1Byte(
 170                                 pBtCoexist, 0x456, pCoexDm->backupAmpduMaxTime
 171                         );
 172                         break;
 173                 case 1: /*  AMPDU timw = 0x38 * 32us */
 174                         pBtCoexist->fBtcWrite1Byte(pBtCoexist, 0x456, 0x38);
 175                         break;
 176                 default:
 177                         break;
 178                 }
 179         }
 180
 181         pCoexDm->preAmpduTimeType = pCoexDm->curAmpduTimeType;
 182 }
 183
 184 static void halbtc8723b1ant_LimitedTx(
 185         struct btc_coexist *pBtCoexist,
 186         bool bForceExec,
 187         u8 raMaskType,
 188         u8 arfrType,
 189         u8 retryLimitType,
 190         u8 ampduTimeType
 191 )
 192 {
 193         switch (raMaskType) {
 194         case 0: /*  normal mode */
 195                 halbtc8723b1ant_UpdateRaMask(pBtCoexist, bForceExec, 0x0);
 196                 break;
 197         case 1: /*  disable cck 1/2 */
 198                 halbtc8723b1ant_UpdateRaMask(pBtCoexist, bForceExec, 0x00000003);
 199                 break;
 200         case 2: /*  disable cck 1/2/5.5, ofdm 6/9/12/18/24, mcs 0/1/2/3/4 */
 201                 halbtc8723b1ant_UpdateRaMask(pBtCoexist, bForceExec, 0x0001f1f7);
 202                 break;
 203         default:
 204                 break;
 205         }
 206
 207         halbtc8723b1ant_AutoRateFallbackRetry(pBtCoexist, bForceExec, arfrType);
 208         halbtc8723b1ant_RetryLimit(pBtCoexist, bForceExec, retryLimitType);
 209         halbtc8723b1ant_AmpduMaxTime(pBtCoexist, bForceExec, ampduTimeType);
 210 }
 211
 212 static void halbtc8723b1ant_LimitedRx(
 213         struct btc_coexist *pBtCoexist,
 214         bool bForceExec,
 215         bool bRejApAggPkt,
 216         bool bBtCtrlAggBufSize,
 217         u8 aggBufSize
 218 )
 219 {
 220         bool bRejectRxAgg = bRejApAggPkt;
 221         bool bBtCtrlRxAggSize = bBtCtrlAggBufSize;
 222         u8 rxAggSize = aggBufSize;
 223
 224         /*  */
 225         /*      Rx Aggregation related setting */
 226         /*  */
 227         pBtCoexist->fBtcSet(
 228                 pBtCoexist, BTC_SET_BL_TO_REJ_AP_AGG_PKT, &bRejectRxAgg
 229         );
 230         /*  decide BT control aggregation buf size or not */
 231         pBtCoexist->fBtcSet(
 232                 pBtCoexist, BTC_SET_BL_BT_CTRL_AGG_SIZE, &bBtCtrlRxAggSize
 233         );
 234         /*  aggregation buf size, only work when BT control Rx aggregation size. */
 235         pBtCoexist->fBtcSet(pBtCoexist, BTC_SET_U1_AGG_BUF_SIZE, &rxAggSize);
 236         /*  real update aggregation setting */
 237         pBtCoexist->fBtcSet(pBtCoexist, BTC_SET_ACT_AGGREGATE_CTRL, NULL);
 238
 239
 240 }
 241
 242 static void halbtc8723b1ant_QueryBtInfo(struct btc_coexist *pBtCoexist)
 243 {
 244         u8 H2C_Parameter[1] = {0};
 245
 246         pCoexSta->bC2hBtInfoReqSent = true;
 247
 248         H2C_Parameter[0] |= BIT0;       /*  trigger */
 249
 250         pBtCoexist->fBtcFillH2c(pBtCoexist, 0x61, 1, H2C_Parameter);
 251 }
 252
 253 static void halbtc8723b1ant_MonitorBtCtr(struct btc_coexist *pBtCoexist)
 254 {
 255         u32 regHPTxRx, regLPTxRx, u4Tmp;
 256         u32 regHPTx = 0, regHPRx = 0, regLPTx = 0, regLPRx = 0;
 257         static u8 NumOfBtCounterChk;
 258
 259        /* to avoid 0x76e[3] = 1 (WLAN_Act control by PTA) during IPS */
 260         /* if (! (pBtCoexist->fBtcRead1Byte(pBtCoexist, 0x76e) & 0x8)) */
 261
 262         if (pCoexSta->bUnderIps) {
 263                 pCoexSta->highPriorityTx = 65535;
 264                 pCoexSta->highPriorityRx = 65535;
 265                 pCoexSta->lowPriorityTx = 65535;
 266                 pCoexSta->lowPriorityRx = 65535;
 267                 return;
 268         }
 269
 270         regHPTxRx = 0x770;
 271         regLPTxRx = 0x774;
 272
 273         u4Tmp = pBtCoexist->fBtcRead4Byte(pBtCoexist, regHPTxRx);
 274         regHPTx = u4Tmp & bMaskLWord;
 275         regHPRx = (u4Tmp & bMaskHWord) >> 16;
 276
 277         u4Tmp = pBtCoexist->fBtcRead4Byte(pBtCoexist, regLPTxRx);
 278         regLPTx = u4Tmp & bMaskLWord;
 279         regLPRx = (u4Tmp & bMaskHWord) >> 16;
 280
 281         pCoexSta->highPriorityTx = regHPTx;
 282         pCoexSta->highPriorityRx = regHPRx;
 283         pCoexSta->lowPriorityTx = regLPTx;
 284         pCoexSta->lowPriorityRx = regLPRx;
 285
 286         if ((pCoexSta->lowPriorityTx >= 1050) && (!pCoexSta->bC2hBtInquiryPage))
 287                 pCoexSta->popEventCnt++;
 288
 289         /*  reset counter */
 290         pBtCoexist->fBtcWrite1Byte(pBtCoexist, 0x76e, 0xc);
 291
 292         if ((regHPTx == 0) && (regHPRx == 0) && (regLPTx == 0) && (regLPRx == 0)) {
 293                 NumOfBtCounterChk++;
 294                 if (NumOfBtCounterChk >= 3) {
 295                         halbtc8723b1ant_QueryBtInfo(pBtCoexist);
 296                         NumOfBtCounterChk = 0;
 297                 }
 298         }
 299 }
 300
 301
 302 static void halbtc8723b1ant_MonitorWiFiCtr(struct btc_coexist *pBtCoexist)
 303 {
 304         s32     wifiRssi = 0;
 305         bool bWifiBusy = false, bWifiUnderBMode = false;
 306         static u8 nCCKLockCounter;
 307
 308         pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_WIFI_BUSY, &bWifiBusy);
 309         pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_S4_WIFI_RSSI, &wifiRssi);
 310         pBtCoexist->fBtcGet(
 311                 pBtCoexist, BTC_GET_BL_WIFI_UNDER_B_MODE, &bWifiUnderBMode
 312         );
 313
 314         if (pCoexSta->bUnderIps) {
 315                 pCoexSta->nCRCOK_CCK = 0;
 316                 pCoexSta->nCRCOK_11g = 0;
 317                 pCoexSta->nCRCOK_11n = 0;
 318                 pCoexSta->nCRCOK_11nAgg = 0;
 319
 320                 pCoexSta->nCRCErr_CCK = 0;
 321                 pCoexSta->nCRCErr_11g = 0;
 322                 pCoexSta->nCRCErr_11n = 0;
 323                 pCoexSta->nCRCErr_11nAgg = 0;
 324         } else {
 325                 pCoexSta->nCRCOK_CCK    = pBtCoexist->fBtcRead4Byte(pBtCoexist, 0xf88);
 326                 pCoexSta->nCRCOK_11g    = pBtCoexist->fBtcRead2Byte(pBtCoexist, 0xf94);
 327                 pCoexSta->nCRCOK_11n    = pBtCoexist->fBtcRead2Byte(pBtCoexist, 0xf90);
 328                 pCoexSta->nCRCOK_11nAgg = pBtCoexist->fBtcRead2Byte(pBtCoexist, 0xfb8);
 329
 330                 pCoexSta->nCRCErr_CCK    = pBtCoexist->fBtcRead4Byte(pBtCoexist, 0xf84);
 331                 pCoexSta->nCRCErr_11g    = pBtCoexist->fBtcRead2Byte(pBtCoexist, 0xf96);
 332                 pCoexSta->nCRCErr_11n    = pBtCoexist->fBtcRead2Byte(pBtCoexist, 0xf92);
 333                 pCoexSta->nCRCErr_11nAgg = pBtCoexist->fBtcRead2Byte(pBtCoexist, 0xfba);
 334         }
 335
 336
 337         /* reset counter */
 338         pBtCoexist->fBtcWrite1ByteBitMask(pBtCoexist, 0xf16, 0x1, 0x1);
 339         pBtCoexist->fBtcWrite1ByteBitMask(pBtCoexist, 0xf16, 0x1, 0x0);
 340
 341         if (bWifiBusy && (wifiRssi >= 30) && !bWifiUnderBMode) {
 342                 if (
 343                         (pCoexDm->btStatus == BT_8723B_1ANT_BT_STATUS_ACL_BUSY) ||
 344                         (pCoexDm->btStatus == BT_8723B_1ANT_BT_STATUS_ACL_SCO_BUSY) ||
 345                         (pCoexDm->btStatus == BT_8723B_1ANT_BT_STATUS_SCO_BUSY)
 346                 ) {
 347                         if (
 348                                 pCoexSta->nCRCOK_CCK > (
 349                                         pCoexSta->nCRCOK_11g +
 350                                         pCoexSta->nCRCOK_11n +
 351                                         pCoexSta->nCRCOK_11nAgg
 352                                 )
 353                         ) {
 354                                 if (nCCKLockCounter < 5)
 355                                         nCCKLockCounter++;
 356                         } else {
 357                                 if (nCCKLockCounter > 0)
 358                                         nCCKLockCounter--;
 359                         }
 360
 361                 } else {
 362                         if (nCCKLockCounter > 0)
 363                                 nCCKLockCounter--;
 364                 }
 365         } else {
 366                 if (nCCKLockCounter > 0)
 367                         nCCKLockCounter--;
 368         }
 369
 370         if (!pCoexSta->bPreCCKLock) {
 371
 372                 if (nCCKLockCounter >= 5)
 373                         pCoexSta->bCCKLock = true;
 374                 else
 375                         pCoexSta->bCCKLock = false;
 376         } else {
 377                 if (nCCKLockCounter == 0)
 378                         pCoexSta->bCCKLock = false;
 379                 else
 380                         pCoexSta->bCCKLock = true;
 381         }
 382
 383         pCoexSta->bPreCCKLock =  pCoexSta->bCCKLock;
 384
 385
 386 }
 387
 388 static bool halbtc8723b1ant_IsWifiStatusChanged(struct btc_coexist *pBtCoexist)
 389 {
 390         static bool     bPreWifiBusy, bPreUnder4way, bPreBtHsOn;
 391         bool bWifiBusy = false, bUnder4way = false, bBtHsOn = false;
 392         bool bWifiConnected = false;
 393
 394         pBtCoexist->fBtcGet(
 395                 pBtCoexist, BTC_GET_BL_WIFI_CONNECTED, &bWifiConnected
 396         );
 397         pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_WIFI_BUSY, &bWifiBusy);
 398         pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_HS_OPERATION, &bBtHsOn);
 399         pBtCoexist->fBtcGet(
 400                 pBtCoexist, BTC_GET_BL_WIFI_4_WAY_PROGRESS, &bUnder4way
 401         );
 402
 403         if (bWifiConnected) {
 404                 if (bWifiBusy != bPreWifiBusy) {
 405                         bPreWifiBusy = bWifiBusy;
 406                         return true;
 407                 }
 408
 409                 if (bUnder4way != bPreUnder4way) {
 410                         bPreUnder4way = bUnder4way;
 411                         return true;
 412                 }
 413
 414                 if (bBtHsOn != bPreBtHsOn) {
 415                         bPreBtHsOn = bBtHsOn;
 416                         return true;
 417                 }
 418         }
 419
 420         return false;
 421 }
 422
 423 static void halbtc8723b1ant_UpdateBtLinkInfo(struct btc_coexist *pBtCoexist)
 424 {
 425         struct btc_bt_link_info *pBtLinkInfo = &pBtCoexist->btLinkInfo;
 426         bool bBtHsOn = false;
 427
 428         pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_HS_OPERATION, &bBtHsOn);
 429
 430         pBtLinkInfo->bBtLinkExist = pCoexSta->bBtLinkExist;
 431         pBtLinkInfo->bScoExist = pCoexSta->bScoExist;
 432         pBtLinkInfo->bA2dpExist = pCoexSta->bA2dpExist;
 433         pBtLinkInfo->bPanExist = pCoexSta->bPanExist;
 434         pBtLinkInfo->bHidExist = pCoexSta->bHidExist;
 435
 436         /*  work around for HS mode. */
 437         if (bBtHsOn) {
 438                 pBtLinkInfo->bPanExist = true;
 439                 pBtLinkInfo->bBtLinkExist = true;
 440         }
 441
 442         /*  check if Sco only */
 443         if (
 444                 pBtLinkInfo->bScoExist &&
 445                 !pBtLinkInfo->bA2dpExist &&
 446                 !pBtLinkInfo->bPanExist &&
 447                 !pBtLinkInfo->bHidExist
 448         )
 449                 pBtLinkInfo->bScoOnly = true;
 450         else
 451                 pBtLinkInfo->bScoOnly = false;
 452
 453         /*  check if A2dp only */
 454         if (
 455                 !pBtLinkInfo->bScoExist &&
 456                 pBtLinkInfo->bA2dpExist &&
 457                 !pBtLinkInfo->bPanExist &&
 458                 !pBtLinkInfo->bHidExist
 459         )
 460                 pBtLinkInfo->bA2dpOnly = true;
 461         else
 462                 pBtLinkInfo->bA2dpOnly = false;
 463
 464         /*  check if Pan only */
 465         if (
 466                 !pBtLinkInfo->bScoExist &&
 467                 !pBtLinkInfo->bA2dpExist &&
 468                 pBtLinkInfo->bPanExist &&
 469                 !pBtLinkInfo->bHidExist
 470         )
 471                 pBtLinkInfo->bPanOnly = true;
 472         else
 473                 pBtLinkInfo->bPanOnly = false;
 474
 475         /*  check if Hid only */
 476         if (
 477                 !pBtLinkInfo->bScoExist &&
 478                 !pBtLinkInfo->bA2dpExist &&
 479                 !pBtLinkInfo->bPanExist &&
 480                 pBtLinkInfo->bHidExist
 481         )
 482                 pBtLinkInfo->bHidOnly = true;
 483         else
 484                 pBtLinkInfo->bHidOnly = false;
 485 }
 486
 487 static u8 halbtc8723b1ant_ActionAlgorithm(struct btc_coexist *pBtCoexist)
 488 {
 489         struct btc_bt_link_info *pBtLinkInfo = &pBtCoexist->btLinkInfo;
 490         bool bBtHsOn = false;
 491         u8 algorithm = BT_8723B_1ANT_COEX_ALGO_UNDEFINED;
 492         u8 numOfDiffProfile = 0;
 493
 494         pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_HS_OPERATION, &bBtHsOn);
 495
 496         if (!pBtLinkInfo->bBtLinkExist)
 497                 return algorithm;
 498
 499         if (pBtLinkInfo->bScoExist)
 500                 numOfDiffProfile++;
 501         if (pBtLinkInfo->bHidExist)
 502                 numOfDiffProfile++;
 503         if (pBtLinkInfo->bPanExist)
 504                 numOfDiffProfile++;
 505         if (pBtLinkInfo->bA2dpExist)
 506                 numOfDiffProfile++;
 507
 508         if (numOfDiffProfile == 1) {
 509                 if (pBtLinkInfo->bScoExist) {
 510                         algorithm = BT_8723B_1ANT_COEX_ALGO_SCO;
 511                 } else {
 512                         if (pBtLinkInfo->bHidExist) {
 513                                 algorithm = BT_8723B_1ANT_COEX_ALGO_HID;
 514                         } else if (pBtLinkInfo->bA2dpExist) {
 515                                 algorithm = BT_8723B_1ANT_COEX_ALGO_A2DP;
 516                         } else if (pBtLinkInfo->bPanExist) {
 517                                 if (bBtHsOn)
 518                                         algorithm = BT_8723B_1ANT_COEX_ALGO_PANHS;
 519                                 else
 520                                         algorithm = BT_8723B_1ANT_COEX_ALGO_PANEDR;
 521                         }
 522                 }
 523         } else if (numOfDiffProfile == 2) {
 524                 if (pBtLinkInfo->bScoExist) {
 525                         if (pBtLinkInfo->bHidExist) {
 526                                 algorithm = BT_8723B_1ANT_COEX_ALGO_HID;
 527                         } else if (pBtLinkInfo->bA2dpExist) {
 528                                 algorithm = BT_8723B_1ANT_COEX_ALGO_SCO;
 529                         } else if (pBtLinkInfo->bPanExist) {
 530                                 if (bBtHsOn)
 531                                         algorithm = BT_8723B_1ANT_COEX_ALGO_SCO;
 532                                 else
 533                                         algorithm = BT_8723B_1ANT_COEX_ALGO_PANEDR_HID;
 534                         }
 535                 } else {
 536                         if (pBtLinkInfo->bHidExist && pBtLinkInfo->bA2dpExist) {
 537                                 algorithm = BT_8723B_1ANT_COEX_ALGO_HID_A2DP;
 538                         } else if (pBtLinkInfo->bHidExist && pBtLinkInfo->bPanExist) {
 539                                 if (bBtHsOn)
 540                                         algorithm = BT_8723B_1ANT_COEX_ALGO_HID_A2DP;
 541                                 else
 542                                         algorithm = BT_8723B_1ANT_COEX_ALGO_PANEDR_HID;
 543                         } else if (pBtLinkInfo->bPanExist && pBtLinkInfo->bA2dpExist) {
 544                                 if (bBtHsOn)
 545                                         algorithm = BT_8723B_1ANT_COEX_ALGO_A2DP_PANHS;
 546                                 else
 547                                         algorithm = BT_8723B_1ANT_COEX_ALGO_PANEDR_A2DP;
 548                         }
 549                 }
 550         } else if (numOfDiffProfile == 3) {
 551                 if (pBtLinkInfo->bScoExist) {
 552                         if (pBtLinkInfo->bHidExist && pBtLinkInfo->bA2dpExist) {
 553                                 algorithm = BT_8723B_1ANT_COEX_ALGO_HID;
 554                         } else if (
 555                                 pBtLinkInfo->bHidExist && pBtLinkInfo->bPanExist
 556                         ) {
 557                                 if (bBtHsOn)
 558                                         algorithm = BT_8723B_1ANT_COEX_ALGO_HID_A2DP;
 559                                 else
 560                                         algorithm = BT_8723B_1ANT_COEX_ALGO_PANEDR_HID;
 561                         } else if (pBtLinkInfo->bPanExist && pBtLinkInfo->bA2dpExist) {
 562                                 if (bBtHsOn)
 563                                         algorithm = BT_8723B_1ANT_COEX_ALGO_SCO;
 564                                 else
 565                                         algorithm = BT_8723B_1ANT_COEX_ALGO_PANEDR_HID;
 566                         }
 567                 } else {
 568                         if (
 569                                 pBtLinkInfo->bHidExist &&
 570                                 pBtLinkInfo->bPanExist &&
 571                                 pBtLinkInfo->bA2dpExist
 572                         ) {
 573                                 if (bBtHsOn)
 574                                         algorithm = BT_8723B_1ANT_COEX_ALGO_HID_A2DP;
 575                                 else
 576                                         algorithm = BT_8723B_1ANT_COEX_ALGO_HID_A2DP_PANEDR;
 577                         }
 578                 }
 579         } else if (numOfDiffProfile >= 3) {
 580                 if (pBtLinkInfo->bScoExist) {
 581                         if (
 582                                 pBtLinkInfo->bHidExist &&
 583                                 pBtLinkInfo->bPanExist &&
 584                                 pBtLinkInfo->bA2dpExist
 585                         ) {
 586                                 if (!bBtHsOn)
 587                                         algorithm = BT_8723B_1ANT_COEX_ALGO_PANEDR_HID;
 588
 589                         }
 590                 }
 591         }
 592
 593         return algorithm;
 594 }
 595
 596 static void halbtc8723b1ant_SetSwPenaltyTxRateAdaptive(
 597         struct btc_coexist *pBtCoexist, bool bLowPenaltyRa
 598 )
 599 {
 600         u8 H2C_Parameter[6] = {0};
 601
 602         H2C_Parameter[0] = 0x6; /*  opCode, 0x6 = Retry_Penalty */
 603
 604         if (bLowPenaltyRa) {
 605                 H2C_Parameter[1] |= BIT0;
 606                 H2C_Parameter[2] = 0x00;  /* normal rate except MCS7/6/5, OFDM54/48/36 */
 607                 H2C_Parameter[3] = 0xf7;  /* MCS7 or OFDM54 */
 608                 H2C_Parameter[4] = 0xf8;  /* MCS6 or OFDM48 */
 609                 H2C_Parameter[5] = 0xf9;        /* MCS5 or OFDM36 */
 610         }
 611
 612         pBtCoexist->fBtcFillH2c(pBtCoexist, 0x69, 6, H2C_Parameter);
 613 }
 614
 615 static void halbtc8723b1ant_LowPenaltyRa(
 616         struct btc_coexist *pBtCoexist, bool bForceExec, bool bLowPenaltyRa
 617 )
 618 {
 619         pCoexDm->bCurLowPenaltyRa = bLowPenaltyRa;
 620
 621         if (!bForceExec) {
 622                 if (pCoexDm->bPreLowPenaltyRa == pCoexDm->bCurLowPenaltyRa)
 623                         return;
 624         }
 625         halbtc8723b1ant_SetSwPenaltyTxRateAdaptive(
 626                 pBtCoexist, pCoexDm->bCurLowPenaltyRa
 627         );
 628
 629         pCoexDm->bPreLowPenaltyRa = pCoexDm->bCurLowPenaltyRa;
 630 }
 631
 632 static void halbtc8723b1ant_SetCoexTable(
 633         struct btc_coexist *pBtCoexist,
 634         u32 val0x6c0,
 635         u32 val0x6c4,
 636         u32 val0x6c8,
 637         u8 val0x6cc
 638 )
 639 {
 640         pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0x6c0, val0x6c0);
 641
 642         pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0x6c4, val0x6c4);
 643
 644         pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0x6c8, val0x6c8);
 645
 646         pBtCoexist->fBtcWrite1Byte(pBtCoexist, 0x6cc, val0x6cc);
 647 }
 648
 649 static void halbtc8723b1ant_CoexTable(
 650         struct btc_coexist *pBtCoexist,
 651         bool bForceExec,
 652         u32 val0x6c0,
 653         u32 val0x6c4,
 654         u32 val0x6c8,
 655         u8 val0x6cc
 656 )
 657 {
 658         pCoexDm->curVal0x6c0 = val0x6c0;
 659         pCoexDm->curVal0x6c4 = val0x6c4;
 660         pCoexDm->curVal0x6c8 = val0x6c8;
 661         pCoexDm->curVal0x6cc = val0x6cc;
 662
 663         if (!bForceExec) {
 664                 if (
 665                         (pCoexDm->preVal0x6c0 == pCoexDm->curVal0x6c0) &&
 666                     (pCoexDm->preVal0x6c4 == pCoexDm->curVal0x6c4) &&
 667                     (pCoexDm->preVal0x6c8 == pCoexDm->curVal0x6c8) &&
 668                     (pCoexDm->preVal0x6cc == pCoexDm->curVal0x6cc)
 669                 )
 670                         return;
 671         }
 672
 673         halbtc8723b1ant_SetCoexTable(
 674                 pBtCoexist, val0x6c0, val0x6c4, val0x6c8, val0x6cc
 675         );
 676
 677         pCoexDm->preVal0x6c0 = pCoexDm->curVal0x6c0;
 678         pCoexDm->preVal0x6c4 = pCoexDm->curVal0x6c4;
 679         pCoexDm->preVal0x6c8 = pCoexDm->curVal0x6c8;
 680         pCoexDm->preVal0x6cc = pCoexDm->curVal0x6cc;
 681 }
 682
 683 static void halbtc8723b1ant_CoexTableWithType(
 684         struct btc_coexist *pBtCoexist, bool bForceExec, u8 type
 685 )
 686 {
 687         pCoexSta->nCoexTableType = type;
 688
 689         switch (type) {
 690         case 0:
 691                 halbtc8723b1ant_CoexTable(
 692                         pBtCoexist, bForceExec, 0x55555555, 0x55555555, 0xffffff, 0x3
 693                 );
 694                 break;
 695         case 1:
 696                 halbtc8723b1ant_CoexTable(
 697                         pBtCoexist, bForceExec, 0x55555555, 0x5a5a5a5a, 0xffffff, 0x3
 698                 );
 699                 break;
 700         case 2:
 701                 halbtc8723b1ant_CoexTable(
 702                         pBtCoexist, bForceExec, 0x5a5a5a5a, 0x5a5a5a5a, 0xffffff, 0x3
 703                 );
 704                 break;
 705         case 3:
 706                 halbtc8723b1ant_CoexTable(
 707                         pBtCoexist, bForceExec, 0xaaaa5555, 0xaaaa5a5a, 0xffffff, 0x3
 708                 );
 709                 break;
 710         case 4:
 711                 halbtc8723b1ant_CoexTable(
 712                         pBtCoexist, bForceExec, 0x55555555, 0xaaaa5a5a, 0xffffff, 0x3
 713                 );
 714                 break;
 715         case 5:
 716                 halbtc8723b1ant_CoexTable(
 717                         pBtCoexist, bForceExec, 0x5a5a5a5a, 0xaaaa5a5a, 0xffffff, 0x3
 718                 );
 719                 break;
 720         case 6:
 721                 halbtc8723b1ant_CoexTable(
 722                         pBtCoexist, bForceExec, 0x55555555, 0xaaaaaaaa, 0xffffff, 0x3
 723                 );
 724                 break;
 725         case 7:
 726                 halbtc8723b1ant_CoexTable(
 727                         pBtCoexist, bForceExec, 0xaaaaaaaa, 0xaaaaaaaa, 0xffffff, 0x3
 728                 );
 729                 break;
 730         default:
 731                 break;
 732         }
 733 }
 734
 735 static void halbtc8723b1ant_SetFwIgnoreWlanAct(
 736         struct btc_coexist *pBtCoexist, bool bEnable
 737 )
 738 {
 739         u8 H2C_Parameter[1] = {0};
 740
 741         if (bEnable)
 742                 H2C_Parameter[0] |= BIT0; /* function enable */
 743
 744         pBtCoexist->fBtcFillH2c(pBtCoexist, 0x63, 1, H2C_Parameter);
 745 }
 746
 747 static void halbtc8723b1ant_IgnoreWlanAct(
 748         struct btc_coexist *pBtCoexist, bool bForceExec, bool bEnable
 749 )
 750 {
 751         pCoexDm->bCurIgnoreWlanAct = bEnable;
 752
 753         if (!bForceExec) {
 754                 if (pCoexDm->bPreIgnoreWlanAct == pCoexDm->bCurIgnoreWlanAct)
 755                         return;
 756         }
 757         halbtc8723b1ant_SetFwIgnoreWlanAct(pBtCoexist, bEnable);
 758
 759         pCoexDm->bPreIgnoreWlanAct = pCoexDm->bCurIgnoreWlanAct;
 760 }
 761
 762 static void halbtc8723b1ant_SetLpsRpwm(
 763         struct btc_coexist *pBtCoexist, u8 lpsVal, u8 rpwmVal
 764 )
 765 {
 766         u8 lps = lpsVal;
 767         u8 rpwm = rpwmVal;
 768
 769         pBtCoexist->fBtcSet(pBtCoexist, BTC_SET_U1_LPS_VAL, &lps);
 770         pBtCoexist->fBtcSet(pBtCoexist, BTC_SET_U1_RPWM_VAL, &rpwm);
 771 }
 772
 773 static void halbtc8723b1ant_LpsRpwm(
 774         struct btc_coexist *pBtCoexist, bool bForceExec, u8 lpsVal, u8 rpwmVal
 775 )
 776 {
 777         pCoexDm->curLps = lpsVal;
 778         pCoexDm->curRpwm = rpwmVal;
 779
 780         if (!bForceExec) {
 781                 if (
 782                         (pCoexDm->preLps == pCoexDm->curLps) &&
 783                         (pCoexDm->preRpwm == pCoexDm->curRpwm)
 784                 ) {
 785                         return;
 786                 }
 787         }
 788         halbtc8723b1ant_SetLpsRpwm(pBtCoexist, lpsVal, rpwmVal);
 789
 790         pCoexDm->preLps = pCoexDm->curLps;
 791         pCoexDm->preRpwm = pCoexDm->curRpwm;
 792 }
 793
 794 static void halbtc8723b1ant_SwMechanism(
 795         struct btc_coexist *pBtCoexist, bool bLowPenaltyRA
 796 )
 797 {
 798         halbtc8723b1ant_LowPenaltyRa(pBtCoexist, NORMAL_EXEC, bLowPenaltyRA);
 799 }
 800
 801 static void halbtc8723b1ant_SetAntPath(
 802         struct btc_coexist *pBtCoexist, u8 antPosType, bool bInitHwCfg, bool bWifiOff
 803 )
 804 {
 805         struct btc_board_info *pBoardInfo = &pBtCoexist->boardInfo;
 806         u32 fwVer = 0, u4Tmp = 0, cntBtCalChk = 0;
 807         bool bPgExtSwitch = false;
 808         bool bUseExtSwitch = false;
 809         bool bIsInMpMode = false;
 810         u8 H2C_Parameter[2] = {0}, u1Tmp = 0;
 811
 812         pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_EXT_SWITCH, &bPgExtSwitch);
 813         pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_U4_WIFI_FW_VER, &fwVer); /*  [31:16]=fw ver, [15:0]=fw sub ver */
 814
 815         if ((fwVer > 0 && fwVer < 0xc0000) || bPgExtSwitch)
 816                 bUseExtSwitch = true;
 817
 818         if (bInitHwCfg) {
 819                 pBtCoexist->fBtcSetRfReg(pBtCoexist, BTC_RF_A, 0x1, 0xfffff, 0x780); /* WiFi TRx Mask on */
 820                 pBtCoexist->fBtcSetBtReg(pBtCoexist, BTC_BT_REG_RF, 0x3c, 0x15); /* BT TRx Mask on */
 821
 822                 if (fwVer >= 0x180000) {
 823                         /* Use H2C to set GNT_BT to HIGH */
 824                         H2C_Parameter[0] = 1;
 825                         pBtCoexist->fBtcFillH2c(pBtCoexist, 0x6E, 1, H2C_Parameter);
 826                 } else /*  set grant_bt to high */
 827                         pBtCoexist->fBtcWrite1Byte(pBtCoexist, 0x765, 0x18);
 828
 829                 /* set wlan_act control by PTA */
 830                 pBtCoexist->fBtcWrite1Byte(pBtCoexist, 0x76e, 0x4);
 831
 832                 pBtCoexist->fBtcWrite1ByteBitMask(pBtCoexist, 0x67, 0x20, 0x1); /* BT select s0/s1 is controlled by WiFi */
 833
 834                 pBtCoexist->fBtcWrite1ByteBitMask(pBtCoexist, 0x39, 0x8, 0x1);
 835                 pBtCoexist->fBtcWrite1Byte(pBtCoexist, 0x974, 0xff);
 836                 pBtCoexist->fBtcWrite1ByteBitMask(pBtCoexist, 0x944, 0x3, 0x3);
 837                 pBtCoexist->fBtcWrite1Byte(pBtCoexist, 0x930, 0x77);
 838         } else if (bWifiOff) {
 839                 if (fwVer >= 0x180000) {
 840                         /* Use H2C to set GNT_BT to HIGH */
 841                         H2C_Parameter[0] = 1;
 842                         pBtCoexist->fBtcFillH2c(pBtCoexist, 0x6E, 1, H2C_Parameter);
 843                 } else /*  set grant_bt to high */
 844                         pBtCoexist->fBtcWrite1Byte(pBtCoexist, 0x765, 0x18);
 845
 846                 /* set wlan_act to always low */
 847                 pBtCoexist->fBtcWrite1Byte(pBtCoexist, 0x76e, 0x4);
 848
 849                 pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_WIFI_IS_IN_MP_MODE, &bIsInMpMode);
 850                 if (!bIsInMpMode)
 851                         pBtCoexist->fBtcWrite1ByteBitMask(pBtCoexist, 0x67, 0x20, 0x0); /* BT select s0/s1 is controlled by BT */
 852                 else
 853                         pBtCoexist->fBtcWrite1ByteBitMask(pBtCoexist, 0x67, 0x20, 0x1); /* BT select s0/s1 is controlled by WiFi */
 854
 855                 /*  0x4c[24:23]= 00, Set Antenna control by BT_RFE_CTRL BT Vendor 0xac = 0xf002 */
 856                 u4Tmp = pBtCoexist->fBtcRead4Byte(pBtCoexist, 0x4c);
 857                 u4Tmp &= ~BIT23;
 858                 u4Tmp &= ~BIT24;
 859                 pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0x4c, u4Tmp);
 860         } else {
 861                 /* Use H2C to set GNT_BT to LOW */
 862                 if (fwVer >= 0x180000) {
 863                         if (pBtCoexist->fBtcRead1Byte(pBtCoexist, 0x765) != 0) {
 864                                 H2C_Parameter[0] = 0;
 865                                 pBtCoexist->fBtcFillH2c(pBtCoexist, 0x6E, 1, H2C_Parameter);
 866                         }
 867                 } else {
 868                         /*  BT calibration check */
 869                         while (cntBtCalChk <= 20) {
 870                                 u1Tmp = pBtCoexist->fBtcRead1Byte(pBtCoexist, 0x49d);
 871                                 cntBtCalChk++;
 872
 873                                 if (u1Tmp & BIT0)
 874                                         mdelay(50);
 875                                 else
 876                                         break;
 877                         }
 878
 879                         /*  set grant_bt to PTA */
 880                         pBtCoexist->fBtcWrite1Byte(pBtCoexist, 0x765, 0x0);
 881                 }
 882
 883                 if (pBtCoexist->fBtcRead1Byte(pBtCoexist, 0x76e) != 0xc)
 884                         /* set wlan_act control by PTA */
 885                         pBtCoexist->fBtcWrite1Byte(pBtCoexist, 0x76e, 0xc);
 886         }
 887
 888         if (bUseExtSwitch) {
 889                 if (bInitHwCfg) {
 890                         /*  0x4c[23]= 0, 0x4c[24]= 1  Antenna control by WL/BT */
 891                         u4Tmp = pBtCoexist->fBtcRead4Byte(pBtCoexist, 0x4c);
 892                         u4Tmp &= ~BIT23;
 893                         u4Tmp |= BIT24;
 894                         pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0x4c, u4Tmp);
 895
 896                         pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0x948, 0x0); /*  fixed internal switch S1->WiFi, S0->BT */
 897
 898                         if (pBoardInfo->btdmAntPos == BTC_ANTENNA_AT_MAIN_PORT) {
 899                                 /* tell firmware "no antenna inverse" */
 900                                 H2C_Parameter[0] = 0;
 901                                 H2C_Parameter[1] = 1;  /* ext switch type */
 902                                 pBtCoexist->fBtcFillH2c(pBtCoexist, 0x65, 2, H2C_Parameter);
 903                         } else {
 904                                 /* tell firmware "antenna inverse" */
 905                                 H2C_Parameter[0] = 1;
 906                                 H2C_Parameter[1] = 1;  /* ext switch type */
 907                                 pBtCoexist->fBtcFillH2c(pBtCoexist, 0x65, 2, H2C_Parameter);
 908                         }
 909                 }
 910
 911
 912                 /*  ext switch setting */
 913                 switch (antPosType) {
 914                 case BTC_ANT_PATH_WIFI:
 915                         if (pBoardInfo->btdmAntPos == BTC_ANTENNA_AT_MAIN_PORT)
 916                                 pBtCoexist->fBtcWrite1ByteBitMask(pBtCoexist, 0x92c, 0x3, 0x1);
 917                         else
 918                                 pBtCoexist->fBtcWrite1ByteBitMask(pBtCoexist, 0x92c, 0x3, 0x2);
 919                         break;
 920                 case BTC_ANT_PATH_BT:
 921                         if (pBoardInfo->btdmAntPos == BTC_ANTENNA_AT_MAIN_PORT)
 922                                 pBtCoexist->fBtcWrite1ByteBitMask(pBtCoexist, 0x92c, 0x3, 0x2);
 923                         else
 924                                 pBtCoexist->fBtcWrite1ByteBitMask(pBtCoexist, 0x92c, 0x3, 0x1);
 925                         break;
 926                 default:
 927                 case BTC_ANT_PATH_PTA:
 928                         if (pBoardInfo->btdmAntPos == BTC_ANTENNA_AT_MAIN_PORT)
 929                                 pBtCoexist->fBtcWrite1ByteBitMask(pBtCoexist, 0x92c, 0x3, 0x1);
 930                         else
 931                                 pBtCoexist->fBtcWrite1ByteBitMask(pBtCoexist, 0x92c, 0x3, 0x2);
 932                         break;
 933                 }
 934
 935         } else {
 936                 if (bInitHwCfg) {
 937                         /*  0x4c[23]= 1, 0x4c[24]= 0  Antenna control by 0x64 */
 938                         u4Tmp = pBtCoexist->fBtcRead4Byte(pBtCoexist, 0x4c);
 939                         u4Tmp |= BIT23;
 940                         u4Tmp &= ~BIT24;
 941                         pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0x4c, u4Tmp);
 942
 943                         /* Fix Ext switch Main->S1, Aux->S0 */
 944                         pBtCoexist->fBtcWrite1ByteBitMask(pBtCoexist, 0x64, 0x1, 0x0);
 945
 946                         if (pBoardInfo->btdmAntPos == BTC_ANTENNA_AT_MAIN_PORT) {
 947
 948                                 /* tell firmware "no antenna inverse" */
 949                                 H2C_Parameter[0] = 0;
 950                                 H2C_Parameter[1] = 0;  /* internal switch type */
 951                                 pBtCoexist->fBtcFillH2c(pBtCoexist, 0x65, 2, H2C_Parameter);
 952                         } else {
 953
 954                                 /* tell firmware "antenna inverse" */
 955                                 H2C_Parameter[0] = 1;
 956                                 H2C_Parameter[1] = 0;  /* internal switch type */
 957                                 pBtCoexist->fBtcFillH2c(pBtCoexist, 0x65, 2, H2C_Parameter);
 958                         }
 959                 }
 960
 961
 962                 /*  internal switch setting */
 963                 switch (antPosType) {
 964                 case BTC_ANT_PATH_WIFI:
 965                         if (pBoardInfo->btdmAntPos == BTC_ANTENNA_AT_MAIN_PORT)
 966                                 pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0x948, 0x0);
 967                         else
 968                                 pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0x948, 0x280);
 969                         break;
 970                 case BTC_ANT_PATH_BT:
 971                         if (pBoardInfo->btdmAntPos == BTC_ANTENNA_AT_MAIN_PORT)
 972                                 pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0x948, 0x280);
 973                         else
 974                                 pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0x948, 0x0);
 975                         break;
 976                 default:
 977                 case BTC_ANT_PATH_PTA:
 978                         if (pBoardInfo->btdmAntPos == BTC_ANTENNA_AT_MAIN_PORT)
 979                                 pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0x948, 0x200);
 980                         else
 981                                 pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0x948, 0x80);
 982                         break;
 983                 }
 984         }
 985 }
 986
 987 static void halbtc8723b1ant_SetFwPstdma(
 988         struct btc_coexist *pBtCoexist, u8 byte1, u8 byte2, u8 byte3, u8 byte4, u8 byte5
 989 )
 990 {
 991         u8 H2C_Parameter[5] = {0};
 992         u8 realByte1 = byte1, realByte5 = byte5;
 993         bool bApEnable = false;
 994
 995         pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_WIFI_AP_MODE_ENABLE, &bApEnable);
 996
 997         if (bApEnable) {
 998                 if (byte1 & BIT4 && !(byte1 & BIT5)) {
 999                         realByte1 &= ~BIT4;
1000                         realByte1 |= BIT5;
1001
1002                         realByte5 |= BIT5;
1003                         realByte5 &= ~BIT6;
1004                 }
1005         }
1006
1007         H2C_Parameter[0] = realByte1;
1008         H2C_Parameter[1] = byte2;
1009         H2C_Parameter[2] = byte3;
1010         H2C_Parameter[3] = byte4;
1011         H2C_Parameter[4] = realByte5;
1012
1013         pCoexDm->psTdmaPara[0] = realByte1;
1014         pCoexDm->psTdmaPara[1] = byte2;
1015         pCoexDm->psTdmaPara[2] = byte3;
1016         pCoexDm->psTdmaPara[3] = byte4;
1017         pCoexDm->psTdmaPara[4] = realByte5;
1018
1019         pBtCoexist->fBtcFillH2c(pBtCoexist, 0x60, 5, H2C_Parameter);
1020 }
1021
1022
1023 static void halbtc8723b1ant_PsTdma(
1024         struct btc_coexist *pBtCoexist, bool bForceExec, bool bTurnOn, u8 type
1025 )
1026 {
1027         struct btc_bt_link_info *pBtLinkInfo = &pBtCoexist->btLinkInfo;
1028         bool bWifiBusy = false;
1029         u8 rssiAdjustVal = 0;
1030         u8 psTdmaByte4Val = 0x50, psTdmaByte0Val = 0x51, psTdmaByte3Val =  0x10;
1031         s8 nWiFiDurationAdjust = 0x0;
1032         /* u32 fwVer = 0; */
1033
1034         pCoexDm->bCurPsTdmaOn = bTurnOn;
1035         pCoexDm->curPsTdma = type;
1036
1037         pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_WIFI_BUSY, &bWifiBusy);
1038
1039         if (!bForceExec) {
1040                 if (
1041                         (pCoexDm->bPrePsTdmaOn == pCoexDm->bCurPsTdmaOn) &&
1042                         (pCoexDm->prePsTdma == pCoexDm->curPsTdma)
1043                 )
1044                         return;
1045         }
1046
1047         if (pCoexSta->nScanAPNum <= 5)
1048                 nWiFiDurationAdjust = 5;
1049         else if  (pCoexSta->nScanAPNum >= 40)
1050                 nWiFiDurationAdjust = -15;
1051         else if  (pCoexSta->nScanAPNum >= 20)
1052                 nWiFiDurationAdjust = -10;
1053
1054         if (!pCoexSta->bForceLpsOn) { /* only for A2DP-only case 1/2/9/11 */
1055                 psTdmaByte0Val = 0x61;  /* no null-pkt */
1056                 psTdmaByte3Val = 0x11; /*  no tx-pause at BT-slot */
1057                 psTdmaByte4Val = 0x10; /*  0x778 = d/1 toggle */
1058         }
1059
1060
1061         if (bTurnOn) {
1062                 if (pBtLinkInfo->bSlaveRole)
1063                         psTdmaByte4Val = psTdmaByte4Val | 0x1;  /* 0x778 = 0x1 at wifi slot (no blocking BT Low-Pri pkts) */
1064
1065
1066                 switch (type) {
1067                 default:
1068                         halbtc8723b1ant_SetFwPstdma(
1069                                 pBtCoexist, 0x51, 0x1a, 0x1a, 0x0, psTdmaByte4Val
1070                         );
1071                         break;
1072                 case 1:
1073                         halbtc8723b1ant_SetFwPstdma(
1074                                 pBtCoexist,
1075                                 psTdmaByte0Val,
1076                                 0x3a + nWiFiDurationAdjust,
1077                                 0x03,
1078                                 psTdmaByte3Val,
1079                                 psTdmaByte4Val
1080                         );
1081                         break;
1082                 case 2:
1083                         halbtc8723b1ant_SetFwPstdma(
1084                                 pBtCoexist,
1085                                 psTdmaByte0Val,
1086                                 0x2d + nWiFiDurationAdjust,
1087                                 0x03,
1088                                 psTdmaByte3Val,
1089                                 psTdmaByte4Val
1090                         );
1091                         break;
1092                 case 3:
1093                         halbtc8723b1ant_SetFwPstdma(
1094                                 pBtCoexist, 0x51, 0x1d, 0x1d, 0x0, 0x10
1095                         );
1096                         break;
1097                 case 4:
1098                         halbtc8723b1ant_SetFwPstdma(
1099                                 pBtCoexist, 0x93, 0x15, 0x3, 0x14, 0x0
1100                         );
1101                         break;
1102                 case 5:
1103                         halbtc8723b1ant_SetFwPstdma(
1104                                 pBtCoexist, 0x61, 0x15, 0x3, 0x11, 0x10
1105                         );
1106                         break;
1107                 case 6:
1108                         halbtc8723b1ant_SetFwPstdma(
1109                                 pBtCoexist, 0x61, 0x20, 0x3, 0x11, 0x11
1110                         );
1111                         break;
1112                 case 7:
1113                         halbtc8723b1ant_SetFwPstdma(pBtCoexist, 0x13, 0xc, 0x5, 0x0, 0x0);
1114                         break;
1115                 case 8:
1116                         halbtc8723b1ant_SetFwPstdma(
1117                                 pBtCoexist, 0x93, 0x25, 0x3, 0x10, 0x0
1118                         );
1119                         break;
1120                 case 9:
1121                         halbtc8723b1ant_SetFwPstdma(
1122                                 pBtCoexist,
1123                                 psTdmaByte0Val,
1124                                 0x21,
1125                                 0x3,
1126                                 psTdmaByte3Val,
1127                                 psTdmaByte4Val
1128                         );
1129                         break;
1130                 case 10:
1131                         halbtc8723b1ant_SetFwPstdma(pBtCoexist, 0x13, 0xa, 0xa, 0x0, 0x40);
1132                         break;
1133                 case 11:
1134                         halbtc8723b1ant_SetFwPstdma(
1135                                 pBtCoexist,
1136                                 psTdmaByte0Val,
1137                                 0x21,
1138                                 0x03,
1139                                 psTdmaByte3Val,
1140                                 psTdmaByte4Val
1141                         );
1142                         break;
1143                 case 12:
1144                         halbtc8723b1ant_SetFwPstdma(
1145                                 pBtCoexist, 0x51, 0x0a, 0x0a, 0x0, 0x50
1146                         );
1147                         break;
1148                 case 13:
1149                         halbtc8723b1ant_SetFwPstdma(
1150                                 pBtCoexist, 0x51, 0x12, 0x12, 0x0, 0x10
1151                         );
1152                         break;
1153                 case 14:
1154                         halbtc8723b1ant_SetFwPstdma(
1155                                 pBtCoexist, 0x51, 0x21, 0x3, 0x10, psTdmaByte4Val
1156                         );
1157                         break;
1158                 case 15:
1159                         halbtc8723b1ant_SetFwPstdma(
1160                                 pBtCoexist, 0x13, 0xa, 0x3, 0x8, 0x0
1161                         );
1162                         break;
1163                 case 16:
1164                         halbtc8723b1ant_SetFwPstdma(
1165                                 pBtCoexist, 0x93, 0x15, 0x3, 0x10, 0x0
1166                         );
1167                         break;
1168                 case 18:
1169                         halbtc8723b1ant_SetFwPstdma(
1170                                 pBtCoexist, 0x93, 0x25, 0x3, 0x10, 0x0
1171                         );
1172                         break;
1173                 case 20:
1174                         halbtc8723b1ant_SetFwPstdma(
1175                                 pBtCoexist, 0x61, 0x3f, 0x03, 0x11, 0x10
1176
1177                         );
1178                         break;
1179                 case 21:
1180                         halbtc8723b1ant_SetFwPstdma(
1181                                 pBtCoexist, 0x61, 0x25, 0x03, 0x11, 0x11
1182                         );
1183                         break;
1184                 case 22:
1185                         halbtc8723b1ant_SetFwPstdma(
1186                                 pBtCoexist, 0x61, 0x25, 0x03, 0x11, 0x10
1187                         );
1188                         break;
1189                 case 23:
1190                         halbtc8723b1ant_SetFwPstdma(
1191                                 pBtCoexist, 0xe3, 0x25, 0x3, 0x31, 0x18
1192                         );
1193                         break;
1194                 case 24:
1195                         halbtc8723b1ant_SetFwPstdma(
1196                                 pBtCoexist, 0xe3, 0x15, 0x3, 0x31, 0x18
1197                         );
1198                         break;
1199                 case 25:
1200                         halbtc8723b1ant_SetFwPstdma(
1201                                 pBtCoexist, 0xe3, 0xa, 0x3, 0x31, 0x18
1202                         );
1203                         break;
1204                 case 26:
1205                         halbtc8723b1ant_SetFwPstdma(
1206                                 pBtCoexist, 0xe3, 0xa, 0x3, 0x31, 0x18
1207                         );
1208                         break;
1209                 case 27:
1210                         halbtc8723b1ant_SetFwPstdma(
1211                                 pBtCoexist, 0xe3, 0x25, 0x3, 0x31, 0x98
1212                         );
1213                         break;
1214                 case 28:
1215                         halbtc8723b1ant_SetFwPstdma(
1216                                 pBtCoexist, 0x69, 0x25, 0x3, 0x31, 0x0
1217                         );
1218                         break;
1219                 case 29:
1220                         halbtc8723b1ant_SetFwPstdma(
1221                                 pBtCoexist, 0xab, 0x1a, 0x1a, 0x1, 0x10
1222                         );
1223                         break;
1224                 case 30:
1225                         halbtc8723b1ant_SetFwPstdma(
1226                                 pBtCoexist, 0x51, 0x30, 0x3, 0x10, 0x10
1227                         );
1228                         break;
1229                 case 31:
1230                         halbtc8723b1ant_SetFwPstdma(
1231                                 pBtCoexist, 0xd3, 0x1a, 0x1a, 0x0, 0x58
1232                         );
1233                         break;
1234                 case 32:
1235                         halbtc8723b1ant_SetFwPstdma(
1236                                 pBtCoexist, 0x61, 0x35, 0x3, 0x11, 0x11
1237                         );
1238                         break;
1239                 case 33:
1240                         halbtc8723b1ant_SetFwPstdma(
1241                                 pBtCoexist, 0xa3, 0x25, 0x3, 0x30, 0x90
1242                         );
1243                         break;
1244                 case 34:
1245                         halbtc8723b1ant_SetFwPstdma(
1246                                 pBtCoexist, 0x53, 0x1a, 0x1a, 0x0, 0x10
1247                         );
1248                         break;
1249                 case 35:
1250                         halbtc8723b1ant_SetFwPstdma(
1251                                 pBtCoexist, 0x63, 0x1a, 0x1a, 0x0, 0x10
1252                         );
1253                         break;
1254                 case 36:
1255                         halbtc8723b1ant_SetFwPstdma(
1256                                 pBtCoexist, 0xd3, 0x12, 0x3, 0x14, 0x50
1257                         );
1258                         break;
1259                 case 40: /*  SoftAP only with no sta associated, BT disable , TDMA mode for power saving */
1260                         /* here softap mode screen off will cost 70-80mA for phone */
1261                         halbtc8723b1ant_SetFwPstdma(
1262                                 pBtCoexist, 0x23, 0x18, 0x00, 0x10, 0x24
1263                         );
1264                         break;
1265                 }
1266         } else {
1267
1268                 /*  disable PS tdma */
1269                 switch (type) {
1270                 case 8: /* PTA Control */
1271                         halbtc8723b1ant_SetFwPstdma(pBtCoexist, 0x8, 0x0, 0x0, 0x0, 0x0);
1272                         halbtc8723b1ant_SetAntPath(
1273                                 pBtCoexist, BTC_ANT_PATH_PTA, false, false
1274                         );
1275                         break;
1276                 case 0:
1277                 default:  /* Software control, Antenna at BT side */
1278                         halbtc8723b1ant_SetFwPstdma(pBtCoexist, 0x0, 0x0, 0x0, 0x0, 0x0);
1279                         halbtc8723b1ant_SetAntPath(
1280                                 pBtCoexist, BTC_ANT_PATH_BT, false, false
1281                         );
1282                         break;
1283                 case 9:   /* Software control, Antenna at WiFi side */
1284                         halbtc8723b1ant_SetFwPstdma(pBtCoexist, 0x0, 0x0, 0x0, 0x0, 0x0);
1285                         halbtc8723b1ant_SetAntPath(
1286                                 pBtCoexist, BTC_ANT_PATH_WIFI, false, false
1287                         );
1288                         break;
1289                 }
1290         }
1291
1292         rssiAdjustVal = 0;
1293         pBtCoexist->fBtcSet(
1294                 pBtCoexist, BTC_SET_U1_RSSI_ADJ_VAL_FOR_1ANT_COEX_TYPE, &rssiAdjustVal
1295         );
1296
1297         /*  update pre state */
1298         pCoexDm->bPrePsTdmaOn = pCoexDm->bCurPsTdmaOn;
1299         pCoexDm->prePsTdma = pCoexDm->curPsTdma;
1300 }
1301
1302 static bool halbtc8723b1ant_IsCommonAction(struct btc_coexist *pBtCoexist)
1303 {
1304         bool bCommon = false, bWifiConnected = false, bWifiBusy = false;
1305
1306         pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_WIFI_CONNECTED, &bWifiConnected);
1307         pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_WIFI_BUSY, &bWifiBusy);
1308
1309         if (
1310                 !bWifiConnected &&
1311                 pCoexDm->btStatus == BT_8723B_1ANT_BT_STATUS_NON_CONNECTED_IDLE
1312         ) {
1313                 /* halbtc8723b1ant_SwMechanism(pBtCoexist, false); */
1314
1315                 bCommon = true;
1316         } else if (
1317                 bWifiConnected &&
1318                 (pCoexDm->btStatus == BT_8723B_1ANT_BT_STATUS_NON_CONNECTED_IDLE)
1319         ) {
1320                 /* halbtc8723b1ant_SwMechanism(pBtCoexist, false); */
1321
1322                 bCommon = true;
1323         } else if (
1324                 !bWifiConnected &&
1325                 (pCoexDm->btStatus == BT_8723B_1ANT_BT_STATUS_CONNECTED_IDLE)
1326         ) {
1327                 /* halbtc8723b1ant_SwMechanism(pBtCoexist, false); */
1328
1329                 bCommon = true;
1330         } else if (
1331                 bWifiConnected &&
1332                 (pCoexDm->btStatus == BT_8723B_1ANT_BT_STATUS_CONNECTED_IDLE)
1333         ) {
1334                 /* halbtc8723b1ant_SwMechanism(pBtCoexist, false); */
1335
1336                 bCommon = true;
1337         } else if (
1338                 !bWifiConnected &&
1339                 (pCoexDm->btStatus != BT_8723B_1ANT_BT_STATUS_CONNECTED_IDLE)
1340         ) {
1341                 /* halbtc8723b1ant_SwMechanism(pBtCoexist, false); */
1342
1343                 bCommon = true;
1344         } else {
1345                 bCommon = false;
1346         }
1347
1348         return bCommon;
1349 }
1350
1351
1352 static void halbtc8723b1ant_TdmaDurationAdjustForAcl(
1353         struct btc_coexist *pBtCoexist, u8 wifiStatus
1354 )
1355 {
1356         static s32 up, dn, m, n, WaitCount;
1357         s32 result;   /* 0: no change, +1: increase WiFi duration, -1: decrease WiFi duration */
1358         u8 retryCount = 0, btInfoExt;
1359
1360         if (
1361                 (wifiStatus == BT_8723B_1ANT_WIFI_STATUS_NON_CONNECTED_ASSO_AUTH_SCAN) ||
1362                 (wifiStatus == BT_8723B_1ANT_WIFI_STATUS_CONNECTED_SCAN) ||
1363                 (wifiStatus == BT_8723B_1ANT_WIFI_STATUS_CONNECTED_SPECIAL_PKT)
1364         ) {
1365                 if (
1366                         pCoexDm->curPsTdma != 1 &&
1367                         pCoexDm->curPsTdma != 2 &&
1368                         pCoexDm->curPsTdma != 3 &&
1369                         pCoexDm->curPsTdma != 9
1370                 ) {
1371                         halbtc8723b1ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 9);
1372                         pCoexDm->psTdmaDuAdjType = 9;
1373
1374                         up = 0;
1375                         dn = 0;
1376                         m = 1;
1377                         n = 3;
1378                         result = 0;
1379                         WaitCount = 0;
1380                 }
1381                 return;
1382         }
1383
1384         if (!pCoexDm->bAutoTdmaAdjust) {
1385                 pCoexDm->bAutoTdmaAdjust = true;
1386
1387                 halbtc8723b1ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 2);
1388                 pCoexDm->psTdmaDuAdjType = 2;
1389                 /*  */
1390                 up = 0;
1391                 dn = 0;
1392                 m = 1;
1393                 n = 3;
1394                 result = 0;
1395                 WaitCount = 0;
1396         } else {
1397                 /* acquire the BT TRx retry count from BT_Info byte2 */
1398                 retryCount = pCoexSta->btRetryCnt;
1399                 btInfoExt = pCoexSta->btInfoExt;
1400
1401                 if (pCoexSta->lowPriorityTx > 1050 || pCoexSta->lowPriorityRx > 1250)
1402                         retryCount++;
1403
1404                 result = 0;
1405                 WaitCount++;
1406
1407                 if (retryCount == 0) { /*  no retry in the last 2-second duration */
1408                         up++;
1409                         dn--;
1410
1411                         if (dn <= 0)
1412                                 dn = 0;
1413
1414                         if (up >= n) { /*  if 連續 n 個2秒 retry count為0, 則調寬WiFi duration */
1415                                 WaitCount = 0;
1416                                 n = 3;
1417                                 up = 0;
1418                                 dn = 0;
1419                                 result = 1;
1420                         }
1421                 } else if (retryCount <= 3) { /*  <=3 retry in the last 2-second duration */
1422                         up--;
1423                         dn++;
1424
1425                         if (up <= 0)
1426                                 up = 0;
1427
1428                         if (dn == 2) { /*  if 連續 2 個2秒 retry count< 3, 則調窄WiFi duration */
1429                                 if (WaitCount <= 2)
1430                                         m++; /*  避免一直在兩個level中來回 */
1431                                 else
1432                                         m = 1;
1433
1434                                 if (m >= 20) /* m 最大值 = 20 ' 最大120秒 recheck是否調整 WiFi duration. */
1435                                         m = 20;
1436
1437                                 n = 3 * m;
1438                                 up = 0;
1439                                 dn = 0;
1440                                 WaitCount = 0;
1441                                 result = -1;
1442                         }
1443                 } else { /* retry count > 3, 只要1次 retry count > 3, 則調窄WiFi duration */
1444                         if (WaitCount == 1)
1445                                 m++; /*  避免一直在兩個level中來回 */
1446                         else
1447                                 m = 1;
1448
1449                         if (m >= 20) /* m 最大值 = 20 ' 最大120秒 recheck是否調整 WiFi duration. */
1450                                 m = 20;
1451
1452                         n = 3 * m;
1453                         up = 0;
1454                         dn = 0;
1455                         WaitCount = 0;
1456                         result = -1;
1457                 }
1458
1459                 if (result == -1) {
1460                         if (
1461                                 BT_INFO_8723B_1ANT_A2DP_BASIC_RATE(btInfoExt) &&
1462                                 ((pCoexDm->curPsTdma == 1) || (pCoexDm->curPsTdma == 2))
1463                         ) {
1464                                 halbtc8723b1ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 9);
1465                                 pCoexDm->psTdmaDuAdjType = 9;
1466                         } else if (pCoexDm->curPsTdma == 1) {
1467                                 halbtc8723b1ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 2);
1468                                 pCoexDm->psTdmaDuAdjType = 2;
1469                         } else if (pCoexDm->curPsTdma == 2) {
1470                                 halbtc8723b1ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 9);
1471                                 pCoexDm->psTdmaDuAdjType = 9;
1472                         } else if (pCoexDm->curPsTdma == 9) {
1473                                 halbtc8723b1ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 11);
1474                                 pCoexDm->psTdmaDuAdjType = 11;
1475                         }
1476                 } else if (result == 1) {
1477                         if (
1478                                 BT_INFO_8723B_1ANT_A2DP_BASIC_RATE(btInfoExt) &&
1479                                 ((pCoexDm->curPsTdma == 1) || (pCoexDm->curPsTdma == 2))
1480                         ) {
1481                                 halbtc8723b1ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 9);
1482                                 pCoexDm->psTdmaDuAdjType = 9;
1483                         } else if (pCoexDm->curPsTdma == 11) {
1484                                 halbtc8723b1ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 9);
1485                                 pCoexDm->psTdmaDuAdjType = 9;
1486                         } else if (pCoexDm->curPsTdma == 9) {
1487                                 halbtc8723b1ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 2);
1488                                 pCoexDm->psTdmaDuAdjType = 2;
1489                         } else if (pCoexDm->curPsTdma == 2) {
1490                                 halbtc8723b1ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 1);
1491                                 pCoexDm->psTdmaDuAdjType = 1;
1492                         }
1493                 }
1494
1495                 if (
1496                         pCoexDm->curPsTdma != 1 &&
1497                         pCoexDm->curPsTdma != 2 &&
1498                         pCoexDm->curPsTdma != 9 &&
1499                         pCoexDm->curPsTdma != 11
1500                 ) /*  recover to previous adjust type */
1501                         halbtc8723b1ant_PsTdma(
1502                                 pBtCoexist, NORMAL_EXEC, true, pCoexDm->psTdmaDuAdjType
1503                         );
1504         }
1505 }
1506
1507 static void halbtc8723b1ant_PsTdmaCheckForPowerSaveState(
1508         struct btc_coexist *pBtCoexist, bool bNewPsState
1509 )
1510 {
1511         u8 lpsMode = 0x0;
1512
1513         pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_U1_LPS_MODE, &lpsMode);
1514
1515         if (lpsMode) {  /*  already under LPS state */
1516                 if (bNewPsState) {
1517                         /*  keep state under LPS, do nothing. */
1518                 } else /*  will leave LPS state, turn off psTdma first */
1519                         halbtc8723b1ant_PsTdma(pBtCoexist, NORMAL_EXEC, false, 0);
1520         } else {                                                /*  NO PS state */
1521                 if (bNewPsState) /*  will enter LPS state, turn off psTdma first */
1522                         halbtc8723b1ant_PsTdma(pBtCoexist, NORMAL_EXEC, false, 0);
1523                 else {
1524                         /*  keep state under NO PS state, do nothing. */
1525                 }
1526         }
1527 }
1528
1529 static void halbtc8723b1ant_PowerSaveState(
1530         struct btc_coexist *pBtCoexist, u8 psType, u8 lpsVal, u8 rpwmVal
1531 )
1532 {
1533         bool bLowPwrDisable = false;
1534
1535         switch (psType) {
1536         case BTC_PS_WIFI_NATIVE:
1537                 /*  recover to original 32k low power setting */
1538                 bLowPwrDisable = false;
1539                 pBtCoexist->fBtcSet(
1540                         pBtCoexist, BTC_SET_ACT_DISABLE_LOW_POWER, &bLowPwrDisable
1541                 );
1542                 pBtCoexist->fBtcSet(pBtCoexist, BTC_SET_ACT_NORMAL_LPS, NULL);
1543                 pCoexSta->bForceLpsOn = false;
1544                 break;
1545         case BTC_PS_LPS_ON:
1546                 halbtc8723b1ant_PsTdmaCheckForPowerSaveState(pBtCoexist, true);
1547                 halbtc8723b1ant_LpsRpwm(pBtCoexist, NORMAL_EXEC, lpsVal, rpwmVal);
1548                 /*  when coex force to enter LPS, do not enter 32k low power. */
1549                 bLowPwrDisable = true;
1550                 pBtCoexist->fBtcSet(
1551                         pBtCoexist, BTC_SET_ACT_DISABLE_LOW_POWER, &bLowPwrDisable
1552                 );
1553                 /*  power save must executed before psTdma. */
1554                 pBtCoexist->fBtcSet(pBtCoexist, BTC_SET_ACT_ENTER_LPS, NULL);
1555                 pCoexSta->bForceLpsOn = true;
1556                 break;
1557         case BTC_PS_LPS_OFF:
1558                 halbtc8723b1ant_PsTdmaCheckForPowerSaveState(pBtCoexist, false);
1559                 pBtCoexist->fBtcSet(pBtCoexist, BTC_SET_ACT_LEAVE_LPS, NULL);
1560                 pCoexSta->bForceLpsOn = false;
1561                 break;
1562         default:
1563                 break;
1564         }
1565 }
1566
1567 /*  */
1568 /*  */
1569 /*      Software Coex Mechanism start */
1570 /*  */
1571 /*  */
1572
1573 /*  */
1574 /*  */
1575 /*      Non-Software Coex Mechanism start */
1576 /*  */
1577 /*  */
1578 static void halbtc8723b1ant_ActionWifiMultiPort(struct btc_coexist *pBtCoexist)
1579 {
1580         halbtc8723b1ant_PowerSaveState(pBtCoexist, BTC_PS_WIFI_NATIVE, 0x0, 0x0);
1581
1582         halbtc8723b1ant_PsTdma(pBtCoexist, NORMAL_EXEC, false, 8);
1583         halbtc8723b1ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 2);
1584 }
1585
1586 static void halbtc8723b1ant_ActionHs(struct btc_coexist *pBtCoexist)
1587 {
1588         halbtc8723b1ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 5);
1589         halbtc8723b1ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 2);
1590 }
1591
1592 static void halbtc8723b1ant_ActionBtInquiry(struct btc_coexist *pBtCoexist)
1593 {
1594         struct btc_bt_link_info *pBtLinkInfo = &pBtCoexist->btLinkInfo;
1595         bool bWifiConnected = false;
1596         bool bApEnable = false;
1597         bool bWifiBusy = false;
1598         bool bBtBusy = false;
1599
1600         pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_WIFI_AP_MODE_ENABLE, &bApEnable);
1601         pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_WIFI_CONNECTED, &bWifiConnected);
1602         pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_WIFI_BUSY, &bWifiBusy);
1603         pBtCoexist->fBtcSet(pBtCoexist, BTC_SET_BL_BT_TRAFFIC_BUSY, &bBtBusy);
1604
1605         if (!bWifiConnected && !pCoexSta->bWiFiIsHighPriTask) {
1606                 halbtc8723b1ant_PowerSaveState(pBtCoexist, BTC_PS_WIFI_NATIVE, 0x0, 0x0);
1607                 halbtc8723b1ant_PsTdma(pBtCoexist, NORMAL_EXEC, false, 8);
1608
1609                 halbtc8723b1ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 0);
1610         } else if (
1611                 pBtLinkInfo->bScoExist ||
1612                 pBtLinkInfo->bHidExist ||
1613                 pBtLinkInfo->bA2dpExist
1614         ) {
1615                 /*  SCO/HID/A2DP busy */
1616                 halbtc8723b1ant_PowerSaveState(pBtCoexist, BTC_PS_WIFI_NATIVE, 0x0, 0x0);
1617                 halbtc8723b1ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 32);
1618
1619                 halbtc8723b1ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 4);
1620         } else if (pBtLinkInfo->bPanExist || bWifiBusy) {
1621                 halbtc8723b1ant_PowerSaveState(pBtCoexist, BTC_PS_WIFI_NATIVE, 0x0, 0x0);
1622                 halbtc8723b1ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 20);
1623
1624                 halbtc8723b1ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 4);
1625         } else {
1626                 halbtc8723b1ant_PowerSaveState(pBtCoexist, BTC_PS_WIFI_NATIVE, 0x0, 0x0);
1627                 halbtc8723b1ant_PsTdma(pBtCoexist, NORMAL_EXEC, false, 8);
1628
1629                 halbtc8723b1ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 7);
1630         }
1631 }
1632
1633 static void halbtc8723b1ant_ActionBtScoHidOnlyBusy(
1634         struct btc_coexist *pBtCoexist, u8 wifiStatus
1635 )
1636 {
1637         struct btc_bt_link_info *pBtLinkInfo = &pBtCoexist->btLinkInfo;
1638         bool bWifiConnected = false;
1639
1640         pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_WIFI_CONNECTED, &bWifiConnected);
1641
1642         /*  tdma and coex table */
1643
1644         if (pBtLinkInfo->bScoExist) {
1645                 halbtc8723b1ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 5);
1646                 halbtc8723b1ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 5);
1647         } else { /* HID */
1648                 halbtc8723b1ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 6);
1649                 halbtc8723b1ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 5);
1650         }
1651 }
1652
1653 static void halbtc8723b1ant_ActionWifiConnectedBtAclBusy(
1654         struct btc_coexist *pBtCoexist, u8 wifiStatus
1655 )
1656 {
1657         struct btc_bt_link_info *pBtLinkInfo = &pBtCoexist->btLinkInfo;
1658
1659         halbtc8723b1ant_BtRssiState(2, 28, 0);
1660
1661         if ((pCoexSta->lowPriorityRx >= 1000) && (pCoexSta->lowPriorityRx != 65535))
1662                 pBtLinkInfo->bSlaveRole = true;
1663         else
1664                 pBtLinkInfo->bSlaveRole = false;
1665
1666         if (pBtLinkInfo->bHidOnly) { /* HID */
1667                 halbtc8723b1ant_ActionBtScoHidOnlyBusy(pBtCoexist, wifiStatus);
1668                 pCoexDm->bAutoTdmaAdjust = false;
1669                 return;
1670         } else if (pBtLinkInfo->bA2dpOnly) { /* A2DP */
1671                 if (wifiStatus == BT_8723B_1ANT_WIFI_STATUS_CONNECTED_IDLE) {
1672                         halbtc8723b1ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 32);
1673                         halbtc8723b1ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 4);
1674                         pCoexDm->bAutoTdmaAdjust = false;
1675                 } else {
1676                         halbtc8723b1ant_TdmaDurationAdjustForAcl(pBtCoexist, wifiStatus);
1677                         halbtc8723b1ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 4);
1678                         pCoexDm->bAutoTdmaAdjust = true;
1679                 }
1680         } else if (pBtLinkInfo->bHidExist && pBtLinkInfo->bA2dpExist) { /* HID+A2DP */
1681                 halbtc8723b1ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 14);
1682                 pCoexDm->bAutoTdmaAdjust = false;
1683
1684                 halbtc8723b1ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 4);
1685         } else if (
1686                 pBtLinkInfo->bPanOnly ||
1687                 (pBtLinkInfo->bHidExist && pBtLinkInfo->bPanExist)
1688         ) { /* PAN(OPP, FTP), HID+PAN(OPP, FTP) */
1689                 halbtc8723b1ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 3);
1690                 halbtc8723b1ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 4);
1691                 pCoexDm->bAutoTdmaAdjust = false;
1692         } else if (
1693                 (pBtLinkInfo->bA2dpExist && pBtLinkInfo->bPanExist) ||
1694                 (pBtLinkInfo->bHidExist && pBtLinkInfo->bA2dpExist && pBtLinkInfo->bPanExist)
1695         ) { /* A2DP+PAN(OPP, FTP), HID+A2DP+PAN(OPP, FTP) */
1696                 halbtc8723b1ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 13);
1697                 halbtc8723b1ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 4);
1698                 pCoexDm->bAutoTdmaAdjust = false;
1699         } else {
1700                 /* BT no-profile busy (0x9) */
1701                 halbtc8723b1ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 32);
1702                 halbtc8723b1ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 4);
1703                 pCoexDm->bAutoTdmaAdjust = false;
1704         }
1705 }
1706
1707 static void halbtc8723b1ant_ActionWifiNotConnected(struct btc_coexist *pBtCoexist)
1708 {
1709         /*  power save state */
1710         halbtc8723b1ant_PowerSaveState(pBtCoexist, BTC_PS_WIFI_NATIVE, 0x0, 0x0);
1711
1712         /*  tdma and coex table */
1713         halbtc8723b1ant_PsTdma(pBtCoexist, FORCE_EXEC, false, 8);
1714         halbtc8723b1ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 0);
1715 }
1716
1717 static void halbtc8723b1ant_ActionWifiNotConnectedScan(
1718         struct btc_coexist *pBtCoexist
1719 )
1720 {
1721         struct btc_bt_link_info *pBtLinkInfo = &pBtCoexist->btLinkInfo;
1722
1723         halbtc8723b1ant_PowerSaveState(pBtCoexist, BTC_PS_WIFI_NATIVE, 0x0, 0x0);
1724
1725         /*  tdma and coex table */
1726         if (pCoexDm->btStatus == BT_8723B_1ANT_BT_STATUS_ACL_BUSY) {
1727                 if (pBtLinkInfo->bA2dpExist) {
1728                         halbtc8723b1ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 32);
1729                         halbtc8723b1ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 4);
1730                 } else if (pBtLinkInfo->bA2dpExist && pBtLinkInfo->bPanExist) {
1731                         halbtc8723b1ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 22);
1732                         halbtc8723b1ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 4);
1733                 } else {
1734                         halbtc8723b1ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 20);
1735                         halbtc8723b1ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 4);
1736                 }
1737         } else if (
1738                 (pCoexDm->btStatus == BT_8723B_1ANT_BT_STATUS_SCO_BUSY) ||
1739                 (pCoexDm->btStatus == BT_8723B_1ANT_BT_STATUS_ACL_SCO_BUSY)
1740         ) {
1741                 halbtc8723b1ant_ActionBtScoHidOnlyBusy(
1742                         pBtCoexist, BT_8723B_1ANT_WIFI_STATUS_CONNECTED_SCAN
1743                 );
1744         } else {
1745                 /* Bryant Add */
1746                 halbtc8723b1ant_PsTdma(pBtCoexist, NORMAL_EXEC, false, 8);
1747                 halbtc8723b1ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 2);
1748         }
1749 }
1750
1751 static void halbtc8723b1ant_ActionWifiNotConnectedAssoAuth(
1752         struct btc_coexist *pBtCoexist
1753 )
1754 {
1755         struct btc_bt_link_info *pBtLinkInfo = &pBtCoexist->btLinkInfo;
1756
1757         halbtc8723b1ant_PowerSaveState(pBtCoexist, BTC_PS_WIFI_NATIVE, 0x0, 0x0);
1758
1759         /*  tdma and coex table */
1760         if (
1761                 (pBtLinkInfo->bScoExist) ||
1762                 (pBtLinkInfo->bHidExist) ||
1763                 (pBtLinkInfo->bA2dpExist)
1764         ) {
1765                 halbtc8723b1ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 32);
1766                 halbtc8723b1ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 4);
1767         } else if (pBtLinkInfo->bPanExist) {
1768                 halbtc8723b1ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 20);
1769                 halbtc8723b1ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 4);
1770         } else {
1771                 halbtc8723b1ant_PsTdma(pBtCoexist, NORMAL_EXEC, false, 8);
1772                 halbtc8723b1ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 2);
1773         }
1774 }
1775
1776 static void halbtc8723b1ant_ActionWifiConnectedScan(struct btc_coexist *pBtCoexist)
1777 {
1778         struct btc_bt_link_info *pBtLinkInfo = &pBtCoexist->btLinkInfo;
1779
1780         halbtc8723b1ant_PowerSaveState(pBtCoexist, BTC_PS_WIFI_NATIVE, 0x0, 0x0);
1781
1782         /*  tdma and coex table */
1783         if (pCoexDm->btStatus == BT_8723B_1ANT_BT_STATUS_ACL_BUSY) {
1784                 if (pBtLinkInfo->bA2dpExist) {
1785                         halbtc8723b1ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 32);
1786                         halbtc8723b1ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 4);
1787                 } else if (pBtLinkInfo->bA2dpExist && pBtLinkInfo->bPanExist) {
1788                         halbtc8723b1ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 22);
1789                         halbtc8723b1ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 4);
1790                 } else {
1791                         halbtc8723b1ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 20);
1792                         halbtc8723b1ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 4);
1793                 }
1794         } else if (
1795                 (pCoexDm->btStatus == BT_8723B_1ANT_BT_STATUS_SCO_BUSY) ||
1796                 (pCoexDm->btStatus == BT_8723B_1ANT_BT_STATUS_ACL_SCO_BUSY)
1797         ) {
1798                 halbtc8723b1ant_ActionBtScoHidOnlyBusy(
1799                         pBtCoexist, BT_8723B_1ANT_WIFI_STATUS_CONNECTED_SCAN
1800                 );
1801         } else {
1802                 /* Bryant Add */
1803                 halbtc8723b1ant_PsTdma(pBtCoexist, NORMAL_EXEC, false, 8);
1804                 halbtc8723b1ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 2);
1805         }
1806 }
1807
1808 static void halbtc8723b1ant_ActionWifiConnectedSpecialPacket(
1809         struct btc_coexist *pBtCoexist
1810 )
1811 {
1812         struct btc_bt_link_info *pBtLinkInfo = &pBtCoexist->btLinkInfo;
1813
1814         halbtc8723b1ant_PowerSaveState(pBtCoexist, BTC_PS_WIFI_NATIVE, 0x0, 0x0);
1815
1816         /*  tdma and coex table */
1817         if (
1818                 (pBtLinkInfo->bScoExist) ||
1819                 (pBtLinkInfo->bHidExist) ||
1820                 (pBtLinkInfo->bA2dpExist)
1821         ) {
1822                 halbtc8723b1ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 32);
1823                 halbtc8723b1ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 4);
1824         } else if (pBtLinkInfo->bPanExist) {
1825                 halbtc8723b1ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 20);
1826                 halbtc8723b1ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 4);
1827         } else {
1828                 halbtc8723b1ant_PsTdma(pBtCoexist, NORMAL_EXEC, false, 8);
1829                 halbtc8723b1ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 2);
1830         }
1831 }
1832
1833 static void halbtc8723b1ant_ActionWifiConnected(struct btc_coexist *pBtCoexist)
1834 {
1835         bool bWifiBusy = false;
1836         bool bScan = false, bLink = false, bRoam = false;
1837         bool bUnder4way = false, bApEnable = false;
1838
1839         pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_WIFI_4_WAY_PROGRESS, &bUnder4way);
1840         if (bUnder4way) {
1841                 halbtc8723b1ant_ActionWifiConnectedSpecialPacket(pBtCoexist);
1842                 return;
1843         }
1844
1845         pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_WIFI_SCAN, &bScan);
1846         pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_WIFI_LINK, &bLink);
1847         pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_WIFI_ROAM, &bRoam);
1848         if (bScan || bLink || bRoam) {
1849                 if (bScan)
1850                         halbtc8723b1ant_ActionWifiConnectedScan(pBtCoexist);
1851                 else
1852                         halbtc8723b1ant_ActionWifiConnectedSpecialPacket(pBtCoexist);
1853                 return;
1854         }
1855
1856         pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_WIFI_AP_MODE_ENABLE, &bApEnable);
1857         pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_WIFI_BUSY, &bWifiBusy);
1858
1859         /*  power save state */
1860         if (
1861                 !bApEnable &&
1862                 pCoexDm->btStatus == BT_8723B_1ANT_BT_STATUS_ACL_BUSY &&
1863                 !pBtCoexist->btLinkInfo.bHidOnly
1864         ) {
1865                 if (pBtCoexist->btLinkInfo.bA2dpOnly) { /* A2DP */
1866                         if (!bWifiBusy)
1867                                 halbtc8723b1ant_PowerSaveState(
1868                                         pBtCoexist, BTC_PS_WIFI_NATIVE, 0x0, 0x0
1869                                 );
1870                         else { /* busy */
1871                                 if  (pCoexSta->nScanAPNum >= BT_8723B_1ANT_WIFI_NOISY_THRESH)  /* no force LPS, no PS-TDMA, use pure TDMA */
1872                                         halbtc8723b1ant_PowerSaveState(
1873                                                 pBtCoexist, BTC_PS_WIFI_NATIVE, 0x0, 0x0
1874                                         );
1875                                 else
1876                                         halbtc8723b1ant_PowerSaveState(
1877                                                 pBtCoexist, BTC_PS_LPS_ON, 0x50, 0x4
1878                                         );
1879                         }
1880                 } else if (
1881                         (!pCoexSta->bPanExist) &&
1882                         (!pCoexSta->bA2dpExist) &&
1883                         (!pCoexSta->bHidExist)
1884                 )
1885                         halbtc8723b1ant_PowerSaveState(pBtCoexist, BTC_PS_WIFI_NATIVE, 0x0, 0x0);
1886                 else
1887                         halbtc8723b1ant_PowerSaveState(pBtCoexist, BTC_PS_LPS_ON, 0x50, 0x4);
1888         } else
1889                 halbtc8723b1ant_PowerSaveState(pBtCoexist, BTC_PS_WIFI_NATIVE, 0x0, 0x0);
1890
1891         /*  tdma and coex table */
1892         if (!bWifiBusy) {
1893                 if (pCoexDm->btStatus == BT_8723B_1ANT_BT_STATUS_ACL_BUSY) {
1894                         halbtc8723b1ant_ActionWifiConnectedBtAclBusy(
1895                                 pBtCoexist,
1896                                 BT_8723B_1ANT_WIFI_STATUS_CONNECTED_IDLE
1897                         );
1898                 } else if (
1899                         (pCoexDm->btStatus == BT_8723B_1ANT_BT_STATUS_SCO_BUSY) ||
1900                         (pCoexDm->btStatus == BT_8723B_1ANT_BT_STATUS_ACL_SCO_BUSY)
1901                 ) {
1902                         halbtc8723b1ant_ActionBtScoHidOnlyBusy(pBtCoexist,
1903                                 BT_8723B_1ANT_WIFI_STATUS_CONNECTED_IDLE);
1904                 } else {
1905                         halbtc8723b1ant_PsTdma(pBtCoexist, NORMAL_EXEC, false, 8);
1906
1907                         if ((pCoexSta->highPriorityTx) + (pCoexSta->highPriorityRx) <= 60)
1908                                 halbtc8723b1ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 2);
1909                         else
1910                                 halbtc8723b1ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 7);
1911                 }
1912         } else {
1913                 if (pCoexDm->btStatus == BT_8723B_1ANT_BT_STATUS_ACL_BUSY) {
1914                         halbtc8723b1ant_ActionWifiConnectedBtAclBusy(
1915                                 pBtCoexist,
1916                                 BT_8723B_1ANT_WIFI_STATUS_CONNECTED_BUSY
1917                         );
1918                 } else if (
1919                         (pCoexDm->btStatus == BT_8723B_1ANT_BT_STATUS_SCO_BUSY) ||
1920                         (pCoexDm->btStatus == BT_8723B_1ANT_BT_STATUS_ACL_SCO_BUSY)
1921                 ) {
1922                         halbtc8723b1ant_ActionBtScoHidOnlyBusy(
1923                                 pBtCoexist,
1924                                 BT_8723B_1ANT_WIFI_STATUS_CONNECTED_BUSY
1925                         );
1926                 } else {
1927                         halbtc8723b1ant_PsTdma(pBtCoexist, NORMAL_EXEC, false, 8);
1928
1929                         if ((pCoexSta->highPriorityTx) + (pCoexSta->highPriorityRx) <= 60)
1930                                 halbtc8723b1ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 2);
1931                         else
1932                                 halbtc8723b1ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 7);
1933                 }
1934         }
1935 }
1936
1937 static void halbtc8723b1ant_RunSwCoexistMechanism(struct btc_coexist *pBtCoexist)
1938 {
1939         u8 algorithm = 0;
1940
1941         algorithm = halbtc8723b1ant_ActionAlgorithm(pBtCoexist);
1942         pCoexDm->curAlgorithm = algorithm;
1943
1944         if (halbtc8723b1ant_IsCommonAction(pBtCoexist)) {
1945
1946         } else {
1947                 switch (pCoexDm->curAlgorithm) {
1948                 case BT_8723B_1ANT_COEX_ALGO_SCO:
1949                         /* halbtc8723b1ant_ActionSco(pBtCoexist); */
1950                         break;
1951                 case BT_8723B_1ANT_COEX_ALGO_HID:
1952                         /* halbtc8723b1ant_ActionHid(pBtCoexist); */
1953                         break;
1954                 case BT_8723B_1ANT_COEX_ALGO_A2DP:
1955                         /* halbtc8723b1ant_ActionA2dp(pBtCoexist); */
1956                         break;
1957                 case BT_8723B_1ANT_COEX_ALGO_A2DP_PANHS:
1958                         /* halbtc8723b1ant_ActionA2dpPanHs(pBtCoexist); */
1959                         break;
1960                 case BT_8723B_1ANT_COEX_ALGO_PANEDR:
1961                         /* halbtc8723b1ant_ActionPanEdr(pBtCoexist); */
1962                         break;
1963                 case BT_8723B_1ANT_COEX_ALGO_PANHS:
1964                         /* halbtc8723b1ant_ActionPanHs(pBtCoexist); */
1965                         break;
1966                 case BT_8723B_1ANT_COEX_ALGO_PANEDR_A2DP:
1967                         /* halbtc8723b1ant_ActionPanEdrA2dp(pBtCoexist); */
1968                         break;
1969                 case BT_8723B_1ANT_COEX_ALGO_PANEDR_HID:
1970                         /* halbtc8723b1ant_ActionPanEdrHid(pBtCoexist); */
1971                         break;
1972                 case BT_8723B_1ANT_COEX_ALGO_HID_A2DP_PANEDR:
1973                         /* halbtc8723b1ant_ActionHidA2dpPanEdr(pBtCoexist); */
1974                         break;
1975                 case BT_8723B_1ANT_COEX_ALGO_HID_A2DP:
1976                         /* halbtc8723b1ant_ActionHidA2dp(pBtCoexist); */
1977                         break;
1978                 default:
1979                         break;
1980                 }
1981                 pCoexDm->preAlgorithm = pCoexDm->curAlgorithm;
1982         }
1983 }
1984
1985 static void halbtc8723b1ant_RunCoexistMechanism(struct btc_coexist *pBtCoexist)
1986 {
1987         struct btc_bt_link_info *pBtLinkInfo = &pBtCoexist->btLinkInfo;
1988         bool bWifiConnected = false, bBtHsOn = false;
1989         bool bIncreaseScanDevNum = false;
1990         bool bBtCtrlAggBufSize = false;
1991         u8 aggBufSize = 5;
1992         u32 wifiLinkStatus = 0;
1993         u32 numOfWifiLink = 0;
1994
1995         if (pBtCoexist->bManualControl)
1996                 return;
1997
1998         if (pBtCoexist->bStopCoexDm)
1999                 return;
2000
2001         if (pCoexSta->bUnderIps)
2002                 return;
2003
2004         if (
2005                 (pCoexDm->btStatus == BT_8723B_1ANT_BT_STATUS_ACL_BUSY) ||
2006                 (pCoexDm->btStatus == BT_8723B_1ANT_BT_STATUS_SCO_BUSY) ||
2007                 (pCoexDm->btStatus == BT_8723B_1ANT_BT_STATUS_ACL_SCO_BUSY)
2008         ){
2009                 bIncreaseScanDevNum = true;
2010         }
2011
2012         pBtCoexist->fBtcSet(
2013                 pBtCoexist,
2014                 BTC_SET_BL_INC_SCAN_DEV_NUM,
2015                 &bIncreaseScanDevNum
2016         );
2017         pBtCoexist->fBtcGet(
2018                 pBtCoexist,
2019                 BTC_GET_BL_WIFI_CONNECTED,
2020                 &bWifiConnected
2021         );
2022
2023         pBtCoexist->fBtcGet(
2024                 pBtCoexist,
2025                 BTC_GET_U4_WIFI_LINK_STATUS,
2026                 &wifiLinkStatus
2027         );
2028         numOfWifiLink = wifiLinkStatus >> 16;
2029
2030         if ((numOfWifiLink >= 2) || (wifiLinkStatus & WIFI_P2P_GO_CONNECTED)) {
2031                 halbtc8723b1ant_LimitedTx(pBtCoexist, NORMAL_EXEC, 0, 0, 0, 0);
2032                 halbtc8723b1ant_LimitedRx(pBtCoexist, NORMAL_EXEC, false, bBtCtrlAggBufSize, aggBufSize);
2033
2034                 if ((pBtLinkInfo->bA2dpExist) && (pCoexSta->bC2hBtInquiryPage))
2035                         halbtc8723b1ant_ActionBtInquiry(pBtCoexist);
2036                 else
2037                         halbtc8723b1ant_ActionWifiMultiPort(pBtCoexist);
2038
2039                 return;
2040         }
2041
2042         if ((pBtLinkInfo->bBtLinkExist) && (bWifiConnected)) {
2043                 halbtc8723b1ant_LimitedTx(pBtCoexist, NORMAL_EXEC, 1, 1, 0, 1);
2044
2045                 if (pBtLinkInfo->bScoExist)
2046                         halbtc8723b1ant_LimitedRx(pBtCoexist, NORMAL_EXEC, false, true, 0x5);
2047                 else
2048                         halbtc8723b1ant_LimitedRx(pBtCoexist, NORMAL_EXEC, false, true, 0x8);
2049
2050                 halbtc8723b1ant_SwMechanism(pBtCoexist, true);
2051                 halbtc8723b1ant_RunSwCoexistMechanism(pBtCoexist);  /* just print debug message */
2052         } else {
2053                 halbtc8723b1ant_LimitedTx(pBtCoexist, NORMAL_EXEC, 0, 0, 0, 0);
2054
2055                 halbtc8723b1ant_LimitedRx(pBtCoexist, NORMAL_EXEC, false, false, 0x5);
2056
2057                 halbtc8723b1ant_SwMechanism(pBtCoexist, false);
2058                 halbtc8723b1ant_RunSwCoexistMechanism(pBtCoexist); /* just print debug message */
2059         }
2060
2061         pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_HS_OPERATION, &bBtHsOn);
2062         if (pCoexSta->bC2hBtInquiryPage) {
2063                 halbtc8723b1ant_ActionBtInquiry(pBtCoexist);
2064                 return;
2065         } else if (bBtHsOn) {
2066                 halbtc8723b1ant_ActionHs(pBtCoexist);
2067                 return;
2068         }
2069
2070
2071         if (!bWifiConnected) {
2072                 bool bScan = false, bLink = false, bRoam = false;
2073
2074                 pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_WIFI_SCAN, &bScan);
2075                 pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_WIFI_LINK, &bLink);
2076                 pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_WIFI_ROAM, &bRoam);
2077
2078                 if (bScan || bLink || bRoam) {
2079                         if (bScan)
2080                                 halbtc8723b1ant_ActionWifiNotConnectedScan(pBtCoexist);
2081                         else
2082                                 halbtc8723b1ant_ActionWifiNotConnectedAssoAuth(pBtCoexist);
2083                 } else
2084                         halbtc8723b1ant_ActionWifiNotConnected(pBtCoexist);
2085         } else /*  wifi LPS/Busy */
2086                 halbtc8723b1ant_ActionWifiConnected(pBtCoexist);
2087 }
2088
2089 static void halbtc8723b1ant_InitCoexDm(struct btc_coexist *pBtCoexist)
2090 {
2091         /*  force to reset coex mechanism */
2092
2093         /*  sw all off */
2094         halbtc8723b1ant_SwMechanism(pBtCoexist, false);
2095
2096         /* halbtc8723b1ant_PsTdma(pBtCoexist, FORCE_EXEC, false, 8); */
2097         halbtc8723b1ant_CoexTableWithType(pBtCoexist, FORCE_EXEC, 0);
2098
2099         pCoexSta->popEventCnt = 0;
2100 }
2101
2102 static void halbtc8723b1ant_InitHwConfig(
2103         struct btc_coexist *pBtCoexist,
2104         bool bBackUp,
2105         bool bWifiOnly
2106 )
2107 {
2108         pBtCoexist->fBtcWrite1ByteBitMask(pBtCoexist, 0x550, 0x8, 0x1);  /* enable TBTT nterrupt */
2109
2110         /*  0x790[5:0]= 0x5 */
2111         pBtCoexist->fBtcWrite1Byte(pBtCoexist, 0x790, 0x5);
2112
2113         /*  Enable counter statistics */
2114         pBtCoexist->fBtcWrite1Byte(pBtCoexist, 0x778, 0x1);
2115         pBtCoexist->fBtcWrite1ByteBitMask(pBtCoexist, 0x40, 0x20, 0x1);
2116
2117         /* Antenna config */
2118         if (bWifiOnly) {
2119                 halbtc8723b1ant_SetAntPath(pBtCoexist, BTC_ANT_PATH_WIFI, true, false);
2120                 halbtc8723b1ant_PsTdma(pBtCoexist, FORCE_EXEC, false, 9);
2121         } else
2122                 halbtc8723b1ant_SetAntPath(pBtCoexist, BTC_ANT_PATH_BT, true, false);
2123
2124         /*  PTA parameter */
2125         halbtc8723b1ant_CoexTableWithType(pBtCoexist, FORCE_EXEC, 0);
2126
2127         pBtCoexist->fBtcRead4Byte(pBtCoexist, 0x948);
2128         pBtCoexist->fBtcRead1Byte(pBtCoexist, 0x765);
2129         pBtCoexist->fBtcRead1Byte(pBtCoexist, 0x67);
2130 }
2131
2132 /*  */
2133 /*  work around function start with wa_halbtc8723b1ant_ */
2134 /*  */
2135 /*  */
2136 /*  extern function start with EXhalbtc8723b1ant_ */
2137 /*  */
2138 void EXhalbtc8723b1ant_PowerOnSetting(struct btc_coexist *pBtCoexist)
2139 {
2140         struct btc_board_info *pBoardInfo = &pBtCoexist->boardInfo;
2141         u8 u1Tmp = 0x0;
2142         u16 u2Tmp = 0x0;
2143
2144         pBtCoexist->fBtcWrite1Byte(pBtCoexist, 0x67, 0x20);
2145
2146         /*  enable BB, REG_SYS_FUNC_EN such that we can write 0x948 correctly. */
2147         u2Tmp = pBtCoexist->fBtcRead2Byte(pBtCoexist, 0x2);
2148         pBtCoexist->fBtcWrite2Byte(pBtCoexist, 0x2, u2Tmp | BIT0 | BIT1);
2149
2150         /*  set GRAN_BT = 1 */
2151         pBtCoexist->fBtcWrite1Byte(pBtCoexist, 0x765, 0x18);
2152         /*  set WLAN_ACT = 0 */
2153         pBtCoexist->fBtcWrite1Byte(pBtCoexist, 0x76e, 0x4);
2154
2155         /*  */
2156         /*  S0 or S1 setting and Local register setting(By the setting fw can get ant number, S0/S1, ... info) */
2157         /*  Local setting bit define */
2158         /*      BIT0: "0" for no antenna inverse; "1" for antenna inverse */
2159         /*      BIT1: "0" for internal switch; "1" for external switch */
2160         /*      BIT2: "0" for one antenna; "1" for two antenna */
2161         /*  NOTE: here default all internal switch and 1-antenna ==> BIT1 = 0 and BIT2 = 0 */
2162         if (pBtCoexist->chipInterface == BTC_INTF_USB) {
2163                 /*  fixed at S0 for USB interface */
2164                 pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0x948, 0x0);
2165
2166                 u1Tmp |= 0x1;   /*  antenna inverse */
2167                 pBtCoexist->fBtcWriteLocalReg1Byte(pBtCoexist, 0xfe08, u1Tmp);
2168
2169                 pBoardInfo->btdmAntPos = BTC_ANTENNA_AT_AUX_PORT;
2170         } else {
2171                 /*  for PCIE and SDIO interface, we check efuse 0xc3[6] */
2172                 if (pBoardInfo->singleAntPath == 0) {
2173                         /*  set to S1 */
2174                         pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0x948, 0x280);
2175                         pBoardInfo->btdmAntPos = BTC_ANTENNA_AT_MAIN_PORT;
2176                 } else if (pBoardInfo->singleAntPath == 1) {
2177                         /*  set to S0 */
2178                         pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0x948, 0x0);
2179                         u1Tmp |= 0x1;   /*  antenna inverse */
2180                         pBoardInfo->btdmAntPos = BTC_ANTENNA_AT_AUX_PORT;
2181                 }
2182
2183                 if (pBtCoexist->chipInterface == BTC_INTF_PCI)
2184                         pBtCoexist->fBtcWriteLocalReg1Byte(pBtCoexist, 0x384, u1Tmp);
2185                 else if (pBtCoexist->chipInterface == BTC_INTF_SDIO)
2186                         pBtCoexist->fBtcWriteLocalReg1Byte(pBtCoexist, 0x60, u1Tmp);
2187         }
2188 }
2189
2190 void EXhalbtc8723b1ant_InitHwConfig(struct btc_coexist *pBtCoexist, bool bWifiOnly)
2191 {
2192         halbtc8723b1ant_InitHwConfig(pBtCoexist, true, bWifiOnly);
2193 }
2194
2195 void EXhalbtc8723b1ant_InitCoexDm(struct btc_coexist *pBtCoexist)
2196 {
2197         pBtCoexist->bStopCoexDm = false;
2198
2199         halbtc8723b1ant_InitCoexDm(pBtCoexist);
2200
2201         halbtc8723b1ant_QueryBtInfo(pBtCoexist);
2202 }
2203
2204 void EXhalbtc8723b1ant_IpsNotify(struct btc_coexist *pBtCoexist, u8 type)
2205 {
2206         if (pBtCoexist->bManualControl ||       pBtCoexist->bStopCoexDm)
2207                 return;
2208
2209         if (type == BTC_IPS_ENTER) {
2210                 pCoexSta->bUnderIps = true;
2211
2212                 halbtc8723b1ant_PsTdma(pBtCoexist, NORMAL_EXEC, false, 0);
2213                 halbtc8723b1ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 0);
2214                 halbtc8723b1ant_SetAntPath(pBtCoexist, BTC_ANT_PATH_BT, false, true);
2215         } else if (type == BTC_IPS_LEAVE) {
2216                 pCoexSta->bUnderIps = false;
2217
2218                 halbtc8723b1ant_InitHwConfig(pBtCoexist, false, false);
2219                 halbtc8723b1ant_InitCoexDm(pBtCoexist);
2220                 halbtc8723b1ant_QueryBtInfo(pBtCoexist);
2221         }
2222 }
2223
2224 void EXhalbtc8723b1ant_LpsNotify(struct btc_coexist *pBtCoexist, u8 type)
2225 {
2226         if (pBtCoexist->bManualControl || pBtCoexist->bStopCoexDm)
2227                 return;
2228
2229         if (type == BTC_LPS_ENABLE)
2230                 pCoexSta->bUnderLps = true;
2231         else if (type == BTC_LPS_DISABLE)
2232                 pCoexSta->bUnderLps = false;
2233 }
2234
2235 void EXhalbtc8723b1ant_ScanNotify(struct btc_coexist *pBtCoexist, u8 type)
2236 {
2237         bool bWifiConnected = false, bBtHsOn = false;
2238         u32 wifiLinkStatus = 0;
2239         u32 numOfWifiLink = 0;
2240         bool bBtCtrlAggBufSize = false;
2241         u8 aggBufSize = 5;
2242
2243         if (pBtCoexist->bManualControl || pBtCoexist->bStopCoexDm)
2244                 return;
2245
2246         if (type == BTC_SCAN_START) {
2247                 pCoexSta->bWiFiIsHighPriTask = true;
2248
2249                 halbtc8723b1ant_PsTdma(pBtCoexist, FORCE_EXEC, false, 8);  /* Force antenna setup for no scan result issue */
2250                 pBtCoexist->fBtcRead4Byte(pBtCoexist, 0x948);
2251                 pBtCoexist->fBtcRead1Byte(pBtCoexist, 0x765);
2252                 pBtCoexist->fBtcRead1Byte(pBtCoexist, 0x67);
2253         } else {
2254                 pCoexSta->bWiFiIsHighPriTask = false;
2255
2256                 pBtCoexist->fBtcGet(
2257                         pBtCoexist, BTC_GET_U1_AP_NUM, &pCoexSta->nScanAPNum
2258                 );
2259         }
2260
2261         if (pBtCoexist->btInfo.bBtDisabled)
2262                 return;
2263
2264         pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_HS_OPERATION, &bBtHsOn);
2265         pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_WIFI_CONNECTED, &bWifiConnected);
2266
2267         halbtc8723b1ant_QueryBtInfo(pBtCoexist);
2268
2269         pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_U4_WIFI_LINK_STATUS, &wifiLinkStatus);
2270         numOfWifiLink = wifiLinkStatus >> 16;
2271
2272         if (numOfWifiLink >= 2) {
2273                 halbtc8723b1ant_LimitedTx(pBtCoexist, NORMAL_EXEC, 0, 0, 0, 0);
2274                 halbtc8723b1ant_LimitedRx(
2275                         pBtCoexist, NORMAL_EXEC, false, bBtCtrlAggBufSize, aggBufSize
2276                 );
2277                 halbtc8723b1ant_ActionWifiMultiPort(pBtCoexist);
2278                 return;
2279         }
2280
2281         if (pCoexSta->bC2hBtInquiryPage) {
2282                 halbtc8723b1ant_ActionBtInquiry(pBtCoexist);
2283                 return;
2284         } else if (bBtHsOn) {
2285                 halbtc8723b1ant_ActionHs(pBtCoexist);
2286                 return;
2287         }
2288
2289         if (type == BTC_SCAN_START) {
2290                 if (!bWifiConnected)    /*  non-connected scan */
2291                         halbtc8723b1ant_ActionWifiNotConnectedScan(pBtCoexist);
2292                 else    /*  wifi is connected */
2293                         halbtc8723b1ant_ActionWifiConnectedScan(pBtCoexist);
2294         } else if (type == BTC_SCAN_FINISH) {
2295                 if (!bWifiConnected)    /*  non-connected scan */
2296                         halbtc8723b1ant_ActionWifiNotConnected(pBtCoexist);
2297                 else
2298                         halbtc8723b1ant_ActionWifiConnected(pBtCoexist);
2299         }
2300 }
2301
2302 void EXhalbtc8723b1ant_ConnectNotify(struct btc_coexist *pBtCoexist, u8 type)
2303 {
2304         bool bWifiConnected = false, bBtHsOn = false;
2305         u32 wifiLinkStatus = 0;
2306         u32 numOfWifiLink = 0;
2307         bool bBtCtrlAggBufSize = false;
2308         u8 aggBufSize = 5;
2309
2310         if (
2311                 pBtCoexist->bManualControl ||
2312                 pBtCoexist->bStopCoexDm ||
2313                 pBtCoexist->btInfo.bBtDisabled
2314         )
2315                 return;
2316
2317         if (type == BTC_ASSOCIATE_START) {
2318                 pCoexSta->bWiFiIsHighPriTask = true;
2319                  pCoexDm->nArpCnt = 0;
2320         } else {
2321                 pCoexSta->bWiFiIsHighPriTask = false;
2322                 /* pCoexDm->nArpCnt = 0; */
2323         }
2324
2325         pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_U4_WIFI_LINK_STATUS, &wifiLinkStatus);
2326         numOfWifiLink = wifiLinkStatus >> 16;
2327         if (numOfWifiLink >= 2) {
2328                 halbtc8723b1ant_LimitedTx(pBtCoexist, NORMAL_EXEC, 0, 0, 0, 0);
2329                 halbtc8723b1ant_LimitedRx(pBtCoexist, NORMAL_EXEC, false, bBtCtrlAggBufSize, aggBufSize);
2330                 halbtc8723b1ant_ActionWifiMultiPort(pBtCoexist);
2331                 return;
2332         }
2333
2334         pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_HS_OPERATION, &bBtHsOn);
2335         if (pCoexSta->bC2hBtInquiryPage) {
2336                 halbtc8723b1ant_ActionBtInquiry(pBtCoexist);
2337                 return;
2338         } else if (bBtHsOn) {
2339                 halbtc8723b1ant_ActionHs(pBtCoexist);
2340                 return;
2341         }
2342
2343         if (type == BTC_ASSOCIATE_START) {
2344                 halbtc8723b1ant_ActionWifiNotConnectedAssoAuth(pBtCoexist);
2345         } else if (type == BTC_ASSOCIATE_FINISH) {
2346                 pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_WIFI_CONNECTED, &bWifiConnected);
2347                 if (!bWifiConnected) /*  non-connected scan */
2348                         halbtc8723b1ant_ActionWifiNotConnected(pBtCoexist);
2349                 else
2350                         halbtc8723b1ant_ActionWifiConnected(pBtCoexist);
2351         }
2352 }
2353
2354 void EXhalbtc8723b1ant_MediaStatusNotify(struct btc_coexist *pBtCoexist, u8 type)
2355 {
2356         u8 H2C_Parameter[3] = {0};
2357         u32 wifiBw;
2358         u8 wifiCentralChnl;
2359         bool bWifiUnderBMode = false;
2360
2361         if (
2362                 pBtCoexist->bManualControl ||
2363                 pBtCoexist->bStopCoexDm ||
2364                 pBtCoexist->btInfo.bBtDisabled
2365         )
2366                 return;
2367
2368         if (type == BTC_MEDIA_CONNECT) {
2369                 pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_WIFI_UNDER_B_MODE, &bWifiUnderBMode);
2370
2371                 /* Set CCK Tx/Rx high Pri except 11b mode */
2372                 if (bWifiUnderBMode) {
2373                         pBtCoexist->fBtcWrite1Byte(pBtCoexist, 0x6cd, 0x00); /* CCK Tx */
2374                         pBtCoexist->fBtcWrite1Byte(pBtCoexist, 0x6cf, 0x00); /* CCK Rx */
2375                 } else {
2376                         pBtCoexist->fBtcWrite1Byte(pBtCoexist, 0x6cd, 0x10); /* CCK Tx */
2377                         pBtCoexist->fBtcWrite1Byte(pBtCoexist, 0x6cf, 0x10); /* CCK Rx */
2378                 }
2379
2380                 pCoexDm->backupArfrCnt1 = pBtCoexist->fBtcRead4Byte(pBtCoexist, 0x430);
2381                 pCoexDm->backupArfrCnt2 = pBtCoexist->fBtcRead4Byte(pBtCoexist, 0x434);
2382                 pCoexDm->backupRetryLimit = pBtCoexist->fBtcRead2Byte(pBtCoexist, 0x42a);
2383                 pCoexDm->backupAmpduMaxTime = pBtCoexist->fBtcRead1Byte(pBtCoexist, 0x456);
2384         } else {
2385                 pCoexDm->nArpCnt = 0;
2386
2387                 pBtCoexist->fBtcWrite1Byte(pBtCoexist, 0x6cd, 0x0); /* CCK Tx */
2388                 pBtCoexist->fBtcWrite1Byte(pBtCoexist, 0x6cf, 0x0); /* CCK Rx */
2389         }
2390
2391         /*  only 2.4G we need to inform bt the chnl mask */
2392         pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_U1_WIFI_CENTRAL_CHNL, &wifiCentralChnl);
2393         if ((type == BTC_MEDIA_CONNECT) && (wifiCentralChnl <= 14)) {
2394                 /* H2C_Parameter[0] = 0x1; */
2395                 H2C_Parameter[0] = 0x0;
2396                 H2C_Parameter[1] = wifiCentralChnl;
2397                 pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_U4_WIFI_BW, &wifiBw);
2398
2399                 if (wifiBw == BTC_WIFI_BW_HT40)
2400                         H2C_Parameter[2] = 0x30;
2401                 else
2402                         H2C_Parameter[2] = 0x20;
2403         }
2404
2405         pCoexDm->wifiChnlInfo[0] = H2C_Parameter[0];
2406         pCoexDm->wifiChnlInfo[1] = H2C_Parameter[1];
2407         pCoexDm->wifiChnlInfo[2] = H2C_Parameter[2];
2408
2409         pBtCoexist->fBtcFillH2c(pBtCoexist, 0x66, 3, H2C_Parameter);
2410 }
2411
2412 void EXhalbtc8723b1ant_SpecialPacketNotify(struct btc_coexist *pBtCoexist, u8 type)
2413 {
2414         bool bBtHsOn = false;
2415         u32 wifiLinkStatus = 0;
2416         u32 numOfWifiLink = 0;
2417         bool bBtCtrlAggBufSize = false;
2418         u8 aggBufSize = 5;
2419
2420         if (
2421                 pBtCoexist->bManualControl ||
2422                 pBtCoexist->bStopCoexDm ||
2423                 pBtCoexist->btInfo.bBtDisabled
2424         )
2425                 return;
2426
2427         if (
2428                 type == BTC_PACKET_DHCP ||
2429                 type == BTC_PACKET_EAPOL ||
2430                 type == BTC_PACKET_ARP
2431         ) {
2432                 if (type == BTC_PACKET_ARP) {
2433                         pCoexDm->nArpCnt++;
2434
2435                         if (pCoexDm->nArpCnt >= 10) /*  if APR PKT > 10 after connect, do not go to ActionWifiConnectedSpecialPacket(pBtCoexist) */
2436                                 pCoexSta->bWiFiIsHighPriTask = false;
2437                         else
2438                                 pCoexSta->bWiFiIsHighPriTask = true;
2439                 } else {
2440                         pCoexSta->bWiFiIsHighPriTask = true;
2441                 }
2442         } else {
2443                 pCoexSta->bWiFiIsHighPriTask = false;
2444         }
2445
2446         pCoexSta->specialPktPeriodCnt = 0;
2447
2448         pBtCoexist->fBtcGet(
2449                 pBtCoexist, BTC_GET_U4_WIFI_LINK_STATUS, &wifiLinkStatus
2450         );
2451         numOfWifiLink = wifiLinkStatus >> 16;
2452
2453         if (numOfWifiLink >= 2) {
2454                 halbtc8723b1ant_LimitedTx(pBtCoexist, NORMAL_EXEC, 0, 0, 0, 0);
2455                 halbtc8723b1ant_LimitedRx(
2456                         pBtCoexist, NORMAL_EXEC, false, bBtCtrlAggBufSize, aggBufSize
2457                 );
2458                 halbtc8723b1ant_ActionWifiMultiPort(pBtCoexist);
2459                 return;
2460         }
2461
2462         pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_HS_OPERATION, &bBtHsOn);
2463         if (pCoexSta->bC2hBtInquiryPage) {
2464                 halbtc8723b1ant_ActionBtInquiry(pBtCoexist);
2465                 return;
2466         } else if (bBtHsOn) {
2467                 halbtc8723b1ant_ActionHs(pBtCoexist);
2468                 return;
2469         }
2470
2471         if (
2472                 type == BTC_PACKET_DHCP ||
2473                 type == BTC_PACKET_EAPOL ||
2474                 ((type == BTC_PACKET_ARP) && (pCoexSta->bWiFiIsHighPriTask))
2475         )
2476                 halbtc8723b1ant_ActionWifiConnectedSpecialPacket(pBtCoexist);
2477 }
2478
2479 void EXhalbtc8723b1ant_BtInfoNotify(
2480         struct btc_coexist *pBtCoexist, u8 *tmpBuf, u8 length
2481 )
2482 {
2483         u8 btInfo = 0;
2484         u8 i, rspSource = 0;
2485         bool bWifiConnected = false;
2486         bool bBtBusy = false;
2487
2488         pCoexSta->bC2hBtInfoReqSent = false;
2489
2490         rspSource = tmpBuf[0] & 0xf;
2491         if (rspSource >= BT_INFO_SRC_8723B_1ANT_MAX)
2492                 rspSource = BT_INFO_SRC_8723B_1ANT_WIFI_FW;
2493         pCoexSta->btInfoC2hCnt[rspSource]++;
2494
2495         for (i = 0; i < length; i++) {
2496                 pCoexSta->btInfoC2h[rspSource][i] = tmpBuf[i];
2497                 if (i == 1)
2498                         btInfo = tmpBuf[i];
2499         }
2500
2501         if (rspSource != BT_INFO_SRC_8723B_1ANT_WIFI_FW) {
2502                 pCoexSta->btRetryCnt = pCoexSta->btInfoC2h[rspSource][2] & 0xf;
2503
2504                 if (pCoexSta->btRetryCnt >= 1)
2505                         pCoexSta->popEventCnt++;
2506
2507                 if (pCoexSta->btInfoC2h[rspSource][2] & 0x20)
2508                         pCoexSta->bC2hBtPage = true;
2509                 else
2510                         pCoexSta->bC2hBtPage = false;
2511
2512                 pCoexSta->btRssi = pCoexSta->btInfoC2h[rspSource][3] * 2 - 90;
2513                 /* pCoexSta->btInfoC2h[rspSource][3]*2+10; */
2514
2515                 pCoexSta->btInfoExt = pCoexSta->btInfoC2h[rspSource][4];
2516
2517                 pCoexSta->bBtTxRxMask = (pCoexSta->btInfoC2h[rspSource][2] & 0x40);
2518                 pBtCoexist->fBtcSet(pBtCoexist, BTC_SET_BL_BT_TX_RX_MASK, &pCoexSta->bBtTxRxMask);
2519
2520                 if (!pCoexSta->bBtTxRxMask) {
2521                         /* BT into is responded by BT FW and BT RF REG 0x3C != 0x15 => Need to switch BT TRx Mask */
2522                         pBtCoexist->fBtcSetBtReg(pBtCoexist, BTC_BT_REG_RF, 0x3c, 0x15);
2523                 }
2524
2525                 /*  Here we need to resend some wifi info to BT */
2526                 /*  because bt is reset and loss of the info. */
2527                 if (pCoexSta->btInfoExt & BIT1) {
2528                         pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_WIFI_CONNECTED, &bWifiConnected);
2529                         if (bWifiConnected)
2530                                 EXhalbtc8723b1ant_MediaStatusNotify(pBtCoexist, BTC_MEDIA_CONNECT);
2531                         else
2532                                 EXhalbtc8723b1ant_MediaStatusNotify(pBtCoexist, BTC_MEDIA_DISCONNECT);
2533                 }
2534
2535                 if (pCoexSta->btInfoExt & BIT3) {
2536                         if (!pBtCoexist->bManualControl && !pBtCoexist->bStopCoexDm)
2537                                 halbtc8723b1ant_IgnoreWlanAct(pBtCoexist, FORCE_EXEC, false);
2538                 } else {
2539                         /*  BT already NOT ignore Wlan active, do nothing here. */
2540                 }
2541         }
2542
2543         /*  check BIT2 first ==> check if bt is under inquiry or page scan */
2544         if (btInfo & BT_INFO_8723B_1ANT_B_INQ_PAGE)
2545                 pCoexSta->bC2hBtInquiryPage = true;
2546         else
2547                 pCoexSta->bC2hBtInquiryPage = false;
2548
2549         /*  set link exist status */
2550         if (!(btInfo & BT_INFO_8723B_1ANT_B_CONNECTION)) {
2551                 pCoexSta->bBtLinkExist = false;
2552                 pCoexSta->bPanExist = false;
2553                 pCoexSta->bA2dpExist = false;
2554                 pCoexSta->bHidExist = false;
2555                 pCoexSta->bScoExist = false;
2556         } else {        /*  connection exists */
2557                 pCoexSta->bBtLinkExist = true;
2558                 if (btInfo & BT_INFO_8723B_1ANT_B_FTP)
2559                         pCoexSta->bPanExist = true;
2560                 else
2561                         pCoexSta->bPanExist = false;
2562
2563                 if (btInfo & BT_INFO_8723B_1ANT_B_A2DP)
2564                         pCoexSta->bA2dpExist = true;
2565                 else
2566                         pCoexSta->bA2dpExist = false;
2567
2568                 if (btInfo & BT_INFO_8723B_1ANT_B_HID)
2569                         pCoexSta->bHidExist = true;
2570                 else
2571                         pCoexSta->bHidExist = false;
2572
2573                 if (btInfo & BT_INFO_8723B_1ANT_B_SCO_ESCO)
2574                         pCoexSta->bScoExist = true;
2575                 else
2576                         pCoexSta->bScoExist = false;
2577         }
2578
2579         halbtc8723b1ant_UpdateBtLinkInfo(pBtCoexist);
2580
2581         btInfo = btInfo & 0x1f;  /* mask profile bit for connect-ilde identification (for CSR case: A2DP idle --> 0x41) */
2582
2583         if (!(btInfo & BT_INFO_8723B_1ANT_B_CONNECTION)) {
2584                 pCoexDm->btStatus = BT_8723B_1ANT_BT_STATUS_NON_CONNECTED_IDLE;
2585         } else if (btInfo == BT_INFO_8723B_1ANT_B_CONNECTION)   {
2586                 /*  connection exists but no busy */
2587                 pCoexDm->btStatus = BT_8723B_1ANT_BT_STATUS_CONNECTED_IDLE;
2588         } else if (
2589                 (btInfo & BT_INFO_8723B_1ANT_B_SCO_ESCO) ||
2590                 (btInfo & BT_INFO_8723B_1ANT_B_SCO_BUSY)
2591         ) {
2592                 pCoexDm->btStatus = BT_8723B_1ANT_BT_STATUS_SCO_BUSY;
2593         } else if (btInfo & BT_INFO_8723B_1ANT_B_ACL_BUSY) {
2594                 if (pCoexDm->btStatus != BT_8723B_1ANT_BT_STATUS_ACL_BUSY)
2595                         pCoexDm->bAutoTdmaAdjust = false;
2596
2597                 pCoexDm->btStatus = BT_8723B_1ANT_BT_STATUS_ACL_BUSY;
2598         } else {
2599                 pCoexDm->btStatus = BT_8723B_1ANT_BT_STATUS_MAX;
2600         }
2601
2602         if (
2603                 (pCoexDm->btStatus == BT_8723B_1ANT_BT_STATUS_ACL_BUSY) ||
2604                 (pCoexDm->btStatus == BT_8723B_1ANT_BT_STATUS_SCO_BUSY) ||
2605                 (pCoexDm->btStatus == BT_8723B_1ANT_BT_STATUS_ACL_SCO_BUSY)
2606         )
2607                 bBtBusy = true;
2608         else
2609                 bBtBusy = false;
2610         pBtCoexist->fBtcSet(pBtCoexist, BTC_SET_BL_BT_TRAFFIC_BUSY, &bBtBusy);
2611
2612         halbtc8723b1ant_RunCoexistMechanism(pBtCoexist);
2613 }
2614
2615 void EXhalbtc8723b1ant_HaltNotify(struct btc_coexist *pBtCoexist)
2616 {
2617         halbtc8723b1ant_PowerSaveState(pBtCoexist, BTC_PS_WIFI_NATIVE, 0x0, 0x0);
2618         halbtc8723b1ant_PsTdma(pBtCoexist, FORCE_EXEC, false, 0);
2619         halbtc8723b1ant_SetAntPath(pBtCoexist, BTC_ANT_PATH_BT, false, true);
2620
2621         halbtc8723b1ant_IgnoreWlanAct(pBtCoexist, FORCE_EXEC, true);
2622
2623         EXhalbtc8723b1ant_MediaStatusNotify(pBtCoexist, BTC_MEDIA_DISCONNECT);
2624
2625         pBtCoexist->bStopCoexDm = true;
2626 }
2627
2628 void EXhalbtc8723b1ant_PnpNotify(struct btc_coexist *pBtCoexist, u8 pnpState)
2629 {
2630         if (pnpState == BTC_WIFI_PNP_SLEEP) {
2631                 halbtc8723b1ant_PowerSaveState(pBtCoexist, BTC_PS_WIFI_NATIVE, 0x0, 0x0);
2632                 halbtc8723b1ant_PsTdma(pBtCoexist, NORMAL_EXEC, false, 0);
2633                 halbtc8723b1ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 2);
2634                 halbtc8723b1ant_SetAntPath(pBtCoexist, BTC_ANT_PATH_BT, false, true);
2635
2636                 pBtCoexist->bStopCoexDm = true;
2637         } else if (pnpState == BTC_WIFI_PNP_WAKE_UP) {
2638                 pBtCoexist->bStopCoexDm = false;
2639                 halbtc8723b1ant_InitHwConfig(pBtCoexist, false, false);
2640                 halbtc8723b1ant_InitCoexDm(pBtCoexist);
2641                 halbtc8723b1ant_QueryBtInfo(pBtCoexist);
2642         }
2643 }
2644
2645 void EXhalbtc8723b1ant_Periodical(struct btc_coexist *pBtCoexist)
2646 {
2647         static u8 disVerInfoCnt;
2648         u32 fwVer = 0, btPatchVer = 0;
2649
2650         if (disVerInfoCnt <= 5) {
2651                 disVerInfoCnt += 1;
2652                 pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_U4_BT_PATCH_VER, &btPatchVer);
2653                 pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_U4_WIFI_FW_VER, &fwVer);
2654         }
2655
2656         halbtc8723b1ant_MonitorBtCtr(pBtCoexist);
2657         halbtc8723b1ant_MonitorWiFiCtr(pBtCoexist);
2658
2659         if (
2660                 halbtc8723b1ant_IsWifiStatusChanged(pBtCoexist) ||
2661                 pCoexDm->bAutoTdmaAdjust
2662         )
2663                 halbtc8723b1ant_RunCoexistMechanism(pBtCoexist);
2664
2665         pCoexSta->specialPktPeriodCnt++;
2666 }