LXR linux/drivers/staging/rtl8723bs/hal/HalBtc8723b2Ant.c

   1// SPDX-License-Identifier: GPL-2.0
   2/******************************************************************************
   3 *
   4 * Copyright(c) 2007 - 2012 Realtek Corporation. All rights reserved.
   5 *
   6 ******************************************************************************/
   7
   8#include "Mp_Precomp.h"
   9
  10/*  Global variables, these are static variables */
  11static COEX_DM_8723B_2ANT GLCoexDm8723b2Ant;
  12static PCOEX_DM_8723B_2ANT pCoexDm = &GLCoexDm8723b2Ant;
  13static COEX_STA_8723B_2ANT GLCoexSta8723b2Ant;
  14static PCOEX_STA_8723B_2ANT pCoexSta = &GLCoexSta8723b2Ant;
  15
  16static const char *const GLBtInfoSrc8723b2Ant[] = {
  17        "BT Info[wifi fw]",
  18        "BT Info[bt rsp]",
  19        "BT Info[bt auto report]",
  20};
  21
  22static u32 GLCoexVerDate8723b2Ant = 20131211;
  23static u32 GLCoexVer8723b2Ant = 0x40;
  24
  25/*  local function start with halbtc8723b2ant_ */
  26static u8 halbtc8723b2ant_BtRssiState(
  27        u8 levelNum, u8 rssiThresh, u8 rssiThresh1
  28)
  29{
  30        s32 btRssi = 0;
  31        u8 btRssiState = pCoexSta->preBtRssiState;
  32
  33        btRssi = pCoexSta->btRssi;
  34
  35        if (levelNum == 2) {
  36                if (
  37                        (pCoexSta->preBtRssiState == BTC_RSSI_STATE_LOW) ||
  38                        (pCoexSta->preBtRssiState == BTC_RSSI_STATE_STAY_LOW)
  39                ) {
  40                        if (btRssi >= (rssiThresh+BTC_RSSI_COEX_THRESH_TOL_8723B_2ANT)) {
  41                                btRssiState = BTC_RSSI_STATE_HIGH;
  42                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE, ("[BTCoex], BT Rssi state switch to High\n"));
  43                        } else {
  44                                btRssiState = BTC_RSSI_STATE_STAY_LOW;
  45                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE, ("[BTCoex], BT Rssi state stay at Low\n"));
  46                        }
  47                } else {
  48                        if (btRssi < rssiThresh) {
  49                                btRssiState = BTC_RSSI_STATE_LOW;
  50                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE, ("[BTCoex], BT Rssi state switch to Low\n"));
  51                        } else {
  52                                btRssiState = BTC_RSSI_STATE_STAY_HIGH;
  53                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE, ("[BTCoex], BT Rssi state stay at High\n"));
  54                        }
  55                }
  56        } else if (levelNum == 3) {
  57                if (rssiThresh > rssiThresh1) {
  58                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE, ("[BTCoex], BT Rssi thresh error!!\n"));
  59                        return pCoexSta->preBtRssiState;
  60                }
  61
  62                if (
  63                        (pCoexSta->preBtRssiState == BTC_RSSI_STATE_LOW) ||
  64                        (pCoexSta->preBtRssiState == BTC_RSSI_STATE_STAY_LOW)
  65                ) {
  66                        if (btRssi >= (rssiThresh+BTC_RSSI_COEX_THRESH_TOL_8723B_2ANT)) {
  67                                btRssiState = BTC_RSSI_STATE_MEDIUM;
  68                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE, ("[BTCoex], BT Rssi state switch to Medium\n"));
  69                        } else {
  70                                btRssiState = BTC_RSSI_STATE_STAY_LOW;
  71                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE, ("[BTCoex], BT Rssi state stay at Low\n"));
  72                        }
  73                } else if (
  74                        (pCoexSta->preBtRssiState == BTC_RSSI_STATE_MEDIUM) ||
  75                        (pCoexSta->preBtRssiState == BTC_RSSI_STATE_STAY_MEDIUM)
  76                ) {
  77                        if (btRssi >= (rssiThresh1+BTC_RSSI_COEX_THRESH_TOL_8723B_2ANT)) {
  78                                btRssiState = BTC_RSSI_STATE_HIGH;
  79                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE, ("[BTCoex], BT Rssi state switch to High\n"));
  80                        } else if (btRssi < rssiThresh) {
  81                                btRssiState = BTC_RSSI_STATE_LOW;
  82                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE, ("[BTCoex], BT Rssi state switch to Low\n"));
  83                        } else {
  84                                btRssiState = BTC_RSSI_STATE_STAY_MEDIUM;
  85                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE, ("[BTCoex], BT Rssi state stay at Medium\n"));
  86                        }
  87                } else {
  88                        if (btRssi < rssiThresh1) {
  89                                btRssiState = BTC_RSSI_STATE_MEDIUM;
  90                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE, ("[BTCoex], BT Rssi state switch to Medium\n"));
  91                        } else {
  92                                btRssiState = BTC_RSSI_STATE_STAY_HIGH;
  93                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE, ("[BTCoex], BT Rssi state stay at High\n"));
  94                        }
  95                }
  96        }
  97
  98        pCoexSta->preBtRssiState = btRssiState;
  99
 100        return btRssiState;
 101}
 102
 103static u8 halbtc8723b2ant_WifiRssiState(
 104        PBTC_COEXIST pBtCoexist,
 105        u8 index,
 106        u8 levelNum,
 107        u8 rssiThresh,
 108        u8 rssiThresh1
 109)
 110{
 111        s32 wifiRssi = 0;
 112        u8 wifiRssiState = pCoexSta->preWifiRssiState[index];
 113
 114        pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_S4_WIFI_RSSI, &wifiRssi);
 115
 116        if (levelNum == 2) {
 117                if (
 118                        (pCoexSta->preWifiRssiState[index] == BTC_RSSI_STATE_LOW) ||
 119                        (pCoexSta->preWifiRssiState[index] == BTC_RSSI_STATE_STAY_LOW)
 120                ) {
 121                        if (wifiRssi >= (rssiThresh+BTC_RSSI_COEX_THRESH_TOL_8723B_2ANT)) {
 122                                wifiRssiState = BTC_RSSI_STATE_HIGH;
 123                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_WIFI_RSSI_STATE, ("[BTCoex], wifi RSSI state switch to High\n"));
 124                        } else {
 125                                wifiRssiState = BTC_RSSI_STATE_STAY_LOW;
 126                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_WIFI_RSSI_STATE, ("[BTCoex], wifi RSSI state stay at Low\n"));
 127                        }
 128                } else {
 129                        if (wifiRssi < rssiThresh) {
 130                                wifiRssiState = BTC_RSSI_STATE_LOW;
 131                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_WIFI_RSSI_STATE, ("[BTCoex], wifi RSSI state switch to Low\n"));
 132                        } else {
 133                                wifiRssiState = BTC_RSSI_STATE_STAY_HIGH;
 134                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_WIFI_RSSI_STATE, ("[BTCoex], wifi RSSI state stay at High\n"));
 135                        }
 136                }
 137        } else if (levelNum == 3) {
 138                if (rssiThresh > rssiThresh1) {
 139                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_WIFI_RSSI_STATE, ("[BTCoex], wifi RSSI thresh error!!\n"));
 140                        return pCoexSta->preWifiRssiState[index];
 141                }
 142
 143                if (
 144                        (pCoexSta->preWifiRssiState[index] == BTC_RSSI_STATE_LOW) ||
 145                        (pCoexSta->preWifiRssiState[index] == BTC_RSSI_STATE_STAY_LOW)
 146                ) {
 147                        if (wifiRssi >= (rssiThresh+BTC_RSSI_COEX_THRESH_TOL_8723B_2ANT)) {
 148                                wifiRssiState = BTC_RSSI_STATE_MEDIUM;
 149                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_WIFI_RSSI_STATE, ("[BTCoex], wifi RSSI state switch to Medium\n"));
 150                        } else {
 151                                wifiRssiState = BTC_RSSI_STATE_STAY_LOW;
 152                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_WIFI_RSSI_STATE, ("[BTCoex], wifi RSSI state stay at Low\n"));
 153                        }
 154                } else if (
 155                        (pCoexSta->preWifiRssiState[index] == BTC_RSSI_STATE_MEDIUM) ||
 156                        (pCoexSta->preWifiRssiState[index] == BTC_RSSI_STATE_STAY_MEDIUM)
 157                ) {
 158                        if (wifiRssi >= (rssiThresh1+BTC_RSSI_COEX_THRESH_TOL_8723B_2ANT)) {
 159                                wifiRssiState = BTC_RSSI_STATE_HIGH;
 160                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_WIFI_RSSI_STATE, ("[BTCoex], wifi RSSI state switch to High\n"));
 161                        } else if (wifiRssi < rssiThresh) {
 162                                wifiRssiState = BTC_RSSI_STATE_LOW;
 163                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_WIFI_RSSI_STATE, ("[BTCoex], wifi RSSI state switch to Low\n"));
 164                        } else {
 165                                wifiRssiState = BTC_RSSI_STATE_STAY_MEDIUM;
 166                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_WIFI_RSSI_STATE, ("[BTCoex], wifi RSSI state stay at Medium\n"));
 167                        }
 168                } else {
 169                        if (wifiRssi < rssiThresh1) {
 170                                wifiRssiState = BTC_RSSI_STATE_MEDIUM;
 171                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_WIFI_RSSI_STATE, ("[BTCoex], wifi RSSI state switch to Medium\n"));
 172                        } else {
 173                                wifiRssiState = BTC_RSSI_STATE_STAY_HIGH;
 174                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_WIFI_RSSI_STATE, ("[BTCoex], wifi RSSI state stay at High\n"));
 175                        }
 176                }
 177        }
 178
 179        pCoexSta->preWifiRssiState[index] = wifiRssiState;
 180
 181        return wifiRssiState;
 182}
 183
 184static void halbtc8723b2ant_LimitedRx(
 185        PBTC_COEXIST pBtCoexist,
 186        bool bForceExec,
 187        bool bRejApAggPkt,
 188        bool bBtCtrlAggBufSize,
 189        u8 aggBufSize
 190)
 191{
 192        bool bRejectRxAgg = bRejApAggPkt;
 193        bool bBtCtrlRxAggSize = bBtCtrlAggBufSize;
 194        u8 rxAggSize = aggBufSize;
 195
 196        /*  */
 197        /*      Rx Aggregation related setting */
 198        /*  */
 199        pBtCoexist->fBtcSet(pBtCoexist, BTC_SET_BL_TO_REJ_AP_AGG_PKT, &bRejectRxAgg);
 200        /*  decide BT control aggregation buf size or not */
 201        pBtCoexist->fBtcSet(pBtCoexist, BTC_SET_BL_BT_CTRL_AGG_SIZE, &bBtCtrlRxAggSize);
 202        /*  aggregation buf size, only work when BT control Rx aggregation size. */
 203        pBtCoexist->fBtcSet(pBtCoexist, BTC_SET_U1_AGG_BUF_SIZE, &rxAggSize);
 204        /*  real update aggregation setting */
 205        pBtCoexist->fBtcSet(pBtCoexist, BTC_SET_ACT_AGGREGATE_CTRL, NULL);
 206}
 207
 208static void halbtc8723b2ant_MonitorBtCtr(PBTC_COEXIST pBtCoexist)
 209{
 210        u32 regHPTxRx, regLPTxRx, u4Tmp;
 211        u32 regHPTx = 0, regHPRx = 0, regLPTx = 0, regLPRx = 0;
 212
 213        regHPTxRx = 0x770;
 214        regLPTxRx = 0x774;
 215
 216        u4Tmp = pBtCoexist->fBtcRead4Byte(pBtCoexist, regHPTxRx);
 217        regHPTx = u4Tmp & bMaskLWord;
 218        regHPRx = (u4Tmp & bMaskHWord)>>16;
 219
 220        u4Tmp = pBtCoexist->fBtcRead4Byte(pBtCoexist, regLPTxRx);
 221        regLPTx = u4Tmp & bMaskLWord;
 222        regLPRx = (u4Tmp & bMaskHWord)>>16;
 223
 224        pCoexSta->highPriorityTx = regHPTx;
 225        pCoexSta->highPriorityRx = regHPRx;
 226        pCoexSta->lowPriorityTx = regLPTx;
 227        pCoexSta->lowPriorityRx = regLPRx;
 228
 229        BTC_PRINT(
 230                BTC_MSG_ALGORITHM,
 231                ALGO_BT_MONITOR,
 232                (
 233                        "[BTCoex], High Priority Tx/Rx (reg 0x%x) = 0x%x(%d)/0x%x(%d)\n",
 234                        regHPTxRx,
 235                        regHPTx,
 236                        regHPTx,
 237                        regHPRx,
 238                        regHPRx
 239                )
 240        );
 241        BTC_PRINT(
 242                BTC_MSG_ALGORITHM,
 243                ALGO_BT_MONITOR,
 244                (
 245                        "[BTCoex], Low Priority Tx/Rx (reg 0x%x) = 0x%x(%d)/0x%x(%d)\n",
 246                        regLPTxRx,
 247                        regLPTx,
 248                        regLPTx,
 249                        regLPRx,
 250                        regLPRx
 251                )
 252        );
 253
 254        /*  reset counter */
 255        pBtCoexist->fBtcWrite1Byte(pBtCoexist, 0x76e, 0xc);
 256}
 257
 258static void halbtc8723b2ant_QueryBtInfo(PBTC_COEXIST pBtCoexist)
 259{
 260        u8      H2C_Parameter[1] = {0};
 261
 262        pCoexSta->bC2hBtInfoReqSent = true;
 263
 264        H2C_Parameter[0] |= BIT0;       /*  trigger */
 265
 266        BTC_PRINT(
 267                BTC_MSG_ALGORITHM,
 268                ALGO_TRACE_FW_EXEC,
 269                ("[BTCoex], Query Bt Info, FW write 0x61 = 0x%x\n", H2C_Parameter[0])
 270        );
 271
 272        pBtCoexist->fBtcFillH2c(pBtCoexist, 0x61, 1, H2C_Parameter);
 273}
 274
 275static bool halbtc8723b2ant_IsWifiStatusChanged(PBTC_COEXIST pBtCoexist)
 276{
 277        static bool     bPreWifiBusy, bPreUnder4way, bPreBtHsOn;
 278        bool bWifiBusy = false, bUnder4way = false, bBtHsOn = false;
 279        bool bWifiConnected = false;
 280
 281        pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_WIFI_CONNECTED, &bWifiConnected);
 282        pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_WIFI_BUSY, &bWifiBusy);
 283        pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_HS_OPERATION, &bBtHsOn);
 284        pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_WIFI_4_WAY_PROGRESS, &bUnder4way);
 285
 286        if (bWifiConnected) {
 287                if (bWifiBusy != bPreWifiBusy) {
 288                        bPreWifiBusy = bWifiBusy;
 289                        return true;
 290                }
 291
 292                if (bUnder4way != bPreUnder4way) {
 293                        bPreUnder4way = bUnder4way;
 294                        return true;
 295                }
 296
 297                if (bBtHsOn != bPreBtHsOn) {
 298                        bPreBtHsOn = bBtHsOn;
 299                        return true;
 300                }
 301        }
 302
 303        return false;
 304}
 305
 306static void halbtc8723b2ant_UpdateBtLinkInfo(PBTC_COEXIST pBtCoexist)
 307{
 308        PBTC_BT_LINK_INFO pBtLinkInfo = &pBtCoexist->btLinkInfo;
 309        bool bBtHsOn = false;
 310
 311        pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_HS_OPERATION, &bBtHsOn);
 312
 313        pBtLinkInfo->bBtLinkExist = pCoexSta->bBtLinkExist;
 314        pBtLinkInfo->bScoExist = pCoexSta->bScoExist;
 315        pBtLinkInfo->bA2dpExist = pCoexSta->bA2dpExist;
 316        pBtLinkInfo->bPanExist = pCoexSta->bPanExist;
 317        pBtLinkInfo->bHidExist = pCoexSta->bHidExist;
 318
 319        /*  work around for HS mode. */
 320        if (bBtHsOn) {
 321                pBtLinkInfo->bPanExist = true;
 322                pBtLinkInfo->bBtLinkExist = true;
 323        }
 324
 325        /*  check if Sco only */
 326        if (
 327                pBtLinkInfo->bScoExist &&
 328                !pBtLinkInfo->bA2dpExist &&
 329                !pBtLinkInfo->bPanExist &&
 330                !pBtLinkInfo->bHidExist
 331        )
 332                pBtLinkInfo->bScoOnly = true;
 333        else
 334                pBtLinkInfo->bScoOnly = false;
 335
 336        /*  check if A2dp only */
 337        if (
 338                !pBtLinkInfo->bScoExist &&
 339                pBtLinkInfo->bA2dpExist &&
 340                !pBtLinkInfo->bPanExist &&
 341                !pBtLinkInfo->bHidExist
 342        )
 343                pBtLinkInfo->bA2dpOnly = true;
 344        else
 345                pBtLinkInfo->bA2dpOnly = false;
 346
 347        /*  check if Pan only */
 348        if (
 349                !pBtLinkInfo->bScoExist &&
 350                !pBtLinkInfo->bA2dpExist &&
 351                pBtLinkInfo->bPanExist &&
 352                !pBtLinkInfo->bHidExist
 353        )
 354                pBtLinkInfo->bPanOnly = true;
 355        else
 356                pBtLinkInfo->bPanOnly = false;
 357
 358        /*  check if Hid only */
 359        if (
 360                !pBtLinkInfo->bScoExist &&
 361                !pBtLinkInfo->bA2dpExist &&
 362                !pBtLinkInfo->bPanExist &&
 363                pBtLinkInfo->bHidExist
 364        )
 365                pBtLinkInfo->bHidOnly = true;
 366        else
 367                pBtLinkInfo->bHidOnly = false;
 368}
 369
 370static u8 halbtc8723b2ant_ActionAlgorithm(PBTC_COEXIST pBtCoexist)
 371{
 372        PBTC_BT_LINK_INFO pBtLinkInfo = &pBtCoexist->btLinkInfo;
 373        bool bBtHsOn = false;
 374        u8 algorithm = BT_8723B_2ANT_COEX_ALGO_UNDEFINED;
 375        u8 numOfDiffProfile = 0;
 376
 377        pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_HS_OPERATION, &bBtHsOn);
 378
 379        if (!pBtLinkInfo->bBtLinkExist) {
 380                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], No BT link exists!!!\n"));
 381                return algorithm;
 382        }
 383
 384        if (pBtLinkInfo->bScoExist)
 385                numOfDiffProfile++;
 386
 387        if (pBtLinkInfo->bHidExist)
 388                numOfDiffProfile++;
 389
 390        if (pBtLinkInfo->bPanExist)
 391                numOfDiffProfile++;
 392
 393        if (pBtLinkInfo->bA2dpExist)
 394                numOfDiffProfile++;
 395
 396        if (numOfDiffProfile == 1) {
 397                if (pBtLinkInfo->bScoExist) {
 398                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], SCO only\n"));
 399                        algorithm = BT_8723B_2ANT_COEX_ALGO_SCO;
 400                } else {
 401                        if (pBtLinkInfo->bHidExist) {
 402                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], HID only\n"));
 403                                algorithm = BT_8723B_2ANT_COEX_ALGO_HID;
 404                        } else if (pBtLinkInfo->bA2dpExist) {
 405                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], A2DP only\n"));
 406                                algorithm = BT_8723B_2ANT_COEX_ALGO_A2DP;
 407                        } else if (pBtLinkInfo->bPanExist) {
 408                                if (bBtHsOn) {
 409                                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], PAN(HS) only\n"));
 410                                        algorithm = BT_8723B_2ANT_COEX_ALGO_PANHS;
 411                                } else {
 412                                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], PAN(EDR) only\n"));
 413                                        algorithm = BT_8723B_2ANT_COEX_ALGO_PANEDR;
 414                                }
 415                        }
 416                }
 417        } else if (numOfDiffProfile == 2) {
 418                if (pBtLinkInfo->bScoExist) {
 419                        if (pBtLinkInfo->bHidExist) {
 420                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], SCO + HID\n"));
 421                                algorithm = BT_8723B_2ANT_COEX_ALGO_PANEDR_HID;
 422                        } else if (pBtLinkInfo->bA2dpExist) {
 423                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], SCO + A2DP ==> SCO\n"));
 424                                algorithm = BT_8723B_2ANT_COEX_ALGO_PANEDR_HID;
 425                        } else if (pBtLinkInfo->bPanExist) {
 426                                if (bBtHsOn) {
 427                                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], SCO + PAN(HS)\n"));
 428                                        algorithm = BT_8723B_2ANT_COEX_ALGO_SCO;
 429                                } else {
 430                                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], SCO + PAN(EDR)\n"));
 431                                        algorithm = BT_8723B_2ANT_COEX_ALGO_PANEDR_HID;
 432                                }
 433                        }
 434                } else {
 435                        if (
 436                                pBtLinkInfo->bHidExist &&
 437                                pBtLinkInfo->bA2dpExist
 438                        ) {
 439                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], HID + A2DP\n"));
 440                                algorithm = BT_8723B_2ANT_COEX_ALGO_HID_A2DP;
 441                        } else if (
 442                                pBtLinkInfo->bHidExist &&
 443                                pBtLinkInfo->bPanExist
 444                        ) {
 445                                if (bBtHsOn) {
 446                                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], HID + PAN(HS)\n"));
 447                                        algorithm = BT_8723B_2ANT_COEX_ALGO_HID;
 448                                } else {
 449                                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], HID + PAN(EDR)\n"));
 450                                        algorithm = BT_8723B_2ANT_COEX_ALGO_PANEDR_HID;
 451                                }
 452                        } else if (
 453                                pBtLinkInfo->bPanExist &&
 454                                pBtLinkInfo->bA2dpExist
 455                        ) {
 456                                if (bBtHsOn) {
 457                                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], A2DP + PAN(HS)\n"));
 458                                        algorithm = BT_8723B_2ANT_COEX_ALGO_A2DP_PANHS;
 459                                } else {
 460                                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], A2DP + PAN(EDR)\n"));
 461                                        algorithm = BT_8723B_2ANT_COEX_ALGO_PANEDR_A2DP;
 462                                }
 463                        }
 464                }
 465        } else if (numOfDiffProfile == 3) {
 466                if (pBtLinkInfo->bScoExist) {
 467                        if (
 468                                pBtLinkInfo->bHidExist &&
 469                                pBtLinkInfo->bA2dpExist
 470                        ) {
 471                                BTC_PRINT(
 472                                        BTC_MSG_ALGORITHM,
 473                                        ALGO_TRACE,
 474                                        ("[BTCoex], SCO + HID + A2DP ==> HID\n")
 475                                );
 476                                algorithm = BT_8723B_2ANT_COEX_ALGO_PANEDR_HID;
 477                        } else if (
 478                                pBtLinkInfo->bHidExist &&
 479                                pBtLinkInfo->bPanExist
 480                        ) {
 481                                if (bBtHsOn) {
 482                                        BTC_PRINT(
 483                                                BTC_MSG_ALGORITHM,
 484                                                ALGO_TRACE,
 485                                                ("[BTCoex], SCO + HID + PAN(HS)\n")
 486                                        );
 487                                        algorithm = BT_8723B_2ANT_COEX_ALGO_PANEDR_HID;
 488                                } else {
 489                                        BTC_PRINT(
 490                                                BTC_MSG_ALGORITHM,
 491                                                ALGO_TRACE,
 492                                                ("[BTCoex], SCO + HID + PAN(EDR)\n")
 493                                        );
 494                                        algorithm = BT_8723B_2ANT_COEX_ALGO_PANEDR_HID;
 495                                }
 496                        } else if (
 497                                pBtLinkInfo->bPanExist &&
 498                                pBtLinkInfo->bA2dpExist
 499                        ) {
 500                                if (bBtHsOn) {
 501                                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], SCO + A2DP + PAN(HS)\n"));
 502                                        algorithm = BT_8723B_2ANT_COEX_ALGO_PANEDR_HID;
 503                                } else {
 504                                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], SCO + A2DP + PAN(EDR) ==> HID\n"));
 505                                        algorithm = BT_8723B_2ANT_COEX_ALGO_PANEDR_HID;
 506                                }
 507                        }
 508                } else {
 509                        if (
 510                                pBtLinkInfo->bHidExist &&
 511                                pBtLinkInfo->bPanExist &&
 512                                pBtLinkInfo->bA2dpExist
 513                        ) {
 514                                if (bBtHsOn) {
 515                                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], HID + A2DP + PAN(HS)\n"));
 516                                        algorithm = BT_8723B_2ANT_COEX_ALGO_HID_A2DP;
 517                                } else {
 518                                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], HID + A2DP + PAN(EDR)\n"));
 519                                        algorithm = BT_8723B_2ANT_COEX_ALGO_HID_A2DP_PANEDR;
 520                                }
 521                        }
 522                }
 523        } else if (numOfDiffProfile >= 3) {
 524                if (pBtLinkInfo->bScoExist) {
 525                        if (
 526                                pBtLinkInfo->bHidExist &&
 527                                pBtLinkInfo->bPanExist &&
 528                                pBtLinkInfo->bA2dpExist
 529                        ) {
 530                                if (bBtHsOn) {
 531                                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], Error!!! SCO + HID + A2DP + PAN(HS)\n"));
 532
 533                                } else {
 534                                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], SCO + HID + A2DP + PAN(EDR) ==>PAN(EDR)+HID\n"));
 535                                        algorithm = BT_8723B_2ANT_COEX_ALGO_PANEDR_HID;
 536                                }
 537                        }
 538                }
 539        }
 540
 541        return algorithm;
 542}
 543
 544static void halbtc8723b2ant_SetFwDacSwingLevel(
 545        PBTC_COEXIST pBtCoexist, u8 dacSwingLvl
 546)
 547{
 548        u8      H2C_Parameter[1] = {0};
 549
 550        /*  There are several type of dacswing */
 551        /*  0x18/ 0x10/ 0xc/ 0x8/ 0x4/ 0x6 */
 552        H2C_Parameter[0] = dacSwingLvl;
 553
 554        BTC_PRINT(
 555                BTC_MSG_ALGORITHM,
 556                ALGO_TRACE_FW_EXEC,
 557                ("[BTCoex], Set Dac Swing Level = 0x%x\n", dacSwingLvl)
 558        );
 559        BTC_PRINT(
 560                BTC_MSG_ALGORITHM,
 561                ALGO_TRACE_FW_EXEC,
 562                ("[BTCoex], FW write 0x64 = 0x%x\n", H2C_Parameter[0])
 563        );
 564
 565        pBtCoexist->fBtcFillH2c(pBtCoexist, 0x64, 1, H2C_Parameter);
 566}
 567
 568static void halbtc8723b2ant_SetFwDecBtPwr(
 569        PBTC_COEXIST pBtCoexist, u8 decBtPwrLvl
 570)
 571{
 572        u8      H2C_Parameter[1] = {0};
 573
 574        H2C_Parameter[0] = decBtPwrLvl;
 575
 576        BTC_PRINT(
 577                BTC_MSG_ALGORITHM,
 578                ALGO_TRACE_FW_EXEC,
 579                (
 580                        "[BTCoex], decrease Bt Power level = %d, FW write 0x62 = 0x%x\n",
 581                        decBtPwrLvl,
 582                        H2C_Parameter[0]
 583                )
 584        );
 585
 586        pBtCoexist->fBtcFillH2c(pBtCoexist, 0x62, 1, H2C_Parameter);
 587}
 588
 589static void halbtc8723b2ant_DecBtPwr(
 590        PBTC_COEXIST pBtCoexist, bool bForceExec, u8 decBtPwrLvl
 591)
 592{
 593        BTC_PRINT(
 594                BTC_MSG_ALGORITHM,
 595                ALGO_TRACE_FW,
 596                (
 597                        "[BTCoex], %s Dec BT power level = %d\n",
 598                        (bForceExec ? "force to" : ""),
 599                        decBtPwrLvl
 600                )
 601        );
 602        pCoexDm->curBtDecPwrLvl = decBtPwrLvl;
 603
 604        if (!bForceExec) {
 605                BTC_PRINT(
 606                        BTC_MSG_ALGORITHM,
 607                        ALGO_TRACE_FW_DETAIL,
 608                        (
 609                                "[BTCoex], preBtDecPwrLvl =%d, curBtDecPwrLvl =%d\n",
 610                                pCoexDm->preBtDecPwrLvl,
 611                                pCoexDm->curBtDecPwrLvl
 612                        )
 613                );
 614
 615                if (pCoexDm->preBtDecPwrLvl == pCoexDm->curBtDecPwrLvl)
 616                        return;
 617        }
 618        halbtc8723b2ant_SetFwDecBtPwr(pBtCoexist, pCoexDm->curBtDecPwrLvl);
 619
 620        pCoexDm->preBtDecPwrLvl = pCoexDm->curBtDecPwrLvl;
 621}
 622
 623static void halbtc8723b2ant_FwDacSwingLvl(
 624        PBTC_COEXIST pBtCoexist, bool bForceExec, u8 fwDacSwingLvl
 625)
 626{
 627        BTC_PRINT(
 628                BTC_MSG_ALGORITHM,
 629                ALGO_TRACE_FW,
 630                (
 631                        "[BTCoex], %s set FW Dac Swing level = %d\n",
 632                        (bForceExec ? "force to" : ""),
 633                        fwDacSwingLvl
 634                )
 635        );
 636        pCoexDm->curFwDacSwingLvl = fwDacSwingLvl;
 637
 638        if (!bForceExec) {
 639                BTC_PRINT(
 640                        BTC_MSG_ALGORITHM,
 641                        ALGO_TRACE_FW_DETAIL,
 642                        (
 643                                "[BTCoex], preFwDacSwingLvl =%d, curFwDacSwingLvl =%d\n",
 644                                pCoexDm->preFwDacSwingLvl,
 645                                pCoexDm->curFwDacSwingLvl
 646                        )
 647                );
 648
 649                if (pCoexDm->preFwDacSwingLvl == pCoexDm->curFwDacSwingLvl)
 650                        return;
 651        }
 652
 653        halbtc8723b2ant_SetFwDacSwingLevel(pBtCoexist, pCoexDm->curFwDacSwingLvl);
 654
 655        pCoexDm->preFwDacSwingLvl = pCoexDm->curFwDacSwingLvl;
 656}
 657
 658static void halbtc8723b2ant_SetSwRfRxLpfCorner(
 659        PBTC_COEXIST pBtCoexist,
 660        bool bRxRfShrinkOn
 661)
 662{
 663        if (bRxRfShrinkOn) {
 664                /* Shrink RF Rx LPF corner */
 665                BTC_PRINT(
 666                        BTC_MSG_ALGORITHM,
 667                        ALGO_TRACE_SW_EXEC,
 668                        ("[BTCoex], Shrink RF Rx LPF corner!!\n")
 669                );
 670                pBtCoexist->fBtcSetRfReg(pBtCoexist, BTC_RF_A, 0x1e, 0xfffff, 0xffffc);
 671        } else {
 672                /* Resume RF Rx LPF corner */
 673                /*  After initialized, we can use pCoexDm->btRf0x1eBackup */
 674                if (pBtCoexist->bInitilized) {
 675                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_EXEC, ("[BTCoex], Resume RF Rx LPF corner!!\n"));
 676                        pBtCoexist->fBtcSetRfReg(pBtCoexist, BTC_RF_A, 0x1e, 0xfffff, pCoexDm->btRf0x1eBackup);
 677                }
 678        }
 679}
 680
 681static void halbtc8723b2ant_RfShrink(
 682        PBTC_COEXIST pBtCoexist, bool bForceExec, bool bRxRfShrinkOn
 683)
 684{
 685        BTC_PRINT(
 686                BTC_MSG_ALGORITHM,
 687                ALGO_TRACE_SW,
 688                (
 689                        "[BTCoex], %s turn Rx RF Shrink = %s\n",
 690                        (bForceExec ? "force to" : ""),
 691                        (bRxRfShrinkOn ? "ON" : "OFF")
 692                )
 693        );
 694        pCoexDm->bCurRfRxLpfShrink = bRxRfShrinkOn;
 695
 696        if (!bForceExec) {
 697                BTC_PRINT(
 698                        BTC_MSG_ALGORITHM,
 699                        ALGO_TRACE_SW_DETAIL,
 700                        (
 701                                "[BTCoex], bPreRfRxLpfShrink =%d, bCurRfRxLpfShrink =%d\n",
 702                                pCoexDm->bPreRfRxLpfShrink,
 703                                pCoexDm->bCurRfRxLpfShrink
 704                        )
 705                );
 706
 707                if (pCoexDm->bPreRfRxLpfShrink == pCoexDm->bCurRfRxLpfShrink)
 708                        return;
 709        }
 710        halbtc8723b2ant_SetSwRfRxLpfCorner(pBtCoexist, pCoexDm->bCurRfRxLpfShrink);
 711
 712        pCoexDm->bPreRfRxLpfShrink = pCoexDm->bCurRfRxLpfShrink;
 713}
 714
 715static void halbtc8723b2ant_SetSwPenaltyTxRateAdaptive(
 716        PBTC_COEXIST pBtCoexist, bool bLowPenaltyRa
 717)
 718{
 719        u8      H2C_Parameter[6] = {0};
 720
 721        H2C_Parameter[0] = 0x6; /*  opCode, 0x6 = Retry_Penalty */
 722
 723        if (bLowPenaltyRa) {
 724                H2C_Parameter[1] |= BIT0;
 725                H2C_Parameter[2] = 0x00;  /* normal rate except MCS7/6/5, OFDM54/48/36 */
 726                H2C_Parameter[3] = 0xf7;  /* MCS7 or OFDM54 */
 727                H2C_Parameter[4] = 0xf8;  /* MCS6 or OFDM48 */
 728                H2C_Parameter[5] = 0xf9;        /* MCS5 or OFDM36 */
 729        }
 730
 731        BTC_PRINT(
 732                BTC_MSG_ALGORITHM,
 733                ALGO_TRACE_FW_EXEC,
 734                (
 735                        "[BTCoex], set WiFi Low-Penalty Retry: %s",
 736                        (bLowPenaltyRa ? "ON!!" : "OFF!!")
 737                )
 738        );
 739
 740        pBtCoexist->fBtcFillH2c(pBtCoexist, 0x69, 6, H2C_Parameter);
 741}
 742
 743static void halbtc8723b2ant_LowPenaltyRa(
 744        PBTC_COEXIST pBtCoexist, bool bForceExec, bool bLowPenaltyRa
 745)
 746{
 747        /* return; */
 748        BTC_PRINT(
 749                BTC_MSG_ALGORITHM,
 750                ALGO_TRACE_SW,
 751                (
 752                        "[BTCoex], %s turn LowPenaltyRA = %s\n",
 753                        (bForceExec ? "force to" : ""),
 754                        (bLowPenaltyRa ? "ON" : "OFF")
 755                )
 756        );
 757        pCoexDm->bCurLowPenaltyRa = bLowPenaltyRa;
 758
 759        if (!bForceExec) {
 760                BTC_PRINT(
 761                        BTC_MSG_ALGORITHM,
 762                        ALGO_TRACE_SW_DETAIL,
 763                        (
 764                                "[BTCoex], bPreLowPenaltyRa =%d, bCurLowPenaltyRa =%d\n",
 765                                pCoexDm->bPreLowPenaltyRa,
 766                                pCoexDm->bCurLowPenaltyRa
 767                        )
 768                );
 769
 770                if (pCoexDm->bPreLowPenaltyRa == pCoexDm->bCurLowPenaltyRa)
 771                        return;
 772        }
 773        halbtc8723b2ant_SetSwPenaltyTxRateAdaptive(pBtCoexist, pCoexDm->bCurLowPenaltyRa);
 774
 775        pCoexDm->bPreLowPenaltyRa = pCoexDm->bCurLowPenaltyRa;
 776}
 777
 778static void halbtc8723b2ant_SetDacSwingReg(PBTC_COEXIST pBtCoexist, u32 level)
 779{
 780        u8 val = (u8)level;
 781
 782        BTC_PRINT(
 783                BTC_MSG_ALGORITHM,
 784                ALGO_TRACE_SW_EXEC,
 785                ("[BTCoex], Write SwDacSwing = 0x%x\n", level)
 786        );
 787        pBtCoexist->fBtcWrite1ByteBitMask(pBtCoexist, 0x883, 0x3e, val);
 788}
 789
 790static void halbtc8723b2ant_SetSwFullTimeDacSwing(
 791        PBTC_COEXIST pBtCoexist, bool bSwDacSwingOn, u32 swDacSwingLvl
 792)
 793{
 794        if (bSwDacSwingOn)
 795                halbtc8723b2ant_SetDacSwingReg(pBtCoexist, swDacSwingLvl);
 796        else
 797                halbtc8723b2ant_SetDacSwingReg(pBtCoexist, 0x18);
 798}
 799
 800
 801static void halbtc8723b2ant_DacSwing(
 802        PBTC_COEXIST pBtCoexist,
 803        bool bForceExec,
 804        bool bDacSwingOn,
 805        u32 dacSwingLvl
 806)
 807{
 808        BTC_PRINT(
 809                BTC_MSG_ALGORITHM,
 810                ALGO_TRACE_SW,
 811                (
 812                        "[BTCoex], %s turn DacSwing =%s, dacSwingLvl = 0x%x\n",
 813                        (bForceExec ? "force to" : ""),
 814                        (bDacSwingOn ? "ON" : "OFF"),
 815                        dacSwingLvl
 816                )
 817        );
 818        pCoexDm->bCurDacSwingOn = bDacSwingOn;
 819        pCoexDm->curDacSwingLvl = dacSwingLvl;
 820
 821        if (!bForceExec) {
 822                BTC_PRINT(
 823                        BTC_MSG_ALGORITHM,
 824                        ALGO_TRACE_SW_DETAIL,
 825                        (
 826                                "[BTCoex], bPreDacSwingOn =%d, preDacSwingLvl = 0x%x, bCurDacSwingOn =%d, curDacSwingLvl = 0x%x\n",
 827                                pCoexDm->bPreDacSwingOn,
 828                                pCoexDm->preDacSwingLvl,
 829                                pCoexDm->bCurDacSwingOn,
 830                                pCoexDm->curDacSwingLvl
 831                        )
 832                );
 833
 834                if ((pCoexDm->bPreDacSwingOn == pCoexDm->bCurDacSwingOn) &&
 835                        (pCoexDm->preDacSwingLvl == pCoexDm->curDacSwingLvl))
 836                        return;
 837        }
 838        mdelay(30);
 839        halbtc8723b2ant_SetSwFullTimeDacSwing(pBtCoexist, bDacSwingOn, dacSwingLvl);
 840
 841        pCoexDm->bPreDacSwingOn = pCoexDm->bCurDacSwingOn;
 842        pCoexDm->preDacSwingLvl = pCoexDm->curDacSwingLvl;
 843}
 844
 845static void halbtc8723b2ant_SetAgcTable(
 846        PBTC_COEXIST pBtCoexist, bool bAgcTableEn
 847)
 848{
 849        u8 rssiAdjustVal = 0;
 850
 851        /* BB AGC Gain Table */
 852        if (bAgcTableEn) {
 853                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_EXEC, ("[BTCoex], BB Agc Table On!\n"));
 854                pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0xc78, 0x6e1A0001);
 855                pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0xc78, 0x6d1B0001);
 856                pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0xc78, 0x6c1C0001);
 857                pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0xc78, 0x6b1D0001);
 858                pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0xc78, 0x6a1E0001);
 859                pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0xc78, 0x691F0001);
 860                pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0xc78, 0x68200001);
 861        } else {
 862                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_EXEC, ("[BTCoex], BB Agc Table Off!\n"));
 863                pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0xc78, 0xaa1A0001);
 864                pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0xc78, 0xa91B0001);
 865                pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0xc78, 0xa81C0001);
 866                pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0xc78, 0xa71D0001);
 867                pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0xc78, 0xa61E0001);
 868                pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0xc78, 0xa51F0001);
 869                pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0xc78, 0xa4200001);
 870        }
 871
 872
 873        /* RF Gain */
 874        pBtCoexist->fBtcSetRfReg(pBtCoexist, BTC_RF_A, 0xef, 0xfffff, 0x02000);
 875        if (bAgcTableEn) {
 876                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_EXEC, ("[BTCoex], Agc Table On!\n"));
 877                pBtCoexist->fBtcSetRfReg(pBtCoexist, BTC_RF_A, 0x3b, 0xfffff, 0x38fff);
 878                pBtCoexist->fBtcSetRfReg(pBtCoexist, BTC_RF_A, 0x3b, 0xfffff, 0x38ffe);
 879        } else {
 880                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_EXEC, ("[BTCoex], Agc Table Off!\n"));
 881                pBtCoexist->fBtcSetRfReg(pBtCoexist, BTC_RF_A, 0x3b, 0xfffff, 0x380c3);
 882                pBtCoexist->fBtcSetRfReg(pBtCoexist, BTC_RF_A, 0x3b, 0xfffff, 0x28ce6);
 883        }
 884        pBtCoexist->fBtcSetRfReg(pBtCoexist, BTC_RF_A, 0xef, 0xfffff, 0x0);
 885
 886        pBtCoexist->fBtcSetRfReg(pBtCoexist, BTC_RF_A, 0xed, 0xfffff, 0x1);
 887        if (bAgcTableEn) {
 888                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_EXEC, ("[BTCoex], Agc Table On!\n"));
 889                pBtCoexist->fBtcSetRfReg(pBtCoexist, BTC_RF_A, 0x40, 0xfffff, 0x38fff);
 890                pBtCoexist->fBtcSetRfReg(pBtCoexist, BTC_RF_A, 0x40, 0xfffff, 0x38ffe);
 891        } else {
 892                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_EXEC, ("[BTCoex], Agc Table Off!\n"));
 893                pBtCoexist->fBtcSetRfReg(pBtCoexist, BTC_RF_A, 0x40, 0xfffff, 0x380c3);
 894                pBtCoexist->fBtcSetRfReg(pBtCoexist, BTC_RF_A, 0x40, 0xfffff, 0x28ce6);
 895        }
 896        pBtCoexist->fBtcSetRfReg(pBtCoexist, BTC_RF_A, 0xed, 0xfffff, 0x0);
 897
 898        /*  set rssiAdjustVal for wifi module. */
 899        if (bAgcTableEn)
 900                rssiAdjustVal = 8;
 901
 902        pBtCoexist->fBtcSet(pBtCoexist, BTC_SET_U1_RSSI_ADJ_VAL_FOR_AGC_TABLE_ON, &rssiAdjustVal);
 903}
 904
 905static void halbtc8723b2ant_AgcTable(
 906        PBTC_COEXIST pBtCoexist, bool bForceExec, bool bAgcTableEn
 907)
 908{
 909        BTC_PRINT(
 910                BTC_MSG_ALGORITHM,
 911                ALGO_TRACE_SW,
 912                (
 913                        "[BTCoex], %s %s Agc Table\n",
 914                        (bForceExec ? "force to" : ""),
 915                        (bAgcTableEn ? "Enable" : "Disable")
 916                )
 917        );
 918        pCoexDm->bCurAgcTableEn = bAgcTableEn;
 919
 920        if (!bForceExec) {
 921                BTC_PRINT(
 922                        BTC_MSG_ALGORITHM,
 923                        ALGO_TRACE_SW_DETAIL,
 924                        (
 925                                "[BTCoex], bPreAgcTableEn =%d, bCurAgcTableEn =%d\n",
 926                                pCoexDm->bPreAgcTableEn,
 927                                pCoexDm->bCurAgcTableEn
 928                        )
 929                );
 930
 931                if (pCoexDm->bPreAgcTableEn == pCoexDm->bCurAgcTableEn)
 932                        return;
 933        }
 934        halbtc8723b2ant_SetAgcTable(pBtCoexist, bAgcTableEn);
 935
 936        pCoexDm->bPreAgcTableEn = pCoexDm->bCurAgcTableEn;
 937}
 938
 939static void halbtc8723b2ant_SetCoexTable(
 940        PBTC_COEXIST pBtCoexist,
 941        u32 val0x6c0,
 942        u32 val0x6c4,
 943        u32 val0x6c8,
 944        u8 val0x6cc
 945)
 946{
 947        BTC_PRINT(
 948                BTC_MSG_ALGORITHM,
 949                ALGO_TRACE_SW_EXEC,
 950                ("[BTCoex], set coex table, set 0x6c0 = 0x%x\n", val0x6c0)
 951        );
 952        pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0x6c0, val0x6c0);
 953
 954        BTC_PRINT(
 955                BTC_MSG_ALGORITHM,
 956                ALGO_TRACE_SW_EXEC,
 957                ("[BTCoex], set coex table, set 0x6c4 = 0x%x\n", val0x6c4)
 958        );
 959        pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0x6c4, val0x6c4);
 960
 961        BTC_PRINT(
 962                BTC_MSG_ALGORITHM,
 963                ALGO_TRACE_SW_EXEC,
 964                ("[BTCoex], set coex table, set 0x6c8 = 0x%x\n", val0x6c8)
 965        );
 966        pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0x6c8, val0x6c8);
 967
 968        BTC_PRINT(
 969                BTC_MSG_ALGORITHM,
 970                ALGO_TRACE_SW_EXEC,
 971                ("[BTCoex], set coex table, set 0x6cc = 0x%x\n", val0x6cc)
 972        );
 973        pBtCoexist->fBtcWrite1Byte(pBtCoexist, 0x6cc, val0x6cc);
 974}
 975
 976static void halbtc8723b2ant_CoexTable(
 977        PBTC_COEXIST pBtCoexist,
 978        bool bForceExec,
 979        u32 val0x6c0,
 980        u32 val0x6c4,
 981        u32 val0x6c8,
 982        u8 val0x6cc
 983)
 984{
 985        BTC_PRINT(
 986                BTC_MSG_ALGORITHM,
 987                ALGO_TRACE_SW,
 988                (
 989                        "[BTCoex], %s write Coex Table 0x6c0 = 0x%x, 0x6c4 = 0x%x, 0x6c8 = 0x%x, 0x6cc = 0x%x\n",
 990                        (bForceExec ? "force to" : ""),
 991                        val0x6c0,
 992                        val0x6c4,
 993                        val0x6c8,
 994                        val0x6cc
 995                )
 996        );
 997        pCoexDm->curVal0x6c0 = val0x6c0;
 998        pCoexDm->curVal0x6c4 = val0x6c4;
 999        pCoexDm->curVal0x6c8 = val0x6c8;
1000        pCoexDm->curVal0x6cc = val0x6cc;

1001
1002        if (!bForceExec) {
1003                BTC_PRINT(
1004                        BTC_MSG_ALGORITHM,
1005                        ALGO_TRACE_SW_DETAIL,
1006                        (
1007                                "[BTCoex], preVal0x6c0 = 0x%x, preVal0x6c4 = 0x%x, preVal0x6c8 = 0x%x, preVal0x6cc = 0x%x !!\n",
1008                                pCoexDm->preVal0x6c0,
1009                                pCoexDm->preVal0x6c4,
1010                                pCoexDm->preVal0x6c8,
1011                                pCoexDm->preVal0x6cc
1012                        )
1013                );
1014                BTC_PRINT(
1015                        BTC_MSG_ALGORITHM,
1016                        ALGO_TRACE_SW_DETAIL,
1017                        (
1018                                "[BTCoex], curVal0x6c0 = 0x%x, curVal0x6c4 = 0x%x, curVal0x6c8 = 0x%x, curVal0x6cc = 0x%x !!\n",
1019                                pCoexDm->curVal0x6c0,
1020                                pCoexDm->curVal0x6c4,
1021                                pCoexDm->curVal0x6c8,
1022                                pCoexDm->curVal0x6cc
1023                        )
1024                );
1025
1026                if (
1027                        (pCoexDm->preVal0x6c0 == pCoexDm->curVal0x6c0) &&
1028                        (pCoexDm->preVal0x6c4 == pCoexDm->curVal0x6c4) &&
1029                        (pCoexDm->preVal0x6c8 == pCoexDm->curVal0x6c8) &&
1030                        (pCoexDm->preVal0x6cc == pCoexDm->curVal0x6cc)
1031                )
1032                        return;
1033        }
1034        halbtc8723b2ant_SetCoexTable(pBtCoexist, val0x6c0, val0x6c4, val0x6c8, val0x6cc);
1035
1036        pCoexDm->preVal0x6c0 = pCoexDm->curVal0x6c0;
1037        pCoexDm->preVal0x6c4 = pCoexDm->curVal0x6c4;
1038        pCoexDm->preVal0x6c8 = pCoexDm->curVal0x6c8;
1039        pCoexDm->preVal0x6cc = pCoexDm->curVal0x6cc;
1040}
1041
1042static void halbtc8723b2ant_CoexTableWithType(
1043        PBTC_COEXIST pBtCoexist, bool bForceExec, u8 type
1044)
1045{
1046        switch (type) {
1047        case 0:
1048                halbtc8723b2ant_CoexTable(pBtCoexist, bForceExec, 0x55555555, 0x55555555, 0xffff, 0x3);
1049                break;
1050        case 1:
1051                halbtc8723b2ant_CoexTable(pBtCoexist, bForceExec, 0x55555555, 0x5afa5afa, 0xffff, 0x3);
1052                break;
1053        case 2:
1054                halbtc8723b2ant_CoexTable(pBtCoexist, bForceExec, 0x5a5a5a5a, 0x5a5a5a5a, 0xffff, 0x3);
1055                break;
1056        case 3:
1057                halbtc8723b2ant_CoexTable(pBtCoexist, bForceExec, 0xaaaaaaaa, 0xaaaaaaaa, 0xffff, 0x3);
1058                break;
1059        case 4:
1060                halbtc8723b2ant_CoexTable(pBtCoexist, bForceExec, 0xffffffff, 0xffffffff, 0xffff, 0x3);
1061                break;
1062        case 5:
1063                halbtc8723b2ant_CoexTable(pBtCoexist, bForceExec, 0x5fff5fff, 0x5fff5fff, 0xffff, 0x3);
1064                break;
1065        case 6:
1066                halbtc8723b2ant_CoexTable(pBtCoexist, bForceExec, 0x55ff55ff, 0x5a5a5a5a, 0xffff, 0x3);
1067                break;
1068        case 7:
1069                halbtc8723b2ant_CoexTable(pBtCoexist, bForceExec, 0x55ff55ff, 0xfafafafa, 0xffff, 0x3);
1070                break;
1071        case 8:
1072                halbtc8723b2ant_CoexTable(pBtCoexist, bForceExec, 0x5aea5aea, 0x5aea5aea, 0xffff, 0x3);
1073                break;
1074        case 9:
1075                halbtc8723b2ant_CoexTable(pBtCoexist, bForceExec, 0x55ff55ff, 0x5aea5aea, 0xffff, 0x3);
1076                break;
1077        case 10:
1078                halbtc8723b2ant_CoexTable(pBtCoexist, bForceExec, 0x55ff55ff, 0x5aff5aff, 0xffff, 0x3);
1079                break;
1080        case 11:
1081                halbtc8723b2ant_CoexTable(pBtCoexist, bForceExec, 0x55ff55ff, 0x5a5f5a5f, 0xffff, 0x3);
1082                break;
1083        case 12:
1084                halbtc8723b2ant_CoexTable(pBtCoexist, bForceExec, 0x55ff55ff, 0x5f5f5f5f, 0xffff, 0x3);
1085                break;
1086        default:
1087                break;
1088        }
1089}
1090
1091static void halbtc8723b2ant_SetFwIgnoreWlanAct(
1092        PBTC_COEXIST pBtCoexist, bool bEnable
1093)
1094{
1095        u8      H2C_Parameter[1] = {0};
1096
1097        if (bEnable)
1098                H2C_Parameter[0] |= BIT0;               /*  function enable */
1099
1100        BTC_PRINT(
1101                BTC_MSG_ALGORITHM,
1102                ALGO_TRACE_FW_EXEC,
1103                (
1104                        "[BTCoex], set FW for BT Ignore Wlan_Act, FW write 0x63 = 0x%x\n",
1105                        H2C_Parameter[0]
1106                )
1107        );
1108
1109        pBtCoexist->fBtcFillH2c(pBtCoexist, 0x63, 1, H2C_Parameter);
1110}
1111
1112static void halbtc8723b2ant_IgnoreWlanAct(
1113        PBTC_COEXIST pBtCoexist, bool bForceExec, bool bEnable
1114)
1115{
1116        BTC_PRINT(
1117                BTC_MSG_ALGORITHM,
1118                ALGO_TRACE_FW,
1119                (
1120                        "[BTCoex], %s turn Ignore WlanAct %s\n",
1121                        (bForceExec ? "force to" : ""),
1122                        (bEnable ? "ON" : "OFF")
1123                )
1124        );
1125
1126        pCoexDm->bCurIgnoreWlanAct = bEnable;
1127
1128        if (!bForceExec) {
1129                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL, ("[BTCoex], bPreIgnoreWlanAct = %d, bCurIgnoreWlanAct = %d!!\n",
1130                        pCoexDm->bPreIgnoreWlanAct, pCoexDm->bCurIgnoreWlanAct));
1131
1132                if (pCoexDm->bPreIgnoreWlanAct == pCoexDm->bCurIgnoreWlanAct)
1133                        return;
1134        }
1135        halbtc8723b2ant_SetFwIgnoreWlanAct(pBtCoexist, bEnable);
1136
1137        pCoexDm->bPreIgnoreWlanAct = pCoexDm->bCurIgnoreWlanAct;
1138}
1139
1140static void halbtc8723b2ant_SetFwPstdma(
1141        PBTC_COEXIST pBtCoexist,
1142        u8 byte1,
1143        u8 byte2,
1144        u8 byte3,
1145        u8 byte4,
1146        u8 byte5
1147)
1148{
1149        u8      H2C_Parameter[5] = {0};
1150
1151        H2C_Parameter[0] = byte1;
1152        H2C_Parameter[1] = byte2;
1153        H2C_Parameter[2] = byte3;
1154        H2C_Parameter[3] = byte4;
1155        H2C_Parameter[4] = byte5;
1156
1157        pCoexDm->psTdmaPara[0] = byte1;
1158        pCoexDm->psTdmaPara[1] = byte2;
1159        pCoexDm->psTdmaPara[2] = byte3;
1160        pCoexDm->psTdmaPara[3] = byte4;
1161        pCoexDm->psTdmaPara[4] = byte5;
1162
1163        BTC_PRINT(
1164                BTC_MSG_ALGORITHM,
1165                ALGO_TRACE_FW_EXEC,
1166                (
1167                        "[BTCoex], FW write 0x60(5bytes) = 0x%x%08x\n",
1168                        H2C_Parameter[0],
1169                        H2C_Parameter[1]<<24|
1170                        H2C_Parameter[2]<<16|
1171                        H2C_Parameter[3]<<8|
1172                        H2C_Parameter[4]
1173                )
1174        );
1175
1176        pBtCoexist->fBtcFillH2c(pBtCoexist, 0x60, 5, H2C_Parameter);
1177}
1178
1179static void halbtc8723b2ant_SwMechanism1(
1180        PBTC_COEXIST pBtCoexist,
1181        bool bShrinkRxLPF,
1182        bool bLowPenaltyRA,
1183        bool bLimitedDIG,
1184        bool bBTLNAConstrain
1185)
1186{
1187        halbtc8723b2ant_RfShrink(pBtCoexist, NORMAL_EXEC, bShrinkRxLPF);
1188        halbtc8723b2ant_LowPenaltyRa(pBtCoexist, NORMAL_EXEC, bLowPenaltyRA);
1189}
1190
1191static void halbtc8723b2ant_SwMechanism2(
1192        PBTC_COEXIST pBtCoexist,
1193        bool bAGCTableShift,
1194        bool bADCBackOff,
1195        bool bSWDACSwing,
1196        u32 dacSwingLvl
1197)
1198{
1199        halbtc8723b2ant_AgcTable(pBtCoexist, NORMAL_EXEC, bAGCTableShift);
1200        halbtc8723b2ant_DacSwing(pBtCoexist, NORMAL_EXEC, bSWDACSwing, dacSwingLvl);
1201}
1202
1203static void halbtc8723b2ant_SetAntPath(
1204        PBTC_COEXIST pBtCoexist, u8 antPosType, bool bInitHwCfg, bool bWifiOff
1205)
1206{
1207        PBTC_BOARD_INFO pBoardInfo = &pBtCoexist->boardInfo;
1208        u32 fwVer = 0, u4Tmp = 0;
1209        bool bPgExtSwitch = false;
1210        bool bUseExtSwitch = false;
1211        u8      H2C_Parameter[2] = {0};
1212
1213        pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_EXT_SWITCH, &bPgExtSwitch);
1214        pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_U4_WIFI_FW_VER, &fwVer);        /*  [31:16]=fw ver, [15:0]=fw sub ver */
1215
1216        if ((fwVer > 0 && fwVer < 0xc0000) || bPgExtSwitch)
1217                bUseExtSwitch = true;
1218
1219        if (bInitHwCfg) {
1220                pBtCoexist->fBtcWrite1ByteBitMask(pBtCoexist, 0x39, 0x8, 0x1);
1221                pBtCoexist->fBtcWrite1Byte(pBtCoexist, 0x974, 0xff);
1222                pBtCoexist->fBtcWrite1ByteBitMask(pBtCoexist, 0x944, 0x3, 0x3);
1223                pBtCoexist->fBtcWrite1Byte(pBtCoexist, 0x930, 0x77);
1224                pBtCoexist->fBtcWrite1ByteBitMask(pBtCoexist, 0x67, 0x20, 0x1);
1225
1226                if (fwVer >= 0x180000) {
1227                        /* Use H2C to set GNT_BT to LOW */
1228                        H2C_Parameter[0] = 0;
1229                        pBtCoexist->fBtcFillH2c(pBtCoexist, 0x6E, 1, H2C_Parameter);
1230                } else {
1231                        pBtCoexist->fBtcWrite1Byte(pBtCoexist, 0x765, 0x0);
1232                }
1233
1234                pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0x948, 0x0);
1235
1236                pBtCoexist->fBtcSetRfReg(pBtCoexist, BTC_RF_A, 0x1, 0xfffff, 0x0); /* WiFi TRx Mask off */
1237                pBtCoexist->fBtcSetBtReg(pBtCoexist, BTC_BT_REG_RF, 0x3c, 0x01); /* BT TRx Mask off */
1238
1239                if (pBoardInfo->btdmAntPos == BTC_ANTENNA_AT_MAIN_PORT) {
1240                        /* tell firmware "no antenna inverse" */
1241                        H2C_Parameter[0] = 0;
1242                } else {
1243                        /* tell firmware "antenna inverse" */
1244                        H2C_Parameter[0] = 1;
1245                }
1246
1247                if (bUseExtSwitch) {
1248                        /* ext switch type */
1249                        H2C_Parameter[1] = 1;
1250                } else {
1251                        /* int switch type */
1252                        H2C_Parameter[1] = 0;
1253                }
1254                pBtCoexist->fBtcFillH2c(pBtCoexist, 0x65, 2, H2C_Parameter);
1255        }
1256
1257        /*  ext switch setting */
1258        if (bUseExtSwitch) {
1259                if (bInitHwCfg) {
1260                        /*  0x4c[23]= 0, 0x4c[24]= 1  Antenna control by WL/BT */
1261                        u4Tmp = pBtCoexist->fBtcRead4Byte(pBtCoexist, 0x4c);
1262                        u4Tmp &= ~BIT23;
1263                        u4Tmp |= BIT24;
1264                        pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0x4c, u4Tmp);
1265                }
1266
1267                pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0x948, 0x0); /*  fixed internal switch S1->WiFi, S0->BT */
1268                switch (antPosType) {
1269                case BTC_ANT_WIFI_AT_MAIN:
1270                        pBtCoexist->fBtcWrite1ByteBitMask(pBtCoexist, 0x92c, 0x3, 0x1); /*  ext switch main at wifi */
1271                        break;
1272                case BTC_ANT_WIFI_AT_AUX:
1273                        pBtCoexist->fBtcWrite1ByteBitMask(pBtCoexist, 0x92c, 0x3, 0x2); /*  ext switch aux at wifi */
1274                        break;
1275                }
1276        } else { /*  internal switch */
1277                if (bInitHwCfg) {
1278                        /*  0x4c[23]= 0, 0x4c[24]= 1  Antenna control by WL/BT */
1279                        u4Tmp = pBtCoexist->fBtcRead4Byte(pBtCoexist, 0x4c);
1280                        u4Tmp |= BIT23;
1281                        u4Tmp &= ~BIT24;
1282                        pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0x4c, u4Tmp);
1283                }
1284
1285                pBtCoexist->fBtcWrite1ByteBitMask(pBtCoexist, 0x64, 0x1, 0x0); /* fixed external switch S1->Main, S0->Aux */
1286                switch (antPosType) {
1287                case BTC_ANT_WIFI_AT_MAIN:
1288                        pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0x948, 0x0); /*  fixed internal switch S1->WiFi, S0->BT */
1289                        break;
1290                case BTC_ANT_WIFI_AT_AUX:
1291                        pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0x948, 0x280); /*  fixed internal switch S0->WiFi, S1->BT */
1292                        break;
1293                }
1294        }
1295}
1296
1297static void halbtc8723b2ant_PsTdma(
1298        PBTC_COEXIST pBtCoexist, bool bForceExec, bool bTurnOn, u8 type
1299)
1300{
1301        BTC_PRINT(
1302                BTC_MSG_ALGORITHM,
1303                ALGO_TRACE_FW,
1304                (
1305                        "[BTCoex], %s turn %s PS TDMA, type =%d\n",
1306                        (bForceExec ? "force to" : ""),
1307                        (bTurnOn ? "ON" : "OFF"),
1308                        type
1309                )
1310        );
1311        pCoexDm->bCurPsTdmaOn = bTurnOn;
1312        pCoexDm->curPsTdma = type;
1313
1314        if (!bForceExec) {
1315                BTC_PRINT(
1316                        BTC_MSG_ALGORITHM,
1317                        ALGO_TRACE_FW_DETAIL,
1318                        (
1319                                "[BTCoex], bPrePsTdmaOn = %d, bCurPsTdmaOn = %d!!\n",
1320                                pCoexDm->bPrePsTdmaOn,
1321                                pCoexDm->bCurPsTdmaOn
1322                        )
1323                );
1324                BTC_PRINT(
1325                        BTC_MSG_ALGORITHM,
1326                        ALGO_TRACE_FW_DETAIL,
1327                        (
1328                                "[BTCoex], prePsTdma = %d, curPsTdma = %d!!\n",
1329                                pCoexDm->prePsTdma, pCoexDm->curPsTdma
1330                        )
1331                );
1332
1333                if (
1334                        (pCoexDm->bPrePsTdmaOn == pCoexDm->bCurPsTdmaOn) &&
1335                        (pCoexDm->prePsTdma == pCoexDm->curPsTdma)
1336                )
1337                        return;
1338        }
1339
1340        if (bTurnOn) {
1341                switch (type) {
1342                case 1:
1343                default:
1344                        halbtc8723b2ant_SetFwPstdma(pBtCoexist, 0xe3, 0x1a, 0x1a, 0xe1, 0x90);
1345                        break;
1346                case 2:
1347                        halbtc8723b2ant_SetFwPstdma(pBtCoexist, 0xe3, 0x12, 0x12, 0xe1, 0x90);
1348                        break;
1349                case 3:
1350                        halbtc8723b2ant_SetFwPstdma(pBtCoexist, 0xe3, 0x1c, 0x3, 0xf1, 0x90);
1351                        break;
1352                case 4:
1353                        halbtc8723b2ant_SetFwPstdma(pBtCoexist, 0xe3, 0x10, 0x03, 0xf1, 0x90);
1354                        break;
1355                case 5:
1356                        halbtc8723b2ant_SetFwPstdma(pBtCoexist, 0xe3, 0x1a, 0x1a, 0x60, 0x90);
1357                        break;
1358                case 6:
1359                        halbtc8723b2ant_SetFwPstdma(pBtCoexist, 0xe3, 0x12, 0x12, 0x60, 0x90);
1360                        break;
1361                case 7:
1362                        halbtc8723b2ant_SetFwPstdma(pBtCoexist, 0xe3, 0x1c, 0x3, 0x70, 0x90);
1363                        break;
1364                case 8:
1365                        halbtc8723b2ant_SetFwPstdma(pBtCoexist, 0xa3, 0x10, 0x3, 0x70, 0x90);
1366                        break;
1367                case 9:
1368                        halbtc8723b2ant_SetFwPstdma(pBtCoexist, 0xe3, 0x1a, 0x1a, 0xe1, 0x90);
1369                        break;
1370                case 10:
1371                        halbtc8723b2ant_SetFwPstdma(pBtCoexist, 0xe3, 0x12, 0x12, 0xe1, 0x90);
1372                        break;
1373                case 11:
1374                        halbtc8723b2ant_SetFwPstdma(pBtCoexist, 0xe3, 0xa, 0xa, 0xe1, 0x90);
1375                        break;
1376                case 12:
1377                        halbtc8723b2ant_SetFwPstdma(pBtCoexist, 0xe3, 0x5, 0x5, 0xe1, 0x90);
1378                        break;
1379                case 13:
1380                        halbtc8723b2ant_SetFwPstdma(pBtCoexist, 0xe3, 0x1a, 0x1a, 0x60, 0x90);
1381                        break;
1382                case 14:
1383                        halbtc8723b2ant_SetFwPstdma(pBtCoexist, 0xe3, 0x12, 0x12, 0x60, 0x90);
1384                        break;
1385                case 15:
1386                        halbtc8723b2ant_SetFwPstdma(pBtCoexist, 0xe3, 0xa, 0xa, 0x60, 0x90);
1387                        break;
1388                case 16:
1389                        halbtc8723b2ant_SetFwPstdma(pBtCoexist, 0xe3, 0x5, 0x5, 0x60, 0x90);
1390                        break;
1391                case 17:
1392                        halbtc8723b2ant_SetFwPstdma(pBtCoexist, 0xa3, 0x2f, 0x2f, 0x60, 0x90);
1393                        break;
1394                case 18:
1395                        halbtc8723b2ant_SetFwPstdma(pBtCoexist, 0xe3, 0x5, 0x5, 0xe1, 0x90);
1396                        break;
1397                case 19:
1398                        halbtc8723b2ant_SetFwPstdma(pBtCoexist, 0xe3, 0x25, 0x25, 0xe1, 0x90);
1399                        break;
1400                case 20:
1401                        halbtc8723b2ant_SetFwPstdma(pBtCoexist, 0xe3, 0x25, 0x25, 0x60, 0x90);
1402                        break;
1403                case 21:
1404                        halbtc8723b2ant_SetFwPstdma(pBtCoexist, 0xe3, 0x15, 0x03, 0x70, 0x90);
1405                        break;
1406                case 71:
1407                        halbtc8723b2ant_SetFwPstdma(pBtCoexist, 0xe3, 0x1a, 0x1a, 0xe1, 0x90);
1408                        break;
1409                }
1410        } else {
1411                /*  disable PS tdma */
1412                switch (type) {
1413                case 0:
1414                        halbtc8723b2ant_SetFwPstdma(pBtCoexist, 0x0, 0x0, 0x0, 0x40, 0x0);
1415                        break;
1416                case 1:
1417                        halbtc8723b2ant_SetFwPstdma(pBtCoexist, 0x0, 0x0, 0x0, 0x48, 0x0);
1418                        break;
1419                default:
1420                        halbtc8723b2ant_SetFwPstdma(pBtCoexist, 0x0, 0x0, 0x0, 0x40, 0x0);
1421                        break;
1422                }
1423        }
1424
1425        /*  update pre state */
1426        pCoexDm->bPrePsTdmaOn = pCoexDm->bCurPsTdmaOn;
1427        pCoexDm->prePsTdma = pCoexDm->curPsTdma;
1428}
1429
1430static void halbtc8723b2ant_CoexAllOff(PBTC_COEXIST pBtCoexist)
1431{
1432        /*  fw all off */
1433        halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, false, 1);
1434        halbtc8723b2ant_FwDacSwingLvl(pBtCoexist, NORMAL_EXEC, 6);
1435        halbtc8723b2ant_DecBtPwr(pBtCoexist, NORMAL_EXEC, 0);
1436
1437        /*  sw all off */
1438        halbtc8723b2ant_SwMechanism1(pBtCoexist, false, false, false, false);
1439        halbtc8723b2ant_SwMechanism2(pBtCoexist, false, false, false, 0x18);
1440
1441        /*  hw all off */
1442        /* pBtCoexist->fBtcSetRfReg(pBtCoexist, BTC_RF_A, 0x1, 0xfffff, 0x0); */
1443        halbtc8723b2ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 0);
1444}
1445
1446static void halbtc8723b2ant_InitCoexDm(PBTC_COEXIST pBtCoexist)
1447{
1448        /*  force to reset coex mechanism */
1449
1450        halbtc8723b2ant_PsTdma(pBtCoexist, FORCE_EXEC, false, 1);
1451        halbtc8723b2ant_FwDacSwingLvl(pBtCoexist, FORCE_EXEC, 6);
1452        halbtc8723b2ant_DecBtPwr(pBtCoexist, FORCE_EXEC, 0);
1453
1454        halbtc8723b2ant_SwMechanism1(pBtCoexist, false, false, false, false);
1455        halbtc8723b2ant_SwMechanism2(pBtCoexist, false, false, false, 0x18);
1456}
1457
1458static void halbtc8723b2ant_ActionBtInquiry(PBTC_COEXIST pBtCoexist)
1459{
1460        bool bWifiConnected = false;
1461        bool bLowPwrDisable = true;
1462
1463        pBtCoexist->fBtcSet(pBtCoexist, BTC_SET_ACT_DISABLE_LOW_POWER, &bLowPwrDisable);
1464        pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_WIFI_CONNECTED, &bWifiConnected);
1465
1466        if (bWifiConnected) {
1467                halbtc8723b2ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 7);
1468                halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 3);
1469        } else {
1470                halbtc8723b2ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 0);
1471                halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, false, 1);
1472        }
1473
1474        halbtc8723b2ant_FwDacSwingLvl(pBtCoexist, FORCE_EXEC, 6);
1475        halbtc8723b2ant_DecBtPwr(pBtCoexist, NORMAL_EXEC, 0);
1476
1477        halbtc8723b2ant_SwMechanism1(pBtCoexist, false, false, false, false);
1478        halbtc8723b2ant_SwMechanism2(pBtCoexist, false, false, false, 0x18);
1479
1480        pCoexDm->bNeedRecover0x948 = true;
1481        pCoexDm->backup0x948 = pBtCoexist->fBtcRead4Byte(pBtCoexist, 0x948);
1482
1483        halbtc8723b2ant_SetAntPath(pBtCoexist, BTC_ANT_WIFI_AT_AUX, false, false);
1484}
1485
1486static bool halbtc8723b2ant_IsCommonAction(PBTC_COEXIST pBtCoexist)
1487{
1488        u8 btRssiState = BTC_RSSI_STATE_HIGH;
1489        bool bCommon = false, bWifiConnected = false, bWifiBusy = false;
1490        bool bBtHsOn = false, bLowPwrDisable = false;
1491
1492        pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_HS_OPERATION, &bBtHsOn);
1493        pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_WIFI_CONNECTED, &bWifiConnected);
1494        pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_WIFI_BUSY, &bWifiBusy);
1495
1496        if (!bWifiConnected) {
1497                bLowPwrDisable = false;
1498                pBtCoexist->fBtcSet(pBtCoexist, BTC_SET_ACT_DISABLE_LOW_POWER, &bLowPwrDisable);
1499                halbtc8723b2ant_LimitedRx(pBtCoexist, NORMAL_EXEC, false, false, 0x8);
1500
1501                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], Wifi non-connected idle!!\n"));
1502
1503                pBtCoexist->fBtcSetRfReg(pBtCoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
1504                halbtc8723b2ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 0);
1505                halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, false, 1);
1506                halbtc8723b2ant_FwDacSwingLvl(pBtCoexist, NORMAL_EXEC, 6);
1507                halbtc8723b2ant_DecBtPwr(pBtCoexist, NORMAL_EXEC, 0);
1508
1509                halbtc8723b2ant_SwMechanism1(pBtCoexist, false, false, false, false);
1510                halbtc8723b2ant_SwMechanism2(pBtCoexist, false, false, false, 0x18);
1511
1512                bCommon = true;
1513        } else {
1514                if (BT_8723B_2ANT_BT_STATUS_NON_CONNECTED_IDLE == pCoexDm->btStatus) {
1515                        bLowPwrDisable = false;
1516                        pBtCoexist->fBtcSet(pBtCoexist, BTC_SET_ACT_DISABLE_LOW_POWER, &bLowPwrDisable);
1517                        halbtc8723b2ant_LimitedRx(pBtCoexist, NORMAL_EXEC, false, false, 0x8);
1518
1519                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], Wifi connected + BT non connected-idle!!\n"));
1520
1521                        pBtCoexist->fBtcSetRfReg(pBtCoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
1522                        halbtc8723b2ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 0);
1523                        halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, false, 1);
1524                        halbtc8723b2ant_FwDacSwingLvl(pBtCoexist, NORMAL_EXEC, 0xb);
1525                        halbtc8723b2ant_DecBtPwr(pBtCoexist, NORMAL_EXEC, 0);
1526
1527                        halbtc8723b2ant_SwMechanism1(pBtCoexist, false, false, false, false);
1528                        halbtc8723b2ant_SwMechanism2(pBtCoexist, false, false, false, 0x18);
1529
1530                        bCommon = true;
1531                } else if (BT_8723B_2ANT_BT_STATUS_CONNECTED_IDLE == pCoexDm->btStatus) {
1532                        bLowPwrDisable = true;
1533                        pBtCoexist->fBtcSet(pBtCoexist, BTC_SET_ACT_DISABLE_LOW_POWER, &bLowPwrDisable);
1534
1535                        if (bBtHsOn)
1536                                return false;
1537
1538                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], Wifi connected + BT connected-idle!!\n"));
1539                        halbtc8723b2ant_LimitedRx(pBtCoexist, NORMAL_EXEC, false, false, 0x8);
1540
1541                        pBtCoexist->fBtcSetRfReg(pBtCoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
1542                        halbtc8723b2ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 0);
1543                        halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, false, 1);
1544                        halbtc8723b2ant_FwDacSwingLvl(pBtCoexist, NORMAL_EXEC, 0xb);
1545                        halbtc8723b2ant_DecBtPwr(pBtCoexist, NORMAL_EXEC, 0);
1546
1547                        halbtc8723b2ant_SwMechanism1(pBtCoexist, true, false, false, false);
1548                        halbtc8723b2ant_SwMechanism2(pBtCoexist, false, false, false, 0x18);
1549
1550                        bCommon = true;
1551                } else {
1552                        bLowPwrDisable = true;
1553                        pBtCoexist->fBtcSet(pBtCoexist, BTC_SET_ACT_DISABLE_LOW_POWER, &bLowPwrDisable);
1554
1555                        if (bWifiBusy) {
1556                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], Wifi Connected-Busy + BT Busy!!\n"));
1557                                bCommon = false;
1558                        } else {
1559                                if (bBtHsOn)
1560                                        return false;
1561
1562                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], Wifi Connected-Idle + BT Busy!!\n"));
1563                                btRssiState = halbtc8723b2ant_BtRssiState(2, 29, 0);
1564                                halbtc8723b2ant_LimitedRx(pBtCoexist, NORMAL_EXEC, false, false, 0x8);
1565
1566                                pBtCoexist->fBtcSetRfReg(pBtCoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
1567                                halbtc8723b2ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 7);
1568                                halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 21);
1569                                halbtc8723b2ant_FwDacSwingLvl(pBtCoexist, NORMAL_EXEC, 0xb);
1570
1571                                if (BTC_RSSI_HIGH(btRssiState))
1572                                        halbtc8723b2ant_DecBtPwr(pBtCoexist, NORMAL_EXEC, 2);
1573                                else
1574                                        halbtc8723b2ant_DecBtPwr(pBtCoexist, NORMAL_EXEC, 0);
1575
1576                                halbtc8723b2ant_SwMechanism1(pBtCoexist, false, false, false, false);
1577                                halbtc8723b2ant_SwMechanism2(pBtCoexist, false, false, false, 0x18);
1578                                bCommon = true;
1579                        }
1580                }
1581        }
1582
1583        return bCommon;
1584}
1585
1586static void halbtc8723b2ant_TdmaDurationAdjust(
1587        PBTC_COEXIST pBtCoexist, bool bScoHid, bool bTxPause, u8 maxInterval
1588)
1589{
1590        static s32 up, dn, m, n, WaitCount;
1591        s32 result;   /* 0: no change, +1: increase WiFi duration, -1: decrease WiFi duration */
1592        u8 retryCount = 0;
1593
1594        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW, ("[BTCoex], TdmaDurationAdjust()\n"));
1595
1596        if (!pCoexDm->bAutoTdmaAdjust) {
1597                pCoexDm->bAutoTdmaAdjust = true;
1598                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL, ("[BTCoex], first run TdmaDurationAdjust()!!\n"));
1599                {
1600                        if (bScoHid) {
1601                                if (bTxPause) {
1602                                        if (maxInterval == 1) {
1603                                                halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 13);
1604                                                pCoexDm->psTdmaDuAdjType = 13;
1605                                        } else if (maxInterval == 2) {
1606                                                halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 14);
1607                                                pCoexDm->psTdmaDuAdjType = 14;
1608                                        } else if (maxInterval == 3) {
1609                                                halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 15);
1610                                                pCoexDm->psTdmaDuAdjType = 15;
1611                                        } else {
1612                                                halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 15);
1613                                                pCoexDm->psTdmaDuAdjType = 15;
1614                                        }
1615                                } else {
1616                                        if (maxInterval == 1) {
1617                                                halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 9);
1618                                                pCoexDm->psTdmaDuAdjType = 9;
1619                                        } else if (maxInterval == 2) {
1620                                                halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 10);
1621                                                pCoexDm->psTdmaDuAdjType = 10;
1622                                        } else if (maxInterval == 3) {
1623                                                halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 11);
1624                                                pCoexDm->psTdmaDuAdjType = 11;
1625                                        } else {
1626                                                halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 11);
1627                                                pCoexDm->psTdmaDuAdjType = 11;
1628                                        }
1629                                }
1630                        } else {
1631                                if (bTxPause) {
1632                                        if (maxInterval == 1) {
1633                                                halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 5);
1634                                                pCoexDm->psTdmaDuAdjType = 5;
1635                                        } else if (maxInterval == 2) {
1636                                                halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 6);
1637                                                pCoexDm->psTdmaDuAdjType = 6;
1638                                        } else if (maxInterval == 3) {
1639                                                halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 7);
1640                                                pCoexDm->psTdmaDuAdjType = 7;
1641                                        } else {
1642                                                halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 7);
1643                                                pCoexDm->psTdmaDuAdjType = 7;
1644                                        }
1645                                } else {
1646                                        if (maxInterval == 1) {
1647                                                halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 1);
1648                                                pCoexDm->psTdmaDuAdjType = 1;
1649                                        } else if (maxInterval == 2) {
1650                                                halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 2);
1651                                                pCoexDm->psTdmaDuAdjType = 2;
1652                                        } else if (maxInterval == 3) {
1653                                                halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 3);
1654                                                pCoexDm->psTdmaDuAdjType = 3;
1655                                        } else {
1656                                                halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 3);
1657                                                pCoexDm->psTdmaDuAdjType = 3;
1658                                        }
1659                                }
1660                        }
1661                }
1662                /*  */
1663                up = 0;
1664                dn = 0;
1665                m = 1;
1666                n = 3;
1667                result = 0;
1668                WaitCount = 0;
1669        } else {
1670                /* accquire the BT TRx retry count from BT_Info byte2 */
1671                retryCount = pCoexSta->btRetryCnt;
1672                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL, ("[BTCoex], retryCount = %d\n", retryCount));
1673                BTC_PRINT(
1674                        BTC_MSG_ALGORITHM,
1675                        ALGO_TRACE_FW_DETAIL,
1676                        (
1677                                "[BTCoex], up =%d, dn =%d, m =%d, n =%d, WaitCount =%d\n",
1678                                up, dn, m, n, WaitCount
1679                        )
1680                );
1681                result = 0;
1682                WaitCount++;
1683
1684                if (retryCount == 0) { /*  no retry in the last 2-second duration */
1685                        up++;
1686                        dn--;
1687
1688                        if (dn <= 0)
1689                                dn = 0;
1690
1691                        if (up >= n) { /*  if 連續 n 個2秒 retry count為0, 則調寬WiFi duration */
1692                                WaitCount = 0;
1693                                n = 3;
1694                                up = 0;
1695                                dn = 0;
1696                                result = 1;
1697                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL, ("[BTCoex], Increase wifi duration!!\n"));
1698                        }
1699                } else if (retryCount <= 3) { /*  <=3 retry in the last 2-second duration */
1700                        up--;
1701                        dn++;
1702
1703                        if (up <= 0)
1704                                up = 0;
1705
1706                        if (dn == 2) { /*  if 連續 2 個2秒 retry count< 3, 則調窄WiFi duration */
1707                                if (WaitCount <= 2)
1708                                        m++; /*  避免一直在兩個level中來回 */
1709                                else
1710                                        m = 1;
1711
1712                                if (m >= 20) /* m 最大值 = 20 ' 最大120秒 recheck是否調整 WiFi duration. */
1713                                        m = 20;
1714
1715                                n = 3*m;
1716                                up = 0;
1717                                dn = 0;
1718                                WaitCount = 0;
1719                                result = -1;
1720                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL, ("[BTCoex], Decrease wifi duration for retryCounter<3!!\n"));
1721                        }
1722                } else { /* retry count > 3, 只要1次 retry count > 3, 則調窄WiFi duration */
1723                        if (WaitCount == 1)
1724                                m++; /*  避免一直在兩個level中來回 */
1725                        else
1726                                m = 1;
1727
1728                        if (m >= 20) /* m 最大值 = 20 ' 最大120秒 recheck是否調整 WiFi duration. */
1729                                m = 20;
1730
1731                        n = 3*m;
1732                        up = 0;
1733                        dn = 0;
1734                        WaitCount = 0;
1735                        result = -1;
1736                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL, ("[BTCoex], Decrease wifi duration for retryCounter>3!!\n"));
1737                }
1738
1739                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL, ("[BTCoex], max Interval = %d\n", maxInterval));
1740                if (maxInterval == 1) {
1741                        if (bTxPause) {
1742                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL, ("[BTCoex], TxPause = 1\n"));
1743
1744                                if (pCoexDm->curPsTdma == 71) {
1745                                        halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 5);
1746                                        pCoexDm->psTdmaDuAdjType = 5;
1747                                } else if (pCoexDm->curPsTdma == 1) {
1748                                        halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 5);
1749                                        pCoexDm->psTdmaDuAdjType = 5;
1750                                } else if (pCoexDm->curPsTdma == 2) {
1751                                        halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 6);
1752                                        pCoexDm->psTdmaDuAdjType = 6;
1753                                } else if (pCoexDm->curPsTdma == 3) {
1754                                        halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 7);
1755                                        pCoexDm->psTdmaDuAdjType = 7;
1756                                } else if (pCoexDm->curPsTdma == 4) {
1757                                        halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 8);
1758                                        pCoexDm->psTdmaDuAdjType = 8;
1759                                }
1760
1761                                if (pCoexDm->curPsTdma == 9) {
1762                                        halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 13);
1763                                        pCoexDm->psTdmaDuAdjType = 13;
1764                                } else if (pCoexDm->curPsTdma == 10) {
1765                                        halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 14);
1766                                        pCoexDm->psTdmaDuAdjType = 14;
1767                                } else if (pCoexDm->curPsTdma == 11) {
1768                                        halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 15);
1769                                        pCoexDm->psTdmaDuAdjType = 15;
1770                                } else if (pCoexDm->curPsTdma == 12) {
1771                                        halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 16);
1772                                        pCoexDm->psTdmaDuAdjType = 16;
1773                                }
1774
1775                                if (result == -1) {
1776                                        if (pCoexDm->curPsTdma == 5) {
1777                                                halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 6);
1778                                                pCoexDm->psTdmaDuAdjType = 6;
1779                                        } else if (pCoexDm->curPsTdma == 6) {
1780                                                halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 7);
1781                                                pCoexDm->psTdmaDuAdjType = 7;
1782                                        } else if (pCoexDm->curPsTdma == 7) {
1783                                                halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 8);
1784                                                pCoexDm->psTdmaDuAdjType = 8;
1785                                        } else if (pCoexDm->curPsTdma == 13) {
1786                                                halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 14);
1787                                                pCoexDm->psTdmaDuAdjType = 14;
1788                                        } else if (pCoexDm->curPsTdma == 14) {
1789                                                halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 15);
1790                                                pCoexDm->psTdmaDuAdjType = 15;
1791                                        } else if (pCoexDm->curPsTdma == 15) {
1792                                                halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 16);
1793                                                pCoexDm->psTdmaDuAdjType = 16;
1794                                        }
1795                                } else if (result == 1) {
1796                                        if (pCoexDm->curPsTdma == 8) {
1797                                                halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 7);
1798                                                pCoexDm->psTdmaDuAdjType = 7;
1799                                        } else if (pCoexDm->curPsTdma == 7) {
1800                                                halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 6);
1801                                                pCoexDm->psTdmaDuAdjType = 6;
1802                                        } else if (pCoexDm->curPsTdma == 6) {
1803                                                halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 5);
1804                                                pCoexDm->psTdmaDuAdjType = 5;
1805                                        } else if (pCoexDm->curPsTdma == 16) {
1806                                                halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 15);
1807                                                pCoexDm->psTdmaDuAdjType = 15;
1808                                        } else if (pCoexDm->curPsTdma == 15) {
1809                                                halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 14);
1810                                                pCoexDm->psTdmaDuAdjType = 14;
1811                                        } else if (pCoexDm->curPsTdma == 14) {
1812                                                halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 13);
1813                                                pCoexDm->psTdmaDuAdjType = 13;
1814                                        }
1815                                }
1816                        } else {
1817                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL, ("[BTCoex], TxPause = 0\n"));
1818                                if (pCoexDm->curPsTdma == 5) {
1819                                        halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 71);
1820                                        pCoexDm->psTdmaDuAdjType = 71;
1821                                } else if (pCoexDm->curPsTdma == 6) {
1822                                        halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 2);
1823                                        pCoexDm->psTdmaDuAdjType = 2;
1824                                } else if (pCoexDm->curPsTdma == 7) {
1825                                        halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 3);
1826                                        pCoexDm->psTdmaDuAdjType = 3;
1827                                } else if (pCoexDm->curPsTdma == 8) {
1828                                        halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 4);
1829                                        pCoexDm->psTdmaDuAdjType = 4;
1830                                }
1831
1832                                if (pCoexDm->curPsTdma == 13) {
1833                                        halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 9);
1834                                        pCoexDm->psTdmaDuAdjType = 9;
1835                                } else if (pCoexDm->curPsTdma == 14) {
1836                                        halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 10);
1837                                        pCoexDm->psTdmaDuAdjType = 10;
1838                                } else if (pCoexDm->curPsTdma == 15) {
1839                                        halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 11);
1840                                        pCoexDm->psTdmaDuAdjType = 11;
1841                                } else if (pCoexDm->curPsTdma == 16) {
1842                                        halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 12);
1843                                        pCoexDm->psTdmaDuAdjType = 12;
1844                                }
1845
1846                                if (result == -1) {
1847                                        if (pCoexDm->curPsTdma == 71) {
1848                                                halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 1);
1849                                                pCoexDm->psTdmaDuAdjType = 1;
1850                                        } else if (pCoexDm->curPsTdma == 1) {
1851                                                halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 2);
1852                                                pCoexDm->psTdmaDuAdjType = 2;
1853                                        } else if (pCoexDm->curPsTdma == 2) {
1854                                                halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 3);
1855                                                pCoexDm->psTdmaDuAdjType = 3;
1856                                        } else if (pCoexDm->curPsTdma == 3) {
1857                                                halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 4);
1858                                                pCoexDm->psTdmaDuAdjType = 4;
1859                                        } else if (pCoexDm->curPsTdma == 9) {
1860                                                halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 10);
1861                                                pCoexDm->psTdmaDuAdjType = 10;
1862                                        } else if (pCoexDm->curPsTdma == 10) {
1863                                                halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 11);
1864                                                pCoexDm->psTdmaDuAdjType = 11;
1865                                        } else if (pCoexDm->curPsTdma == 11) {
1866                                                halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 12);
1867                                                pCoexDm->psTdmaDuAdjType = 12;
1868                                        }
1869                                } else if (result == 1) {
1870                                        if (pCoexDm->curPsTdma == 4) {
1871                                                halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 3);
1872                                                pCoexDm->psTdmaDuAdjType = 3;
1873                                        } else if (pCoexDm->curPsTdma == 3) {
1874                                                halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 2);
1875                                                pCoexDm->psTdmaDuAdjType = 2;
1876                                        } else if (pCoexDm->curPsTdma == 2) {
1877                                                halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 1);
1878                                                pCoexDm->psTdmaDuAdjType = 1;
1879                                        } else if (pCoexDm->curPsTdma == 1) {
1880                                                halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 71);
1881                                                pCoexDm->psTdmaDuAdjType = 71;
1882                                        } else if (pCoexDm->curPsTdma == 12) {
1883                                                halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 11);
1884                                                pCoexDm->psTdmaDuAdjType = 11;
1885                                        } else if (pCoexDm->curPsTdma == 11) {
1886                                                halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 10);
1887                                                pCoexDm->psTdmaDuAdjType = 10;
1888                                        } else if (pCoexDm->curPsTdma == 10) {
1889                                                halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 9);
1890                                                pCoexDm->psTdmaDuAdjType = 9;
1891                                        }
1892                                }
1893                        }
1894                } else if (maxInterval == 2) {
1895                        if (bTxPause) {
1896                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL, ("[BTCoex], TxPause = 1\n"));
1897                                if (pCoexDm->curPsTdma == 1) {
1898                                        halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 6);
1899                                        pCoexDm->psTdmaDuAdjType = 6;
1900                                } else if (pCoexDm->curPsTdma == 2) {
1901                                        halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 6);
1902                                        pCoexDm->psTdmaDuAdjType = 6;
1903                                } else if (pCoexDm->curPsTdma == 3) {
1904                                        halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 7);
1905                                        pCoexDm->psTdmaDuAdjType = 7;
1906                                } else if (pCoexDm->curPsTdma == 4) {
1907                                        halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 8);
1908                                        pCoexDm->psTdmaDuAdjType = 8;
1909                                }
1910
1911                                if (pCoexDm->curPsTdma == 9) {
1912                                        halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 14);
1913                                        pCoexDm->psTdmaDuAdjType = 14;
1914                                } else if (pCoexDm->curPsTdma == 10) {
1915                                        halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 14);
1916                                        pCoexDm->psTdmaDuAdjType = 14;
1917                                } else if (pCoexDm->curPsTdma == 11) {
1918                                        halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 15);
1919                                        pCoexDm->psTdmaDuAdjType = 15;
1920                                } else if (pCoexDm->curPsTdma == 12) {
1921                                        halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 16);
1922                                        pCoexDm->psTdmaDuAdjType = 16;
1923                                }
1924
1925                                if (result == -1) {
1926                                        if (pCoexDm->curPsTdma == 5) {
1927                                                halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 6);
1928                                                pCoexDm->psTdmaDuAdjType = 6;
1929                                        } else if (pCoexDm->curPsTdma == 6) {
1930                                                halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 7);
1931                                                pCoexDm->psTdmaDuAdjType = 7;
1932                                        } else if (pCoexDm->curPsTdma == 7) {
1933                                                halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 8);
1934                                                pCoexDm->psTdmaDuAdjType = 8;
1935                                        } else if (pCoexDm->curPsTdma == 13) {
1936                                                halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 14);
1937                                                pCoexDm->psTdmaDuAdjType = 14;
1938                                        } else if (pCoexDm->curPsTdma == 14) {
1939                                                halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 15);
1940                                                pCoexDm->psTdmaDuAdjType = 15;
1941                                        } else if (pCoexDm->curPsTdma == 15) {
1942                                                halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 16);
1943                                                pCoexDm->psTdmaDuAdjType = 16;
1944                                        }
1945                                } else if (result == 1) {
1946                                        if (pCoexDm->curPsTdma == 8) {
1947                                                halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 7);
1948                                                pCoexDm->psTdmaDuAdjType = 7;
1949                                        } else if (pCoexDm->curPsTdma == 7) {
1950                                                halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 6);
1951                                                pCoexDm->psTdmaDuAdjType = 6;
1952                                        } else if (pCoexDm->curPsTdma == 6) {
1953                                                halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 6);
1954                                                pCoexDm->psTdmaDuAdjType = 6;
1955                                        } else if (pCoexDm->curPsTdma == 16) {
1956                                                halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 15);
1957                                                pCoexDm->psTdmaDuAdjType = 15;
1958                                        } else if (pCoexDm->curPsTdma == 15) {
1959                                                halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 14);
1960                                                pCoexDm->psTdmaDuAdjType = 14;
1961                                        } else if (pCoexDm->curPsTdma == 14) {
1962                                                halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 14);
1963                                                pCoexDm->psTdmaDuAdjType = 14;
1964                                        }
1965                                }
1966                        } else {
1967                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL, ("[BTCoex], TxPause = 0\n"));
1968                                if (pCoexDm->curPsTdma == 5) {
1969                                        halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 2);
1970                                        pCoexDm->psTdmaDuAdjType = 2;
1971                                } else if (pCoexDm->curPsTdma == 6) {
1972                                        halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 2);
1973                                        pCoexDm->psTdmaDuAdjType = 2;
1974                                } else if (pCoexDm->curPsTdma == 7) {
1975                                        halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 3);
1976                                        pCoexDm->psTdmaDuAdjType = 3;
1977                                } else if (pCoexDm->curPsTdma == 8) {
1978                                        halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 4);
1979                                        pCoexDm->psTdmaDuAdjType = 4;
1980                                }
1981
1982                                if (pCoexDm->curPsTdma == 13) {
1983                                        halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 10);
1984                                        pCoexDm->psTdmaDuAdjType = 10;
1985                                } else if (pCoexDm->curPsTdma == 14) {
1986                                        halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 10);
1987                                        pCoexDm->psTdmaDuAdjType = 10;
1988                                } else if (pCoexDm->curPsTdma == 15) {
1989                                        halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 11);
1990                                        pCoexDm->psTdmaDuAdjType = 11;
1991                                } else if (pCoexDm->curPsTdma == 16) {
1992                                        halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 12);
1993                                        pCoexDm->psTdmaDuAdjType = 12;
1994                                }
1995
1996                                if (result == -1) {
1997                                        if (pCoexDm->curPsTdma == 1) {
1998                                                halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 2);
1999                                                pCoexDm->psTdmaDuAdjType = 2;
2000                                        } else if (pCoexDm->curPsTdma == 2) {

2001                                                halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 3);
2002                                                pCoexDm->psTdmaDuAdjType = 3;
2003                                        } else if (pCoexDm->curPsTdma == 3) {
2004                                                halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 4);
2005                                                pCoexDm->psTdmaDuAdjType = 4;
2006                                        } else if (pCoexDm->curPsTdma == 9) {
2007                                                halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 10);
2008                                                pCoexDm->psTdmaDuAdjType = 10;
2009                                        } else if (pCoexDm->curPsTdma == 10) {
2010                                                halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 11);
2011                                                pCoexDm->psTdmaDuAdjType = 11;
2012                                        } else if (pCoexDm->curPsTdma == 11) {
2013                                                halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 12);
2014                                                pCoexDm->psTdmaDuAdjType = 12;
2015                                        }
2016                                } else if (result == 1) {
2017                                        if (pCoexDm->curPsTdma == 4) {
2018                                                halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 3);
2019                                                pCoexDm->psTdmaDuAdjType = 3;
2020                                        } else if (pCoexDm->curPsTdma == 3) {
2021                                                halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 2);
2022                                                pCoexDm->psTdmaDuAdjType = 2;
2023                                        } else if (pCoexDm->curPsTdma == 2) {
2024                                                halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 2);
2025                                                pCoexDm->psTdmaDuAdjType = 2;
2026                                        } else if (pCoexDm->curPsTdma == 12) {
2027                                                halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 11);
2028                                                pCoexDm->psTdmaDuAdjType = 11;
2029                                        } else if (pCoexDm->curPsTdma == 11) {
2030                                                halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 10);
2031                                                pCoexDm->psTdmaDuAdjType = 10;
2032                                        } else if (pCoexDm->curPsTdma == 10) {
2033                                                halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 10);
2034                                                pCoexDm->psTdmaDuAdjType = 10;
2035                                        }
2036                                }
2037                        }
2038                } else if (maxInterval == 3) {
2039                        if (bTxPause) {
2040                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL, ("[BTCoex], TxPause = 1\n"));
2041                                if (pCoexDm->curPsTdma == 1) {
2042                                        halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 7);
2043                                        pCoexDm->psTdmaDuAdjType = 7;
2044                                } else if (pCoexDm->curPsTdma == 2) {
2045                                        halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 7);
2046                                        pCoexDm->psTdmaDuAdjType = 7;
2047                                } else if (pCoexDm->curPsTdma == 3) {
2048                                        halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 7);
2049                                        pCoexDm->psTdmaDuAdjType = 7;
2050                                } else if (pCoexDm->curPsTdma == 4) {
2051                                        halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 8);
2052                                        pCoexDm->psTdmaDuAdjType = 8;
2053                                }
2054
2055                                if (pCoexDm->curPsTdma == 9) {
2056                                        halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 15);
2057                                        pCoexDm->psTdmaDuAdjType = 15;
2058                                } else if (pCoexDm->curPsTdma == 10) {
2059                                        halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 15);
2060                                        pCoexDm->psTdmaDuAdjType = 15;
2061                                } else if (pCoexDm->curPsTdma == 11) {
2062                                        halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 15);
2063                                        pCoexDm->psTdmaDuAdjType = 15;
2064                                } else if (pCoexDm->curPsTdma == 12) {
2065                                        halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 16);
2066                                        pCoexDm->psTdmaDuAdjType = 16;
2067                                }
2068
2069                                if (result == -1) {
2070                                        if (pCoexDm->curPsTdma == 5) {
2071                                                halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 7);
2072                                                pCoexDm->psTdmaDuAdjType = 7;
2073                                        } else if (pCoexDm->curPsTdma == 6) {
2074                                                halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 7);
2075                                                pCoexDm->psTdmaDuAdjType = 7;
2076                                        } else if (pCoexDm->curPsTdma == 7) {
2077                                                halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 8);
2078                                                pCoexDm->psTdmaDuAdjType = 8;
2079                                        } else if (pCoexDm->curPsTdma == 13) {
2080                                                halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 15);
2081                                                pCoexDm->psTdmaDuAdjType = 15;
2082                                        } else if (pCoexDm->curPsTdma == 14) {
2083                                                halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 15);
2084                                                pCoexDm->psTdmaDuAdjType = 15;
2085                                        } else if (pCoexDm->curPsTdma == 15) {
2086                                                halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 16);
2087                                                pCoexDm->psTdmaDuAdjType = 16;
2088                                        }
2089                                } else if (result == 1) {
2090                                        if (pCoexDm->curPsTdma == 8) {
2091                                                halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 7);
2092                                                pCoexDm->psTdmaDuAdjType = 7;
2093                                        } else if (pCoexDm->curPsTdma == 7) {
2094                                                halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 7);
2095                                                pCoexDm->psTdmaDuAdjType = 7;
2096                                        } else if (pCoexDm->curPsTdma == 6) {
2097                                                halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 7);
2098                                                pCoexDm->psTdmaDuAdjType = 7;
2099                                        } else if (pCoexDm->curPsTdma == 16) {
2100                                                halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 15);
2101                                                pCoexDm->psTdmaDuAdjType = 15;
2102                                        } else if (pCoexDm->curPsTdma == 15) {
2103                                                halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 15);
2104                                                pCoexDm->psTdmaDuAdjType = 15;
2105                                        } else if (pCoexDm->curPsTdma == 14) {
2106                                                halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 15);
2107                                                pCoexDm->psTdmaDuAdjType = 15;
2108                                        }
2109                                }
2110                        } else {
2111                                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL, ("[BTCoex], TxPause = 0\n"));
2112                                if (pCoexDm->curPsTdma == 5) {
2113                                        halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 3);
2114                                        pCoexDm->psTdmaDuAdjType = 3;
2115                                } else if (pCoexDm->curPsTdma == 6) {
2116                                        halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 3);
2117                                        pCoexDm->psTdmaDuAdjType = 3;
2118                                } else if (pCoexDm->curPsTdma == 7) {
2119                                        halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 3);
2120                                        pCoexDm->psTdmaDuAdjType = 3;
2121                                } else if (pCoexDm->curPsTdma == 8) {
2122                                        halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 4);
2123                                        pCoexDm->psTdmaDuAdjType = 4;
2124                                }
2125
2126                                if (pCoexDm->curPsTdma == 13) {
2127                                        halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 11);
2128                                        pCoexDm->psTdmaDuAdjType = 11;
2129                                } else if (pCoexDm->curPsTdma == 14) {
2130                                        halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 11);
2131                                        pCoexDm->psTdmaDuAdjType = 11;
2132                                } else if (pCoexDm->curPsTdma == 15) {
2133                                        halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 11);
2134                                        pCoexDm->psTdmaDuAdjType = 11;
2135                                } else if (pCoexDm->curPsTdma == 16) {
2136                                        halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 12);
2137                                        pCoexDm->psTdmaDuAdjType = 12;
2138                                }
2139
2140                                if (result == -1) {
2141                                        if (pCoexDm->curPsTdma == 1) {
2142                                                halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 3);
2143                                                pCoexDm->psTdmaDuAdjType = 3;
2144                                        } else if (pCoexDm->curPsTdma == 2) {
2145                                                halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 3);
2146                                                pCoexDm->psTdmaDuAdjType = 3;
2147                                        } else if (pCoexDm->curPsTdma == 3) {
2148                                                halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 4);
2149                                                pCoexDm->psTdmaDuAdjType = 4;
2150                                        } else if (pCoexDm->curPsTdma == 9) {
2151                                                halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 11);
2152                                                pCoexDm->psTdmaDuAdjType = 11;
2153                                        } else if (pCoexDm->curPsTdma == 10) {
2154                                                halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 11);
2155                                                pCoexDm->psTdmaDuAdjType = 11;
2156                                        } else if (pCoexDm->curPsTdma == 11) {
2157                                                halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 12);
2158                                                pCoexDm->psTdmaDuAdjType = 12;
2159                                        }
2160                                } else if (result == 1) {
2161                                        if (pCoexDm->curPsTdma == 4) {
2162                                                halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 3);
2163                                                pCoexDm->psTdmaDuAdjType = 3;
2164                                        } else if (pCoexDm->curPsTdma == 3) {
2165                                                halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 3);
2166                                                pCoexDm->psTdmaDuAdjType = 3;
2167                                        } else if (pCoexDm->curPsTdma == 2) {
2168                                                halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 3);
2169                                                pCoexDm->psTdmaDuAdjType = 3;
2170                                        } else if (pCoexDm->curPsTdma == 12) {
2171                                                halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 11);
2172                                                pCoexDm->psTdmaDuAdjType = 11;
2173                                        } else if (pCoexDm->curPsTdma == 11) {
2174                                                halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 11);
2175                                                pCoexDm->psTdmaDuAdjType = 11;
2176                                        } else if (pCoexDm->curPsTdma == 10) {
2177                                                halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 11);
2178                                                pCoexDm->psTdmaDuAdjType = 11;
2179                                        }
2180                                }
2181                        }
2182                }
2183        }
2184
2185        /*  if current PsTdma not match with the recorded one (when scan, dhcp...), */
2186        /*  then we have to adjust it back to the previous record one. */
2187        if (pCoexDm->curPsTdma != pCoexDm->psTdmaDuAdjType) {
2188                bool bScan = false, bLink = false, bRoam = false;
2189                BTC_PRINT(
2190                        BTC_MSG_ALGORITHM,
2191                        ALGO_TRACE_FW_DETAIL,
2192                        (
2193                                "[BTCoex], PsTdma type mismatch!!!, curPsTdma =%d, recordPsTdma =%d\n",
2194                                pCoexDm->curPsTdma,
2195                                pCoexDm->psTdmaDuAdjType
2196                        )
2197                );
2198
2199                pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_WIFI_SCAN, &bScan);
2200                pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_WIFI_LINK, &bLink);
2201                pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_WIFI_ROAM, &bRoam);
2202
2203                if (!bScan && !bLink && !bRoam)
2204                        halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, pCoexDm->psTdmaDuAdjType);
2205                else {
2206                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL, ("[BTCoex], roaming/link/scan is under progress, will adjust next time!!!\n"));
2207                }
2208        }
2209}
2210
2211/*  SCO only or SCO+PAN(HS) */
2212static void halbtc8723b2ant_ActionSco(PBTC_COEXIST pBtCoexist)
2213{
2214        u8 wifiRssiState, btRssiState;
2215        u32 wifiBw;
2216
2217        wifiRssiState = halbtc8723b2ant_WifiRssiState(pBtCoexist, 0, 2, 15, 0);
2218        btRssiState = halbtc8723b2ant_BtRssiState(2, 29, 0);
2219
2220        pBtCoexist->fBtcSetRfReg(pBtCoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
2221
2222        halbtc8723b2ant_LimitedRx(pBtCoexist, NORMAL_EXEC, false, false, 0x8);
2223
2224        halbtc8723b2ant_FwDacSwingLvl(pBtCoexist, NORMAL_EXEC, 4);
2225
2226        if (BTC_RSSI_HIGH(btRssiState))
2227                halbtc8723b2ant_DecBtPwr(pBtCoexist, NORMAL_EXEC, 2);
2228        else
2229                halbtc8723b2ant_DecBtPwr(pBtCoexist, NORMAL_EXEC, 0);
2230
2231        pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_U4_WIFI_BW, &wifiBw);
2232
2233        if (BTC_WIFI_BW_LEGACY == wifiBw) /* for SCO quality at 11b/g mode */
2234                halbtc8723b2ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 2);
2235        else  /* for SCO quality & wifi performance balance at 11n mode */
2236                halbtc8723b2ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 8);
2237
2238        halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, false, 0); /* for voice quality */
2239
2240        /*  sw mechanism */
2241        if (BTC_WIFI_BW_HT40 == wifiBw) {
2242                if (
2243                        (wifiRssiState == BTC_RSSI_STATE_HIGH) ||
2244                        (wifiRssiState == BTC_RSSI_STATE_STAY_HIGH)
2245                ) {
2246                        halbtc8723b2ant_SwMechanism1(pBtCoexist, true, true, false, false);
2247                        halbtc8723b2ant_SwMechanism2(pBtCoexist, true, false, true, 0x4);
2248                } else {
2249                        halbtc8723b2ant_SwMechanism1(pBtCoexist, true, true, false, false);
2250                        halbtc8723b2ant_SwMechanism2(pBtCoexist, false, false, true, 0x4);
2251                }
2252        } else {
2253                if (
2254                        (wifiRssiState == BTC_RSSI_STATE_HIGH) ||
2255                        (wifiRssiState == BTC_RSSI_STATE_STAY_HIGH)
2256                ) {
2257                        halbtc8723b2ant_SwMechanism1(pBtCoexist, false, true, false, false);
2258                        halbtc8723b2ant_SwMechanism2(pBtCoexist, true, false, true, 0x4);
2259                } else {
2260                        halbtc8723b2ant_SwMechanism1(pBtCoexist, false, true, false, false);
2261                        halbtc8723b2ant_SwMechanism2(pBtCoexist, false, false, true, 0x4);
2262                }
2263        }
2264}
2265
2266
2267static void halbtc8723b2ant_ActionHid(PBTC_COEXIST pBtCoexist)
2268{
2269        u8 wifiRssiState, btRssiState;
2270        u32 wifiBw;
2271
2272        wifiRssiState = halbtc8723b2ant_WifiRssiState(pBtCoexist, 0, 2, 15, 0);
2273        btRssiState = halbtc8723b2ant_BtRssiState(2, 29, 0);
2274
2275        pBtCoexist->fBtcSetRfReg(pBtCoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
2276
2277        halbtc8723b2ant_LimitedRx(pBtCoexist, NORMAL_EXEC, false, false, 0x8);
2278
2279        halbtc8723b2ant_FwDacSwingLvl(pBtCoexist, NORMAL_EXEC, 6);
2280
2281        if (BTC_RSSI_HIGH(btRssiState))
2282                halbtc8723b2ant_DecBtPwr(pBtCoexist, NORMAL_EXEC, 2);
2283        else
2284                halbtc8723b2ant_DecBtPwr(pBtCoexist, NORMAL_EXEC, 0);
2285
2286        pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_U4_WIFI_BW, &wifiBw);
2287
2288        if (BTC_WIFI_BW_LEGACY == wifiBw) /* for HID at 11b/g mode */
2289                halbtc8723b2ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 7);
2290        else  /* for HID quality & wifi performance balance at 11n mode */
2291                halbtc8723b2ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 9);
2292
2293        if (
2294                (btRssiState == BTC_RSSI_STATE_HIGH) ||
2295                (btRssiState == BTC_RSSI_STATE_STAY_HIGH)
2296        )
2297                halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 9);
2298        else
2299                halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 13);
2300
2301        /*  sw mechanism */
2302        if (BTC_WIFI_BW_HT40 == wifiBw) {
2303                if (
2304                        (wifiRssiState == BTC_RSSI_STATE_HIGH) ||
2305                        (wifiRssiState == BTC_RSSI_STATE_STAY_HIGH)
2306                ) {
2307                        halbtc8723b2ant_SwMechanism1(pBtCoexist, true, true, false, false);
2308                        halbtc8723b2ant_SwMechanism2(pBtCoexist, true, false, false, 0x18);
2309                } else {
2310                        halbtc8723b2ant_SwMechanism1(pBtCoexist, true, true, false, false);
2311                        halbtc8723b2ant_SwMechanism2(pBtCoexist, false, false, false, 0x18);
2312                }
2313        } else {
2314                if (
2315                        (wifiRssiState == BTC_RSSI_STATE_HIGH) ||
2316                        (wifiRssiState == BTC_RSSI_STATE_STAY_HIGH)
2317                ) {
2318                        halbtc8723b2ant_SwMechanism1(pBtCoexist, false, true, false, false);
2319                        halbtc8723b2ant_SwMechanism2(pBtCoexist, true, false, false, 0x18);
2320                } else {
2321                        halbtc8723b2ant_SwMechanism1(pBtCoexist, false, true, false, false);
2322                        halbtc8723b2ant_SwMechanism2(pBtCoexist, false, false, false, 0x18);
2323                }
2324        }
2325}
2326
2327/* A2DP only / PAN(EDR) only/ A2DP+PAN(HS) */
2328static void halbtc8723b2ant_ActionA2dp(PBTC_COEXIST pBtCoexist)
2329{
2330        u8 wifiRssiState, wifiRssiState1, btRssiState;
2331        u32 wifiBw;
2332        u8 apNum = 0;
2333
2334        wifiRssiState = halbtc8723b2ant_WifiRssiState(pBtCoexist, 0, 2, 15, 0);
2335        wifiRssiState1 = halbtc8723b2ant_WifiRssiState(pBtCoexist, 1, 2, 40, 0);
2336        btRssiState = halbtc8723b2ant_BtRssiState(2, 29, 0);
2337
2338        pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_U1_AP_NUM, &apNum);
2339
2340        /*  define the office environment */
2341        if (apNum >= 10 && BTC_RSSI_HIGH(wifiRssiState1)) {
2342                /* DbgPrint(" AP#>10(%d)\n", apNum); */
2343                pBtCoexist->fBtcSetRfReg(pBtCoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
2344                halbtc8723b2ant_LimitedRx(pBtCoexist, NORMAL_EXEC, false, false, 0x8);
2345                halbtc8723b2ant_FwDacSwingLvl(pBtCoexist, NORMAL_EXEC, 6);
2346                halbtc8723b2ant_DecBtPwr(pBtCoexist, NORMAL_EXEC, 0);
2347                halbtc8723b2ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 0);
2348                halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, false, 1);
2349
2350                /*  sw mechanism */
2351                pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_U4_WIFI_BW, &wifiBw);
2352                if (BTC_WIFI_BW_HT40 == wifiBw) {
2353                        halbtc8723b2ant_SwMechanism1(pBtCoexist, true, false, false, false);
2354                        halbtc8723b2ant_SwMechanism2(pBtCoexist, true, false, true, 0x18);
2355                } else {
2356                        halbtc8723b2ant_SwMechanism1(pBtCoexist, false, false, false, false);
2357                        halbtc8723b2ant_SwMechanism2(pBtCoexist, true, false, true, 0x18);
2358                }
2359                return;
2360        }
2361
2362        pBtCoexist->fBtcSetRfReg(pBtCoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
2363        halbtc8723b2ant_LimitedRx(pBtCoexist, NORMAL_EXEC, false, false, 0x8);
2364
2365        halbtc8723b2ant_FwDacSwingLvl(pBtCoexist, NORMAL_EXEC, 6);
2366
2367        if (BTC_RSSI_HIGH(btRssiState))
2368                halbtc8723b2ant_DecBtPwr(pBtCoexist, NORMAL_EXEC, 2);
2369        else
2370                halbtc8723b2ant_DecBtPwr(pBtCoexist, NORMAL_EXEC, 0);
2371
2372        halbtc8723b2ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 7);
2373
2374        if (
2375                (btRssiState == BTC_RSSI_STATE_HIGH) ||
2376                (btRssiState == BTC_RSSI_STATE_STAY_HIGH)
2377        )
2378                halbtc8723b2ant_TdmaDurationAdjust(pBtCoexist, false, false, 1);
2379        else
2380                halbtc8723b2ant_TdmaDurationAdjust(pBtCoexist, false, true, 1);
2381
2382        /*  sw mechanism */
2383        pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_U4_WIFI_BW, &wifiBw);
2384        if (BTC_WIFI_BW_HT40 == wifiBw) {
2385                if (
2386                        (wifiRssiState == BTC_RSSI_STATE_HIGH) ||
2387                        (wifiRssiState == BTC_RSSI_STATE_STAY_HIGH)
2388                ) {
2389                        halbtc8723b2ant_SwMechanism1(pBtCoexist, true, false, false, false);
2390                        halbtc8723b2ant_SwMechanism2(pBtCoexist, true, false, false, 0x18);
2391                } else {
2392                        halbtc8723b2ant_SwMechanism1(pBtCoexist, true, false, false, false);
2393                        halbtc8723b2ant_SwMechanism2(pBtCoexist, false, false, false, 0x18);
2394                }
2395        } else {
2396                if (
2397                        (wifiRssiState == BTC_RSSI_STATE_HIGH) ||
2398                        (wifiRssiState == BTC_RSSI_STATE_STAY_HIGH)
2399                ) {
2400                        halbtc8723b2ant_SwMechanism1(pBtCoexist, false, false, false, false);
2401                        halbtc8723b2ant_SwMechanism2(pBtCoexist, true, false, false, 0x18);
2402                } else {
2403                        halbtc8723b2ant_SwMechanism1(pBtCoexist, false, false, false, false);
2404                        halbtc8723b2ant_SwMechanism2(pBtCoexist, false, false, false, 0x18);
2405                }
2406        }
2407}
2408
2409static void halbtc8723b2ant_ActionA2dpPanHs(PBTC_COEXIST pBtCoexist)
2410{
2411        u8 wifiRssiState, btRssiState;
2412        u32 wifiBw;
2413
2414        wifiRssiState = halbtc8723b2ant_WifiRssiState(pBtCoexist, 0, 2, 15, 0);
2415        btRssiState = halbtc8723b2ant_BtRssiState(2, 29, 0);
2416
2417        pBtCoexist->fBtcSetRfReg(pBtCoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
2418
2419        halbtc8723b2ant_LimitedRx(pBtCoexist, NORMAL_EXEC, false, false, 0x8);
2420
2421        halbtc8723b2ant_FwDacSwingLvl(pBtCoexist, NORMAL_EXEC, 6);
2422
2423        if (BTC_RSSI_HIGH(btRssiState))
2424                halbtc8723b2ant_DecBtPwr(pBtCoexist, NORMAL_EXEC, 2);
2425        else
2426                halbtc8723b2ant_DecBtPwr(pBtCoexist, NORMAL_EXEC, 0);
2427
2428        halbtc8723b2ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 7);
2429
2430        halbtc8723b2ant_TdmaDurationAdjust(pBtCoexist, false, true, 2);
2431
2432        /*  sw mechanism */
2433        pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_U4_WIFI_BW, &wifiBw);
2434        if (BTC_WIFI_BW_HT40 == wifiBw) {
2435                if (
2436                        (wifiRssiState == BTC_RSSI_STATE_HIGH) ||
2437                        (wifiRssiState == BTC_RSSI_STATE_STAY_HIGH)
2438                ) {
2439                        halbtc8723b2ant_SwMechanism1(pBtCoexist, true, false, false, false);
2440                        halbtc8723b2ant_SwMechanism2(pBtCoexist, true, false, false, 0x18);
2441                } else {
2442                        halbtc8723b2ant_SwMechanism1(pBtCoexist, true, false, false, false);
2443                        halbtc8723b2ant_SwMechanism2(pBtCoexist, false, false, false, 0x18);
2444                }
2445        } else {
2446                if (
2447                        (wifiRssiState == BTC_RSSI_STATE_HIGH) ||
2448                        (wifiRssiState == BTC_RSSI_STATE_STAY_HIGH)
2449                ) {
2450                        halbtc8723b2ant_SwMechanism1(pBtCoexist, false, false, false, false);
2451                        halbtc8723b2ant_SwMechanism2(pBtCoexist, true, false, false, 0x18);
2452                } else {
2453                        halbtc8723b2ant_SwMechanism1(pBtCoexist, false, false, false, false);
2454                        halbtc8723b2ant_SwMechanism2(pBtCoexist, false, false, false, 0x18);
2455                }
2456        }
2457}
2458
2459static void halbtc8723b2ant_ActionPanEdr(PBTC_COEXIST pBtCoexist)
2460{
2461        u8 wifiRssiState, btRssiState;
2462        u32 wifiBw;
2463
2464        wifiRssiState = halbtc8723b2ant_WifiRssiState(pBtCoexist, 0, 2, 15, 0);
2465        btRssiState = halbtc8723b2ant_BtRssiState(2, 29, 0);
2466
2467        pBtCoexist->fBtcSetRfReg(pBtCoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
2468
2469        halbtc8723b2ant_LimitedRx(pBtCoexist, NORMAL_EXEC, false, false, 0x8);
2470
2471        halbtc8723b2ant_FwDacSwingLvl(pBtCoexist, NORMAL_EXEC, 6);
2472
2473        if (BTC_RSSI_HIGH(btRssiState))
2474                halbtc8723b2ant_DecBtPwr(pBtCoexist, NORMAL_EXEC, 2);
2475        else
2476                halbtc8723b2ant_DecBtPwr(pBtCoexist, NORMAL_EXEC, 0);
2477
2478        halbtc8723b2ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 10);
2479
2480        if (
2481                (btRssiState == BTC_RSSI_STATE_HIGH) ||
2482                (btRssiState == BTC_RSSI_STATE_STAY_HIGH)
2483        )
2484                halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 1);
2485        else
2486                halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 5);
2487
2488        /*  sw mechanism */
2489        pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_U4_WIFI_BW, &wifiBw);
2490        if (BTC_WIFI_BW_HT40 == wifiBw) {
2491                if (
2492                        (wifiRssiState == BTC_RSSI_STATE_HIGH) ||
2493                        (wifiRssiState == BTC_RSSI_STATE_STAY_HIGH)
2494                ) {
2495                        halbtc8723b2ant_SwMechanism1(pBtCoexist, true, false, false, false);
2496                        halbtc8723b2ant_SwMechanism2(pBtCoexist, true, false, false, 0x18);
2497                } else {
2498                        halbtc8723b2ant_SwMechanism1(pBtCoexist, true, false, false, false);
2499                        halbtc8723b2ant_SwMechanism2(pBtCoexist, false, false, false, 0x18);
2500                }
2501        } else {
2502                if (
2503                        (wifiRssiState == BTC_RSSI_STATE_HIGH) ||
2504                        (wifiRssiState == BTC_RSSI_STATE_STAY_HIGH)
2505                ) {
2506                        halbtc8723b2ant_SwMechanism1(pBtCoexist, false, false, false, false);
2507                        halbtc8723b2ant_SwMechanism2(pBtCoexist, true, false, false, 0x18);
2508                } else {
2509                        halbtc8723b2ant_SwMechanism1(pBtCoexist, false, false, false, false);
2510                        halbtc8723b2ant_SwMechanism2(pBtCoexist, false, false, false, 0x18);
2511                }
2512        }
2513}
2514
2515
2516/* PAN(HS) only */
2517static void halbtc8723b2ant_ActionPanHs(PBTC_COEXIST pBtCoexist)
2518{
2519        u8 wifiRssiState, btRssiState;
2520        u32 wifiBw;
2521
2522        wifiRssiState = halbtc8723b2ant_WifiRssiState(pBtCoexist, 0, 2, 15, 0);
2523        btRssiState = halbtc8723b2ant_BtRssiState(2, 29, 0);
2524
2525        pBtCoexist->fBtcSetRfReg(pBtCoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
2526
2527        halbtc8723b2ant_LimitedRx(pBtCoexist, NORMAL_EXEC, false, false, 0x8);
2528
2529        halbtc8723b2ant_FwDacSwingLvl(pBtCoexist, NORMAL_EXEC, 6);
2530
2531        if (BTC_RSSI_HIGH(btRssiState))
2532                halbtc8723b2ant_DecBtPwr(pBtCoexist, NORMAL_EXEC, 2);
2533        else
2534                halbtc8723b2ant_DecBtPwr(pBtCoexist, NORMAL_EXEC, 0);
2535
2536        halbtc8723b2ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 7);
2537
2538        halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, false, 1);
2539
2540        pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_U4_WIFI_BW, &wifiBw);
2541        if (BTC_WIFI_BW_HT40 == wifiBw) {
2542                if (
2543                        (wifiRssiState == BTC_RSSI_STATE_HIGH) ||
2544                        (wifiRssiState == BTC_RSSI_STATE_STAY_HIGH)
2545                ) {
2546                        halbtc8723b2ant_SwMechanism1(pBtCoexist, true, false, false, false);
2547                        halbtc8723b2ant_SwMechanism2(pBtCoexist, true, false, false, 0x18);
2548                } else {
2549                        halbtc8723b2ant_SwMechanism1(pBtCoexist, true, false, false, false);
2550                        halbtc8723b2ant_SwMechanism2(pBtCoexist, false, false, false, 0x18);
2551                }
2552        } else {
2553                if (
2554                        (wifiRssiState == BTC_RSSI_STATE_HIGH) ||
2555                        (wifiRssiState == BTC_RSSI_STATE_STAY_HIGH)
2556                ) {
2557                        halbtc8723b2ant_SwMechanism1(pBtCoexist, false, false, false, false);
2558                        halbtc8723b2ant_SwMechanism2(pBtCoexist, true, false, false, 0x18);
2559                } else {
2560                        halbtc8723b2ant_SwMechanism1(pBtCoexist, false, false, false, false);
2561                        halbtc8723b2ant_SwMechanism2(pBtCoexist, false, false, false, 0x18);
2562                }
2563        }
2564}
2565
2566/* PAN(EDR)+A2DP */
2567static void halbtc8723b2ant_ActionPanEdrA2dp(PBTC_COEXIST pBtCoexist)
2568{
2569        u8 wifiRssiState, btRssiState;
2570        u32 wifiBw;
2571
2572        wifiRssiState = halbtc8723b2ant_WifiRssiState(pBtCoexist, 0, 2, 15, 0);
2573        btRssiState = halbtc8723b2ant_BtRssiState(2, 29, 0);
2574
2575        pBtCoexist->fBtcSetRfReg(pBtCoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
2576
2577        halbtc8723b2ant_LimitedRx(pBtCoexist, NORMAL_EXEC, false, false, 0x8);
2578
2579        halbtc8723b2ant_FwDacSwingLvl(pBtCoexist, NORMAL_EXEC, 6);
2580
2581        if (BTC_RSSI_HIGH(btRssiState))
2582                halbtc8723b2ant_DecBtPwr(pBtCoexist, NORMAL_EXEC, 2);
2583        else
2584                halbtc8723b2ant_DecBtPwr(pBtCoexist, NORMAL_EXEC, 0);
2585
2586        pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_U4_WIFI_BW, &wifiBw);
2587
2588        if (
2589                (btRssiState == BTC_RSSI_STATE_HIGH) ||
2590                (btRssiState == BTC_RSSI_STATE_STAY_HIGH)
2591        ) {
2592                halbtc8723b2ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 12);
2593                if (BTC_WIFI_BW_HT40 == wifiBw)
2594                        halbtc8723b2ant_TdmaDurationAdjust(pBtCoexist, false, true, 3);
2595                else
2596                        halbtc8723b2ant_TdmaDurationAdjust(pBtCoexist, false, false, 3);
2597        } else {
2598                halbtc8723b2ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 7);
2599                halbtc8723b2ant_TdmaDurationAdjust(pBtCoexist, false, true, 3);
2600        }
2601
2602        /*  sw mechanism */
2603        if (BTC_WIFI_BW_HT40 == wifiBw) {
2604                if (
2605                        (wifiRssiState == BTC_RSSI_STATE_HIGH) ||
2606                        (wifiRssiState == BTC_RSSI_STATE_STAY_HIGH)
2607                ) {
2608                        halbtc8723b2ant_SwMechanism1(pBtCoexist, true, false, false, false);
2609                        halbtc8723b2ant_SwMechanism2(pBtCoexist, true, false, false, 0x18);
2610                } else {
2611                        halbtc8723b2ant_SwMechanism1(pBtCoexist, true, false, false, false);
2612                        halbtc8723b2ant_SwMechanism2(pBtCoexist, false, false, false, 0x18);
2613                }
2614        } else {
2615                if (
2616                        (wifiRssiState == BTC_RSSI_STATE_HIGH) ||
2617                        (wifiRssiState == BTC_RSSI_STATE_STAY_HIGH)
2618                ) {
2619                        halbtc8723b2ant_SwMechanism1(pBtCoexist, false, false, false, false);
2620                        halbtc8723b2ant_SwMechanism2(pBtCoexist, true, false, false, 0x18);
2621                } else {
2622                        halbtc8723b2ant_SwMechanism1(pBtCoexist, false, false, false, false);
2623                        halbtc8723b2ant_SwMechanism2(pBtCoexist, false, false, false, 0x18);
2624                }
2625        }
2626}
2627
2628static void halbtc8723b2ant_ActionPanEdrHid(PBTC_COEXIST pBtCoexist)
2629{
2630        u8 wifiRssiState, btRssiState;
2631        u32 wifiBw;
2632
2633        wifiRssiState = halbtc8723b2ant_WifiRssiState(pBtCoexist, 0, 2, 15, 0);
2634        btRssiState = halbtc8723b2ant_BtRssiState(2, 29, 0);
2635        pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_U4_WIFI_BW, &wifiBw);
2636
2637        halbtc8723b2ant_LimitedRx(pBtCoexist, NORMAL_EXEC, false, false, 0x8);
2638
2639        if (BTC_RSSI_HIGH(btRssiState))
2640                halbtc8723b2ant_DecBtPwr(pBtCoexist, NORMAL_EXEC, 2);
2641        else
2642                halbtc8723b2ant_DecBtPwr(pBtCoexist, NORMAL_EXEC, 0);
2643
2644        if (
2645                (btRssiState == BTC_RSSI_STATE_HIGH) ||
2646                (btRssiState == BTC_RSSI_STATE_STAY_HIGH)
2647        ) {
2648                if (BTC_WIFI_BW_HT40 == wifiBw) {
2649                        halbtc8723b2ant_FwDacSwingLvl(pBtCoexist, NORMAL_EXEC, 3);
2650                        halbtc8723b2ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 11);
2651                        pBtCoexist->fBtcSetRfReg(pBtCoexist, BTC_RF_A, 0x1, 0xfffff, 0x780);
2652                } else {
2653                        halbtc8723b2ant_FwDacSwingLvl(pBtCoexist, NORMAL_EXEC, 6);
2654                        halbtc8723b2ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 7);
2655                        pBtCoexist->fBtcSetRfReg(pBtCoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
2656                }
2657                halbtc8723b2ant_TdmaDurationAdjust(pBtCoexist, true, false, 2);
2658        } else {
2659                halbtc8723b2ant_FwDacSwingLvl(pBtCoexist, NORMAL_EXEC, 6);
2660                halbtc8723b2ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 11);
2661                pBtCoexist->fBtcSetRfReg(pBtCoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
2662                halbtc8723b2ant_TdmaDurationAdjust(pBtCoexist, true, true, 2);
2663        }
2664
2665        /*  sw mechanism */
2666        if (BTC_WIFI_BW_HT40 == wifiBw) {
2667                if (
2668                        (wifiRssiState == BTC_RSSI_STATE_HIGH) ||
2669                        (wifiRssiState == BTC_RSSI_STATE_STAY_HIGH)
2670                ) {
2671                        halbtc8723b2ant_SwMechanism1(pBtCoexist, true, true, false, false);
2672                        halbtc8723b2ant_SwMechanism2(pBtCoexist, true, false, false, 0x18);
2673                } else {
2674                        halbtc8723b2ant_SwMechanism1(pBtCoexist, true, true, false, false);
2675                        halbtc8723b2ant_SwMechanism2(pBtCoexist, false, false, false, 0x18);
2676                }
2677        } else {
2678                if (
2679                        (wifiRssiState == BTC_RSSI_STATE_HIGH) ||
2680                        (wifiRssiState == BTC_RSSI_STATE_STAY_HIGH)
2681                ) {
2682                        halbtc8723b2ant_SwMechanism1(pBtCoexist, false, true, false, false);
2683                        halbtc8723b2ant_SwMechanism2(pBtCoexist, true, false, false, 0x18);
2684                } else {
2685                        halbtc8723b2ant_SwMechanism1(pBtCoexist, false, true, false, false);
2686                        halbtc8723b2ant_SwMechanism2(pBtCoexist, false, false, false, 0x18);
2687                }
2688        }
2689}
2690
2691/*  HID+A2DP+PAN(EDR) */
2692static void halbtc8723b2ant_ActionHidA2dpPanEdr(PBTC_COEXIST pBtCoexist)
2693{
2694        u8 wifiRssiState, btRssiState;
2695        u32 wifiBw;
2696
2697        wifiRssiState = halbtc8723b2ant_WifiRssiState(pBtCoexist, 0, 2, 15, 0);
2698        btRssiState = halbtc8723b2ant_BtRssiState(2, 29, 0);
2699
2700        pBtCoexist->fBtcSetRfReg(pBtCoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
2701
2702        halbtc8723b2ant_LimitedRx(pBtCoexist, NORMAL_EXEC, false, false, 0x8);
2703
2704        halbtc8723b2ant_FwDacSwingLvl(pBtCoexist, NORMAL_EXEC, 6);
2705
2706        if (BTC_RSSI_HIGH(btRssiState))
2707                halbtc8723b2ant_DecBtPwr(pBtCoexist, NORMAL_EXEC, 2);
2708        else
2709                halbtc8723b2ant_DecBtPwr(pBtCoexist, NORMAL_EXEC, 0);
2710
2711        pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_U4_WIFI_BW, &wifiBw);
2712
2713        halbtc8723b2ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 7);
2714
2715        if (
2716                (btRssiState == BTC_RSSI_STATE_HIGH) ||
2717                (btRssiState == BTC_RSSI_STATE_STAY_HIGH)
2718        ) {
2719                if (BTC_WIFI_BW_HT40 == wifiBw)
2720                        halbtc8723b2ant_TdmaDurationAdjust(pBtCoexist, true, true, 2);
2721                else
2722                        halbtc8723b2ant_TdmaDurationAdjust(pBtCoexist, true, false, 3);
2723        } else
2724                halbtc8723b2ant_TdmaDurationAdjust(pBtCoexist, true, true, 3);
2725
2726        /*  sw mechanism */
2727        if (BTC_WIFI_BW_HT40 == wifiBw) {
2728                if (
2729                        (wifiRssiState == BTC_RSSI_STATE_HIGH) ||
2730                        (wifiRssiState == BTC_RSSI_STATE_STAY_HIGH)
2731                ) {
2732                        halbtc8723b2ant_SwMechanism1(pBtCoexist, true, true, false, false);
2733                        halbtc8723b2ant_SwMechanism2(pBtCoexist, true, false, false, 0x18);
2734                } else {
2735                        halbtc8723b2ant_SwMechanism1(pBtCoexist, true, true, false, false);
2736                        halbtc8723b2ant_SwMechanism2(pBtCoexist, false, false, false, 0x18);
2737                }
2738        } else {
2739                if (
2740                        (wifiRssiState == BTC_RSSI_STATE_HIGH) ||
2741                        (wifiRssiState == BTC_RSSI_STATE_STAY_HIGH)
2742                ) {
2743                        halbtc8723b2ant_SwMechanism1(pBtCoexist, false, true, false, false);
2744                        halbtc8723b2ant_SwMechanism2(pBtCoexist, true, false, false, 0x18);
2745                } else {
2746                        halbtc8723b2ant_SwMechanism1(pBtCoexist, false, true, false, false);
2747                        halbtc8723b2ant_SwMechanism2(pBtCoexist, false, false, false, 0x18);
2748                }
2749        }
2750}
2751
2752static void halbtc8723b2ant_ActionHidA2dp(PBTC_COEXIST pBtCoexist)
2753{
2754        u8 wifiRssiState, btRssiState;
2755        u32 wifiBw;
2756        u8 apNum = 0;
2757
2758        wifiRssiState = halbtc8723b2ant_WifiRssiState(pBtCoexist, 0, 2, 15, 0);
2759        /* btRssiState = halbtc8723b2ant_BtRssiState(2, 29, 0); */
2760        btRssiState = halbtc8723b2ant_BtRssiState(3, 29, 37);
2761
2762        pBtCoexist->fBtcSetRfReg(pBtCoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
2763
2764        halbtc8723b2ant_LimitedRx(pBtCoexist, NORMAL_EXEC, false, true, 0x5);
2765
2766        halbtc8723b2ant_FwDacSwingLvl(pBtCoexist, NORMAL_EXEC, 6);
2767
2768        pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_U4_WIFI_BW, &wifiBw);
2769        if (BTC_WIFI_BW_LEGACY == wifiBw) {
2770                if (BTC_RSSI_HIGH(btRssiState))
2771                        halbtc8723b2ant_DecBtPwr(pBtCoexist, NORMAL_EXEC, 2);
2772                else if (BTC_RSSI_MEDIUM(btRssiState))
2773                        halbtc8723b2ant_DecBtPwr(pBtCoexist, NORMAL_EXEC, 2);
2774                else
2775                        halbtc8723b2ant_DecBtPwr(pBtCoexist, NORMAL_EXEC, 0);
2776        } else {
2777                /*  only 802.11N mode we have to dec bt power to 4 degree */
2778                if (BTC_RSSI_HIGH(btRssiState)) {
2779                        pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_U1_AP_NUM, &apNum);
2780                        /*  need to check ap Number of Not */
2781                        if (apNum < 10)
2782                                halbtc8723b2ant_DecBtPwr(pBtCoexist, NORMAL_EXEC, 4);
2783                        else
2784                                halbtc8723b2ant_DecBtPwr(pBtCoexist, NORMAL_EXEC, 2);
2785                } else if (BTC_RSSI_MEDIUM(btRssiState))
2786                        halbtc8723b2ant_DecBtPwr(pBtCoexist, NORMAL_EXEC, 2);
2787                else
2788                        halbtc8723b2ant_DecBtPwr(pBtCoexist, NORMAL_EXEC, 0);
2789        }
2790
2791        halbtc8723b2ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 7);
2792
2793        if (
2794                (btRssiState == BTC_RSSI_STATE_HIGH) ||
2795                (btRssiState == BTC_RSSI_STATE_STAY_HIGH)
2796        )
2797                halbtc8723b2ant_TdmaDurationAdjust(pBtCoexist, true, false, 2);
2798        else
2799                halbtc8723b2ant_TdmaDurationAdjust(pBtCoexist, true, true, 2);
2800
2801        /*  sw mechanism */
2802        if (BTC_WIFI_BW_HT40 == wifiBw) {
2803                if (
2804                        (wifiRssiState == BTC_RSSI_STATE_HIGH) ||
2805                        (wifiRssiState == BTC_RSSI_STATE_STAY_HIGH)
2806                ) {
2807                        halbtc8723b2ant_SwMechanism1(pBtCoexist, true, true, false, false);
2808                        halbtc8723b2ant_SwMechanism2(pBtCoexist, true, false, false, 0x18);
2809                } else {
2810                        halbtc8723b2ant_SwMechanism1(pBtCoexist, true, true, false, false);
2811                        halbtc8723b2ant_SwMechanism2(pBtCoexist, false, false, false, 0x18);
2812                }
2813        } else {
2814                if (
2815                        (wifiRssiState == BTC_RSSI_STATE_HIGH) ||
2816                        (wifiRssiState == BTC_RSSI_STATE_STAY_HIGH)
2817                ) {
2818                        halbtc8723b2ant_SwMechanism1(pBtCoexist, false, true, false, false);
2819                        halbtc8723b2ant_SwMechanism2(pBtCoexist, true, false, false, 0x18);
2820                } else {
2821                        halbtc8723b2ant_SwMechanism1(pBtCoexist, false, true, false, false);
2822                        halbtc8723b2ant_SwMechanism2(pBtCoexist, false, false, false, 0x18);
2823                }
2824        }
2825}
2826
2827static void halbtc8723b2ant_RunCoexistMechanism(PBTC_COEXIST pBtCoexist)
2828{
2829        u8 algorithm = 0;
2830
2831        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], RunCoexistMechanism() ===>\n"));
2832
2833        if (pBtCoexist->bManualControl) {
2834                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], RunCoexistMechanism(), return for Manual CTRL <===\n"));
2835                return;
2836        }
2837
2838        if (pCoexSta->bUnderIps) {
2839                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], wifi is under IPS !!!\n"));
2840                return;
2841        }
2842
2843        algorithm = halbtc8723b2ant_ActionAlgorithm(pBtCoexist);
2844        if (pCoexSta->bC2hBtInquiryPage && (BT_8723B_2ANT_COEX_ALGO_PANHS != algorithm)) {
2845                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], BT is under inquiry/page scan !!\n"));
2846                halbtc8723b2ant_ActionBtInquiry(pBtCoexist);
2847                return;
2848        } else {
2849                if (pCoexDm->bNeedRecover0x948) {
2850                        pCoexDm->bNeedRecover0x948 = false;
2851                        pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0x948, pCoexDm->backup0x948);
2852                }
2853        }
2854
2855        pCoexDm->curAlgorithm = algorithm;
2856        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], Algorithm = %d\n", pCoexDm->curAlgorithm));
2857
2858        if (halbtc8723b2ant_IsCommonAction(pBtCoexist)) {
2859                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], Action 2-Ant common.\n"));
2860                pCoexDm->bAutoTdmaAdjust = false;
2861        } else {
2862                if (pCoexDm->curAlgorithm != pCoexDm->preAlgorithm) {
2863                        BTC_PRINT(
2864                                BTC_MSG_ALGORITHM,
2865                                ALGO_TRACE,
2866                                (
2867                                        "[BTCoex], preAlgorithm =%d, curAlgorithm =%d\n",
2868                                        pCoexDm->preAlgorithm,
2869                                        pCoexDm->curAlgorithm
2870                                )
2871                        );
2872                        pCoexDm->bAutoTdmaAdjust = false;
2873                }
2874
2875
2876                switch (pCoexDm->curAlgorithm) {
2877                case BT_8723B_2ANT_COEX_ALGO_SCO:
2878                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], Action 2-Ant, algorithm = SCO.\n"));
2879                        halbtc8723b2ant_ActionSco(pBtCoexist);
2880                        break;
2881                case BT_8723B_2ANT_COEX_ALGO_HID:
2882                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], Action 2-Ant, algorithm = HID.\n"));
2883                        halbtc8723b2ant_ActionHid(pBtCoexist);
2884                        break;
2885                case BT_8723B_2ANT_COEX_ALGO_A2DP:
2886                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], Action 2-Ant, algorithm = A2DP.\n"));
2887                        halbtc8723b2ant_ActionA2dp(pBtCoexist);
2888                        break;
2889                case BT_8723B_2ANT_COEX_ALGO_A2DP_PANHS:
2890                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], Action 2-Ant, algorithm = A2DP+PAN(HS).\n"));
2891                        halbtc8723b2ant_ActionA2dpPanHs(pBtCoexist);
2892                        break;
2893                case BT_8723B_2ANT_COEX_ALGO_PANEDR:
2894                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], Action 2-Ant, algorithm = PAN(EDR).\n"));
2895                        halbtc8723b2ant_ActionPanEdr(pBtCoexist);
2896                        break;
2897                case BT_8723B_2ANT_COEX_ALGO_PANHS:
2898                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], Action 2-Ant, algorithm = HS mode.\n"));
2899                        halbtc8723b2ant_ActionPanHs(pBtCoexist);
2900                        break;
2901                case BT_8723B_2ANT_COEX_ALGO_PANEDR_A2DP:
2902                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], Action 2-Ant, algorithm = PAN+A2DP.\n"));
2903                        halbtc8723b2ant_ActionPanEdrA2dp(pBtCoexist);
2904                        break;
2905                case BT_8723B_2ANT_COEX_ALGO_PANEDR_HID:
2906                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], Action 2-Ant, algorithm = PAN(EDR)+HID.\n"));
2907                        halbtc8723b2ant_ActionPanEdrHid(pBtCoexist);
2908                        break;
2909                case BT_8723B_2ANT_COEX_ALGO_HID_A2DP_PANEDR:
2910                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], Action 2-Ant, algorithm = HID+A2DP+PAN.\n"));
2911                        halbtc8723b2ant_ActionHidA2dpPanEdr(pBtCoexist);
2912                        break;
2913                case BT_8723B_2ANT_COEX_ALGO_HID_A2DP:
2914                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], Action 2-Ant, algorithm = HID+A2DP.\n"));
2915                        halbtc8723b2ant_ActionHidA2dp(pBtCoexist);
2916                        break;
2917                default:
2918                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], Action 2-Ant, algorithm = coexist All Off!!\n"));
2919                        halbtc8723b2ant_CoexAllOff(pBtCoexist);
2920                        break;
2921                }
2922                pCoexDm->preAlgorithm = pCoexDm->curAlgorithm;
2923        }
2924}
2925
2926static void halbtc8723b2ant_WifiOffHwCfg(PBTC_COEXIST pBtCoexist)
2927{
2928        bool bIsInMpMode = false;
2929        u8 H2C_Parameter[2] = {0};
2930        u32 fwVer = 0;
2931
2932        /*  set wlan_act to low */
2933        pBtCoexist->fBtcWrite1Byte(pBtCoexist, 0x76e, 0x4);
2934
2935        pBtCoexist->fBtcSetRfReg(pBtCoexist, BTC_RF_A, 0x1, 0xfffff, 0x780); /* WiFi goto standby while GNT_BT 0-->1 */
2936        pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_U4_WIFI_FW_VER, &fwVer);
2937        if (fwVer >= 0x180000) {
2938                /* Use H2C to set GNT_BT to HIGH */
2939                H2C_Parameter[0] = 1;
2940                pBtCoexist->fBtcFillH2c(pBtCoexist, 0x6E, 1, H2C_Parameter);
2941        } else
2942                pBtCoexist->fBtcWrite1Byte(pBtCoexist, 0x765, 0x18);
2943
2944        pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_WIFI_IS_IN_MP_MODE, &bIsInMpMode);
2945        if (!bIsInMpMode)
2946                pBtCoexist->fBtcWrite1ByteBitMask(pBtCoexist, 0x67, 0x20, 0x0); /* BT select s0/s1 is controlled by BT */
2947        else
2948                pBtCoexist->fBtcWrite1ByteBitMask(pBtCoexist, 0x67, 0x20, 0x1); /* BT select s0/s1 is controlled by WiFi */
2949}
2950
2951static void halbtc8723b2ant_InitHwConfig(PBTC_COEXIST pBtCoexist, bool bBackUp)
2952{
2953        u8 u1Tmp = 0;
2954
2955        BTC_PRINT(BTC_MSG_INTERFACE, INTF_INIT, ("[BTCoex], 2Ant Init HW Config!!\n"));
2956
2957        /*  backup rf 0x1e value */
2958        pCoexDm->btRf0x1eBackup =
2959                pBtCoexist->fBtcGetRfReg(pBtCoexist, BTC_RF_A, 0x1e, 0xfffff);
2960
2961        /*  0x790[5:0]= 0x5 */
2962        u1Tmp = pBtCoexist->fBtcRead1Byte(pBtCoexist, 0x790);
2963        u1Tmp &= 0xc0;
2964        u1Tmp |= 0x5;
2965        pBtCoexist->fBtcWrite1Byte(pBtCoexist, 0x790, u1Tmp);
2966
2967        /* Antenna config */
2968        halbtc8723b2ant_SetAntPath(pBtCoexist, BTC_ANT_WIFI_AT_MAIN, true, false);
2969
2970        /*  PTA parameter */
2971        halbtc8723b2ant_CoexTableWithType(pBtCoexist, FORCE_EXEC, 0);
2972
2973        /*  Enable counter statistics */
2974        pBtCoexist->fBtcWrite1Byte(pBtCoexist, 0x76e, 0xc); /* 0x76e[3] = 1, WLAN_Act control by PTA */
2975        pBtCoexist->fBtcWrite1Byte(pBtCoexist, 0x778, 0x3);
2976        pBtCoexist->fBtcWrite1ByteBitMask(pBtCoexist, 0x40, 0x20, 0x1);
2977}
2978
2979/*  */
2980/*  work around function start with wa_halbtc8723b2ant_ */
2981/*  */
2982/*  */
2983/*  extern function start with EXhalbtc8723b2ant_ */
2984/*  */
2985void EXhalbtc8723b2ant_PowerOnSetting(PBTC_COEXIST pBtCoexist)
2986{
2987        PBTC_BOARD_INFO pBoardInfo = &pBtCoexist->boardInfo;
2988        u8 u1Tmp = 0x4; /* Set BIT2 by default since it's 2ant case */
2989        u16 u2Tmp = 0x0;
2990
2991        pBtCoexist->fBtcWrite1Byte(pBtCoexist, 0x67, 0x20);
2992
2993        /*  enable BB, REG_SYS_FUNC_EN such that we can write 0x948 correctly. */
2994        u2Tmp = pBtCoexist->fBtcRead2Byte(pBtCoexist, 0x2);
2995        pBtCoexist->fBtcWrite2Byte(pBtCoexist, 0x2, u2Tmp|BIT0|BIT1);
2996
2997        /*  set GRAN_BT = 1 */
2998        pBtCoexist->fBtcWrite1Byte(pBtCoexist, 0x765, 0x18);
2999        /*  set WLAN_ACT = 0 */
3000        pBtCoexist->fBtcWrite1Byte(pBtCoexist, 0x76e, 0x4);

3001
3002        /*  */
3003        /*  S0 or S1 setting and Local register setting(By the setting fw can get ant number, S0/S1, ... info) */
3004        /*  Local setting bit define */
3005        /*      BIT0: "0" for no antenna inverse; "1" for antenna inverse */
3006        /*      BIT1: "0" for internal switch; "1" for external switch */
3007        /*      BIT2: "0" for one antenna; "1" for two antenna */
3008        /*  NOTE: here default all internal switch and 1-antenna ==> BIT1 = 0 and BIT2 = 0 */
3009        if (pBtCoexist->chipInterface == BTC_INTF_USB) {
3010                /*  fixed at S0 for USB interface */
3011                pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0x948, 0x0);
3012
3013                u1Tmp |= 0x1;   /*  antenna inverse */
3014                pBtCoexist->fBtcWriteLocalReg1Byte(pBtCoexist, 0xfe08, u1Tmp);
3015
3016                pBoardInfo->btdmAntPos = BTC_ANTENNA_AT_AUX_PORT;
3017        } else {
3018                /*  for PCIE and SDIO interface, we check efuse 0xc3[6] */
3019                if (pBoardInfo->singleAntPath == 0) {
3020                        /*  set to S1 */
3021                        pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0x948, 0x280);
3022                        pBoardInfo->btdmAntPos = BTC_ANTENNA_AT_MAIN_PORT;
3023                } else if (pBoardInfo->singleAntPath == 1) {
3024                        /*  set to S0 */
3025                        pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0x948, 0x0);
3026                        u1Tmp |= 0x1;   /*  antenna inverse */
3027                        pBoardInfo->btdmAntPos = BTC_ANTENNA_AT_AUX_PORT;
3028                }
3029
3030                if (pBtCoexist->chipInterface == BTC_INTF_PCI)
3031                        pBtCoexist->fBtcWriteLocalReg1Byte(pBtCoexist, 0x384, u1Tmp);
3032                else if (pBtCoexist->chipInterface == BTC_INTF_SDIO)
3033                        pBtCoexist->fBtcWriteLocalReg1Byte(pBtCoexist, 0x60, u1Tmp);
3034        }
3035}
3036
3037void EXhalbtc8723b2ant_InitHwConfig(PBTC_COEXIST pBtCoexist, bool bWifiOnly)
3038{
3039        halbtc8723b2ant_InitHwConfig(pBtCoexist, true);
3040}
3041
3042void EXhalbtc8723b2ant_InitCoexDm(PBTC_COEXIST pBtCoexist)
3043{
3044        BTC_PRINT(BTC_MSG_INTERFACE, INTF_INIT, ("[BTCoex], Coex Mechanism Init!!\n"));
3045
3046        halbtc8723b2ant_InitCoexDm(pBtCoexist);
3047}
3048
3049void EXhalbtc8723b2ant_DisplayCoexInfo(PBTC_COEXIST pBtCoexist)
3050{
3051        PBTC_BOARD_INFO pBoardInfo = &pBtCoexist->boardInfo;
3052        PBTC_STACK_INFO pStackInfo = &pBtCoexist->stackInfo;
3053        PBTC_BT_LINK_INFO pBtLinkInfo = &pBtCoexist->btLinkInfo;
3054        u8 *cliBuf = pBtCoexist->cliBuf;
3055        u8 u1Tmp[4], i, btInfoExt, psTdmaCase = 0;
3056        u32 u4Tmp[4];
3057        bool bRoam = false, bScan = false, bLink = false, bWifiUnder5G = false;
3058        bool bBtHsOn = false, bWifiBusy = false;
3059        s32 wifiRssi = 0, btHsRssi = 0;
3060        u32 wifiBw, wifiTrafficDir, faOfdm, faCck;
3061        u8 wifiDot11Chnl, wifiHsChnl;
3062        u32 fwVer = 0, btPatchVer = 0;
3063        u8 apNum = 0;
3064
3065        CL_SPRINTF(cliBuf, BT_TMP_BUF_SIZE, "\r\n ============[BT Coexist info]============");
3066        CL_PRINTF(cliBuf);
3067
3068        if (pBtCoexist->bManualControl) {
3069                CL_SPRINTF(cliBuf, BT_TMP_BUF_SIZE, "\r\n ============[Under Manual Control]============");
3070                CL_PRINTF(cliBuf);
3071                CL_SPRINTF(cliBuf, BT_TMP_BUF_SIZE, "\r\n ==========================================");
3072                CL_PRINTF(cliBuf);
3073        }
3074
3075        CL_SPRINTF(
3076                cliBuf,
3077                BT_TMP_BUF_SIZE,
3078                "\r\n %-35s = %d/ %d ", "Ant PG number/ Ant mechanism:", \
3079                pBoardInfo->pgAntNum,
3080                pBoardInfo->btdmAntNum
3081        );
3082        CL_PRINTF(cliBuf);
3083
3084        CL_SPRINTF(
3085                cliBuf,
3086                BT_TMP_BUF_SIZE,
3087                "\r\n %-35s = %s / %d", "BT stack/ hci ext ver", \
3088                (pStackInfo->bProfileNotified ? "Yes" : "No"),
3089                pStackInfo->hciVersion
3090        );
3091        CL_PRINTF(cliBuf);
3092
3093        pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_U4_BT_PATCH_VER, &btPatchVer);
3094        pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_U4_WIFI_FW_VER, &fwVer);
3095        CL_SPRINTF(cliBuf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d_%x/ 0x%x/ 0x%x(%d)", "CoexVer/ FwVer/ PatchVer", \
3096                GLCoexVerDate8723b2Ant, GLCoexVer8723b2Ant, fwVer, btPatchVer, btPatchVer);
3097        CL_PRINTF(cliBuf);
3098
3099        pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_HS_OPERATION, &bBtHsOn);
3100        pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_U1_WIFI_DOT11_CHNL, &wifiDot11Chnl);
3101        pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_U1_WIFI_HS_CHNL, &wifiHsChnl);
3102        CL_SPRINTF(
3103                cliBuf,
3104                BT_TMP_BUF_SIZE,
3105                "\r\n %-35s = %d / %d(%d)", "Dot11 channel / HsChnl(HsMode)", \
3106                wifiDot11Chnl,
3107                wifiHsChnl,
3108                bBtHsOn
3109        );
3110        CL_PRINTF(cliBuf);
3111
3112        CL_SPRINTF(
3113                cliBuf,
3114                BT_TMP_BUF_SIZE,
3115                "\r\n %-35s = %02x %02x %02x ", "H2C Wifi inform bt chnl Info", \
3116                pCoexDm->wifiChnlInfo[0],
3117                pCoexDm->wifiChnlInfo[1],
3118                pCoexDm->wifiChnlInfo[2]
3119        );
3120        CL_PRINTF(cliBuf);
3121
3122        pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_S4_WIFI_RSSI, &wifiRssi);
3123        pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_S4_HS_RSSI, &btHsRssi);
3124        pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_U1_AP_NUM, &apNum);
3125        CL_SPRINTF(
3126                cliBuf,
3127                BT_TMP_BUF_SIZE,
3128                "\r\n %-35s = %d/ %d/ %d", "Wifi rssi/ HS rssi/ AP#", \
3129                wifiRssi,
3130                btHsRssi,
3131                apNum
3132        );
3133        CL_PRINTF(cliBuf);
3134
3135        pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_WIFI_SCAN, &bScan);
3136        pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_WIFI_LINK, &bLink);
3137        pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_WIFI_ROAM, &bRoam);
3138        CL_SPRINTF(
3139                cliBuf,
3140                BT_TMP_BUF_SIZE,
3141                "\r\n %-35s = %d/ %d/ %d ", "Wifi bLink/ bRoam/ bScan", \
3142                bLink,
3143                bRoam,
3144                bScan
3145        );
3146        CL_PRINTF(cliBuf);
3147
3148        pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_WIFI_UNDER_5G, &bWifiUnder5G);
3149        pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_U4_WIFI_BW, &wifiBw);
3150        pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_WIFI_BUSY, &bWifiBusy);
3151        pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_U4_WIFI_TRAFFIC_DIRECTION, &wifiTrafficDir);
3152        CL_SPRINTF(
3153                cliBuf,
3154                BT_TMP_BUF_SIZE,
3155                "\r\n %-35s = %s / %s/ %s ", "Wifi status", \
3156                (bWifiUnder5G ? "5G" : "2.4G"),
3157                ((BTC_WIFI_BW_LEGACY == wifiBw) ? "Legacy" : (((BTC_WIFI_BW_HT40 == wifiBw) ? "HT40" : "HT20"))),
3158                ((!bWifiBusy) ? "idle" : ((BTC_WIFI_TRAFFIC_TX == wifiTrafficDir) ? "uplink" : "downlink"))
3159        );
3160        CL_PRINTF(cliBuf);
3161
3162        CL_SPRINTF(
3163                cliBuf,
3164                BT_TMP_BUF_SIZE,
3165                "\r\n %-35s = [%s/ %d/ %d] ", "BT [status/ rssi/ retryCnt]", \
3166                ((pBtCoexist->btInfo.bBtDisabled) ? ("disabled") : ((pCoexSta->bC2hBtInquiryPage) ? ("inquiry/page scan") : ((BT_8723B_2ANT_BT_STATUS_NON_CONNECTED_IDLE == pCoexDm->btStatus) ? "non-connected idle" :
3167                ((BT_8723B_2ANT_BT_STATUS_CONNECTED_IDLE == pCoexDm->btStatus) ? "connected-idle" : "busy")))),
3168                pCoexSta->btRssi,
3169                pCoexSta->btRetryCnt
3170        );
3171        CL_PRINTF(cliBuf);
3172
3173        CL_SPRINTF(
3174                cliBuf,
3175                BT_TMP_BUF_SIZE,
3176                "\r\n %-35s = %d / %d / %d / %d", "SCO/HID/PAN/A2DP", \
3177                pBtLinkInfo->bScoExist,
3178                pBtLinkInfo->bHidExist,
3179                pBtLinkInfo->bPanExist,
3180                pBtLinkInfo->bA2dpExist
3181        );
3182        CL_PRINTF(cliBuf);
3183        pBtCoexist->fBtcDispDbgMsg(pBtCoexist, BTC_DBG_DISP_BT_LINK_INFO);
3184
3185        btInfoExt = pCoexSta->btInfoExt;
3186        CL_SPRINTF(
3187                cliBuf,
3188                BT_TMP_BUF_SIZE,
3189                "\r\n %-35s = %s", "BT Info A2DP rate", \
3190                (btInfoExt&BIT0) ? "Basic rate" : "EDR rate"
3191        );
3192        CL_PRINTF(cliBuf);
3193
3194        for (i = 0; i < BT_INFO_SRC_8723B_2ANT_MAX; i++) {
3195                if (pCoexSta->btInfoC2hCnt[i]) {
3196                        CL_SPRINTF(
3197                                cliBuf,
3198                                BT_TMP_BUF_SIZE,
3199                                "\r\n %-35s = %02x %02x %02x %02x %02x %02x %02x(%d)", GLBtInfoSrc8723b2Ant[i], \
3200                                pCoexSta->btInfoC2h[i][0],
3201                                pCoexSta->btInfoC2h[i][1],
3202                                pCoexSta->btInfoC2h[i][2],
3203                                pCoexSta->btInfoC2h[i][3],
3204                                pCoexSta->btInfoC2h[i][4],
3205                                pCoexSta->btInfoC2h[i][5],
3206                                pCoexSta->btInfoC2h[i][6],
3207                                pCoexSta->btInfoC2hCnt[i]
3208                        );
3209                        CL_PRINTF(cliBuf);
3210                }
3211        }
3212
3213        CL_SPRINTF(
3214                cliBuf,
3215                BT_TMP_BUF_SIZE,
3216                "\r\n %-35s = %s/%s", "PS state, IPS/LPS", \
3217                ((pCoexSta->bUnderIps ? "IPS ON" : "IPS OFF")),
3218                ((pCoexSta->bUnderLps ? "LPS ON" : "LPS OFF"))
3219        );
3220        CL_PRINTF(cliBuf);
3221        pBtCoexist->fBtcDispDbgMsg(pBtCoexist, BTC_DBG_DISP_FW_PWR_MODE_CMD);
3222
3223        /*  Sw mechanism */
3224        CL_SPRINTF(
3225                cliBuf,
3226                BT_TMP_BUF_SIZE,
3227                "\r\n %-35s", "============[Sw mechanism]============"
3228        );
3229        CL_PRINTF(cliBuf);
3230        CL_SPRINTF(
3231                cliBuf,
3232                BT_TMP_BUF_SIZE,
3233                "\r\n %-35s = %d/ %d/ %d ", "SM1[ShRf/ LpRA/ LimDig]", \
3234                pCoexDm->bCurRfRxLpfShrink,
3235                pCoexDm->bCurLowPenaltyRa,
3236                pCoexDm->bLimitedDig
3237        );
3238        CL_PRINTF(cliBuf);
3239        CL_SPRINTF(
3240                cliBuf,
3241                BT_TMP_BUF_SIZE,
3242                "\r\n %-35s = %d/ %d/ %d(0x%x) ",
3243                "SM2[AgcT/ AdcB/ SwDacSwing(lvl)]", \
3244                pCoexDm->bCurAgcTableEn,
3245                pCoexDm->bCurAdcBackOff,
3246                pCoexDm->bCurDacSwingOn,
3247                pCoexDm->curDacSwingLvl
3248        );
3249        CL_PRINTF(cliBuf);
3250
3251        /*  Fw mechanism */
3252        CL_SPRINTF(cliBuf, BT_TMP_BUF_SIZE, "\r\n %-35s", "============[Fw mechanism]============");
3253        CL_PRINTF(cliBuf);
3254
3255        psTdmaCase = pCoexDm->curPsTdma;
3256        CL_SPRINTF(
3257                cliBuf,
3258                BT_TMP_BUF_SIZE,
3259                "\r\n %-35s = %02x %02x %02x %02x %02x case-%d (auto:%d)", "PS TDMA", \
3260                pCoexDm->psTdmaPara[0],
3261                pCoexDm->psTdmaPara[1],
3262                pCoexDm->psTdmaPara[2],
3263                pCoexDm->psTdmaPara[3],
3264                pCoexDm->psTdmaPara[4],
3265                psTdmaCase, pCoexDm->bAutoTdmaAdjust
3266        );
3267        CL_PRINTF(cliBuf);
3268
3269        CL_SPRINTF(
3270                cliBuf,
3271                BT_TMP_BUF_SIZE,
3272                "\r\n %-35s = %d/ %d ", "DecBtPwr/ IgnWlanAct", \
3273                pCoexDm->curBtDecPwrLvl,
3274                pCoexDm->bCurIgnoreWlanAct
3275        );
3276        CL_PRINTF(cliBuf);
3277
3278        /*  Hw setting */
3279        CL_SPRINTF(cliBuf, BT_TMP_BUF_SIZE, "\r\n %-35s", "============[Hw setting]============");
3280        CL_PRINTF(cliBuf);
3281
3282        CL_SPRINTF(
3283                cliBuf,
3284                BT_TMP_BUF_SIZE,
3285                "\r\n %-35s = 0x%x", "RF-A, 0x1e initVal", \
3286                pCoexDm->btRf0x1eBackup
3287        );
3288        CL_PRINTF(cliBuf);
3289
3290        u1Tmp[0] = pBtCoexist->fBtcRead1Byte(pBtCoexist, 0x778);
3291        u4Tmp[0] = pBtCoexist->fBtcRead4Byte(pBtCoexist, 0x880);
3292        CL_SPRINTF(
3293                cliBuf,
3294                BT_TMP_BUF_SIZE,
3295                "\r\n %-35s = 0x%x/ 0x%x", "0x778/0x880[29:25]", \
3296                u1Tmp[0],
3297                (u4Tmp[0]&0x3e000000) >> 25
3298        );
3299        CL_PRINTF(cliBuf);
3300
3301
3302        u4Tmp[0] = pBtCoexist->fBtcRead4Byte(pBtCoexist, 0x948);
3303        u1Tmp[0] = pBtCoexist->fBtcRead1Byte(pBtCoexist, 0x67);
3304        u1Tmp[1] = pBtCoexist->fBtcRead1Byte(pBtCoexist, 0x765);
3305        CL_SPRINTF(
3306                cliBuf,
3307                BT_TMP_BUF_SIZE,
3308                "\r\n %-35s = 0x%x/ 0x%x/ 0x%x", "0x948/ 0x67[5] / 0x765", \
3309                u4Tmp[0],
3310                ((u1Tmp[0]&0x20)>>5),
3311                u1Tmp[1]
3312        );
3313        CL_PRINTF(cliBuf);
3314
3315        u4Tmp[0] = pBtCoexist->fBtcRead4Byte(pBtCoexist, 0x92c);
3316        u4Tmp[1] = pBtCoexist->fBtcRead4Byte(pBtCoexist, 0x930);
3317        u4Tmp[2] = pBtCoexist->fBtcRead4Byte(pBtCoexist, 0x944);
3318        CL_SPRINTF(
3319                cliBuf,
3320                BT_TMP_BUF_SIZE,
3321                "\r\n %-35s = 0x%x/ 0x%x/ 0x%x", "0x92c[1:0]/ 0x930[7:0]/0x944[1:0]", \
3322                u4Tmp[0]&0x3,
3323                u4Tmp[1]&0xff,
3324                u4Tmp[2]&0x3
3325        );
3326        CL_PRINTF(cliBuf);
3327
3328
3329        u1Tmp[0] = pBtCoexist->fBtcRead1Byte(pBtCoexist, 0x39);
3330        u1Tmp[1] = pBtCoexist->fBtcRead1Byte(pBtCoexist, 0x40);
3331        u4Tmp[0] = pBtCoexist->fBtcRead4Byte(pBtCoexist, 0x4c);
3332        u1Tmp[2] = pBtCoexist->fBtcRead1Byte(pBtCoexist, 0x64);
3333        CL_SPRINTF(
3334                cliBuf,
3335                BT_TMP_BUF_SIZE,
3336                "\r\n %-35s = 0x%x/ 0x%x/ 0x%x/ 0x%x", "0x38[11]/0x40/0x4c[24:23]/0x64[0]", \
3337                ((u1Tmp[0] & 0x8)>>3),
3338                u1Tmp[1],
3339                ((u4Tmp[0]&0x01800000)>>23),
3340                u1Tmp[2]&0x1
3341        );
3342        CL_PRINTF(cliBuf);
3343
3344        u4Tmp[0] = pBtCoexist->fBtcRead4Byte(pBtCoexist, 0x550);
3345        u1Tmp[0] = pBtCoexist->fBtcRead1Byte(pBtCoexist, 0x522);
3346        CL_SPRINTF(
3347                cliBuf,
3348                BT_TMP_BUF_SIZE,
3349                "\r\n %-35s = 0x%x/ 0x%x", "0x550(bcn ctrl)/0x522", \
3350                u4Tmp[0],
3351                u1Tmp[0]
3352        );
3353        CL_PRINTF(cliBuf);
3354
3355        u4Tmp[0] = pBtCoexist->fBtcRead4Byte(pBtCoexist, 0xc50);
3356        u1Tmp[0] = pBtCoexist->fBtcRead1Byte(pBtCoexist, 0x49c);
3357        CL_SPRINTF(
3358                cliBuf,
3359                BT_TMP_BUF_SIZE,
3360                "\r\n %-35s = 0x%x/ 0x%x", "0xc50(dig)/0x49c(null-drop)", \
3361                u4Tmp[0]&0xff,
3362                u1Tmp[0]
3363        );
3364        CL_PRINTF(cliBuf);
3365
3366        u4Tmp[0] = pBtCoexist->fBtcRead4Byte(pBtCoexist, 0xda0);
3367        u4Tmp[1] = pBtCoexist->fBtcRead4Byte(pBtCoexist, 0xda4);
3368        u4Tmp[2] = pBtCoexist->fBtcRead4Byte(pBtCoexist, 0xda8);
3369        u4Tmp[3] = pBtCoexist->fBtcRead4Byte(pBtCoexist, 0xcf0);
3370
3371        u1Tmp[0] = pBtCoexist->fBtcRead1Byte(pBtCoexist, 0xa5b);
3372        u1Tmp[1] = pBtCoexist->fBtcRead1Byte(pBtCoexist, 0xa5c);
3373
3374        faOfdm =
3375                ((u4Tmp[0]&0xffff0000) >> 16) +
3376                ((u4Tmp[1]&0xffff0000) >> 16) +
3377                (u4Tmp[1] & 0xffff) +  (u4Tmp[2] & 0xffff) + \
3378                ((u4Tmp[3]&0xffff0000) >> 16) +
3379                (u4Tmp[3] & 0xffff);
3380
3381        faCck = (u1Tmp[0] << 8) + u1Tmp[1];
3382
3383        CL_SPRINTF(
3384                cliBuf,
3385                BT_TMP_BUF_SIZE,
3386                "\r\n %-35s = 0x%x/ 0x%x/ 0x%x", "OFDM-CCA/OFDM-FA/CCK-FA", \
3387                u4Tmp[0]&0xffff,
3388                faOfdm,
3389                faCck
3390        );
3391        CL_PRINTF(cliBuf);
3392
3393        u4Tmp[0] = pBtCoexist->fBtcRead4Byte(pBtCoexist, 0x6c0);
3394        u4Tmp[1] = pBtCoexist->fBtcRead4Byte(pBtCoexist, 0x6c4);
3395        u4Tmp[2] = pBtCoexist->fBtcRead4Byte(pBtCoexist, 0x6c8);
3396        u1Tmp[0] = pBtCoexist->fBtcRead1Byte(pBtCoexist, 0x6cc);
3397        CL_SPRINTF(
3398                cliBuf,
3399                BT_TMP_BUF_SIZE,
3400                "\r\n %-35s = 0x%x/ 0x%x/ 0x%x/ 0x%x", "0x6c0/0x6c4/0x6c8/0x6cc(coexTable)", \
3401                u4Tmp[0],
3402                u4Tmp[1],
3403                u4Tmp[2],
3404                u1Tmp[0]
3405        );
3406        CL_PRINTF(cliBuf);
3407
3408        CL_SPRINTF(
3409                cliBuf,
3410                BT_TMP_BUF_SIZE,
3411                "\r\n %-35s = %d/ %d", "0x770(high-pri rx/tx)", \
3412                pCoexSta->highPriorityRx,
3413                pCoexSta->highPriorityTx
3414        );
3415        CL_PRINTF(cliBuf);
3416        CL_SPRINTF(
3417                cliBuf,
3418                BT_TMP_BUF_SIZE,
3419                "\r\n %-35s = %d/ %d", "0x774(low-pri rx/tx)", \
3420                pCoexSta->lowPriorityRx,
3421                pCoexSta->lowPriorityTx
3422        );
3423        CL_PRINTF(cliBuf);
3424
3425        halbtc8723b2ant_MonitorBtCtr(pBtCoexist);
3426        pBtCoexist->fBtcDispDbgMsg(pBtCoexist, BTC_DBG_DISP_COEX_STATISTICS);
3427}
3428
3429
3430void EXhalbtc8723b2ant_IpsNotify(PBTC_COEXIST pBtCoexist, u8 type)
3431{
3432        if (BTC_IPS_ENTER == type) {
3433                BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY, ("[BTCoex], IPS ENTER notify\n"));
3434                pCoexSta->bUnderIps = true;
3435                halbtc8723b2ant_WifiOffHwCfg(pBtCoexist);
3436                halbtc8723b2ant_IgnoreWlanAct(pBtCoexist, FORCE_EXEC, true);
3437                halbtc8723b2ant_CoexAllOff(pBtCoexist);
3438        } else if (BTC_IPS_LEAVE == type) {
3439                BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY, ("[BTCoex], IPS LEAVE notify\n"));
3440                pCoexSta->bUnderIps = false;
3441                halbtc8723b2ant_InitHwConfig(pBtCoexist, false);
3442                halbtc8723b2ant_InitCoexDm(pBtCoexist);
3443                halbtc8723b2ant_QueryBtInfo(pBtCoexist);
3444        }
3445}
3446
3447void EXhalbtc8723b2ant_LpsNotify(PBTC_COEXIST pBtCoexist, u8 type)
3448{
3449        if (BTC_LPS_ENABLE == type) {
3450                BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY, ("[BTCoex], LPS ENABLE notify\n"));
3451                pCoexSta->bUnderLps = true;
3452        } else if (BTC_LPS_DISABLE == type) {
3453                BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY, ("[BTCoex], LPS DISABLE notify\n"));
3454                pCoexSta->bUnderLps = false;
3455        }
3456}
3457
3458void EXhalbtc8723b2ant_ScanNotify(PBTC_COEXIST pBtCoexist, u8 type)
3459{
3460        if (BTC_SCAN_START == type) {
3461                BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY, ("[BTCoex], SCAN START notify\n"));
3462        } else if (BTC_SCAN_FINISH == type) {
3463                BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY, ("[BTCoex], SCAN FINISH notify\n"));
3464        }
3465}
3466
3467void EXhalbtc8723b2ant_ConnectNotify(PBTC_COEXIST pBtCoexist, u8 type)
3468{
3469        if (BTC_ASSOCIATE_START == type) {
3470                BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY, ("[BTCoex], CONNECT START notify\n"));
3471        } else if (BTC_ASSOCIATE_FINISH == type) {
3472                BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY, ("[BTCoex], CONNECT FINISH notify\n"));
3473        }
3474}
3475
3476void EXhalbtc8723b2ant_MediaStatusNotify(PBTC_COEXIST pBtCoexist, u8 type)
3477{
3478        u8 H2C_Parameter[3] = {0};
3479        u32 wifiBw;
3480        u8 wifiCentralChnl;
3481        u8 apNum = 0;
3482
3483        if (BTC_MEDIA_CONNECT == type) {
3484                BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY, ("[BTCoex], MEDIA connect notify\n"));
3485        } else {
3486                BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY, ("[BTCoex], MEDIA disconnect notify\n"));
3487        }
3488
3489        /*  only 2.4G we need to inform bt the chnl mask */
3490        pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_U1_WIFI_CENTRAL_CHNL, &wifiCentralChnl);
3491        if ((BTC_MEDIA_CONNECT == type) && (wifiCentralChnl <= 14)) {
3492                H2C_Parameter[0] = 0x1;
3493                H2C_Parameter[1] = wifiCentralChnl;
3494                pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_U4_WIFI_BW, &wifiBw);
3495                if (BTC_WIFI_BW_HT40 == wifiBw)
3496                        H2C_Parameter[2] = 0x30;
3497                else {
3498                        pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_U1_AP_NUM, &apNum);
3499                        if (apNum < 10)
3500                                H2C_Parameter[2] = 0x30;
3501                        else
3502                                H2C_Parameter[2] = 0x20;
3503                }
3504        }
3505
3506        pCoexDm->wifiChnlInfo[0] = H2C_Parameter[0];
3507        pCoexDm->wifiChnlInfo[1] = H2C_Parameter[1];
3508        pCoexDm->wifiChnlInfo[2] = H2C_Parameter[2];
3509
3510        BTC_PRINT(
3511                BTC_MSG_ALGORITHM,
3512                ALGO_TRACE_FW_EXEC,
3513                (
3514                        "[BTCoex], FW write 0x66 = 0x%x\n",
3515                        H2C_Parameter[0]<<16|H2C_Parameter[1]<<8|H2C_Parameter[2]
3516                )
3517        );
3518
3519        pBtCoexist->fBtcFillH2c(pBtCoexist, 0x66, 3, H2C_Parameter);
3520}
3521
3522void EXhalbtc8723b2ant_SpecialPacketNotify(PBTC_COEXIST pBtCoexist, u8 type)
3523{
3524        if (type == BTC_PACKET_DHCP) {
3525                BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY, ("[BTCoex], DHCP Packet notify\n"));
3526        }
3527}
3528
3529void EXhalbtc8723b2ant_BtInfoNotify(
3530        PBTC_COEXIST pBtCoexist, u8 *tmpBuf, u8 length
3531)
3532{
3533        u8      btInfo = 0;
3534        u8      i, rspSource = 0;
3535        bool bBtBusy = false, bLimitedDig = false;
3536        bool bWifiConnected = false;
3537
3538        pCoexSta->bC2hBtInfoReqSent = false;
3539
3540        rspSource = tmpBuf[0]&0xf;
3541        if (rspSource >= BT_INFO_SRC_8723B_2ANT_MAX)
3542                rspSource = BT_INFO_SRC_8723B_2ANT_WIFI_FW;
3543
3544        pCoexSta->btInfoC2hCnt[rspSource]++;
3545
3546        BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY, ("[BTCoex], Bt info[%d], length =%d, hex data =[", rspSource, length));
3547        for (i = 0; i < length; i++) {
3548                pCoexSta->btInfoC2h[rspSource][i] = tmpBuf[i];
3549                if (i == 1)
3550                        btInfo = tmpBuf[i];
3551
3552                if (i == length-1) {
3553                        BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY, ("0x%02x]\n", tmpBuf[i]));
3554                } else {
3555                        BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY, ("0x%02x, ", tmpBuf[i]));
3556                }
3557        }
3558
3559        if (pBtCoexist->bManualControl) {
3560                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], BtInfoNotify(), return for Manual CTRL<===\n"));
3561                return;
3562        }
3563
3564        if (BT_INFO_SRC_8723B_2ANT_WIFI_FW != rspSource) {
3565                pCoexSta->btRetryCnt = pCoexSta->btInfoC2h[rspSource][2]&0xf; /* [3:0] */
3566
3567                pCoexSta->btRssi = pCoexSta->btInfoC2h[rspSource][3]*2+10;
3568
3569                pCoexSta->btInfoExt = pCoexSta->btInfoC2h[rspSource][4];
3570
3571                pCoexSta->bBtTxRxMask = (pCoexSta->btInfoC2h[rspSource][2]&0x40);
3572                pBtCoexist->fBtcSet(pBtCoexist, BTC_SET_BL_BT_TX_RX_MASK, &pCoexSta->bBtTxRxMask);
3573                if (pCoexSta->bBtTxRxMask) {
3574                        /* BT into is responded by BT FW and BT RF REG 0x3C != 0x01 => Need to switch BT TRx Mask */
3575                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], Switch BT TRx Mask since BT RF REG 0x3C != 0x01\n"));
3576                        pBtCoexist->fBtcSetBtReg(pBtCoexist, BTC_BT_REG_RF, 0x3c, 0x01);
3577                }
3578
3579                /*  Here we need to resend some wifi info to BT */
3580                /*  because bt is reset and loss of the info. */
3581                if ((pCoexSta->btInfoExt & BIT1)) {
3582                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], BT ext info bit1 check, send wifi BW&Chnl to BT!!\n"));
3583                        pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_WIFI_CONNECTED, &bWifiConnected);
3584
3585                        if (bWifiConnected)
3586                                EXhalbtc8723b2ant_MediaStatusNotify(pBtCoexist, BTC_MEDIA_CONNECT);
3587                        else
3588                                EXhalbtc8723b2ant_MediaStatusNotify(pBtCoexist, BTC_MEDIA_DISCONNECT);
3589                }
3590
3591                if ((pCoexSta->btInfoExt & BIT3)) {
3592                        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], BT ext info bit3 check, set BT NOT to ignore Wlan active!!\n"));
3593                        halbtc8723b2ant_IgnoreWlanAct(pBtCoexist, FORCE_EXEC, false);
3594                } else {
3595                        /*  BT already NOT ignore Wlan active, do nothing here. */
3596                }
3597        }
3598
3599        /*  check BIT2 first ==> check if bt is under inquiry or page scan */
3600        if (btInfo & BT_INFO_8723B_2ANT_B_INQ_PAGE)
3601                pCoexSta->bC2hBtInquiryPage = true;
3602        else
3603                pCoexSta->bC2hBtInquiryPage = false;
3604
3605        /*  set link exist status */
3606        if (!(btInfo&BT_INFO_8723B_2ANT_B_CONNECTION)) {
3607                pCoexSta->bBtLinkExist = false;
3608                pCoexSta->bPanExist = false;
3609                pCoexSta->bA2dpExist = false;
3610                pCoexSta->bHidExist = false;
3611                pCoexSta->bScoExist = false;
3612        } else { /*  connection exists */
3613                pCoexSta->bBtLinkExist = true;
3614                if (btInfo & BT_INFO_8723B_2ANT_B_FTP)
3615                        pCoexSta->bPanExist = true;
3616                else
3617                        pCoexSta->bPanExist = false;
3618                if (btInfo & BT_INFO_8723B_2ANT_B_A2DP)
3619                        pCoexSta->bA2dpExist = true;
3620                else
3621                        pCoexSta->bA2dpExist = false;
3622                if (btInfo & BT_INFO_8723B_2ANT_B_HID)
3623                        pCoexSta->bHidExist = true;
3624                else
3625                        pCoexSta->bHidExist = false;
3626                if (btInfo & BT_INFO_8723B_2ANT_B_SCO_ESCO)
3627                        pCoexSta->bScoExist = true;
3628                else
3629                        pCoexSta->bScoExist = false;
3630        }
3631
3632        halbtc8723b2ant_UpdateBtLinkInfo(pBtCoexist);
3633
3634        if (!(btInfo&BT_INFO_8723B_2ANT_B_CONNECTION)) {
3635                pCoexDm->btStatus = BT_8723B_2ANT_BT_STATUS_NON_CONNECTED_IDLE;
3636                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], BtInfoNotify(), BT Non-Connected idle!!!\n"));
3637        } else if (btInfo == BT_INFO_8723B_2ANT_B_CONNECTION)   { /*  connection exists but no busy */
3638                pCoexDm->btStatus = BT_8723B_2ANT_BT_STATUS_CONNECTED_IDLE;
3639                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], BtInfoNotify(), BT Connected-idle!!!\n"));
3640        } else if (
3641                (btInfo&BT_INFO_8723B_2ANT_B_SCO_ESCO) ||
3642                (btInfo&BT_INFO_8723B_2ANT_B_SCO_BUSY)
3643        ) {
3644                pCoexDm->btStatus = BT_8723B_2ANT_BT_STATUS_SCO_BUSY;
3645                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], BtInfoNotify(), BT SCO busy!!!\n"));
3646        } else if (btInfo&BT_INFO_8723B_2ANT_B_ACL_BUSY) {
3647                pCoexDm->btStatus = BT_8723B_2ANT_BT_STATUS_ACL_BUSY;
3648                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], BtInfoNotify(), BT ACL busy!!!\n"));
3649        } else {
3650                pCoexDm->btStatus = BT_8723B_2ANT_BT_STATUS_MAX;
3651                BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], BtInfoNotify(), BT Non-Defined state!!!\n"));
3652        }
3653
3654        if (
3655                (BT_8723B_2ANT_BT_STATUS_ACL_BUSY == pCoexDm->btStatus) ||
3656                (BT_8723B_2ANT_BT_STATUS_SCO_BUSY == pCoexDm->btStatus) ||
3657                (BT_8723B_2ANT_BT_STATUS_ACL_SCO_BUSY == pCoexDm->btStatus)
3658        ) {
3659                bBtBusy = true;
3660                bLimitedDig = true;
3661        } else {
3662                bBtBusy = false;
3663                bLimitedDig = false;
3664        }
3665
3666        pBtCoexist->fBtcSet(pBtCoexist, BTC_SET_BL_BT_TRAFFIC_BUSY, &bBtBusy);
3667
3668        pCoexDm->bLimitedDig = bLimitedDig;
3669        pBtCoexist->fBtcSet(pBtCoexist, BTC_SET_BL_BT_LIMITED_DIG, &bLimitedDig);
3670
3671        halbtc8723b2ant_RunCoexistMechanism(pBtCoexist);
3672}
3673
3674void EXhalbtc8723b2ant_HaltNotify(PBTC_COEXIST pBtCoexist)
3675{
3676        BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY, ("[BTCoex], Halt notify\n"));
3677
3678        halbtc8723b2ant_WifiOffHwCfg(pBtCoexist);
3679        pBtCoexist->fBtcSetBtReg(pBtCoexist, BTC_BT_REG_RF, 0x3c, 0x15); /* BT goto standby while GNT_BT 1-->0 */
3680        halbtc8723b2ant_IgnoreWlanAct(pBtCoexist, FORCE_EXEC, true);
3681
3682        EXhalbtc8723b2ant_MediaStatusNotify(pBtCoexist, BTC_MEDIA_DISCONNECT);
3683}
3684
3685void EXhalbtc8723b2ant_PnpNotify(PBTC_COEXIST pBtCoexist, u8 pnpState)
3686{
3687        BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY, ("[BTCoex], Pnp notify\n"));
3688
3689        if (BTC_WIFI_PNP_SLEEP == pnpState) {
3690                BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY, ("[BTCoex], Pnp notify to SLEEP\n"));
3691        } else if (BTC_WIFI_PNP_WAKE_UP == pnpState) {
3692                BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY, ("[BTCoex], Pnp notify to WAKE UP\n"));
3693                halbtc8723b2ant_InitHwConfig(pBtCoexist, false);
3694                halbtc8723b2ant_InitCoexDm(pBtCoexist);
3695                halbtc8723b2ant_QueryBtInfo(pBtCoexist);
3696        }
3697}
3698
3699void EXhalbtc8723b2ant_Periodical(PBTC_COEXIST pBtCoexist)
3700{
3701        static u8 disVerInfoCnt;
3702        u32 fwVer = 0, btPatchVer = 0;
3703
3704        BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], ==========================Periodical ===========================\n"));
3705
3706        if (disVerInfoCnt <= 5) {
3707                disVerInfoCnt += 1;
3708                BTC_PRINT(BTC_MSG_INTERFACE, INTF_INIT, ("[BTCoex], ****************************************************************\n"));
3709                pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_U4_BT_PATCH_VER, &btPatchVer);
3710                pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_U4_WIFI_FW_VER, &fwVer);
3711                BTC_PRINT(BTC_MSG_INTERFACE, INTF_INIT, ("[BTCoex], CoexVer/ FwVer/ PatchVer = %d_%x/ 0x%x/ 0x%x(%d)\n", \
3712                        GLCoexVerDate8723b2Ant, GLCoexVer8723b2Ant, fwVer, btPatchVer, btPatchVer));
3713                BTC_PRINT(BTC_MSG_INTERFACE, INTF_INIT, ("[BTCoex], ****************************************************************\n"));
3714        }
3715
3716        if (
3717                halbtc8723b2ant_IsWifiStatusChanged(pBtCoexist) ||
3718                pCoexDm->bAutoTdmaAdjust
3719        )
3720                halbtc8723b2ant_RunCoexistMechanism(pBtCoexist);
3721}
3722