Refactor conditions check to follow the Linux kernel

coding style, which prefers placing the variable on the left side

of the comparison.

Reported by checkpatch:

    WARNING: Comparisons should place the constant on the right side

of the test

Signed-off-by: Erick Karanja <karanja99erick@gmail.com>

---

drivers/staging/rtl8723bs/hal/hal_btcoex.c | 22 +++++++++++-----------

1 file changed, 11 insertions(+), 11 deletions(-)

diff --git a/drivers/staging/rtl8723bs/hal/hal_btcoex.c b/drivers/staging/rtl8723bs/hal/hal_btcoex.c

index XXXXXXX..XXXXXXX 100644

--- a/drivers/staging/rtl8723bs/hal/hal_btcoex.c

+++ b/drivers/staging/rtl8723bs/hal/hal_btcoex.c

@@ -XXX,XX +XXX,XX @@ static void halbtcoutsrc_LeaveLowPower(struct btc_coexist *pBtCoexist)

    stime = jiffies;

    do {

        ready = rtw_register_task_alive(padapter, BTCOEX_ALIVE);

-        if (_SUCCESS == ready)

+        if (ready == _SUCCESS)

            break;

        utime = jiffies_to_msecs(jiffies - stime);

@@ -XXX,XX +XXX,XX @@ static void halbtcoutsrc_WriteLocalReg1Byte(void *pBtcContext, u32 RegAddr, u8 D

    struct btc_coexist *pBtCoexist = (struct btc_coexist *)pBtcContext;

    struct adapter *Adapter = pBtCoexist->Adapter;

-    if (BTC_INTF_SDIO == pBtCoexist->chipInterface)

+    if (pBtCoexist->chipInterface == BTC_INTF_SDIO)

        rtw_write8(Adapter, SDIO_LOCAL_BASE | RegAddr, Data);

    else

        rtw_write8(Adapter, RegAddr, Data);

@@ -XXX,XX +XXX,XX @@ void EXhalbtcoutsrc_IpsNotify(struct btc_coexist *pBtCoexist, u8 type)

    if (pBtCoexist->bManualControl)

        return;

-    if (IPS_NONE == type)

+    if (type == IPS_NONE)

        ipsType = BTC_IPS_LEAVE;

    else

        ipsType = BTC_IPS_ENTER;

@@ -XXX,XX +XXX,XX @@ void EXhalbtcoutsrc_LpsNotify(struct btc_coexist *pBtCoexist, u8 type)

    if (pBtCoexist->bManualControl)

        return;

-    if (PS_MODE_ACTIVE == type)

+    if (type == PS_MODE_ACTIVE)

        lpsType = BTC_LPS_DISABLE;

    else

        lpsType = BTC_LPS_ENABLE;

@@ -XXX,XX +XXX,XX @@ void EXhalbtcoutsrc_MediaStatusNotify(struct btc_coexist *pBtCoexist, enum

    if (pBtCoexist->bManualControl)

        return;

-    if (RT_MEDIA_CONNECT == mediaStatus)

+    if (mediaStatus == RT_MEDIA_CONNECT)

        mStatus = BTC_MEDIA_CONNECT;

    else

        mStatus = BTC_MEDIA_DISCONNECT;

@@ -XXX,XX +XXX,XX @@ void EXhalbtcoutsrc_SpecialPacketNotify(struct btc_coexist *pBtCoexist, u8 pktTy

    if (pBtCoexist->bManualControl)

        return;

-    if (PACKET_DHCP == pktType) {

+    if (pktType == PACKET_DHCP) {

        packetType = BTC_PACKET_DHCP;

-    } else if (PACKET_EAPOL == pktType) {

+    } else if (pktType == PACKET_EAPOL) {

        packetType = BTC_PACKET_EAPOL;

-    } else if (PACKET_ARP == pktType) {

+    } else if (pktType == PACKET_ARP) {

        packetType = BTC_PACKET_ARP;

    } else {

        return;

@@ -XXX,XX +XXX,XX @@ void EXhalbtcoutsrc_Periodical(struct btc_coexist *pBtCoexist)

void EXhalbtcoutsrc_SetAntNum(u8 type, u8 antNum)

{

-    if (BT_COEX_ANT_TYPE_PG == type) {

+    if (type == BT_COEX_ANT_TYPE_PG) {

        GLBtCoexist.boardInfo.pgAntNum = antNum;

        GLBtCoexist.boardInfo.btdmAntNum = antNum;

-    } else if (BT_COEX_ANT_TYPE_ANTDIV == type) {

+    } else if (type == BT_COEX_ANT_TYPE_ANTDIV) {

        GLBtCoexist.boardInfo.btdmAntNum = antNum;

        /* GLBtCoexist.boardInfo.btdmAntPos = BTC_ANTENNA_AT_MAIN_PORT; */

-    } else if (BT_COEX_ANT_TYPE_DETECTED == type) {

+    } else if (type == BT_COEX_ANT_TYPE_DETECTED) {

        GLBtCoexist.boardInfo.btdmAntNum = antNum;

        /* GLBtCoexist.boardInfo.btdmAntPos = BTC_ANTENNA_AT_MAIN_PORT; */

    }

--

2.43.0

Fix spacing around binary arithmetic (`+`) and shift (`>>`) operators

to improve readability and adhere to the Linux kernel coding style.

Reported by checkpatch:

    CHECK: spaces needed around 'operator'

Signed-off-by: Erick Karanja <karanja99erick@gmail.com>

---

drivers/staging/rtl8723bs/hal/odm_CfoTracking.c | 4 ++--

1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/drivers/staging/rtl8723bs/hal/odm_CfoTracking.c b/drivers/staging/rtl8723bs/hal/odm_CfoTracking.c

index XXXXXXX..XXXXXXX 100644

--- a/drivers/staging/rtl8723bs/hal/odm_CfoTracking.c

+++ b/drivers/staging/rtl8723bs/hal/odm_CfoTracking.c

@@ -XXX,XX +XXX,XX @@ void ODM_CfoTracking(void *pDM_VOID)

        /* 4 1.6 Big jump */

        if (pCfoTrack->bAdjust) {

            if (CFO_ave > CFO_TH_XTAL_LOW)

-                Adjust_Xtal = Adjust_Xtal+((CFO_ave-CFO_TH_XTAL_LOW)>>2);

+                Adjust_Xtal = Adjust_Xtal + ((CFO_ave-CFO_TH_XTAL_LOW) >> 2);

            else if (CFO_ave < (-CFO_TH_XTAL_LOW))

-                Adjust_Xtal = Adjust_Xtal+((CFO_TH_XTAL_LOW-CFO_ave)>>2);

+                Adjust_Xtal = Adjust_Xtal + ((CFO_TH_XTAL_LOW-CFO_ave) >> 2);

        }

        /* 4 1.7 Adjust Crystal Cap. */

--

2.43.0

Rename variables to adhere to Linux kernel coding

standards by using snake_case instead of CamelCase

and ensure proper encoding of the variables by removing

initial 'p' for pointers and initial 'b' for boolean.

Fixes checkpatch.pl warning:

CHECK: Avoid CamelCase: <supportRateNum>

Signed-off-by: Erick Karanja <karanja99erick@gmail.com>

---

.../staging/rtl8723bs/hal/HalBtc8723b1Ant.c | 1266 ++++++++---------

1 file changed, 633 insertions(+), 633 deletions(-)

diff --git a/drivers/staging/rtl8723bs/hal/HalBtc8723b1Ant.c b/drivers/staging/rtl8723bs/hal/HalBtc8723b1Ant.c

index XXXXXXX..XXXXXXX 100644

--- a/drivers/staging/rtl8723bs/hal/HalBtc8723b1Ant.c

+++ b/drivers/staging/rtl8723bs/hal/HalBtc8723b1Ant.c

@@ -XXX,XX +XXX,XX @@ static struct coex_sta_8723b_1ant *pCoexSta = &GLCoexSta8723b1Ant;

/* local function proto type if needed */

/* local function start with halbtc8723b1ant_ */

static u8 halbtc8723b1ant_BtRssiState(

-    u8 levelNum, u8 rssiThresh, u8 rssiThresh1

+    u8 level_num, u8 rssi_thresh, u8 rssi_thresh1

)

{

-    s32 btRssi = 0;

-    u8 btRssiState = pCoexSta->preBtRssiState;

+    s32 bt_rssi = 0;

+    u8 bt_rssi_state = pCoexSta->preBtRssiState;

-    btRssi = pCoexSta->btRssi;

+    bt_rssi = pCoexSta->bt_rssi;

-    if (levelNum == 2) {

+    if (level_num == 2) {

        if (

            (pCoexSta->preBtRssiState == BTC_RSSI_STATE_LOW) ||

            (pCoexSta->preBtRssiState == BTC_RSSI_STATE_STAY_LOW)

        ) {

-            if (btRssi >= (rssiThresh + BTC_RSSI_COEX_THRESH_TOL_8723B_1ANT))

+            if (bt_rssi >= (rssi_thresh + BTC_RSSI_COEX_THRESH_TOL_8723B_1ANT))

-                btRssiState = BTC_RSSI_STATE_HIGH;

+                bt_rssi_state = BTC_RSSI_STATE_HIGH;

            else

-                btRssiState = BTC_RSSI_STATE_STAY_LOW;

+                bt_rssi_state = BTC_RSSI_STATE_STAY_LOW;

        } else {

-            if (btRssi < rssiThresh)

-                btRssiState = BTC_RSSI_STATE_LOW;

+            if (bt_rssi < rssi_thresh)

+                bt_rssi_state = BTC_RSSI_STATE_LOW;

            else

-                btRssiState = BTC_RSSI_STATE_STAY_HIGH;

+                bt_rssi_state = BTC_RSSI_STATE_STAY_HIGH;

        }

-    } else if (levelNum == 3) {

-        if (rssiThresh > rssiThresh1)

+    } else if (level_num == 3) {

+        if (rssi_thresh > rssi_thresh1)

            return pCoexSta->preBtRssiState;

        if (

            (pCoexSta->preBtRssiState == BTC_RSSI_STATE_LOW) ||

            (pCoexSta->preBtRssiState == BTC_RSSI_STATE_STAY_LOW)

        ) {

-            if (btRssi >= (rssiThresh + BTC_RSSI_COEX_THRESH_TOL_8723B_1ANT))

-                btRssiState = BTC_RSSI_STATE_MEDIUM;

+            if (bt_rssi >= (rssi_thresh + BTC_RSSI_COEX_THRESH_TOL_8723B_1ANT))

+                bt_rssi_state = BTC_RSSI_STATE_MEDIUM;

            else

-                btRssiState = BTC_RSSI_STATE_STAY_LOW;

+                bt_rssi_state = BTC_RSSI_STATE_STAY_LOW;

        } else if (

            (pCoexSta->preBtRssiState == BTC_RSSI_STATE_MEDIUM) ||

            (pCoexSta->preBtRssiState == BTC_RSSI_STATE_STAY_MEDIUM)

        ) {

-            if (btRssi >= (rssiThresh1 + BTC_RSSI_COEX_THRESH_TOL_8723B_1ANT))

-                btRssiState = BTC_RSSI_STATE_HIGH;

-            else if (btRssi < rssiThresh)

-                btRssiState = BTC_RSSI_STATE_LOW;

+            if (bt_rssi >= (rssi_thresh1 + BTC_RSSI_COEX_THRESH_TOL_8723B_1ANT))

+                bt_rssi_state = BTC_RSSI_STATE_HIGH;

+            else if (bt_rssi < rssi_thresh)

+                bt_rssi_state = BTC_RSSI_STATE_LOW;

            else

-                btRssiState = BTC_RSSI_STATE_STAY_MEDIUM;

+                bt_rssi_state = BTC_RSSI_STATE_STAY_MEDIUM;

        } else {

-            if (btRssi < rssiThresh1)

-                btRssiState = BTC_RSSI_STATE_MEDIUM;

+            if (bt_rssi < rssi_thresh1)

+                bt_rssi_state = BTC_RSSI_STATE_MEDIUM;

            else

-                btRssiState = BTC_RSSI_STATE_STAY_HIGH;

+                bt_rssi_state = BTC_RSSI_STATE_STAY_HIGH;

        }

    }

-    pCoexSta->preBtRssiState = btRssiState;

+    pCoexSta->preBtRssiState = bt_rssi_state;

-    return btRssiState;

+    return bt_rssi_state;

}

static void halbtc8723b1ant_UpdateRaMask(

-    struct btc_coexist *pBtCoexist, bool bForceExec, u32 disRateMask

+    struct btc_coexist *bt_coexist, bool force_exec, u32 dis_rate_mask

)

{

-    pCoexDm->curRaMask = disRateMask;

+    pCoexDm->curRaMask = dis_rate_mask;

-    if (bForceExec || (pCoexDm->preRaMask != pCoexDm->curRaMask))

-        pBtCoexist->fBtcSet(

-            pBtCoexist,

+    if (force_exec || (pCoexDm->preRaMask != pCoexDm->curRaMask))

+        bt_coexist->fBtcSet(

+            bt_coexist,

            BTC_SET_ACT_UPDATE_RAMASK,

            &pCoexDm->curRaMask

        );

@@ -XXX,XX +XXX,XX @@ static void halbtc8723b1ant_UpdateRaMask(

}

static void halbtc8723b1ant_AutoRateFallbackRetry(

-    struct btc_coexist *pBtCoexist, bool bForceExec, u8 type

+    struct btc_coexist *bt_coexist, bool force_exec, u8 type

)

{

-    bool bWifiUnderBMode = false;

+    bool wifi_under_b_mode = false;

    pCoexDm->curArfrType = type;

-    if (bForceExec || (pCoexDm->preArfrType != pCoexDm->curArfrType)) {

+    if (force_exec || (pCoexDm->preArfrType != pCoexDm->curArfrType)) {

        switch (pCoexDm->curArfrType) {

        case 0:    /* normal mode */

-            pBtCoexist->fBtcWrite4Byte(

-                pBtCoexist, 0x430, pCoexDm->backupArfrCnt1

+            bt_coexist->fBtcWrite4Byte(

+                bt_coexist, 0x430, pCoexDm->backupArfrCnt1

            );

-            pBtCoexist->fBtcWrite4Byte(

-                pBtCoexist, 0x434, pCoexDm->backupArfrCnt2

+            bt_coexist->fBtcWrite4Byte(

+                bt_coexist, 0x434, pCoexDm->backupArfrCnt2

            );

            break;

        case 1:

-            pBtCoexist->fBtcGet(

-                pBtCoexist, BTC_GET_BL_WIFI_UNDER_B_MODE, &bWifiUnderBMode

+            bt_coexist->fBtcGet(

+                bt_coexist, BTC_GET_BL_WIFI_UNDER_B_MODE, &wifi_under_b_mode

            );

-            if (bWifiUnderBMode) {

-                pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0x430, 0x0);

-                pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0x434, 0x01010101);

+            if (wifi_under_b_mode) {

+                bt_coexist->fBtcWrite4Byte(bt_coexist, 0x430, 0x0);

+                bt_coexist->fBtcWrite4Byte(bt_coexist, 0x434, 0x01010101);

            } else {

-                pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0x430, 0x0);

-                pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0x434, 0x04030201);

+                bt_coexist->fBtcWrite4Byte(bt_coexist, 0x430, 0x0);

+                bt_coexist->fBtcWrite4Byte(bt_coexist, 0x434, 0x04030201);

            }

            break;

        default:

@@ -XXX,XX +XXX,XX @@ static void halbtc8723b1ant_AutoRateFallbackRetry(

}

static void halbtc8723b1ant_RetryLimit(

-    struct btc_coexist *pBtCoexist, bool bForceExec, u8 type

+    struct btc_coexist *bt_coexist, bool force_exec, u8 type

)

{

    pCoexDm->curRetryLimitType = type;

    if (

-        bForceExec ||

+        force_exec ||

        (pCoexDm->preRetryLimitType != pCoexDm->curRetryLimitType)

    ) {

        switch (pCoexDm->curRetryLimitType) {

        case 0:    /* normal mode */

-            pBtCoexist->fBtcWrite2Byte(

-                pBtCoexist, 0x42a, pCoexDm->backupRetryLimit

+            bt_coexist->fBtcWrite2Byte(

+                bt_coexist, 0x42a, pCoexDm->backupRetryLimit

            );

            break;

        case 1:    /* retry limit =8 */

-            pBtCoexist->fBtcWrite2Byte(pBtCoexist, 0x42a, 0x0808);

+            bt_coexist->fBtcWrite2Byte(bt_coexist, 0x42a, 0x0808);

            break;

        default:

            break;

@@ -XXX,XX +XXX,XX @@ static void halbtc8723b1ant_RetryLimit(

}

static void halbtc8723b1ant_AmpduMaxTime(

-    struct btc_coexist *pBtCoexist, bool bForceExec, u8 type

+    struct btc_coexist *bt_coexist, bool force_exec, u8 type

)

{

    pCoexDm->curAmpduTimeType = type;

    if (

-        bForceExec || (pCoexDm->preAmpduTimeType != pCoexDm->curAmpduTimeType)

+        force_exec || (pCoexDm->preAmpduTimeType != pCoexDm->curAmpduTimeType)

    ) {

        switch (pCoexDm->curAmpduTimeType) {

        case 0:    /* normal mode */

-            pBtCoexist->fBtcWrite1Byte(

-                pBtCoexist, 0x456, pCoexDm->backupAmpduMaxTime

+            bt_coexist->fBtcWrite1Byte(

+                bt_coexist, 0x456, pCoexDm->backupAmpduMaxTime

            );

            break;

        case 1:    /* AMPDU timw = 0x38 * 32us */

-            pBtCoexist->fBtcWrite1Byte(pBtCoexist, 0x456, 0x38);

+            bt_coexist->fBtcWrite1Byte(bt_coexist, 0x456, 0x38);

            break;

        default:

            break;

@@ -XXX,XX +XXX,XX @@ static void halbtc8723b1ant_AmpduMaxTime(

}

static void halbtc8723b1ant_LimitedTx(

-    struct btc_coexist *pBtCoexist,

-    bool bForceExec,

-    u8 raMaskType,

-    u8 arfrType,

-    u8 retryLimitType,

-    u8 ampduTimeType

+    struct btc_coexist *bt_coexist,

+    bool force_exec,

+    u8 ra_mask_type,

+    u8 arfr_type,

+    u8 retry_limit_type,

+    u8 ampdu_time_type

)

{

-    switch (raMaskType) {

+    switch (ra_mask_type) {

    case 0:    /* normal mode */

-        halbtc8723b1ant_UpdateRaMask(pBtCoexist, bForceExec, 0x0);

+        halbtc8723b1ant_UpdateRaMask(bt_coexist, force_exec, 0x0);

        break;

    case 1:    /* disable cck 1/2 */

-        halbtc8723b1ant_UpdateRaMask(pBtCoexist, bForceExec, 0x00000003);

+        halbtc8723b1ant_UpdateRaMask(bt_coexist, force_exec, 0x00000003);

        break;

    case 2:    /* disable cck 1/2/5.5, ofdm 6/9/12/18/24, mcs 0/1/2/3/4 */

-        halbtc8723b1ant_UpdateRaMask(pBtCoexist, bForceExec, 0x0001f1f7);

+        halbtc8723b1ant_UpdateRaMask(bt_coexist, force_exec, 0x0001f1f7);

        break;

    default:

        break;

    }

-    halbtc8723b1ant_AutoRateFallbackRetry(pBtCoexist, bForceExec, arfrType);

-    halbtc8723b1ant_RetryLimit(pBtCoexist, bForceExec, retryLimitType);

-    halbtc8723b1ant_AmpduMaxTime(pBtCoexist, bForceExec, ampduTimeType);

+    halbtc8723b1ant_AutoRateFallbackRetry(bt_coexist, force_exec, arfr_type);

+    halbtc8723b1ant_RetryLimit(bt_coexist, force_exec, retry_limit_type);

+    halbtc8723b1ant_AmpduMaxTime(bt_coexist, force_exec, ampdu_time_type);

}

static void halbtc8723b1ant_LimitedRx(

-    struct btc_coexist *pBtCoexist,

-    bool bForceExec,

-    bool bRejApAggPkt,

-    bool bBtCtrlAggBufSize,

-    u8 aggBufSize

+    struct btc_coexist *bt_coexist,

+    bool force_exec,

+    bool rej_ap_agg_pkt,

+    bool bt_ctrl_agg_buf_size,

+    u8 agg_buf_size

)

{

-    bool bRejectRxAgg = bRejApAggPkt;

-    bool bBtCtrlRxAggSize = bBtCtrlAggBufSize;

-    u8 rxAggSize = aggBufSize;

+    bool bRejectRxAgg = rej_ap_agg_pkt;

+    bool bBtCtrlRxAggSize = bt_ctrl_agg_buf_size;

+    u8 rxAggSize = agg_buf_size;

    /* */

    /*    Rx Aggregation related setting */

    /* */

-    pBtCoexist->fBtcSet(

-        pBtCoexist, BTC_SET_BL_TO_REJ_AP_AGG_PKT, &bRejectRxAgg

+    bt_coexist->fBtcSet(

+        bt_coexist, BTC_SET_BL_TO_REJ_AP_AGG_PKT, &bRejectRxAgg

    );

    /* decide BT control aggregation buf size or not */

-    pBtCoexist->fBtcSet(

-        pBtCoexist, BTC_SET_BL_BT_CTRL_AGG_SIZE, &bBtCtrlRxAggSize

+    bt_coexist->fBtcSet(

+        bt_coexist, BTC_SET_BL_BT_CTRL_AGG_SIZE, &bBtCtrlRxAggSize

    );

    /* aggregation buf size, only work when BT control Rx aggregation size. */

-    pBtCoexist->fBtcSet(pBtCoexist, BTC_SET_U1_AGG_BUF_SIZE, &rxAggSize);

+    bt_coexist->fBtcSet(bt_coexist, BTC_SET_U1_AGG_BUF_SIZE, &rxAggSize);

    /* real update aggregation setting */

-    pBtCoexist->fBtcSet(pBtCoexist, BTC_SET_ACT_AGGREGATE_CTRL, NULL);

+    bt_coexist->fBtcSet(bt_coexist, BTC_SET_ACT_AGGREGATE_CTRL, NULL);

}

-static void halbtc8723b1ant_QueryBtInfo(struct btc_coexist *pBtCoexist)

+static void halbtc8723b1ant_QueryBtInfo(struct btc_coexist *bt_coexist)

{

    u8 H2C_Parameter[1] = {0};

@@ -XXX,XX +XXX,XX @@ static void halbtc8723b1ant_QueryBtInfo(struct btc_coexist *pBtCoexist)

    H2C_Parameter[0] |= BIT0;    /* trigger */

-    pBtCoexist->fBtcFillH2c(pBtCoexist, 0x61, 1, H2C_Parameter);

+    bt_coexist->fBtcFillH2c(bt_coexist, 0x61, 1, H2C_Parameter);

}

-static void halbtc8723b1ant_MonitorBtCtr(struct btc_coexist *pBtCoexist)

+static void halbtc8723b1ant_MonitorBtCtr(struct btc_coexist *bt_coexist)

{

    u32 regHPTxRx, regLPTxRx, u4Tmp;

    u32 regHPTx = 0, regHPRx = 0, regLPTx = 0, regLPRx = 0;

    static u8 NumOfBtCounterChk;

/* to avoid 0x76e[3] = 1 (WLAN_Act control by PTA) during IPS */

-    /* if (! (pBtCoexist->fBtcRead1Byte(pBtCoexist, 0x76e) & 0x8)) */

+    /* if (! (bt_coexist->fBtcRead1Byte(bt_coexist, 0x76e) & 0x8)) */

    if (pCoexSta->bUnderIps) {

        pCoexSta->highPriorityTx = 65535;

@@ -XXX,XX +XXX,XX @@ static void halbtc8723b1ant_MonitorBtCtr(struct btc_coexist *pBtCoexist)

    regHPTxRx = 0x770;

    regLPTxRx = 0x774;

-    u4Tmp = pBtCoexist->fBtcRead4Byte(pBtCoexist, regHPTxRx);

+    u4Tmp = bt_coexist->fBtcRead4Byte(bt_coexist, regHPTxRx);

    regHPTx = u4Tmp & bMaskLWord;

    regHPRx = (u4Tmp & bMaskHWord) >> 16;

-    u4Tmp = pBtCoexist->fBtcRead4Byte(pBtCoexist, regLPTxRx);

+    u4Tmp = bt_coexist->fBtcRead4Byte(bt_coexist, regLPTxRx);

    regLPTx = u4Tmp & bMaskLWord;

    regLPRx = (u4Tmp & bMaskHWord) >> 16;

@@ -XXX,XX +XXX,XX @@ static void halbtc8723b1ant_MonitorBtCtr(struct btc_coexist *pBtCoexist)

        pCoexSta->popEventCnt++;

    /* reset counter */

-    pBtCoexist->fBtcWrite1Byte(pBtCoexist, 0x76e, 0xc);

+    bt_coexist->fBtcWrite1Byte(bt_coexist, 0x76e, 0xc);

    if ((regHPTx == 0) && (regHPRx == 0) && (regLPTx == 0) && (regLPRx == 0)) {

        NumOfBtCounterChk++;

        if (NumOfBtCounterChk >= 3) {

-            halbtc8723b1ant_QueryBtInfo(pBtCoexist);

+            halbtc8723b1ant_QueryBtInfo(bt_coexist);

            NumOfBtCounterChk = 0;

        }

    }

}

-static void halbtc8723b1ant_MonitorWiFiCtr(struct btc_coexist *pBtCoexist)

+static void halbtc8723b1ant_MonitorWiFiCtr(struct btc_coexist *bt_coexist)

{

-    s32    wifiRssi = 0;

-    bool bWifiBusy = false, bWifiUnderBMode = false;

+    s32    wifi_rssi = 0;

+    bool wifi_busy = false, wifi_under_b_mode = false;

    static u8 nCCKLockCounter;

-    pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_WIFI_BUSY, &bWifiBusy);

-    pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_S4_WIFI_RSSI, &wifiRssi);

-    pBtCoexist->fBtcGet(

-        pBtCoexist, BTC_GET_BL_WIFI_UNDER_B_MODE, &bWifiUnderBMode

+    bt_coexist->fBtcGet(bt_coexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy);

+    bt_coexist->fBtcGet(bt_coexist, BTC_GET_S4_WIFI_RSSI, &wifi_rssi);

+    bt_coexist->fBtcGet(

+        bt_coexist, BTC_GET_BL_WIFI_UNDER_B_MODE, &wifi_under_b_mode

    );

    if (pCoexSta->bUnderIps) {

@@ -XXX,XX +XXX,XX @@ static void halbtc8723b1ant_MonitorWiFiCtr(struct btc_coexist *pBtCoexist)

        pCoexSta->nCRCErr_11n = 0;

        pCoexSta->nCRCErr_11nAgg = 0;

    } else {

-        pCoexSta->nCRCOK_CCK    = pBtCoexist->fBtcRead4Byte(pBtCoexist, 0xf88);

-        pCoexSta->nCRCOK_11g    = pBtCoexist->fBtcRead2Byte(pBtCoexist, 0xf94);

-        pCoexSta->nCRCOK_11n    = pBtCoexist->fBtcRead2Byte(pBtCoexist, 0xf90);

-        pCoexSta->nCRCOK_11nAgg = pBtCoexist->fBtcRead2Byte(pBtCoexist, 0xfb8);

+        pCoexSta->nCRCOK_CCK    = bt_coexist->fBtcRead4Byte(bt_coexist, 0xf88);

+        pCoexSta->nCRCOK_11g    = bt_coexist->fBtcRead2Byte(bt_coexist, 0xf94);

+        pCoexSta->nCRCOK_11n    = bt_coexist->fBtcRead2Byte(bt_coexist, 0xf90);

+        pCoexSta->nCRCOK_11nAgg = bt_coexist->fBtcRead2Byte(bt_coexist, 0xfb8);

-        pCoexSta->nCRCErr_CCK     = pBtCoexist->fBtcRead4Byte(pBtCoexist, 0xf84);

-        pCoexSta->nCRCErr_11g     = pBtCoexist->fBtcRead2Byte(pBtCoexist, 0xf96);

-        pCoexSta->nCRCErr_11n     = pBtCoexist->fBtcRead2Byte(pBtCoexist, 0xf92);

-        pCoexSta->nCRCErr_11nAgg = pBtCoexist->fBtcRead2Byte(pBtCoexist, 0xfba);

+        pCoexSta->nCRCErr_CCK     = bt_coexist->fBtcRead4Byte(bt_coexist, 0xf84);

+        pCoexSta->nCRCErr_11g     = bt_coexist->fBtcRead2Byte(bt_coexist, 0xf96);

+        pCoexSta->nCRCErr_11n     = bt_coexist->fBtcRead2Byte(bt_coexist, 0xf92);

+        pCoexSta->nCRCErr_11nAgg = bt_coexist->fBtcRead2Byte(bt_coexist, 0xfba);

    }

    /* reset counter */

-    pBtCoexist->fBtcWrite1ByteBitMask(pBtCoexist, 0xf16, 0x1, 0x1);

-    pBtCoexist->fBtcWrite1ByteBitMask(pBtCoexist, 0xf16, 0x1, 0x0);

+    bt_coexist->fBtcWrite1ByteBitMask(bt_coexist, 0xf16, 0x1, 0x1);

+    bt_coexist->fBtcWrite1ByteBitMask(bt_coexist, 0xf16, 0x1, 0x0);

-    if (bWifiBusy && (wifiRssi >= 30) && !bWifiUnderBMode) {

+    if (wifi_busy && (wifi_rssi >= 30) && !wifi_under_b_mode) {

        if (

            (pCoexDm->btStatus == BT_8723B_1ANT_BT_STATUS_ACL_BUSY) ||

            (pCoexDm->btStatus == BT_8723B_1ANT_BT_STATUS_ACL_SCO_BUSY) ||

@@ -XXX,XX +XXX,XX @@ static void halbtc8723b1ant_MonitorWiFiCtr(struct btc_coexist *pBtCoexist)

}

-static bool halbtc8723b1ant_IsWifiStatusChanged(struct btc_coexist *pBtCoexist)

+static bool halbtc8723b1ant_IsWifiStatusChanged(struct btc_coexist *bt_coexist)

{

    static bool    bPreWifiBusy, bPreUnder4way, bPreBtHsOn;

-    bool bWifiBusy = false, bUnder4way = false, bBtHsOn = false;

+    bool wifi_busy = false, bUnder4way = false, bBtHsOn = false;

    bool bWifiConnected = false;

-    pBtCoexist->fBtcGet(

-        pBtCoexist, BTC_GET_BL_WIFI_CONNECTED, &bWifiConnected

+    bt_coexist->fBtcGet(

+        bt_coexist, BTC_GET_BL_WIFI_CONNECTED, &bWifiConnected

    );

-    pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_WIFI_BUSY, &bWifiBusy);

-    pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_HS_OPERATION, &bBtHsOn);

-    pBtCoexist->fBtcGet(

-        pBtCoexist, BTC_GET_BL_WIFI_4_WAY_PROGRESS, &bUnder4way

+    bt_coexist->fBtcGet(bt_coexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy);

+    bt_coexist->fBtcGet(bt_coexist, BTC_GET_BL_HS_OPERATION, &bBtHsOn);

+    bt_coexist->fBtcGet(

+        bt_coexist, BTC_GET_BL_WIFI_4_WAY_PROGRESS, &bUnder4way

    );

    if (bWifiConnected) {

-        if (bWifiBusy != bPreWifiBusy) {

-            bPreWifiBusy = bWifiBusy;

+        if (wifi_busy != bPreWifiBusy) {

+            bPreWifiBusy = wifi_busy;

            return true;

        }

@@ -XXX,XX +XXX,XX @@ static bool halbtc8723b1ant_IsWifiStatusChanged(struct btc_coexist *pBtCoexist)

    return false;

}

-static void halbtc8723b1ant_UpdateBtLinkInfo(struct btc_coexist *pBtCoexist)

+static void halbtc8723b1ant_UpdateBtLinkInfo(struct btc_coexist *bt_coexist)

{

-    struct btc_bt_link_info *pBtLinkInfo = &pBtCoexist->btLinkInfo;

+    struct btc_bt_link_info *pBtLinkInfo = &bt_coexist->btLinkInfo;

    bool bBtHsOn = false;

-    pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_HS_OPERATION, &bBtHsOn);

+    bt_coexist->fBtcGet(bt_coexist, BTC_GET_BL_HS_OPERATION, &bBtHsOn);

    pBtLinkInfo->bBtLinkExist = pCoexSta->bBtLinkExist;

    pBtLinkInfo->bScoExist = pCoexSta->bScoExist;

@@ -XXX,XX +XXX,XX @@ static void halbtc8723b1ant_UpdateBtLinkInfo(struct btc_coexist *pBtCoexist)

        pBtLinkInfo->bHidOnly = false;

}

-static u8 halbtc8723b1ant_ActionAlgorithm(struct btc_coexist *pBtCoexist)

+static u8 halbtc8723b1ant_ActionAlgorithm(struct btc_coexist *bt_coexist)

{

-    struct btc_bt_link_info *pBtLinkInfo = &pBtCoexist->btLinkInfo;

+    struct btc_bt_link_info *pBtLinkInfo = &bt_coexist->btLinkInfo;

    bool bBtHsOn = false;

    u8 algorithm = BT_8723B_1ANT_COEX_ALGO_UNDEFINED;

    u8 numOfDiffProfile = 0;

-    pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_HS_OPERATION, &bBtHsOn);

+    bt_coexist->fBtcGet(bt_coexist, BTC_GET_BL_HS_OPERATION, &bBtHsOn);

    if (!pBtLinkInfo->bBtLinkExist)

        return algorithm;

@@ -XXX,XX +XXX,XX @@ static u8 halbtc8723b1ant_ActionAlgorithm(struct btc_coexist *pBtCoexist)

}

static void halbtc8723b1ant_SetSwPenaltyTxRateAdaptive(

-    struct btc_coexist *pBtCoexist, bool bLowPenaltyRa

+    struct btc_coexist *bt_coexist, bool bLowPenaltyRa

)

{

    u8 H2C_Parameter[6] = {0};

@@ -XXX,XX +XXX,XX @@ static void halbtc8723b1ant_SetSwPenaltyTxRateAdaptive(

        H2C_Parameter[5] = 0xf9;    /* MCS5 or OFDM36 */

    }

-    pBtCoexist->fBtcFillH2c(pBtCoexist, 0x69, 6, H2C_Parameter);

+    bt_coexist->fBtcFillH2c(bt_coexist, 0x69, 6, H2C_Parameter);

}

static void halbtc8723b1ant_LowPenaltyRa(

-    struct btc_coexist *pBtCoexist, bool bForceExec, bool bLowPenaltyRa

+    struct btc_coexist *bt_coexist, bool force_exec, bool bLowPenaltyRa

)

{

    pCoexDm->bCurLowPenaltyRa = bLowPenaltyRa;

-    if (!bForceExec) {

+    if (!force_exec) {

        if (pCoexDm->bPreLowPenaltyRa == pCoexDm->bCurLowPenaltyRa)

            return;

    }

    halbtc8723b1ant_SetSwPenaltyTxRateAdaptive(

-        pBtCoexist, pCoexDm->bCurLowPenaltyRa

+        bt_coexist, pCoexDm->bCurLowPenaltyRa

    );

    pCoexDm->bPreLowPenaltyRa = pCoexDm->bCurLowPenaltyRa;

}

static void halbtc8723b1ant_SetCoexTable(

-    struct btc_coexist *pBtCoexist,

+    struct btc_coexist *bt_coexist,

    u32 val0x6c0,

    u32 val0x6c4,

    u32 val0x6c8,

    u8 val0x6cc

)

{

-    pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0x6c0, val0x6c0);

+    bt_coexist->fBtcWrite4Byte(bt_coexist, 0x6c0, val0x6c0);

-    pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0x6c4, val0x6c4);

+    bt_coexist->fBtcWrite4Byte(bt_coexist, 0x6c4, val0x6c4);

-    pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0x6c8, val0x6c8);

+    bt_coexist->fBtcWrite4Byte(bt_coexist, 0x6c8, val0x6c8);

-    pBtCoexist->fBtcWrite1Byte(pBtCoexist, 0x6cc, val0x6cc);

+    bt_coexist->fBtcWrite1Byte(bt_coexist, 0x6cc, val0x6cc);

}

static void halbtc8723b1ant_CoexTable(

-    struct btc_coexist *pBtCoexist,

-    bool bForceExec,

+    struct btc_coexist *bt_coexist,

+    bool force_exec,

    u32 val0x6c0,

    u32 val0x6c4,

    u32 val0x6c8,

@@ -XXX,XX +XXX,XX @@ static void halbtc8723b1ant_CoexTable(

    pCoexDm->curVal0x6c8 = val0x6c8;

    pCoexDm->curVal0x6cc = val0x6cc;

-    if (!bForceExec) {

+    if (!force_exec) {

        if (

            (pCoexDm->preVal0x6c0 == pCoexDm->curVal0x6c0) &&

         (pCoexDm->preVal0x6c4 == pCoexDm->curVal0x6c4) &&

@@ -XXX,XX +XXX,XX @@ static void halbtc8723b1ant_CoexTable(

    }

    halbtc8723b1ant_SetCoexTable(

-        pBtCoexist, val0x6c0, val0x6c4, val0x6c8, val0x6cc

+        bt_coexist, val0x6c0, val0x6c4, val0x6c8, val0x6cc

    );

    pCoexDm->preVal0x6c0 = pCoexDm->curVal0x6c0;

@@ -XXX,XX +XXX,XX @@ static void halbtc8723b1ant_CoexTable(

}

static void halbtc8723b1ant_CoexTableWithType(

-    struct btc_coexist *pBtCoexist, bool bForceExec, u8 type

+    struct btc_coexist *bt_coexist, bool force_exec, u8 type

)

{

    pCoexSta->nCoexTableType = type;

@@ -XXX,XX +XXX,XX @@ static void halbtc8723b1ant_CoexTableWithType(

    switch (type) {

    case 0:

        halbtc8723b1ant_CoexTable(

-            pBtCoexist, bForceExec, 0x55555555, 0x55555555, 0xffffff, 0x3

+            bt_coexist, force_exec, 0x55555555, 0x55555555, 0xffffff, 0x3

        );

        break;

    case 1:

        halbtc8723b1ant_CoexTable(

-            pBtCoexist, bForceExec, 0x55555555, 0x5a5a5a5a, 0xffffff, 0x3

+            bt_coexist, force_exec, 0x55555555, 0x5a5a5a5a, 0xffffff, 0x3

        );

        break;

    case 2:

        halbtc8723b1ant_CoexTable(

-            pBtCoexist, bForceExec, 0x5a5a5a5a, 0x5a5a5a5a, 0xffffff, 0x3

+            bt_coexist, force_exec, 0x5a5a5a5a, 0x5a5a5a5a, 0xffffff, 0x3

        );

        break;

    case 3:

        halbtc8723b1ant_CoexTable(

-            pBtCoexist, bForceExec, 0xaaaa5555, 0xaaaa5a5a, 0xffffff, 0x3

+            bt_coexist, force_exec, 0xaaaa5555, 0xaaaa5a5a, 0xffffff, 0x3

        );

        break;

    case 4:

        halbtc8723b1ant_CoexTable(

-            pBtCoexist, bForceExec, 0x55555555, 0xaaaa5a5a, 0xffffff, 0x3

+            bt_coexist, force_exec, 0x55555555, 0xaaaa5a5a, 0xffffff, 0x3

        );

        break;

    case 5:

        halbtc8723b1ant_CoexTable(

-            pBtCoexist, bForceExec, 0x5a5a5a5a, 0xaaaa5a5a, 0xffffff, 0x3

+            bt_coexist, force_exec, 0x5a5a5a5a, 0xaaaa5a5a, 0xffffff, 0x3

        );

        break;

    case 6:

        halbtc8723b1ant_CoexTable(

-            pBtCoexist, bForceExec, 0x55555555, 0xaaaaaaaa, 0xffffff, 0x3

+            bt_coexist, force_exec, 0x55555555, 0xaaaaaaaa, 0xffffff, 0x3

        );

        break;

    case 7:

        halbtc8723b1ant_CoexTable(

-            pBtCoexist, bForceExec, 0xaaaaaaaa, 0xaaaaaaaa, 0xffffff, 0x3

+            bt_coexist, force_exec, 0xaaaaaaaa, 0xaaaaaaaa, 0xffffff, 0x3

        );

        break;

    default:

@@ -XXX,XX +XXX,XX @@ static void halbtc8723b1ant_CoexTableWithType(

}

static void halbtc8723b1ant_SetFwIgnoreWlanAct(

-    struct btc_coexist *pBtCoexist, bool bEnable

+    struct btc_coexist *bt_coexist, bool bEnable

)

{

    u8 H2C_Parameter[1] = {0};

@@ -XXX,XX +XXX,XX @@ static void halbtc8723b1ant_SetFwIgnoreWlanAct(

    if (bEnable)

        H2C_Parameter[0] |= BIT0; /* function enable */

-    pBtCoexist->fBtcFillH2c(pBtCoexist, 0x63, 1, H2C_Parameter);

+    bt_coexist->fBtcFillH2c(bt_coexist, 0x63, 1, H2C_Parameter);

}

static void halbtc8723b1ant_IgnoreWlanAct(

-    struct btc_coexist *pBtCoexist, bool bForceExec, bool bEnable

+    struct btc_coexist *bt_coexist, bool force_exec, bool bEnable

)

{

    pCoexDm->bCurIgnoreWlanAct = bEnable;

-    if (!bForceExec) {

+    if (!force_exec) {

        if (pCoexDm->bPreIgnoreWlanAct == pCoexDm->bCurIgnoreWlanAct)

            return;

    }

-    halbtc8723b1ant_SetFwIgnoreWlanAct(pBtCoexist, bEnable);

+    halbtc8723b1ant_SetFwIgnoreWlanAct(bt_coexist, bEnable);

    pCoexDm->bPreIgnoreWlanAct = pCoexDm->bCurIgnoreWlanAct;

}

static void halbtc8723b1ant_SetLpsRpwm(

-    struct btc_coexist *pBtCoexist, u8 lpsVal, u8 rpwmVal

+    struct btc_coexist *bt_coexist, u8 lpsVal, u8 rpwmVal

)

{

    u8 lps = lpsVal;

    u8 rpwm = rpwmVal;

-    pBtCoexist->fBtcSet(pBtCoexist, BTC_SET_U1_LPS_VAL, &lps);

-    pBtCoexist->fBtcSet(pBtCoexist, BTC_SET_U1_RPWM_VAL, &rpwm);

+    bt_coexist->fBtcSet(bt_coexist, BTC_SET_U1_LPS_VAL, &lps);

+    bt_coexist->fBtcSet(bt_coexist, BTC_SET_U1_RPWM_VAL, &rpwm);

}

static void halbtc8723b1ant_LpsRpwm(

-    struct btc_coexist *pBtCoexist, bool bForceExec, u8 lpsVal, u8 rpwmVal

+    struct btc_coexist *bt_coexist, bool force_exec, u8 lpsVal, u8 rpwmVal

)

{

    pCoexDm->curLps = lpsVal;

    pCoexDm->curRpwm = rpwmVal;

-    if (!bForceExec) {

+    if (!force_exec) {

        if (

            (pCoexDm->preLps == pCoexDm->curLps) &&

            (pCoexDm->preRpwm == pCoexDm->curRpwm)

@@ -XXX,XX +XXX,XX @@ static void halbtc8723b1ant_LpsRpwm(

            return;

        }

    }

-    halbtc8723b1ant_SetLpsRpwm(pBtCoexist, lpsVal, rpwmVal);

+    halbtc8723b1ant_SetLpsRpwm(bt_coexist, lpsVal, rpwmVal);

    pCoexDm->preLps = pCoexDm->curLps;

    pCoexDm->preRpwm = pCoexDm->curRpwm;

}

static void halbtc8723b1ant_SwMechanism(

-    struct btc_coexist *pBtCoexist, bool bLowPenaltyRA

+    struct btc_coexist *bt_coexist, bool bLowPenaltyRA

)

{

-    halbtc8723b1ant_LowPenaltyRa(pBtCoexist, NORMAL_EXEC, bLowPenaltyRA);

+    halbtc8723b1ant_LowPenaltyRa(bt_coexist, NORMAL_EXEC, bLowPenaltyRA);

}

static void halbtc8723b1ant_SetAntPath(

-    struct btc_coexist *pBtCoexist, u8 antPosType, bool bInitHwCfg, bool bWifiOff

+    struct btc_coexist *bt_coexist, u8 antPosType, bool bInitHwCfg, bool bWifiOff

)

{

-    struct btc_board_info *pBoardInfo = &pBtCoexist->boardInfo;

+    struct btc_board_info *pBoardInfo = &bt_coexist->boardInfo;

    u32 fwVer = 0, u4Tmp = 0, cntBtCalChk = 0;

    bool bPgExtSwitch = false;

    bool bUseExtSwitch = false;

    bool bIsInMpMode = false;

    u8 H2C_Parameter[2] = {0}, u1Tmp = 0;

-    pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_EXT_SWITCH, &bPgExtSwitch);

-    pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_U4_WIFI_FW_VER, &fwVer); /* [31:16]=fw ver, [15:0]=fw sub ver */

+    bt_coexist->fBtcGet(bt_coexist, BTC_GET_BL_EXT_SWITCH, &bPgExtSwitch);

+    bt_coexist->fBtcGet(bt_coexist, BTC_GET_U4_WIFI_FW_VER, &fwVer); /* [31:16]=fw ver, [15:0]=fw sub ver */

    if ((fwVer > 0 && fwVer < 0xc0000) || bPgExtSwitch)

        bUseExtSwitch = true;

    if (bInitHwCfg) {

-        pBtCoexist->fBtcSetRfReg(pBtCoexist, BTC_RF_A, 0x1, 0xfffff, 0x780); /* WiFi TRx Mask on */

-        pBtCoexist->fBtcSetBtReg(pBtCoexist, BTC_BT_REG_RF, 0x3c, 0x15); /* BT TRx Mask on */

+        bt_coexist->fBtcSetRfReg(bt_coexist, BTC_RF_A, 0x1, 0xfffff, 0x780); /* WiFi TRx Mask on */

+        bt_coexist->fBtcSetBtReg(bt_coexist, BTC_BT_REG_RF, 0x3c, 0x15); /* BT TRx Mask on */

        if (fwVer >= 0x180000) {

            /* Use H2C to set GNT_BT to HIGH */

            H2C_Parameter[0] = 1;

-            pBtCoexist->fBtcFillH2c(pBtCoexist, 0x6E, 1, H2C_Parameter);

+            bt_coexist->fBtcFillH2c(bt_coexist, 0x6E, 1, H2C_Parameter);

        } else /* set grant_bt to high */

-            pBtCoexist->fBtcWrite1Byte(pBtCoexist, 0x765, 0x18);

+            bt_coexist->fBtcWrite1Byte(bt_coexist, 0x765, 0x18);

        /* set wlan_act control by PTA */

-        pBtCoexist->fBtcWrite1Byte(pBtCoexist, 0x76e, 0x4);

+        bt_coexist->fBtcWrite1Byte(bt_coexist, 0x76e, 0x4);

-        pBtCoexist->fBtcWrite1ByteBitMask(pBtCoexist, 0x67, 0x20, 0x1); /* BT select s0/s1 is controlled by WiFi */

+        bt_coexist->fBtcWrite1ByteBitMask(bt_coexist, 0x67, 0x20, 0x1); /* BT select s0/s1 is controlled by WiFi */

-        pBtCoexist->fBtcWrite1ByteBitMask(pBtCoexist, 0x39, 0x8, 0x1);

-        pBtCoexist->fBtcWrite1Byte(pBtCoexist, 0x974, 0xff);

-        pBtCoexist->fBtcWrite1ByteBitMask(pBtCoexist, 0x944, 0x3, 0x3);

-        pBtCoexist->fBtcWrite1Byte(pBtCoexist, 0x930, 0x77);

+        bt_coexist->fBtcWrite1ByteBitMask(bt_coexist, 0x39, 0x8, 0x1);

+        bt_coexist->fBtcWrite1Byte(bt_coexist, 0x974, 0xff);

+        bt_coexist->fBtcWrite1ByteBitMask(bt_coexist, 0x944, 0x3, 0x3);

+        bt_coexist->fBtcWrite1Byte(bt_coexist, 0x930, 0x77);

    } else if (bWifiOff) {

        if (fwVer >= 0x180000) {

            /* Use H2C to set GNT_BT to HIGH */

            H2C_Parameter[0] = 1;

-            pBtCoexist->fBtcFillH2c(pBtCoexist, 0x6E, 1, H2C_Parameter);

+            bt_coexist->fBtcFillH2c(bt_coexist, 0x6E, 1, H2C_Parameter);

        } else /* set grant_bt to high */

-            pBtCoexist->fBtcWrite1Byte(pBtCoexist, 0x765, 0x18);

+            bt_coexist->fBtcWrite1Byte(bt_coexist, 0x765, 0x18);

        /* set wlan_act to always low */

-        pBtCoexist->fBtcWrite1Byte(pBtCoexist, 0x76e, 0x4);

+        bt_coexist->fBtcWrite1Byte(bt_coexist, 0x76e, 0x4);

-        pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_WIFI_IS_IN_MP_MODE, &bIsInMpMode);

+        bt_coexist->fBtcGet(bt_coexist, BTC_GET_BL_WIFI_IS_IN_MP_MODE, &bIsInMpMode);

        if (!bIsInMpMode)

-            pBtCoexist->fBtcWrite1ByteBitMask(pBtCoexist, 0x67, 0x20, 0x0); /* BT select s0/s1 is controlled by BT */

+            bt_coexist->fBtcWrite1ByteBitMask(bt_coexist, 0x67, 0x20, 0x0); /* BT select s0/s1 is controlled by BT */

        else

-            pBtCoexist->fBtcWrite1ByteBitMask(pBtCoexist, 0x67, 0x20, 0x1); /* BT select s0/s1 is controlled by WiFi */

+            bt_coexist->fBtcWrite1ByteBitMask(bt_coexist, 0x67, 0x20, 0x1); /* BT select s0/s1 is controlled by WiFi */

        /* 0x4c[24:23]= 00, Set Antenna control by BT_RFE_CTRL    BT Vendor 0xac = 0xf002 */

-        u4Tmp = pBtCoexist->fBtcRead4Byte(pBtCoexist, 0x4c);

+        u4Tmp = bt_coexist->fBtcRead4Byte(bt_coexist, 0x4c);

        u4Tmp &= ~BIT23;

        u4Tmp &= ~BIT24;

-        pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0x4c, u4Tmp);

+        bt_coexist->fBtcWrite4Byte(bt_coexist, 0x4c, u4Tmp);

    } else {

        /* Use H2C to set GNT_BT to LOW */

        if (fwVer >= 0x180000) {

-            if (pBtCoexist->fBtcRead1Byte(pBtCoexist, 0x765) != 0) {

+            if (bt_coexist->fBtcRead1Byte(bt_coexist, 0x765) != 0) {

                H2C_Parameter[0] = 0;

-                pBtCoexist->fBtcFillH2c(pBtCoexist, 0x6E, 1, H2C_Parameter);

+                bt_coexist->fBtcFillH2c(bt_coexist, 0x6E, 1, H2C_Parameter);

            }

        } else {

            /* BT calibration check */

            while (cntBtCalChk <= 20) {

-                u1Tmp = pBtCoexist->fBtcRead1Byte(pBtCoexist, 0x49d);

+                u1Tmp = bt_coexist->fBtcRead1Byte(bt_coexist, 0x49d);

                cntBtCalChk++;

                if (u1Tmp & BIT0)

@@ -XXX,XX +XXX,XX @@ static void halbtc8723b1ant_SetAntPath(

            }

            /* set grant_bt to PTA */

-            pBtCoexist->fBtcWrite1Byte(pBtCoexist, 0x765, 0x0);

+            bt_coexist->fBtcWrite1Byte(bt_coexist, 0x765, 0x0);

        }

-        if (pBtCoexist->fBtcRead1Byte(pBtCoexist, 0x76e) != 0xc)

+        if (bt_coexist->fBtcRead1Byte(bt_coexist, 0x76e) != 0xc)

            /* set wlan_act control by PTA */

-            pBtCoexist->fBtcWrite1Byte(pBtCoexist, 0x76e, 0xc);

+            bt_coexist->fBtcWrite1Byte(bt_coexist, 0x76e, 0xc);

    }

    if (bUseExtSwitch) {

        if (bInitHwCfg) {

            /* 0x4c[23]= 0, 0x4c[24]= 1 Antenna control by WL/BT */

-            u4Tmp = pBtCoexist->fBtcRead4Byte(pBtCoexist, 0x4c);

+            u4Tmp = bt_coexist->fBtcRead4Byte(bt_coexist, 0x4c);

            u4Tmp &= ~BIT23;

            u4Tmp |= BIT24;

-            pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0x4c, u4Tmp);

+            bt_coexist->fBtcWrite4Byte(bt_coexist, 0x4c, u4Tmp);

-            pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0x948, 0x0); /* fixed internal switch S1->WiFi, S0->BT */

+            bt_coexist->fBtcWrite4Byte(bt_coexist, 0x948, 0x0); /* fixed internal switch S1->WiFi, S0->BT */

            if (pBoardInfo->btdmAntPos == BTC_ANTENNA_AT_MAIN_PORT) {

                /* tell firmware "no antenna inverse" */

                H2C_Parameter[0] = 0;

                H2C_Parameter[1] = 1; /* ext switch type */

-                pBtCoexist->fBtcFillH2c(pBtCoexist, 0x65, 2, H2C_Parameter);

+                bt_coexist->fBtcFillH2c(bt_coexist, 0x65, 2, H2C_Parameter);

            } else {

                /* tell firmware "antenna inverse" */

                H2C_Parameter[0] = 1;

                H2C_Parameter[1] = 1; /* ext switch type */

-                pBtCoexist->fBtcFillH2c(pBtCoexist, 0x65, 2, H2C_Parameter);

+                bt_coexist->fBtcFillH2c(bt_coexist, 0x65, 2, H2C_Parameter);

            }

        }

@@ -XXX,XX +XXX,XX @@ static void halbtc8723b1ant_SetAntPath(

        switch (antPosType) {

        case BTC_ANT_PATH_WIFI:

            if (pBoardInfo->btdmAntPos == BTC_ANTENNA_AT_MAIN_PORT)

-                pBtCoexist->fBtcWrite1ByteBitMask(pBtCoexist, 0x92c, 0x3, 0x1);

+                bt_coexist->fBtcWrite1ByteBitMask(bt_coexist, 0x92c, 0x3, 0x1);

            else

-                pBtCoexist->fBtcWrite1ByteBitMask(pBtCoexist, 0x92c, 0x3, 0x2);

+                bt_coexist->fBtcWrite1ByteBitMask(bt_coexist, 0x92c, 0x3, 0x2);

            break;

        case BTC_ANT_PATH_BT:

            if (pBoardInfo->btdmAntPos == BTC_ANTENNA_AT_MAIN_PORT)

-                pBtCoexist->fBtcWrite1ByteBitMask(pBtCoexist, 0x92c, 0x3, 0x2);

+                bt_coexist->fBtcWrite1ByteBitMask(bt_coexist, 0x92c, 0x3, 0x2);

            else

-                pBtCoexist->fBtcWrite1ByteBitMask(pBtCoexist, 0x92c, 0x3, 0x1);

+                bt_coexist->fBtcWrite1ByteBitMask(bt_coexist, 0x92c, 0x3, 0x1);

            break;

        default:

        case BTC_ANT_PATH_PTA:

            if (pBoardInfo->btdmAntPos == BTC_ANTENNA_AT_MAIN_PORT)

-                pBtCoexist->fBtcWrite1ByteBitMask(pBtCoexist, 0x92c, 0x3, 0x1);

+                bt_coexist->fBtcWrite1ByteBitMask(bt_coexist, 0x92c, 0x3, 0x1);

            else

-                pBtCoexist->fBtcWrite1ByteBitMask(pBtCoexist, 0x92c, 0x3, 0x2);

+                bt_coexist->fBtcWrite1ByteBitMask(bt_coexist, 0x92c, 0x3, 0x2);

            break;

        }

    } else {

        if (bInitHwCfg) {

            /* 0x4c[23]= 1, 0x4c[24]= 0 Antenna control by 0x64 */

-            u4Tmp = pBtCoexist->fBtcRead4Byte(pBtCoexist, 0x4c);

+            u4Tmp = bt_coexist->fBtcRead4Byte(bt_coexist, 0x4c);

            u4Tmp |= BIT23;

            u4Tmp &= ~BIT24;

-            pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0x4c, u4Tmp);

+            bt_coexist->fBtcWrite4Byte(bt_coexist, 0x4c, u4Tmp);

            /* Fix Ext switch Main->S1, Aux->S0 */

-            pBtCoexist->fBtcWrite1ByteBitMask(pBtCoexist, 0x64, 0x1, 0x0);

+            bt_coexist->fBtcWrite1ByteBitMask(bt_coexist, 0x64, 0x1, 0x0);

            if (pBoardInfo->btdmAntPos == BTC_ANTENNA_AT_MAIN_PORT) {

                /* tell firmware "no antenna inverse" */

                H2C_Parameter[0] = 0;

                H2C_Parameter[1] = 0; /* internal switch type */

-                pBtCoexist->fBtcFillH2c(pBtCoexist, 0x65, 2, H2C_Parameter);

+                bt_coexist->fBtcFillH2c(bt_coexist, 0x65, 2, H2C_Parameter);

            } else {

                /* tell firmware "antenna inverse" */

                H2C_Parameter[0] = 1;

                H2C_Parameter[1] = 0; /* internal switch type */

-                pBtCoexist->fBtcFillH2c(pBtCoexist, 0x65, 2, H2C_Parameter);

+                bt_coexist->fBtcFillH2c(bt_coexist, 0x65, 2, H2C_Parameter);

            }

        }

@@ -XXX,XX +XXX,XX @@ static void halbtc8723b1ant_SetAntPath(

        switch (antPosType) {

        case BTC_ANT_PATH_WIFI:

            if (pBoardInfo->btdmAntPos == BTC_ANTENNA_AT_MAIN_PORT)

-                pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0x948, 0x0);

+                bt_coexist->fBtcWrite4Byte(bt_coexist, 0x948, 0x0);

            else

-                pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0x948, 0x280);

+                bt_coexist->fBtcWrite4Byte(bt_coexist, 0x948, 0x280);

            break;

        case BTC_ANT_PATH_BT:

            if (pBoardInfo->btdmAntPos == BTC_ANTENNA_AT_MAIN_PORT)

-                pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0x948, 0x280);

+                bt_coexist->fBtcWrite4Byte(bt_coexist, 0x948, 0x280);

            else

-                pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0x948, 0x0);

+                bt_coexist->fBtcWrite4Byte(bt_coexist, 0x948, 0x0);

            break;

        default:

        case BTC_ANT_PATH_PTA:

            if (pBoardInfo->btdmAntPos == BTC_ANTENNA_AT_MAIN_PORT)

-                pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0x948, 0x200);

+                bt_coexist->fBtcWrite4Byte(bt_coexist, 0x948, 0x200);

            else

-                pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0x948, 0x80);

+                bt_coexist->fBtcWrite4Byte(bt_coexist, 0x948, 0x80);

            break;

        }

    }

}

static void halbtc8723b1ant_SetFwPstdma(

-    struct btc_coexist *pBtCoexist, u8 byte1, u8 byte2, u8 byte3, u8 byte4, u8 byte5

+    struct btc_coexist *bt_coexist, u8 byte1, u8 byte2, u8 byte3, u8 byte4, u8 byte5

)

{

    u8 H2C_Parameter[5] = {0};

    u8 realByte1 = byte1, realByte5 = byte5;

    bool bApEnable = false;

-    pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_WIFI_AP_MODE_ENABLE, &bApEnable);

+    bt_coexist->fBtcGet(bt_coexist, BTC_GET_BL_WIFI_AP_MODE_ENABLE, &bApEnable);

    if (bApEnable) {

        if (byte1 & BIT4 && !(byte1 & BIT5)) {

@@ -XXX,XX +XXX,XX @@ static void halbtc8723b1ant_SetFwPstdma(

    pCoexDm->psTdmaPara[3] = byte4;

    pCoexDm->psTdmaPara[4] = realByte5;

-    pBtCoexist->fBtcFillH2c(pBtCoexist, 0x60, 5, H2C_Parameter);

+    bt_coexist->fBtcFillH2c(bt_coexist, 0x60, 5, H2C_Parameter);

}