diff options
Diffstat (limited to 'drivers/staging/rtl8821ae/btcoexist/HalBtc8812a1Ant.c')
-rw-r--r-- | drivers/staging/rtl8821ae/btcoexist/HalBtc8812a1Ant.c | 3976 |
1 files changed, 3976 insertions, 0 deletions
diff --git a/drivers/staging/rtl8821ae/btcoexist/HalBtc8812a1Ant.c b/drivers/staging/rtl8821ae/btcoexist/HalBtc8812a1Ant.c new file mode 100644 index 00000000000..b30f17ae021 --- /dev/null +++ b/drivers/staging/rtl8821ae/btcoexist/HalBtc8812a1Ant.c @@ -0,0 +1,3976 @@ +//============================================================ +// Description: +// +// This file is for 8812a1ant Co-exist mechanism +// +// History +// 2012/11/15 Cosa first check in. +// +//============================================================ + +//============================================================ +// include files +//============================================================ +#include "halbt_precomp.h" +#if 1 +//============================================================ +// Global variables, these are static variables +//============================================================ +static COEX_DM_8812A_1ANT GLCoexDm8812a1Ant; +static PCOEX_DM_8812A_1ANT coex_dm=&GLCoexDm8812a1Ant; +static COEX_STA_8812A_1ANT GLCoexSta8812a1Ant; +static PCOEX_STA_8812A_1ANT coex_sta=&GLCoexSta8812a1Ant; + +const char *const GLBtInfoSrc8812a1Ant[]={ + "BT Info[wifi fw]", + "BT Info[bt rsp]", + "BT Info[bt auto report]", +}; + +//============================================================ +// local function proto type if needed +//============================================================ +//============================================================ +// local function start with halbtc8812a1ant_ +//============================================================ +#if 0 +void +halbtc8812a1ant_Reg0x550Bit3( + PBTC_COEXIST btcoexist, + BOOLEAN bSet + ) +{ + u1Byte u1tmp=0; + + u1tmp = btcoexist->btc_read_1byte(btcoexist, 0x550); + if(bSet) + { + u1tmp |= BIT3; + } + else + { + u1tmp &= ~BIT3; + } + btcoexist->btc_write_1byte(btcoexist, 0x550, u1tmp); + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], set 0x550[3]=%d\n", (bSet? 1:0))); +} +#endif +u1Byte +halbtc8812a1ant_BtRssiState( + u1Byte level_num, + u1Byte rssi_thresh, + u1Byte rssi_thresh1 + ) +{ + s4Byte bt_rssi=0; + u1Byte bt_rssi_state; + + bt_rssi = coex_sta->bt_rssi; + + if(level_num == 2) + { + if( (coex_sta->pre_bt_rssi_state == BTC_RSSI_STATE_LOW) || + (coex_sta->pre_bt_rssi_state == BTC_RSSI_STATE_STAY_LOW)) + { + if(bt_rssi >= (rssi_thresh+BTC_RSSI_COEX_THRESH_TOL_8812A_1ANT)) + { + bt_rssi_state = BTC_RSSI_STATE_HIGH; + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE, ("[BTCoex], BT Rssi state switch to High\n")); + } + else + { + bt_rssi_state = BTC_RSSI_STATE_STAY_LOW; + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE, ("[BTCoex], BT Rssi state stay at Low\n")); + } + } + else + { + if(bt_rssi < rssi_thresh) + { + bt_rssi_state = BTC_RSSI_STATE_LOW; + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE, ("[BTCoex], BT Rssi state switch to Low\n")); + } + else + { + bt_rssi_state = BTC_RSSI_STATE_STAY_HIGH; + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE, ("[BTCoex], BT Rssi state stay at High\n")); + } + } + } + else if(level_num == 3) + { + if(rssi_thresh > rssi_thresh1) + { + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE, ("[BTCoex], BT Rssi thresh error!!\n")); + return coex_sta->pre_bt_rssi_state; + } + + if( (coex_sta->pre_bt_rssi_state == BTC_RSSI_STATE_LOW) || + (coex_sta->pre_bt_rssi_state == BTC_RSSI_STATE_STAY_LOW)) + { + if(bt_rssi >= (rssi_thresh+BTC_RSSI_COEX_THRESH_TOL_8812A_1ANT)) + { + bt_rssi_state = BTC_RSSI_STATE_MEDIUM; + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE, ("[BTCoex], BT Rssi state switch to Medium\n")); + } + else + { + bt_rssi_state = BTC_RSSI_STATE_STAY_LOW; + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE, ("[BTCoex], BT Rssi state stay at Low\n")); + } + } + else if( (coex_sta->pre_bt_rssi_state == BTC_RSSI_STATE_MEDIUM) || + (coex_sta->pre_bt_rssi_state == BTC_RSSI_STATE_STAY_MEDIUM)) + { + if(bt_rssi >= (rssi_thresh1+BTC_RSSI_COEX_THRESH_TOL_8812A_1ANT)) + { + bt_rssi_state = BTC_RSSI_STATE_HIGH; + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE, ("[BTCoex], BT Rssi state switch to High\n")); + } + else if(bt_rssi < rssi_thresh) + { + bt_rssi_state = BTC_RSSI_STATE_LOW; + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE, ("[BTCoex], BT Rssi state switch to Low\n")); + } + else + { + bt_rssi_state = BTC_RSSI_STATE_STAY_MEDIUM; + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE, ("[BTCoex], BT Rssi state stay at Medium\n")); + } + } + else + { + if(bt_rssi < rssi_thresh1) + { + bt_rssi_state = BTC_RSSI_STATE_MEDIUM; + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE, ("[BTCoex], BT Rssi state switch to Medium\n")); + } + else + { + bt_rssi_state = BTC_RSSI_STATE_STAY_HIGH; + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE, ("[BTCoex], BT Rssi state stay at High\n")); + } + } + } + + coex_sta->pre_bt_rssi_state = bt_rssi_state; + + return bt_rssi_state; +} + +u1Byte +halbtc8812a1ant_WifiRssiState( + PBTC_COEXIST btcoexist, + u1Byte index, + u1Byte level_num, + u1Byte rssi_thresh, + u1Byte rssi_thresh1 + ) +{ + s4Byte wifi_rssi=0; + u1Byte wifi_rssi_state; + + btcoexist->btc_get(btcoexist, BTC_GET_S4_WIFI_RSSI, &wifi_rssi); + + if(level_num == 2) + { + if( (coex_sta->pre_wifi_rssi_state[index] == BTC_RSSI_STATE_LOW) || + (coex_sta->pre_wifi_rssi_state[index] == BTC_RSSI_STATE_STAY_LOW)) + { + if(wifi_rssi >= (rssi_thresh+BTC_RSSI_COEX_THRESH_TOL_8812A_1ANT)) + { + wifi_rssi_state = BTC_RSSI_STATE_HIGH; + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_WIFI_RSSI_STATE, ("[BTCoex], wifi RSSI state switch to High\n")); + } + else + { + wifi_rssi_state = BTC_RSSI_STATE_STAY_LOW; + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_WIFI_RSSI_STATE, ("[BTCoex], wifi RSSI state stay at Low\n")); + } + } + else + { + if(wifi_rssi < rssi_thresh) + { + wifi_rssi_state = BTC_RSSI_STATE_LOW; + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_WIFI_RSSI_STATE, ("[BTCoex], wifi RSSI state switch to Low\n")); + } + else + { + wifi_rssi_state = BTC_RSSI_STATE_STAY_HIGH; + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_WIFI_RSSI_STATE, ("[BTCoex], wifi RSSI state stay at High\n")); + } + } + } + else if(level_num == 3) + { + if(rssi_thresh > rssi_thresh1) + { + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_WIFI_RSSI_STATE, ("[BTCoex], wifi RSSI thresh error!!\n")); + return coex_sta->pre_wifi_rssi_state[index]; + } + + if( (coex_sta->pre_wifi_rssi_state[index] == BTC_RSSI_STATE_LOW) || + (coex_sta->pre_wifi_rssi_state[index] == BTC_RSSI_STATE_STAY_LOW)) + { + if(wifi_rssi >= (rssi_thresh+BTC_RSSI_COEX_THRESH_TOL_8812A_1ANT)) + { + wifi_rssi_state = BTC_RSSI_STATE_MEDIUM; + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_WIFI_RSSI_STATE, ("[BTCoex], wifi RSSI state switch to Medium\n")); + } + else + { + wifi_rssi_state = BTC_RSSI_STATE_STAY_LOW; + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_WIFI_RSSI_STATE, ("[BTCoex], wifi RSSI state stay at Low\n")); + } + } + else if( (coex_sta->pre_wifi_rssi_state[index] == BTC_RSSI_STATE_MEDIUM) || + (coex_sta->pre_wifi_rssi_state[index] == BTC_RSSI_STATE_STAY_MEDIUM)) + { + if(wifi_rssi >= (rssi_thresh1+BTC_RSSI_COEX_THRESH_TOL_8812A_1ANT)) + { + wifi_rssi_state = BTC_RSSI_STATE_HIGH; + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_WIFI_RSSI_STATE, ("[BTCoex], wifi RSSI state switch to High\n")); + } + else if(wifi_rssi < rssi_thresh) + { + wifi_rssi_state = BTC_RSSI_STATE_LOW; + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_WIFI_RSSI_STATE, ("[BTCoex], wifi RSSI state switch to Low\n")); + } + else + { + wifi_rssi_state = BTC_RSSI_STATE_STAY_MEDIUM; + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_WIFI_RSSI_STATE, ("[BTCoex], wifi RSSI state stay at Medium\n")); + } + } + else + { + if(wifi_rssi < rssi_thresh1) + { + wifi_rssi_state = BTC_RSSI_STATE_MEDIUM; + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_WIFI_RSSI_STATE, ("[BTCoex], wifi RSSI state switch to Medium\n")); + } + else + { + wifi_rssi_state = BTC_RSSI_STATE_STAY_HIGH; + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_WIFI_RSSI_STATE, ("[BTCoex], wifi RSSI state stay at High\n")); + } + } + } + + coex_sta->pre_wifi_rssi_state[index] = wifi_rssi_state; + + return wifi_rssi_state; +} + +void +halbtc8812a1ant_MonitorBtEnableDisable( + PBTC_COEXIST btcoexist + ) +{ + static BOOLEAN pre_bt_disabled=false; + static u4Byte bt_disable_cnt=0; + BOOLEAN bt_active=true, bt_disable_by68=false, bt_disabled=false; + u4Byte u4_tmp=0; + + // This function check if bt is disabled + + if( coex_sta->high_priority_tx == 0 && + coex_sta->high_priority_rx == 0 && + coex_sta->low_priority_tx == 0 && + coex_sta->low_priority_rx == 0) + { + bt_active = false; + } + if( coex_sta->high_priority_tx == 0xffff && + coex_sta->high_priority_rx == 0xffff && + coex_sta->low_priority_tx == 0xffff && + coex_sta->low_priority_rx == 0xffff) + { + bt_active = false; + } + if(bt_active) + { + bt_disable_cnt = 0; + bt_disabled = false; + btcoexist->btc_set(btcoexist, BTC_SET_BL_BT_DISABLE, &bt_disabled); + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_MONITOR, ("[BTCoex], BT is enabled !!\n")); + } + else + { + bt_disable_cnt++; + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_MONITOR, ("[BTCoex], bt all counters=0, %d times!!\n", + bt_disable_cnt)); + if(bt_disable_cnt >= 2 ||bt_disable_by68) + { + bt_disabled = true; + btcoexist->btc_set(btcoexist, BTC_SET_BL_BT_DISABLE, &bt_disabled); + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_MONITOR, ("[BTCoex], BT is disabled !!\n")); + } + } + if(pre_bt_disabled != bt_disabled) + { + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_MONITOR, ("[BTCoex], BT is from %s to %s!!\n", + (pre_bt_disabled ? "disabled":"enabled"), + (bt_disabled ? "disabled":"enabled"))); + pre_bt_disabled = bt_disabled; + if(!bt_disabled) + { + } + else + { + } + } +} + +void +halbtc8812a1ant_MonitorBtCtr( + PBTC_COEXIST btcoexist + ) +{ + u4Byte reg_hp_tx_rx, reg_lp_tx_rx, u4_tmp; + u4Byte reg_hp_tx=0, reg_hp_rx=0, reg_lp_tx=0, reg_lp_rx=0; + u1Byte u1_tmp; + + reg_hp_tx_rx = 0x770; + reg_lp_tx_rx = 0x774; + + u4_tmp = btcoexist->btc_read_4byte(btcoexist, reg_hp_tx_rx); + reg_hp_tx = u4_tmp & bMaskLWord; + reg_hp_rx = (u4_tmp & bMaskHWord)>>16; + + u4_tmp = btcoexist->btc_read_4byte(btcoexist, reg_lp_tx_rx); + reg_lp_tx = u4_tmp & bMaskLWord; + reg_lp_rx = (u4_tmp & bMaskHWord)>>16; + + coex_sta->high_priority_tx = reg_hp_tx; + coex_sta->high_priority_rx = reg_hp_rx; + coex_sta->low_priority_tx = reg_lp_tx; + coex_sta->low_priority_rx = reg_lp_rx; + + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_MONITOR, ("[BTCoex], High Priority Tx/Rx (reg 0x%x)=%x(%d)/%x(%d)\n", + reg_hp_tx_rx, reg_hp_tx, reg_hp_tx, reg_hp_rx, reg_hp_rx)); + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_MONITOR, ("[BTCoex], Low Priority Tx/Rx (reg 0x%x)=%x(%d)/%x(%d)\n", + reg_lp_tx_rx, reg_lp_tx, reg_lp_tx, reg_lp_rx, reg_lp_rx)); + + // reset counter + btcoexist->btc_write_1byte(btcoexist, 0x76e, 0xc); +} + +void +halbtc8812a1ant_QueryBtInfo( + PBTC_COEXIST btcoexist + ) +{ + u1Byte dataLen=3; + u1Byte buf[5] = {0}; + static u4Byte btInfoCnt=0; + + if(!btInfoCnt || + (coex_sta->bt_info_c2h_cnt[BT_INFO_SRC_8812A_1ANT_BT_RSP]-btInfoCnt)>2) + { + buf[0] = dataLen; + buf[1] = 0x1; // polling enable, 1=enable, 0=disable + buf[2] = 0x2; // polling time in seconds + buf[3] = 0x1; // auto report enable, 1=enable, 0=disable + + btcoexist->btc_set(btcoexist, BTC_SET_ACT_CTRL_BT_INFO, (PVOID)&buf[0]); + } + btInfoCnt = coex_sta->bt_info_c2h_cnt[BT_INFO_SRC_8812A_1ANT_BT_RSP]; +} +u1Byte +halbtc8812a1ant_ActionAlgorithm( + PBTC_COEXIST btcoexist + ) +{ + PBTC_STACK_INFO stack_info=&btcoexist->stack_info; + BOOLEAN bt_hs_on=false; + u1Byte algorithm=BT_8812A_1ANT_COEX_ALGO_UNDEFINED; + u1Byte num_of_diff_profile=0; + + btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION, &bt_hs_on); + + if(!stack_info->bt_link_exist) + { + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], No profile exists!!!\n")); + return algorithm; + } + + if(stack_info->sco_exist) + num_of_diff_profile++; + if(stack_info->hid_exist) + num_of_diff_profile++; + if(stack_info->pan_exist) + num_of_diff_profile++; + if(stack_info->a2dp_exist) + num_of_diff_profile++; + + if(num_of_diff_profile == 1) + { + if(stack_info->sco_exist) + { + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], SCO only\n")); + algorithm = BT_8812A_1ANT_COEX_ALGO_SCO; + } + else + { + if(stack_info->hid_exist) + { + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], HID only\n")); + algorithm = BT_8812A_1ANT_COEX_ALGO_HID; + } + else if(stack_info->a2dp_exist) + { + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], A2DP only\n")); + algorithm = BT_8812A_1ANT_COEX_ALGO_A2DP; + } + else if(stack_info->pan_exist) + { + if(bt_hs_on) + { + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], PAN(HS) only\n")); + algorithm = BT_8812A_1ANT_COEX_ALGO_PANHS; + } + else + { + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], PAN(EDR) only\n")); + algorithm = BT_8812A_1ANT_COEX_ALGO_PANEDR; + } + } + } + } + else if(num_of_diff_profile == 2) + { + if(stack_info->sco_exist) + { + if(stack_info->hid_exist) + { + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], SCO + HID\n")); + algorithm = BT_8812A_1ANT_COEX_ALGO_HID; + } + else if(stack_info->a2dp_exist) + { + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], SCO + A2DP ==> SCO\n")); + algorithm = BT_8812A_1ANT_COEX_ALGO_SCO; + } + else if(stack_info->pan_exist) + { + if(bt_hs_on) + { + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], SCO + PAN(HS)\n")); + algorithm = BT_8812A_1ANT_COEX_ALGO_SCO; + } + else + { + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], SCO + PAN(EDR)\n")); + algorithm = BT_8812A_1ANT_COEX_ALGO_PANEDR_HID; + } + } + } + else + { + if( stack_info->hid_exist && + stack_info->a2dp_exist ) + { + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], HID + A2DP\n")); + algorithm = BT_8812A_1ANT_COEX_ALGO_HID_A2DP; + } + else if( stack_info->hid_exist && + stack_info->pan_exist ) + { + if(bt_hs_on) + { + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], HID + PAN(HS)\n")); + algorithm = BT_8812A_1ANT_COEX_ALGO_HID_A2DP; + } + else + { + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], HID + PAN(EDR)\n")); + algorithm = BT_8812A_1ANT_COEX_ALGO_PANEDR_HID; + } + } + else if( stack_info->pan_exist && + stack_info->a2dp_exist ) + { + if(bt_hs_on) + { + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], A2DP + PAN(HS)\n")); + algorithm = BT_8812A_1ANT_COEX_ALGO_A2DP_PANHS; + } + else + { + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], A2DP + PAN(EDR)\n")); + algorithm = BT_8812A_1ANT_COEX_ALGO_PANEDR_A2DP; + } + } + } + } + else if(num_of_diff_profile == 3) + { + if(stack_info->sco_exist) + { + if( stack_info->hid_exist && + stack_info->a2dp_exist ) + { + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], SCO + HID + A2DP ==> HID\n")); + algorithm = BT_8812A_1ANT_COEX_ALGO_HID; + } + else if( stack_info->hid_exist && + stack_info->pan_exist ) + { + if(bt_hs_on) + { + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], SCO + HID + PAN(HS)\n")); + algorithm = BT_8812A_1ANT_COEX_ALGO_HID_A2DP; + } + else + { + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], SCO + HID + PAN(EDR)\n")); + algorithm = BT_8812A_1ANT_COEX_ALGO_PANEDR_HID; + } + } + else if( stack_info->pan_exist && + stack_info->a2dp_exist ) + { + if(bt_hs_on) + { + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], SCO + A2DP + PAN(HS)\n")); + algorithm = BT_8812A_1ANT_COEX_ALGO_SCO; + } + else + { + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], SCO + A2DP + PAN(EDR) ==> HID\n")); + algorithm = BT_8812A_1ANT_COEX_ALGO_PANEDR_HID; + } + } + } + else + { + if( stack_info->hid_exist && + stack_info->pan_exist && + stack_info->a2dp_exist ) + { + if(bt_hs_on) + { + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], HID + A2DP + PAN(HS)\n")); + algorithm = BT_8812A_1ANT_COEX_ALGO_HID_A2DP; + } + else + { + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], HID + A2DP + PAN(EDR)\n")); + algorithm = BT_8812A_1ANT_COEX_ALGO_HID_A2DP_PANEDR; + } + } + } + } + else if(num_of_diff_profile >= 3) + { + if(stack_info->sco_exist) + { + if( stack_info->hid_exist && + stack_info->pan_exist && + stack_info->a2dp_exist ) + { + if(bt_hs_on) + { + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], Error!!! SCO + HID + A2DP + PAN(HS)\n")); + + } + else + { + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], SCO + HID + A2DP + PAN(EDR)==>PAN(EDR)+HID\n")); + algorithm = BT_8812A_1ANT_COEX_ALGO_PANEDR_HID; + } + } + } + } + + return algorithm; +} + +BOOLEAN +halbtc8812a1ant_NeedToDecBtPwr( + PBTC_COEXIST btcoexist + ) +{ + BOOLEAN ret=false; + BOOLEAN bt_hs_on=false, wifi_connected=false; + s4Byte bt_hs_rssi=0; + + if(!btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION, &bt_hs_on)) + return false; + if(!btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED, &wifi_connected)) + return false; + if(!btcoexist->btc_get(btcoexist, BTC_GET_S4_HS_RSSI, &bt_hs_rssi)) + return false; + + if(wifi_connected) + { + if(bt_hs_on) + { + if(bt_hs_rssi > 37) + { + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW, ("[BTCoex], Need to decrease bt power for HS mode!!\n")); + ret = true; + } + } + else + { + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW, ("[BTCoex], Need to decrease bt power for Wifi is connected!!\n")); + ret = true; + } + } + + return ret; +} + +void +halbtc8812a1ant_SetFwDacSwingLevel( + PBTC_COEXIST btcoexist, + u1Byte dac_swing_lvl + ) +{ + u1Byte h2c_parameter[1] ={0}; + + // There are several type of dacswing + // 0x18/ 0x10/ 0xc/ 0x8/ 0x4/ 0x6 + h2c_parameter[0] = dac_swing_lvl; + + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_EXEC, ("[BTCoex], Set Dac Swing Level=0x%x\n", dac_swing_lvl)); + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_EXEC, ("[BTCoex], FW write 0x64=0x%x\n", h2c_parameter[0])); + + btcoexist->btc_fill_h2c(btcoexist, 0x64, 1, h2c_parameter); +} + +void +halbtc8812a1ant_SetFwDecBtPwr( + PBTC_COEXIST btcoexist, + BOOLEAN dec_bt_pwr + ) +{ + u1Byte dataLen=3; + u1Byte buf[5] = {0}; + + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_EXEC, ("[BTCoex], decrease Bt Power : %s\n", + (dec_bt_pwr? "Yes!!":"No!!"))); + + buf[0] = dataLen; + buf[1] = 0x3; // OP_Code + buf[2] = 0x1; // OP_Code_Length + if(dec_bt_pwr) + buf[3] = 0x1; // OP_Code_Content + else + buf[3] = 0x0; + + btcoexist->btc_set(btcoexist, BTC_SET_ACT_CTRL_BT_COEX, (PVOID)&buf[0]); +} + +void +halbtc8812a1ant_DecBtPwr( + PBTC_COEXIST btcoexist, + BOOLEAN force_exec, + BOOLEAN dec_bt_pwr + ) +{ + return; + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW, ("[BTCoex], %s Dec BT power = %s\n", + (force_exec? "force to":""), ((dec_bt_pwr)? "ON":"OFF"))); + coex_dm->cur_dec_bt_pwr = dec_bt_pwr; + + if(!force_exec) + { + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL, ("[BTCoex], pre_dec_bt_pwr=%d, cur_dec_bt_pwr=%d\n", + coex_dm->pre_dec_bt_pwr, coex_dm->cur_dec_bt_pwr)); + + if(coex_dm->pre_dec_bt_pwr == coex_dm->cur_dec_bt_pwr) + return; + } + halbtc8812a1ant_SetFwDecBtPwr(btcoexist, coex_dm->cur_dec_bt_pwr); + + coex_dm->pre_dec_bt_pwr = coex_dm->cur_dec_bt_pwr; +} + +void +halbtc8812a1ant_SetFwBtLnaConstrain( + PBTC_COEXIST btcoexist, + BOOLEAN bt_lna_cons_on + ) +{ + u1Byte dataLen=3; + u1Byte buf[5] = {0}; + + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_EXEC, ("[BTCoex], set BT LNA Constrain: %s\n", + (bt_lna_cons_on? "ON!!":"OFF!!"))); + + buf[0] = dataLen; + buf[1] = 0x2; // OP_Code + buf[2] = 0x1; // OP_Code_Length + if(bt_lna_cons_on) + buf[3] = 0x1; // OP_Code_Content + else + buf[3] = 0x0; + + btcoexist->btc_set(btcoexist, BTC_SET_ACT_CTRL_BT_COEX, (PVOID)&buf[0]); +} + +void +halbtc8812a1ant_SetBtLnaConstrain( + PBTC_COEXIST btcoexist, + BOOLEAN force_exec, + BOOLEAN bt_lna_cons_on + ) +{ + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW, ("[BTCoex], %s BT Constrain = %s\n", + (force_exec? "force":""), ((bt_lna_cons_on)? "ON":"OFF"))); + coex_dm->bCurBtLnaConstrain = bt_lna_cons_on; + + if(!force_exec) + { + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL, ("[BTCoex], bPreBtLnaConstrain=%d, bCurBtLnaConstrain=%d\n", + coex_dm->bPreBtLnaConstrain, coex_dm->bCurBtLnaConstrain)); + + if(coex_dm->bPreBtLnaConstrain == coex_dm->bCurBtLnaConstrain) + return; + } + halbtc8812a1ant_SetFwBtLnaConstrain(btcoexist, coex_dm->bCurBtLnaConstrain); + + coex_dm->bPreBtLnaConstrain = coex_dm->bCurBtLnaConstrain; +} + +void +halbtc8812a1ant_SetFwBtPsdMode( + PBTC_COEXIST btcoexist, + u1Byte bt_psd_mode + ) +{ + u1Byte dataLen=3; + u1Byte buf[5] = {0}; + + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_EXEC, ("[BTCoex], set BT PSD mode=0x%x\n", + bt_psd_mode)); + + buf[0] = dataLen; + buf[1] = 0x4; // OP_Code + buf[2] = 0x1; // OP_Code_Length + buf[3] = bt_psd_mode; // OP_Code_Content + + btcoexist->btc_set(btcoexist, BTC_SET_ACT_CTRL_BT_COEX, (PVOID)&buf[0]); +} + + +void +halbtc8812a1ant_SetBtPsdMode( + PBTC_COEXIST btcoexist, + BOOLEAN force_exec, + u1Byte bt_psd_mode + ) +{ + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW, ("[BTCoex], %s BT PSD mode = 0x%x\n", + (force_exec? "force":""), bt_psd_mode)); + coex_dm->bCurBtPsdMode = bt_psd_mode; + + if(!force_exec) + { + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL, ("[BTCoex], bPreBtPsdMode=0x%x, bCurBtPsdMode=0x%x\n", + coex_dm->bPreBtPsdMode, coex_dm->bCurBtPsdMode)); + + if(coex_dm->bPreBtPsdMode == coex_dm->bCurBtPsdMode) + return; + } + halbtc8812a1ant_SetFwBtPsdMode(btcoexist, coex_dm->bCurBtPsdMode); + + coex_dm->bPreBtPsdMode = coex_dm->bCurBtPsdMode; +} + + +void +halbtc8812a1ant_SetBtAutoReport( + PBTC_COEXIST btcoexist, + BOOLEAN enable_auto_report + ) +{ +#if 0 + u1Byte h2c_parameter[1] ={0}; + + h2c_parameter[0] = 0; + + if(enable_auto_report) + { + h2c_parameter[0] |= BIT0; + } + + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_EXEC, ("[BTCoex], BT FW auto report : %s, FW write 0x68=0x%x\n", + (enable_auto_report? "Enabled!!":"Disabled!!"), h2c_parameter[0])); + + btcoexist->btc_fill_h2c(btcoexist, 0x68, 1, h2c_parameter); +#else + +#endif +} + +void +halbtc8812a1ant_BtAutoReport( + PBTC_COEXIST btcoexist, + BOOLEAN force_exec, + BOOLEAN enable_auto_report + ) +{ + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW, ("[BTCoex], %s BT Auto report = %s\n", + (force_exec? "force to":""), ((enable_auto_report)? "Enabled":"Disabled"))); + coex_dm->cur_bt_auto_report = enable_auto_report; + + if(!force_exec) + { + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL, ("[BTCoex], pre_bt_auto_report=%d, cur_bt_auto_report=%d\n", + coex_dm->pre_bt_auto_report, coex_dm->cur_bt_auto_report)); + + if(coex_dm->pre_bt_auto_report == coex_dm->cur_bt_auto_report) + return; + } + halbtc8812a1ant_SetBtAutoReport(btcoexist, coex_dm->cur_bt_auto_report); + + coex_dm->pre_bt_auto_report = coex_dm->cur_bt_auto_report; +} + +void +halbtc8812a1ant_FwDacSwingLvl( + PBTC_COEXIST btcoexist, + BOOLEAN force_exec, + u1Byte fw_dac_swing_lvl + ) +{ + return; + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW, ("[BTCoex], %s set FW Dac Swing level = %d\n", + (force_exec? "force to":""), fw_dac_swing_lvl)); + coex_dm->cur_fw_dac_swing_lvl = fw_dac_swing_lvl; + + if(!force_exec) + { + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL, ("[BTCoex], pre_fw_dac_swing_lvl=%d, cur_fw_dac_swing_lvl=%d\n", + coex_dm->pre_fw_dac_swing_lvl, coex_dm->cur_fw_dac_swing_lvl)); + + if(coex_dm->pre_fw_dac_swing_lvl == coex_dm->cur_fw_dac_swing_lvl) + return; + } + + halbtc8812a1ant_SetFwDacSwingLevel(btcoexist, coex_dm->cur_fw_dac_swing_lvl); + + coex_dm->pre_fw_dac_swing_lvl = coex_dm->cur_fw_dac_swing_lvl; +} + +void +halbtc8812a1ant_SetSwRfRxLpfCorner( + PBTC_COEXIST btcoexist, + BOOLEAN rx_rf_shrink_on + ) +{ + if(rx_rf_shrink_on) + { + //Shrink RF Rx LPF corner + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_EXEC, ("[BTCoex], Shrink RF Rx LPF corner!!\n")); + btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1e, 0xfffff, 0xf0ff7); + } + else + { + //Resume RF Rx LPF corner + // After initialized, we can use coex_dm->bt_rf0x1e_backup + if(btcoexist->bInitilized) + { + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_EXEC, ("[BTCoex], Resume RF Rx LPF corner!!\n")); + btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x1e, 0xfffff, coex_dm->bt_rf0x1e_backup); + } + } +} + +void +halbtc8812a1ant_RfShrink( + PBTC_COEXIST btcoexist, + BOOLEAN force_exec, + BOOLEAN rx_rf_shrink_on + ) +{ + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW, ("[BTCoex], %s turn Rx RF Shrink = %s\n", + (force_exec? "force to":""), ((rx_rf_shrink_on)? "ON":"OFF"))); + coex_dm->cur_rf_rx_lpf_shrink = rx_rf_shrink_on; + + if(!force_exec) + { + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_DETAIL, ("[BTCoex], pre_rf_rx_lpf_shrink=%d, cur_rf_rx_lpf_shrink=%d\n", + coex_dm->pre_rf_rx_lpf_shrink, coex_dm->cur_rf_rx_lpf_shrink)); + + if(coex_dm->pre_rf_rx_lpf_shrink == coex_dm->cur_rf_rx_lpf_shrink) + return; + } + halbtc8812a1ant_SetSwRfRxLpfCorner(btcoexist, coex_dm->cur_rf_rx_lpf_shrink); + + coex_dm->pre_rf_rx_lpf_shrink = coex_dm->cur_rf_rx_lpf_shrink; +} + +void +halbtc8812a1ant_SetSwPenaltyTxRateAdaptive( + PBTC_COEXIST btcoexist, + BOOLEAN low_penalty_ra + ) +{ + u1Byte u1_tmp; + + u1_tmp = btcoexist->btc_read_1byte(btcoexist, 0x4fd); + u1_tmp |= BIT0; + if(low_penalty_ra) + { + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_EXEC, ("[BTCoex], Tx rate adaptive, set low penalty!!\n")); + u1_tmp &= ~BIT2; + } + else + { + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_EXEC, ("[BTCoex], Tx rate adaptive, set normal!!\n")); + u1_tmp |= BIT2; + } + + btcoexist->btc_write_1byte(btcoexist, 0x4fd, u1_tmp); +} + +void +halbtc8812a1ant_LowPenaltyRa( + PBTC_COEXIST btcoexist, + BOOLEAN force_exec, + BOOLEAN low_penalty_ra + ) +{ + return; + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW, ("[BTCoex], %s turn LowPenaltyRA = %s\n", + (force_exec? "force to":""), ((low_penalty_ra)? "ON":"OFF"))); + coex_dm->cur_low_penalty_ra = low_penalty_ra; + + if(!force_exec) + { + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_DETAIL, ("[BTCoex], pre_low_penalty_ra=%d, cur_low_penalty_ra=%d\n", + coex_dm->pre_low_penalty_ra, coex_dm->cur_low_penalty_ra)); + + if(coex_dm->pre_low_penalty_ra == coex_dm->cur_low_penalty_ra) + return; + } + halbtc8812a1ant_SetSwPenaltyTxRateAdaptive(btcoexist, coex_dm->cur_low_penalty_ra); + + coex_dm->pre_low_penalty_ra = coex_dm->cur_low_penalty_ra; +} + +void +halbtc8812a1ant_SetDacSwingReg( + PBTC_COEXIST btcoexist, + u4Byte level + ) +{ + u1Byte val=(u1Byte)level; + + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_EXEC, ("[BTCoex], Write SwDacSwing = 0x%x\n", level)); + btcoexist->btc_write_1byte_bitmask(btcoexist, 0xc5b, 0x3e, val); +} + +void +halbtc8812a1ant_SetSwFullTimeDacSwing( + PBTC_COEXIST btcoexist, + BOOLEAN sw_dac_swing_on, + u4Byte sw_dac_swing_lvl + ) +{ + if(sw_dac_swing_on) + { + halbtc8812a1ant_SetDacSwingReg(btcoexist, sw_dac_swing_lvl); + } + else + { + halbtc8812a1ant_SetDacSwingReg(btcoexist, 0x18); + } +} + + +void +halbtc8812a1ant_DacSwing( + PBTC_COEXIST btcoexist, + BOOLEAN force_exec, + BOOLEAN dac_swing_on, + u4Byte dac_swing_lvl + ) +{ + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW, ("[BTCoex], %s turn DacSwing=%s, dac_swing_lvl=0x%x\n", + (force_exec? "force to":""), ((dac_swing_on)? "ON":"OFF"), dac_swing_lvl)); + coex_dm->cur_dac_swing_on = dac_swing_on; + coex_dm->cur_dac_swing_lvl = dac_swing_lvl; + + if(!force_exec) + { + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_DETAIL, ("[BTCoex], pre_dac_swing_on=%d, pre_dac_swing_lvl=0x%x, cur_dac_swing_on=%d, cur_dac_swing_lvl=0x%x\n", + coex_dm->pre_dac_swing_on, coex_dm->pre_dac_swing_lvl, + coex_dm->cur_dac_swing_on, coex_dm->cur_dac_swing_lvl)); + + if( (coex_dm->pre_dac_swing_on == coex_dm->cur_dac_swing_on) && + (coex_dm->pre_dac_swing_lvl == coex_dm->cur_dac_swing_lvl) ) + return; + } + delay_ms(30); + halbtc8812a1ant_SetSwFullTimeDacSwing(btcoexist, dac_swing_on, dac_swing_lvl); + + coex_dm->pre_dac_swing_on = coex_dm->cur_dac_swing_on; + coex_dm->pre_dac_swing_lvl = coex_dm->cur_dac_swing_lvl; +} + +void +halbtc8812a1ant_SetAdcBackOff( + PBTC_COEXIST btcoexist, + BOOLEAN adc_back_off + ) +{ + if(adc_back_off) + { + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_EXEC, ("[BTCoex], BB BackOff Level On!\n")); + btcoexist->btc_write_1byte_bitmask(btcoexist, 0x8db, 0x60, 0x3); + } + else + { + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_EXEC, ("[BTCoex], BB BackOff Level Off!\n")); + btcoexist->btc_write_1byte_bitmask(btcoexist, 0x8db, 0x60, 0x1); + } +} + +void +halbtc8812a1ant_AdcBackOff( + PBTC_COEXIST btcoexist, + BOOLEAN force_exec, + BOOLEAN adc_back_off + ) +{ + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW, ("[BTCoex], %s turn AdcBackOff = %s\n", + (force_exec? "force to":""), ((adc_back_off)? "ON":"OFF"))); + coex_dm->cur_adc_back_off = adc_back_off; + + if(!force_exec) + { + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_DETAIL, ("[BTCoex], pre_adc_back_off=%d, cur_adc_back_off=%d\n", + coex_dm->pre_adc_back_off, coex_dm->cur_adc_back_off)); + + if(coex_dm->pre_adc_back_off == coex_dm->cur_adc_back_off) + return; + } + halbtc8812a1ant_SetAdcBackOff(btcoexist, coex_dm->cur_adc_back_off); + + coex_dm->pre_adc_back_off = coex_dm->cur_adc_back_off; +} + +void +halbtc8812a1ant_SetAgcTable( + PBTC_COEXIST btcoexist, + BOOLEAN agc_table_en + ) +{ + u1Byte rssi_adjust_val=0; + + btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0xef, 0xfffff, 0x02000); + if(agc_table_en) + { + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_EXEC, ("[BTCoex], Agc Table On!\n")); + btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x3b, 0xfffff, 0x3fa58); + btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x3b, 0xfffff, 0x37a58); + btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x3b, 0xfffff, 0x2fa58); + rssi_adjust_val = 8; + } + else + { + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_EXEC, ("[BTCoex], Agc Table Off!\n")); + btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x3b, 0xfffff, 0x39258); + btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x3b, 0xfffff, 0x31258); + btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0x3b, 0xfffff, 0x29258); + } + btcoexist->btc_set_rf_reg(btcoexist, BTC_RF_A, 0xef, 0xfffff, 0x0); + + // set rssi_adjust_val for wifi module. + btcoexist->btc_set(btcoexist, BTC_SET_U1_RSSI_ADJ_VAL_FOR_AGC_TABLE_ON, &rssi_adjust_val); +} + + +void +halbtc8812a1ant_AgcTable( + PBTC_COEXIST btcoexist, + BOOLEAN force_exec, + BOOLEAN agc_table_en + ) +{ + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW, ("[BTCoex], %s %s Agc Table\n", + (force_exec? "force to":""), ((agc_table_en)? "Enable":"Disable"))); + coex_dm->cur_agc_table_en = agc_table_en; + + if(!force_exec) + { + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_DETAIL, ("[BTCoex], pre_agc_table_en=%d, cur_agc_table_en=%d\n", + coex_dm->pre_agc_table_en, coex_dm->cur_agc_table_en)); + + if(coex_dm->pre_agc_table_en == coex_dm->cur_agc_table_en) + return; + } + halbtc8812a1ant_SetAgcTable(btcoexist, agc_table_en); + + coex_dm->pre_agc_table_en = coex_dm->cur_agc_table_en; +} + +void +halbtc8812a1ant_SetCoexTable( + PBTC_COEXIST btcoexist, + u4Byte val0x6c0, + u4Byte val0x6c4, + u4Byte val0x6c8, + u1Byte val0x6cc + ) +{ + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_EXEC, ("[BTCoex], set coex table, set 0x6c0=0x%x\n", val0x6c0)); + btcoexist->btc_write_4byte(btcoexist, 0x6c0, val0x6c0); + + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_EXEC, ("[BTCoex], set coex table, set 0x6c4=0x%x\n", val0x6c4)); + btcoexist->btc_write_4byte(btcoexist, 0x6c4, val0x6c4); + + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_EXEC, ("[BTCoex], set coex table, set 0x6c8=0x%x\n", val0x6c8)); + btcoexist->btc_write_4byte(btcoexist, 0x6c8, val0x6c8); + + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_EXEC, ("[BTCoex], set coex table, set 0x6cc=0x%x\n", val0x6cc)); + btcoexist->btc_write_1byte(btcoexist, 0x6cc, val0x6cc); +} + +void +halbtc8812a1ant_CoexTable( + PBTC_COEXIST btcoexist, + BOOLEAN force_exec, + u4Byte val0x6c0, + u4Byte val0x6c4, + u4Byte val0x6c8, + u1Byte val0x6cc + ) +{ + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW, ("[BTCoex], %s write Coex Table 0x6c0=0x%x, 0x6c4=0x%x, 0x6c8=0x%x, 0x6cc=0x%x\n", + (force_exec? "force to":""), val0x6c0, val0x6c4, val0x6c8, val0x6cc)); + coex_dm->cur_val0x6c0 = val0x6c0; + coex_dm->cur_val0x6c4 = val0x6c4; + coex_dm->cur_val0x6c8 = val0x6c8; + coex_dm->cur_val0x6cc = val0x6cc; + + if(!force_exec) + { + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_DETAIL, ("[BTCoex], pre_val0x6c0=0x%x, pre_val0x6c4=0x%x, pre_val0x6c8=0x%x, pre_val0x6cc=0x%x !!\n", + coex_dm->pre_val0x6c0, coex_dm->pre_val0x6c4, coex_dm->pre_val0x6c8, coex_dm->pre_val0x6cc)); + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_DETAIL, ("[BTCoex], cur_val0x6c0=0x%x, cur_val0x6c4=0x%x, cur_val0x6c8=0x%x, cur_val0x6cc=0x%x !!\n", + coex_dm->cur_val0x6c0, coex_dm->cur_val0x6c4, coex_dm->cur_val0x6c8, coex_dm->cur_val0x6cc)); + + if( (coex_dm->pre_val0x6c0 == coex_dm->cur_val0x6c0) && + (coex_dm->pre_val0x6c4 == coex_dm->cur_val0x6c4) && + (coex_dm->pre_val0x6c8 == coex_dm->cur_val0x6c8) && + (coex_dm->pre_val0x6cc == coex_dm->cur_val0x6cc) ) + return; + } + halbtc8812a1ant_SetCoexTable(btcoexist, val0x6c0, val0x6c4, val0x6c8, val0x6cc); + + coex_dm->pre_val0x6c0 = coex_dm->cur_val0x6c0; + coex_dm->pre_val0x6c4 = coex_dm->cur_val0x6c4; + coex_dm->pre_val0x6c8 = coex_dm->cur_val0x6c8; + coex_dm->pre_val0x6cc = coex_dm->cur_val0x6cc; +} + +void +halbtc8812a1ant_SetFwIgnoreWlanAct( + PBTC_COEXIST btcoexist, + BOOLEAN enable + ) +{ + u1Byte dataLen=3; + u1Byte buf[5] = {0}; + + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_EXEC, ("[BTCoex], %s BT Ignore Wlan_Act\n", + (enable? "Enable":"Disable"))); + + buf[0] = dataLen; + buf[1] = 0x1; // OP_Code + buf[2] = 0x1; // OP_Code_Length + if(enable) + buf[3] = 0x1; // OP_Code_Content + else + buf[3] = 0x0; + + btcoexist->btc_set(btcoexist, BTC_SET_ACT_CTRL_BT_COEX, (PVOID)&buf[0]); +} + +void +halbtc8812a1ant_IgnoreWlanAct( + PBTC_COEXIST btcoexist, + BOOLEAN force_exec, + BOOLEAN enable + ) +{ + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW, ("[BTCoex], %s turn Ignore WlanAct %s\n", + (force_exec? "force to":""), (enable? "ON":"OFF"))); + coex_dm->cur_ignore_wlan_act = enable; + + if(!force_exec) + { + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL, ("[BTCoex], pre_ignore_wlan_act = %d, cur_ignore_wlan_act = %d!!\n", + coex_dm->pre_ignore_wlan_act, coex_dm->cur_ignore_wlan_act)); + + if(coex_dm->pre_ignore_wlan_act == coex_dm->cur_ignore_wlan_act) + return; + } + halbtc8812a1ant_SetFwIgnoreWlanAct(btcoexist, enable); + + coex_dm->pre_ignore_wlan_act = coex_dm->cur_ignore_wlan_act; +} + +void +halbtc8812a1ant_SetFwPstdma( + PBTC_COEXIST btcoexist, + u1Byte byte1, + u1Byte byte2, + u1Byte byte3, + u1Byte byte4, + u1Byte byte5 + ) +{ + u1Byte h2c_parameter[5] ={0}; + + h2c_parameter[0] = byte1; + h2c_parameter[1] = byte2; + h2c_parameter[2] = byte3; + h2c_parameter[3] = byte4; + h2c_parameter[4] = byte5; + + coex_dm->ps_tdma_para[0] = byte1; + coex_dm->ps_tdma_para[1] = byte2; + coex_dm->ps_tdma_para[2] = byte3; + coex_dm->ps_tdma_para[3] = byte4; + coex_dm->ps_tdma_para[4] = byte5; + + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_EXEC, ("[BTCoex], FW write 0x60(5bytes)=0x%x%08x\n", + h2c_parameter[0], + h2c_parameter[1]<<24|h2c_parameter[2]<<16|h2c_parameter[3]<<8|h2c_parameter[4])); + + btcoexist->btc_fill_h2c(btcoexist, 0x60, 5, h2c_parameter); +} + +void +halbtc8812a1ant_SetLpsRpwm( + PBTC_COEXIST btcoexist, + u1Byte lps_val, + u1Byte rpwm_val + ) +{ + u1Byte lps=lps_val; + u1Byte rpwm=rpwm_val; + + btcoexist->btc_set(btcoexist, BTC_SET_U1_1ANT_LPS, &lps); + btcoexist->btc_set(btcoexist, BTC_SET_U1_1ANT_RPWM, &rpwm); + + btcoexist->btc_set(btcoexist, BTC_SET_ACT_INC_FORCE_EXEC_PWR_CMD_CNT, NULL); +} + +void +halbtc8812a1ant_LpsRpwm( + PBTC_COEXIST btcoexist, + BOOLEAN force_exec, + u1Byte lps_val, + u1Byte rpwm_val + ) +{ + BOOLEAN bForceExecPwrCmd=false; + + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW, ("[BTCoex], %s set lps/rpwm=0x%x/0x%x \n", + (force_exec? "force to":""), lps_val, rpwm_val)); + coex_dm->cur_lps = lps_val; + coex_dm->cur_rpwm = rpwm_val; + + if(!force_exec) + { + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL, ("[BTCoex], pre_lps/cur_lps=0x%x/0x%x, pre_rpwm/cur_rpwm=0x%x/0x%x!!\n", + coex_dm->pre_lps, coex_dm->cur_lps, coex_dm->pre_rpwm, coex_dm->cur_rpwm)); + + if( (coex_dm->pre_lps == coex_dm->cur_lps) && + (coex_dm->pre_rpwm == coex_dm->cur_rpwm) ) + { + return; + } + } + halbtc8812a1ant_SetLpsRpwm(btcoexist, lps_val, rpwm_val); + + coex_dm->pre_lps = coex_dm->cur_lps; + coex_dm->pre_rpwm = coex_dm->cur_rpwm; +} + +void +halbtc8812a1ant_SwMechanism1( + PBTC_COEXIST btcoexist, + BOOLEAN shrink_rx_lpf, + BOOLEAN low_penalty_ra, + BOOLEAN limited_dig, + BOOLEAN bt_lna_constrain + ) +{ + //halbtc8812a1ant_RfShrink(btcoexist, NORMAL_EXEC, shrink_rx_lpf); + //halbtc8812a1ant_LowPenaltyRa(btcoexist, NORMAL_EXEC, low_penalty_ra); + + //no limited DIG + //halbtc8812a1ant_SetBtLnaConstrain(btcoexist, NORMAL_EXEC, bt_lna_constrain); +} + +void +halbtc8812a1ant_SwMechanism2( + PBTC_COEXIST btcoexist, + BOOLEAN agc_table_shift, + BOOLEAN adc_back_off, + BOOLEAN sw_dac_swing, + u4Byte dac_swing_lvl + ) +{ + //halbtc8812a1ant_AgcTable(btcoexist, NORMAL_EXEC, agc_table_shift); + //halbtc8812a1ant_AdcBackOff(btcoexist, NORMAL_EXEC, adc_back_off); + //halbtc8812a1ant_DacSwing(btcoexist, NORMAL_EXEC, sw_dac_swing, dac_swing_lvl); +} + +void +halbtc8812a1ant_PsTdma( + PBTC_COEXIST btcoexist, + BOOLEAN force_exec, + BOOLEAN turn_on, + u1Byte type + ) +{ + BOOLEAN bTurnOnByCnt=false; + u1Byte psTdmaTypeByCnt=0, rssi_adjust_val=0; + + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW, ("[BTCoex], %s turn %s PS TDMA, type=%d\n", + (force_exec? "force to":""), (turn_on? "ON":"OFF"), type)); + coex_dm->cur_ps_tdma_on = turn_on; + coex_dm->cur_ps_tdma = type; + + if(!force_exec) + { + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL, ("[BTCoex], pre_ps_tdma_on = %d, cur_ps_tdma_on = %d!!\n", + coex_dm->pre_ps_tdma_on, coex_dm->cur_ps_tdma_on)); + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL, ("[BTCoex], pre_ps_tdma = %d, cur_ps_tdma = %d!!\n", + coex_dm->pre_ps_tdma, coex_dm->cur_ps_tdma)); + + if( (coex_dm->pre_ps_tdma_on == coex_dm->cur_ps_tdma_on) && + (coex_dm->pre_ps_tdma == coex_dm->cur_ps_tdma) ) + return; + } + if(turn_on) + { + switch(type) + { + default: + halbtc8812a1ant_SetFwPstdma(btcoexist, 0xd3, 0x1a, 0x1a, 0x0, 0x58); + break; + case 1: + halbtc8812a1ant_SetFwPstdma(btcoexist, 0xd3, 0x1a, 0x1a, 0x0, 0x48); + rssi_adjust_val = 11; + break; + case 2: + halbtc8812a1ant_SetFwPstdma(btcoexist, 0xd3, 0x12, 0x12, 0x0, 0x48); + rssi_adjust_val = 14; + break; + case 3: + halbtc8812a1ant_SetFwPstdma(btcoexist, 0x93, 0x25, 0x3, 0x10, 0x40); + break; + case 4: + halbtc8812a1ant_SetFwPstdma(btcoexist, 0x93, 0x15, 0x3, 0x14, 0x0); + rssi_adjust_val = 17; + break; + case 5: + halbtc8812a1ant_SetFwPstdma(btcoexist, 0x61, 0x15, 0x3, 0x31, 0x0); + break; + case 6: + halbtc8812a1ant_SetFwPstdma(btcoexist, 0x13, 0xa, 0x3, 0x0, 0x0); + break; + case 7: + halbtc8812a1ant_SetFwPstdma(btcoexist, 0x13, 0xc, 0x5, 0x0, 0x0); + break; + case 8: + halbtc8812a1ant_SetFwPstdma(btcoexist, 0x93, 0x25, 0x3, 0x10, 0x0); + break; + case 9: + halbtc8812a1ant_SetFwPstdma(btcoexist, 0xd3, 0xa, 0xa, 0x0, 0x48); + rssi_adjust_val = 18; + break; + case 10: + halbtc8812a1ant_SetFwPstdma(btcoexist, 0x13, 0xa, 0xa, 0x0, 0x40); + break; + case 11: + halbtc8812a1ant_SetFwPstdma(btcoexist, 0xd3, 0x5, 0x5, 0x0, 0x48); + rssi_adjust_val = 20; + break; + case 12: + halbtc8812a1ant_SetFwPstdma(btcoexist, 0xeb, 0xa, 0x3, 0x31, 0x18); + break; + + case 15: + halbtc8812a1ant_SetFwPstdma(btcoexist, 0x13, 0xa, 0x3, 0x8, 0x0); + break; + case 16: + halbtc8812a1ant_SetFwPstdma(btcoexist, 0x93, 0x15, 0x3, 0x10, 0x0); + rssi_adjust_val = 18; + break; + + case 18: + halbtc8812a1ant_SetFwPstdma(btcoexist, 0x93, 0x25, 0x3, 0x10, 0x0); + rssi_adjust_val = 14; + break; + + case 20: + halbtc8812a1ant_SetFwPstdma(btcoexist, 0x13, 0x25, 0x25, 0x0, 0x0); + break; + case 21: + halbtc8812a1ant_SetFwPstdma(btcoexist, 0x93, 0x20, 0x3, 0x10, 0x40); + break; + case 22: + halbtc8812a1ant_SetFwPstdma(btcoexist, 0x13, 0x8, 0x8, 0x0, 0x40); + break; + case 23: + halbtc8812a1ant_SetFwPstdma(btcoexist, 0xe3, 0x25, 0x3, 0x31, 0x18); + rssi_adjust_val = 22; + break; + case 24: + halbtc8812a1ant_SetFwPstdma(btcoexist, 0xe3, 0x15, 0x3, 0x31, 0x18); + rssi_adjust_val = 22; + break; + case 25: + halbtc8812a1ant_SetFwPstdma(btcoexist, 0xe3, 0xa, 0x3, 0x31, 0x18); + rssi_adjust_val = 22; + break; + case 26: + halbtc8812a1ant_SetFwPstdma(btcoexist, 0xe3, 0xa, 0x3, 0x31, 0x18); + rssi_adjust_val = 22; + break; + case 27: + halbtc8812a1ant_SetFwPstdma(btcoexist, 0xe3, 0x25, 0x3, 0x31, 0x98); + rssi_adjust_val = 22; + break; + case 28: + halbtc8812a1ant_SetFwPstdma(btcoexist, 0x69, 0x25, 0x3, 0x31, 0x0); + break; + case 29: + halbtc8812a1ant_SetFwPstdma(btcoexist, 0xab, 0x1a, 0x1a, 0x1, 0x8); + break; + case 30: + halbtc8812a1ant_SetFwPstdma(btcoexist, 0x93, 0x15, 0x3, 0x14, 0x0); + break; + case 31: + halbtc8812a1ant_SetFwPstdma(btcoexist, 0xd3, 0x1a, 0x1a, 0, 0x58); + break; + case 32: + halbtc8812a1ant_SetFwPstdma(btcoexist, 0xab, 0xa, 0x3, 0x31, 0x88); + break; + case 33: + halbtc8812a1ant_SetFwPstdma(btcoexist, 0xa3, 0x25, 0x3, 0x30, 0x88); + break; + case 34: + halbtc8812a1ant_SetFwPstdma(btcoexist, 0xd3, 0x1a, 0x1a, 0x0, 0x8); + break; + case 35: + halbtc8812a1ant_SetFwPstdma(btcoexist, 0xe3, 0x1a, 0x1a, 0x0, 0x8); + break; + case 36: + halbtc8812a1ant_SetFwPstdma(btcoexist, 0xd3, 0x12, 0x3, 0x14, 0x58); + break; + } + } + else + { + // disable PS tdma + switch(type) + { + case 8: + halbtc8812a1ant_SetFwPstdma(btcoexist, 0x8, 0x0, 0x0, 0x0, 0x0); + btcoexist->btc_write_1byte(btcoexist, 0x92c, 0x4); + break; + case 0: + default: + halbtc8812a1ant_SetFwPstdma(btcoexist, 0x0, 0x0, 0x0, 0x0, 0x0); + delay_ms(5); + btcoexist->btc_write_1byte(btcoexist, 0x92c, 0x20); + break; + case 9: + halbtc8812a1ant_SetFwPstdma(btcoexist, 0x0, 0x0, 0x0, 0x0, 0x0); + btcoexist->btc_write_1byte(btcoexist, 0x92c, 0x4); + break; + case 10: + halbtc8812a1ant_SetFwPstdma(btcoexist, 0x0, 0x0, 0x0, 0x8, 0x0); + delay_ms(5); + btcoexist->btc_write_1byte(btcoexist, 0x92c, 0x20); + break; + } + } + rssi_adjust_val =0; + btcoexist->btc_set(btcoexist, BTC_SET_U1_RSSI_ADJ_VAL_FOR_1ANT_COEX_TYPE, &rssi_adjust_val); + + // update pre state + coex_dm->pre_ps_tdma_on = coex_dm->cur_ps_tdma_on; + coex_dm->pre_ps_tdma = coex_dm->cur_ps_tdma; +} + +void +halbtc8812a1ant_CoexAllOff( + PBTC_COEXIST btcoexist + ) +{ + // fw all off + halbtc8812a1ant_FwDacSwingLvl(btcoexist, NORMAL_EXEC, 6); + halbtc8812a1ant_DecBtPwr(btcoexist, NORMAL_EXEC, false); + + // sw all off + halbtc8812a1ant_SwMechanism1(btcoexist,false,false,false,false); + halbtc8812a1ant_SwMechanism2(btcoexist,false,false,false,0x18); + + + // hw all off + halbtc8812a1ant_CoexTable(btcoexist, NORMAL_EXEC, 0x55555555, 0x55555555, 0xffff, 0x3); +} + +void +halbtc8812a1ant_WifiParaAdjust( + PBTC_COEXIST btcoexist, + BOOLEAN enable + ) +{ + if(enable) + { + halbtc8812a1ant_LowPenaltyRa(btcoexist, NORMAL_EXEC, true); + } + else + { + halbtc8812a1ant_LowPenaltyRa(btcoexist, NORMAL_EXEC, false); + } +} + +BOOLEAN +halbtc8812a1ant_IsCommonAction( + PBTC_COEXIST btcoexist + ) +{ + BOOLEAN common=false, wifi_connected=false, wifi_busy=false; + + btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED, &wifi_connected); + btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy); + + //halbtc8812a1ant_CoexTable(btcoexist, NORMAL_EXEC, 0x55555555, 0x55555555, 0xffff, 0x3); + + if(!wifi_connected && + BT_8812A_1ANT_BT_STATUS_NON_CONNECTED_IDLE == coex_dm->bt_status) + { + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], Wifi non connected-idle + BT non connected-idle!!\n")); + halbtc8812a1ant_FwDacSwingLvl(btcoexist, NORMAL_EXEC, 6); + halbtc8812a1ant_DecBtPwr(btcoexist, NORMAL_EXEC, false); + + halbtc8812a1ant_SwMechanism1(btcoexist,false,false,false,false); + halbtc8812a1ant_SwMechanism2(btcoexist,false,false,false,0x18); + + common = true; + } + else if(wifi_connected && + (BT_8812A_1ANT_BT_STATUS_NON_CONNECTED_IDLE == coex_dm->bt_status) ) + { + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], Wifi connected + BT non connected-idle!!\n")); + halbtc8812a1ant_FwDacSwingLvl(btcoexist, NORMAL_EXEC, 6); + halbtc8812a1ant_DecBtPwr(btcoexist, NORMAL_EXEC, true); + + halbtc8812a1ant_SwMechanism1(btcoexist,false,false,false,false); + halbtc8812a1ant_SwMechanism2(btcoexist,false,false,false,0x18); + + common = true; + } + else if(!wifi_connected && + (BT_8812A_1ANT_BT_STATUS_CONNECTED_IDLE == coex_dm->bt_status) ) + { + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], Wifi non connected-idle + BT connected-idle!!\n")); + halbtc8812a1ant_FwDacSwingLvl(btcoexist, NORMAL_EXEC, 6); + halbtc8812a1ant_DecBtPwr(btcoexist, NORMAL_EXEC, false); + + halbtc8812a1ant_SwMechanism1(btcoexist,false,false,false,false); + halbtc8812a1ant_SwMechanism2(btcoexist,false,false,false,0x18); + + common = true; + } + else if(wifi_connected && + (BT_8812A_1ANT_BT_STATUS_CONNECTED_IDLE == coex_dm->bt_status) ) + { + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], Wifi connected + BT connected-idle!!\n")); + halbtc8812a1ant_FwDacSwingLvl(btcoexist, NORMAL_EXEC, 6); + halbtc8812a1ant_DecBtPwr(btcoexist, NORMAL_EXEC, false); + + halbtc8812a1ant_SwMechanism1(btcoexist,true,true,true,true); + halbtc8812a1ant_SwMechanism2(btcoexist,false,false,false,0x18); + + common = true; + } + else if(!wifi_connected && + (BT_8812A_1ANT_BT_STATUS_CONNECTED_IDLE != coex_dm->bt_status) ) + { + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], Wifi non connected-idle + BT Busy!!\n")); + halbtc8812a1ant_FwDacSwingLvl(btcoexist, NORMAL_EXEC, 6); + halbtc8812a1ant_DecBtPwr(btcoexist, NORMAL_EXEC, false); + + halbtc8812a1ant_SwMechanism1(btcoexist,false,false,false,false); + halbtc8812a1ant_SwMechanism2(btcoexist,false,false,false,0x18); + + common = true; + } + else + { + halbtc8812a1ant_SwMechanism1(btcoexist,true,true,true,true); + + common = false; + } + + return common; +} + + +void +halbtc8812a1ant_TdmaDurationAdjustForAcl( + PBTC_COEXIST btcoexist + ) +{ + static s4Byte up,dn,m,n,wait_count; + s4Byte result; //0: no change, +1: increase WiFi duration, -1: decrease WiFi duration + u1Byte retry_count=0, bt_info_ext; + + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW, ("[BTCoex], halbtc8812a1ant_TdmaDurationAdjustForAcl()\n")); + if(coex_dm->reset_tdma_adjust) + { + coex_dm->reset_tdma_adjust = false; + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL, ("[BTCoex], first run TdmaDurationAdjust()!!\n")); + + halbtc8812a1ant_PsTdma(btcoexist, NORMAL_EXEC, true, 2); + coex_dm->ps_tdma_du_adj_type = 2; + //============ + up = 0; + dn = 0; + m = 1; + n= 3; + result = 0; + wait_count = 0; + } + else + { + //accquire the BT TRx retry count from BT_Info byte2 + retry_count = coex_sta->bt_retry_cnt; + bt_info_ext = coex_sta->bt_info_ext; + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL, ("[BTCoex], retry_count = %d\n", retry_count)); + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL, ("[BTCoex], up=%d, dn=%d, m=%d, n=%d, wait_count=%d\n", + up, dn, m, n, wait_count)); + result = 0; + wait_count++; + + if(retry_count == 0) // no retry in the last 2-second duration + { + up++; + dn--; + + if (dn <= 0) + dn = 0; + + if(up >= n) // if ³sÄò n Ó2¬í retry count¬°0, «h½Õ¼eWiFi duration + { + wait_count = 0; + n = 3; + up = 0; + dn = 0; + result = 1; + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL, ("[BTCoex], Increase wifi duration!!\n")); + } + } + else if (retry_count <= 3) // <=3 retry in the last 2-second duration + { + up--; + dn++; + + if (up <= 0) + up = 0; + + if (dn == 2) // if ³sÄò 2 Ó2¬í retry count< 3, «h½Õ¯¶WiFi duration + { + if (wait_count <= 2) + m++; // ÁקK¤@ª½¦b¨âÓlevel¤¤¨Ó¦^ + else + m = 1; + + if ( m >= 20) //m ³Ì¤jÈ = 20 ' ³Ì¤j120¬í recheck¬O§_½Õ¾ã WiFi duration. + m = 20; + + n = 3*m; + up = 0; + dn = 0; + wait_count = 0; + result = -1; + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL, ("[BTCoex], Decrease wifi duration for retryCounter<3!!\n")); + } + } + else //retry count > 3, ¥un1¦¸ retry count > 3, «h½Õ¯¶WiFi duration + { + if (wait_count == 1) + m++; // ÁקK¤@ª½¦b¨âÓlevel¤¤¨Ó¦^ + else + m = 1; + + if ( m >= 20) //m ³Ì¤jÈ = 20 ' ³Ì¤j120¬í recheck¬O§_½Õ¾ã WiFi duration. + m = 20; + + n = 3*m; + up = 0; + dn = 0; + wait_count = 0; + result = -1; + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL, ("[BTCoex], Decrease wifi duration for retryCounter>3!!\n")); + } + + if(result == -1) + { + if( (BT_INFO_8812A_1ANT_A2DP_BASIC_RATE(bt_info_ext)) && + ((coex_dm->cur_ps_tdma == 1) ||(coex_dm->cur_ps_tdma == 2)) ) + { + halbtc8812a1ant_PsTdma(btcoexist, NORMAL_EXEC, true, 9); + coex_dm->ps_tdma_du_adj_type = 9; + } + else if(coex_dm->cur_ps_tdma == 1) + { + halbtc8812a1ant_PsTdma(btcoexist, NORMAL_EXEC, true, 2); + coex_dm->ps_tdma_du_adj_type = 2; + } + else if(coex_dm->cur_ps_tdma == 2) + { + halbtc8812a1ant_PsTdma(btcoexist, NORMAL_EXEC, true, 9); + coex_dm->ps_tdma_du_adj_type = 9; + } + else if(coex_dm->cur_ps_tdma == 9) + { + halbtc8812a1ant_PsTdma(btcoexist, NORMAL_EXEC, true, 11); + coex_dm->ps_tdma_du_adj_type = 11; + } + } + else if(result == 1) + { + if( (BT_INFO_8812A_1ANT_A2DP_BASIC_RATE(bt_info_ext)) && + ((coex_dm->cur_ps_tdma == 1) ||(coex_dm->cur_ps_tdma == 2)) ) + { + halbtc8812a1ant_PsTdma(btcoexist, NORMAL_EXEC, true, 9); + coex_dm->ps_tdma_du_adj_type = 9; + } + else if(coex_dm->cur_ps_tdma == 11) + { + halbtc8812a1ant_PsTdma(btcoexist, NORMAL_EXEC, true, 9); + coex_dm->ps_tdma_du_adj_type = 9; + } + else if(coex_dm->cur_ps_tdma == 9) + { + halbtc8812a1ant_PsTdma(btcoexist, NORMAL_EXEC, true, 2); + coex_dm->ps_tdma_du_adj_type = 2; + } + else if(coex_dm->cur_ps_tdma == 2) + { + halbtc8812a1ant_PsTdma(btcoexist, NORMAL_EXEC, true, 1); + coex_dm->ps_tdma_du_adj_type = 1; + } + } + + if( coex_dm->cur_ps_tdma != 1 && + coex_dm->cur_ps_tdma != 2 && + coex_dm->cur_ps_tdma != 9 && + coex_dm->cur_ps_tdma != 11 ) + { + // recover to previous adjust type + halbtc8812a1ant_PsTdma(btcoexist, NORMAL_EXEC, true, coex_dm->ps_tdma_du_adj_type); + } + } +} + +u1Byte +halbtc8812a1ant_PsTdmaTypeByWifiRssi( + s4Byte wifi_rssi, + s4Byte pre_wifi_rssi, + u1Byte wifi_rssi_thresh + ) +{ + u1Byte ps_tdma_type=0; + + if(wifi_rssi > pre_wifi_rssi) + { + if(wifi_rssi > (wifi_rssi_thresh+5)) + { + ps_tdma_type = 26; + } + else + { + ps_tdma_type = 25; + } + } + else + { + if(wifi_rssi > wifi_rssi_thresh) + { + ps_tdma_type = 26; + } + else + { + ps_tdma_type = 25; + } + } + + return ps_tdma_type; +} + +void +halbtc8812a1ant_PsTdmaCheckForPowerSaveState( + PBTC_COEXIST btcoexist, + BOOLEAN new_ps_state + ) +{ + u1Byte lps_mode=0x0; + + btcoexist->btc_get(btcoexist, BTC_GET_U1_LPS_MODE, &lps_mode); + + if(lps_mode) // already under LPS state + { + if(new_ps_state) + { + // keep state under LPS, do nothing. + } + else + { + // will leave LPS state, turn off psTdma first + halbtc8812a1ant_PsTdma(btcoexist, NORMAL_EXEC, false, 0); + } + } + else // NO PS state + { + if(new_ps_state) + { + // will enter LPS state, turn off psTdma first + halbtc8812a1ant_PsTdma(btcoexist, NORMAL_EXEC, false, 0); + } + else + { + // keep state under NO PS state, do nothing. + } + } +} + +// SCO only or SCO+PAN(HS) +void +halbtc8812a1ant_ActionSco( + PBTC_COEXIST btcoexist + ) +{ + u1Byte wifi_rssi_state; + u4Byte wifi_bw; + + wifi_rssi_state = halbtc8812a1ant_WifiRssiState(btcoexist, 0, 2, 25, 0); + + halbtc8812a1ant_FwDacSwingLvl(btcoexist, NORMAL_EXEC, 4); + + if(halbtc8812a1ant_NeedToDecBtPwr(btcoexist)) + halbtc8812a1ant_DecBtPwr(btcoexist, NORMAL_EXEC, true); + else + halbtc8812a1ant_DecBtPwr(btcoexist, NORMAL_EXEC, false); + + btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw); + + if(BTC_WIFI_BW_HT40 == wifi_bw) + { + // sw mechanism + if( (wifi_rssi_state == BTC_RSSI_STATE_HIGH) || + (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH) ) + { + halbtc8812a1ant_SwMechanism2(btcoexist,true,true,false,0x18); + } + else + { + halbtc8812a1ant_SwMechanism2(btcoexist,false,true,false,0x18); + } + } + else + { + // sw mechanism + if( (wifi_rssi_state == BTC_RSSI_STATE_HIGH) || + (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH) ) + { + halbtc8812a1ant_SwMechanism2(btcoexist,true,true,false,0x18); + } + else + { + halbtc8812a1ant_SwMechanism2(btcoexist,false,false,false,0x18); + } + } +} + + +void +halbtc8812a1ant_ActionHid( + PBTC_COEXIST btcoexist + ) +{ + u1Byte wifi_rssi_state, bt_rssi_state; + u4Byte wifi_bw; + + wifi_rssi_state = halbtc8812a1ant_WifiRssiState(btcoexist, 0, 2, 25, 0); + bt_rssi_state = halbtc8812a1ant_BtRssiState(2, 50, 0); + + halbtc8812a1ant_FwDacSwingLvl(btcoexist, NORMAL_EXEC, 6); + + if(halbtc8812a1ant_NeedToDecBtPwr(btcoexist)) + halbtc8812a1ant_DecBtPwr(btcoexist, NORMAL_EXEC, true); + else + halbtc8812a1ant_DecBtPwr(btcoexist, NORMAL_EXEC, false); + + btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw); + + if(BTC_WIFI_BW_HT40 == wifi_bw) + { + // sw mechanism + if( (wifi_rssi_state == BTC_RSSI_STATE_HIGH) || + (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH) ) + { + halbtc8812a1ant_SwMechanism2(btcoexist,true,false,false,0x18); + } + else + { + halbtc8812a1ant_SwMechanism2(btcoexist,false,false,false,0x18); + } + } + else + { + // sw mechanism + if( (wifi_rssi_state == BTC_RSSI_STATE_HIGH) || + (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH) ) + { + halbtc8812a1ant_SwMechanism2(btcoexist,true,true,false,0x18); + } + else + { + halbtc8812a1ant_SwMechanism2(btcoexist,false,false,false,0x18); + } + } +} + +//A2DP only / PAN(EDR) only/ A2DP+PAN(HS) +void +halbtc8812a1ant_ActionA2dp( + PBTC_COEXIST btcoexist + ) +{ + u1Byte wifi_rssi_state, bt_rssi_state; + u4Byte wifi_bw; + + wifi_rssi_state = halbtc8812a1ant_WifiRssiState(btcoexist, 0, 2, 25, 0); + bt_rssi_state = halbtc8812a1ant_BtRssiState(2, 50, 0); + + halbtc8812a1ant_FwDacSwingLvl(btcoexist, NORMAL_EXEC, 6); + + if(halbtc8812a1ant_NeedToDecBtPwr(btcoexist)) + halbtc8812a1ant_DecBtPwr(btcoexist, NORMAL_EXEC, true); + else + halbtc8812a1ant_DecBtPwr(btcoexist, NORMAL_EXEC, false); + + btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw); + + if(BTC_WIFI_BW_HT40 == wifi_bw) + { + // sw mechanism + if( (wifi_rssi_state == BTC_RSSI_STATE_HIGH) || + (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH) ) + { + halbtc8812a1ant_SwMechanism2(btcoexist,true,true,false,0x18); + } + else + { + halbtc8812a1ant_SwMechanism2(btcoexist,false,true,false,0x18); + } + } + else + { + // sw mechanism + if( (wifi_rssi_state == BTC_RSSI_STATE_HIGH) || + (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH) ) + { + halbtc8812a1ant_SwMechanism2(btcoexist,true,true,false,0x18); + } + else + { + halbtc8812a1ant_SwMechanism2(btcoexist,false,false,false,0x18); + } + } +} + +void +halbtc8812a1ant_ActionA2dpPanHs( + PBTC_COEXIST btcoexist + ) +{ + u1Byte wifi_rssi_state, bt_rssi_state, bt_info_ext; + u4Byte wifi_bw; + + bt_info_ext = coex_sta->bt_info_ext; + wifi_rssi_state = halbtc8812a1ant_WifiRssiState(btcoexist, 0, 2, 25, 0); + bt_rssi_state = halbtc8812a1ant_BtRssiState(2, 50, 0); + + halbtc8812a1ant_FwDacSwingLvl(btcoexist, NORMAL_EXEC, 6); + + if(halbtc8812a1ant_NeedToDecBtPwr(btcoexist)) + halbtc8812a1ant_DecBtPwr(btcoexist, NORMAL_EXEC, true); + else + halbtc8812a1ant_DecBtPwr(btcoexist, NORMAL_EXEC, false); + + btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw); + + if(BTC_WIFI_BW_HT40 == wifi_bw) + { + // sw mechanism + if( (wifi_rssi_state == BTC_RSSI_STATE_HIGH) || + (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH) ) + { + halbtc8812a1ant_SwMechanism2(btcoexist,true,true,false,0x18); + } + else + { + halbtc8812a1ant_SwMechanism2(btcoexist,false,true,false,0x18); + } + } + else + { + // sw mechanism + if( (wifi_rssi_state == BTC_RSSI_STATE_HIGH) || + (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH) ) + { + halbtc8812a1ant_SwMechanism2(btcoexist,true,true,false,0x18); + } + else + { + halbtc8812a1ant_SwMechanism2(btcoexist,false,false,false,0x18); + } + } +} + +void +halbtc8812a1ant_ActionPanEdr( + PBTC_COEXIST btcoexist + ) +{ + u1Byte wifi_rssi_state, bt_rssi_state; + u4Byte wifi_bw; + + wifi_rssi_state = halbtc8812a1ant_WifiRssiState(btcoexist, 0, 2, 25, 0); + bt_rssi_state = halbtc8812a1ant_BtRssiState(2, 50, 0); + + halbtc8812a1ant_FwDacSwingLvl(btcoexist, NORMAL_EXEC, 6); + + if(halbtc8812a1ant_NeedToDecBtPwr(btcoexist)) + halbtc8812a1ant_DecBtPwr(btcoexist, NORMAL_EXEC, true); + else + halbtc8812a1ant_DecBtPwr(btcoexist, NORMAL_EXEC, false); + + btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw); + + if(BTC_WIFI_BW_HT40 == wifi_bw) + { + // sw mechanism + if( (wifi_rssi_state == BTC_RSSI_STATE_HIGH) || + (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH) ) + { + halbtc8812a1ant_SwMechanism2(btcoexist,true,true,false,0x18); + } + else + { + halbtc8812a1ant_SwMechanism2(btcoexist,false,true,false,0x18); + } + } + else + { + // sw mechanism + if( (wifi_rssi_state == BTC_RSSI_STATE_HIGH) || + (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH) ) + { + halbtc8812a1ant_SwMechanism2(btcoexist,true,true,false,0x18); + } + else + { + halbtc8812a1ant_SwMechanism2(btcoexist,false,false,false,0x18); + } + } +} + + +//PAN(HS) only +void +halbtc8812a1ant_ActionPanHs( + PBTC_COEXIST btcoexist + ) +{ + u1Byte wifi_rssi_state, bt_rssi_state; + u4Byte wifi_bw; + + wifi_rssi_state = halbtc8812a1ant_WifiRssiState(btcoexist, 0, 2, 25, 0); + bt_rssi_state = halbtc8812a1ant_BtRssiState(2, 50, 0); + + halbtc8812a1ant_FwDacSwingLvl(btcoexist, NORMAL_EXEC, 6); + + btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw); + + if(BTC_WIFI_BW_HT40 == wifi_bw) + { + // fw mechanism + if( (wifi_rssi_state == BTC_RSSI_STATE_HIGH) || + (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH) ) + { + halbtc8812a1ant_DecBtPwr(btcoexist, NORMAL_EXEC, true); + } + else + { + halbtc8812a1ant_DecBtPwr(btcoexist, NORMAL_EXEC, false); + } + + // sw mechanism + if( (wifi_rssi_state == BTC_RSSI_STATE_HIGH) || + (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH) ) + { + halbtc8812a1ant_SwMechanism2(btcoexist,true,true,false,0x18); + } + else + { + halbtc8812a1ant_SwMechanism2(btcoexist,false,true,false,0x18); + } + } + else + { + // fw mechanism + if( (wifi_rssi_state == BTC_RSSI_STATE_HIGH) || + (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH) ) + { + halbtc8812a1ant_DecBtPwr(btcoexist, NORMAL_EXEC, true); + } + else + { + halbtc8812a1ant_DecBtPwr(btcoexist, NORMAL_EXEC, false); + } + + // sw mechanism + if( (wifi_rssi_state == BTC_RSSI_STATE_HIGH) || + (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH) ) + { + halbtc8812a1ant_SwMechanism2(btcoexist,true,true,false,0x18); + } + else + { + halbtc8812a1ant_SwMechanism2(btcoexist,false,false,false,0x18); + } + } +} + +//PAN(EDR)+A2DP +void +halbtc8812a1ant_ActionPanEdrA2dp( + PBTC_COEXIST btcoexist + ) +{ + u1Byte wifi_rssi_state, bt_rssi_state, bt_info_ext; + u4Byte wifi_bw; + + bt_info_ext = coex_sta->bt_info_ext; + wifi_rssi_state = halbtc8812a1ant_WifiRssiState(btcoexist, 0, 2, 25, 0); + bt_rssi_state = halbtc8812a1ant_BtRssiState(2, 50, 0); + + halbtc8812a1ant_FwDacSwingLvl(btcoexist, NORMAL_EXEC, 6); + + if(halbtc8812a1ant_NeedToDecBtPwr(btcoexist)) + halbtc8812a1ant_DecBtPwr(btcoexist, NORMAL_EXEC, true); + else + halbtc8812a1ant_DecBtPwr(btcoexist, NORMAL_EXEC, false); + + btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw); + + if(BTC_WIFI_BW_HT40 == wifi_bw) + { + // sw mechanism + if( (wifi_rssi_state == BTC_RSSI_STATE_HIGH) || + (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH) ) + { + halbtc8812a1ant_SwMechanism2(btcoexist,true,true,false,0x18); + } + else + { + halbtc8812a1ant_SwMechanism2(btcoexist,false,true,false,0x18); + } + } + else + { + // sw mechanism + if( (wifi_rssi_state == BTC_RSSI_STATE_HIGH) || + (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH) ) + { + halbtc8812a1ant_SwMechanism2(btcoexist,true,true,false,0x18); + } + else + { + halbtc8812a1ant_SwMechanism2(btcoexist,false,false,false,0x18); + } + } +} + +void +halbtc8812a1ant_ActionPanEdrHid( + PBTC_COEXIST btcoexist + ) +{ + u1Byte wifi_rssi_state, bt_rssi_state; + u4Byte wifi_bw; + + wifi_rssi_state = halbtc8812a1ant_WifiRssiState(btcoexist, 0, 2, 25, 0); + bt_rssi_state = halbtc8812a1ant_BtRssiState(2, 50, 0); + + halbtc8812a1ant_FwDacSwingLvl(btcoexist, NORMAL_EXEC, 6); + + if(halbtc8812a1ant_NeedToDecBtPwr(btcoexist)) + halbtc8812a1ant_DecBtPwr(btcoexist, NORMAL_EXEC, true); + else + halbtc8812a1ant_DecBtPwr(btcoexist, NORMAL_EXEC, false); + + btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw); + + if(BTC_WIFI_BW_HT40 == wifi_bw) + { + // sw mechanism + if( (wifi_rssi_state == BTC_RSSI_STATE_HIGH) || + (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH) ) + { + halbtc8812a1ant_SwMechanism2(btcoexist,true,true,false,0x18); + } + else + { + halbtc8812a1ant_SwMechanism2(btcoexist,false,true,false,0x18); + } + } + else + { + // sw mechanism + if( (wifi_rssi_state == BTC_RSSI_STATE_HIGH) || + (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH) ) + { + halbtc8812a1ant_SwMechanism2(btcoexist,true,true,false,0x18); + } + else + { + halbtc8812a1ant_SwMechanism2(btcoexist,false,false,false,0x18); + } + } +} + +// HID+A2DP+PAN(EDR) +void +halbtc8812a1ant_ActionHidA2dpPanEdr( + PBTC_COEXIST btcoexist + ) +{ + u1Byte wifi_rssi_state, bt_rssi_state, bt_info_ext; + u4Byte wifi_bw; + + bt_info_ext = coex_sta->bt_info_ext; + wifi_rssi_state = halbtc8812a1ant_WifiRssiState(btcoexist, 0, 2, 25, 0); + bt_rssi_state = halbtc8812a1ant_BtRssiState(2, 50, 0); + + halbtc8812a1ant_FwDacSwingLvl(btcoexist, NORMAL_EXEC, 6); + + if(halbtc8812a1ant_NeedToDecBtPwr(btcoexist)) + halbtc8812a1ant_DecBtPwr(btcoexist, NORMAL_EXEC, true); + else + halbtc8812a1ant_DecBtPwr(btcoexist, NORMAL_EXEC, false); + + btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw); + + if(BTC_WIFI_BW_HT40 == wifi_bw) + { + // sw mechanism + if( (wifi_rssi_state == BTC_RSSI_STATE_HIGH) || + (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH) ) + { + halbtc8812a1ant_SwMechanism2(btcoexist,true,true,false,0x18); + } + else + { + halbtc8812a1ant_SwMechanism2(btcoexist,false,true,false,0x18); + } + } + else + { + // sw mechanism + if( (wifi_rssi_state == BTC_RSSI_STATE_HIGH) || + (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH) ) + { + halbtc8812a1ant_SwMechanism2(btcoexist,true,true,false,0x18); + } + else + { + halbtc8812a1ant_SwMechanism2(btcoexist,false,false,false,0x18); + } + } +} + +void +halbtc8812a1ant_ActionHidA2dp( + PBTC_COEXIST btcoexist + ) +{ + u1Byte wifi_rssi_state, bt_rssi_state, bt_info_ext; + u4Byte wifi_bw; + + bt_info_ext = coex_sta->bt_info_ext; + wifi_rssi_state = halbtc8812a1ant_WifiRssiState(btcoexist, 0, 2, 25, 0); + bt_rssi_state = halbtc8812a1ant_BtRssiState(2, 50, 0); + + if(halbtc8812a1ant_NeedToDecBtPwr(btcoexist)) + halbtc8812a1ant_DecBtPwr(btcoexist, NORMAL_EXEC, true); + else + halbtc8812a1ant_DecBtPwr(btcoexist, NORMAL_EXEC, false); + + btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw); + + if(BTC_WIFI_BW_HT40 == wifi_bw) + { + // sw mechanism + if( (wifi_rssi_state == BTC_RSSI_STATE_HIGH) || + (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH) ) + { + halbtc8812a1ant_SwMechanism2(btcoexist,true,true,false,0x18); + } + else + { + halbtc8812a1ant_SwMechanism2(btcoexist,false,true,false,0x18); + } + } + else + { + // sw mechanism + if( (wifi_rssi_state == BTC_RSSI_STATE_HIGH) || + (wifi_rssi_state == BTC_RSSI_STATE_STAY_HIGH) ) + { + halbtc8812a1ant_SwMechanism2(btcoexist,true,true,false,0x18); + } + else + { + halbtc8812a1ant_SwMechanism2(btcoexist,false,false,false,0x18); + } + } +} + +void +halbtc8812a1ant_ActionHs( + PBTC_COEXIST btcoexist, + BOOLEAN hs_connecting + ) +{ + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], Action for HS, hs_connecting=%d!!!\n", hs_connecting)); + halbtc8812a1ant_PsTdma(btcoexist, NORMAL_EXEC, false, 8); + + if(hs_connecting) + { + halbtc8812a1ant_CoexTable(btcoexist, FORCE_EXEC, 0xaaaaaaaa, 0xaaaaaaaa, 0xffff, 0x3); + } + else + { + if((coex_sta->high_priority_tx+coex_sta->high_priority_rx+ + coex_sta->low_priority_tx+coex_sta->low_priority_rx)<=1200) + halbtc8812a1ant_CoexTable(btcoexist, FORCE_EXEC, 0xaaaaaaaa, 0xaaaaaaaa, 0xffff, 0x3); + else + halbtc8812a1ant_CoexTable(btcoexist, FORCE_EXEC, 0xffffffff, 0xffffffff, 0xffff, 0x3); + } +} + + +void +halbtc8812a1ant_ActionWifiNotConnected( + PBTC_COEXIST btcoexist + ) +{ + BOOLEAN hs_connecting=false; + + btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_CONNECTING, &hs_connecting); + + halbtc8812a1ant_PsTdmaCheckForPowerSaveState(btcoexist, false); + btcoexist->btc_set(btcoexist, BTC_SET_ACT_LEAVE_LPS, NULL); + + if(hs_connecting) + { + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], HS is connecting!!!\n")); + halbtc8812a1ant_ActionHs(btcoexist, hs_connecting); + } + else + { + halbtc8812a1ant_PsTdma(btcoexist, NORMAL_EXEC, false, 8); + halbtc8812a1ant_CoexTable(btcoexist, NORMAL_EXEC, 0x55555555, 0x55555555, 0xffff, 0x3); + } +} + +void +halbtc8812a1ant_ActionWifiNotConnectedAssoAuthScan( + PBTC_COEXIST btcoexist + ) +{ + PBTC_STACK_INFO stack_info=&btcoexist->stack_info; + BOOLEAN hs_connecting=false; + + btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_CONNECTING, &hs_connecting); + halbtc8812a1ant_PsTdmaCheckForPowerSaveState(btcoexist, false); + btcoexist->btc_set(btcoexist, BTC_SET_ACT_LEAVE_LPS, NULL); + + if(hs_connecting) + { + halbtc8812a1ant_ActionHs(btcoexist, hs_connecting); + } + else if(btcoexist->bt_info.bt_disabled) + { + halbtc8812a1ant_PsTdma(btcoexist, NORMAL_EXEC, false, 9); + halbtc8812a1ant_CoexTable(btcoexist, NORMAL_EXEC, 0x55555555, 0x55555555, 0xffff, 0x3); + } + else if(BT_8812A_1ANT_BT_STATUS_INQ_PAGE == coex_dm->bt_status) +{ + halbtc8812a1ant_PsTdma(btcoexist, NORMAL_EXEC, true, 30); + halbtc8812a1ant_CoexTable(btcoexist, NORMAL_EXEC, 0x55555555, 0x55555555, 0xffff, 0x3); + } + else if( (BT_8812A_1ANT_BT_STATUS_NON_CONNECTED_IDLE == coex_dm->bt_status) || + (BT_8812A_1ANT_BT_STATUS_CONNECTED_IDLE == coex_dm->bt_status) ) + { + halbtc8812a1ant_PsTdma(btcoexist, NORMAL_EXEC, true, 28); + halbtc8812a1ant_CoexTable(btcoexist, NORMAL_EXEC, 0x55555555, 0x55555555, 0xffff, 0x3); + } + else if(BT_8812A_1ANT_BT_STATUS_ACL_BUSY == coex_dm->bt_status) + { + if(stack_info->hid_exist) + halbtc8812a1ant_PsTdma(btcoexist, NORMAL_EXEC, true, 35); + else + halbtc8812a1ant_PsTdma(btcoexist, NORMAL_EXEC, true, 29); + halbtc8812a1ant_CoexTable(btcoexist, NORMAL_EXEC, 0x55555555, 0x5afa5afa, 0xffff, 0x3); + } + else if( (BT_8812A_1ANT_BT_STATUS_SCO_BUSY == coex_dm->bt_status) || + (BT_8812A_1ANT_BT_STATUS_ACL_SCO_BUSY == coex_dm->bt_status) ) + { + halbtc8812a1ant_PsTdma(btcoexist, NORMAL_EXEC, false, 8); + halbtc8812a1ant_CoexTable(btcoexist, NORMAL_EXEC, 0x5aea5aea, 0x5aea5aea, 0xffff, 0x3); + } + else + { + //error condition, should not reach here, record error number for debugging. + coex_dm->error_condition = 1; + } +} + +void +halbtc8812a1ant_ActionWifiConnectedScan( + PBTC_COEXIST btcoexist + ) +{ + PBTC_STACK_INFO stack_info=&btcoexist->stack_info; + + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], ActionConnectedScan()===>\n")); + + if(btcoexist->bt_info.bt_disabled) + { + halbtc8812a1ant_PsTdmaCheckForPowerSaveState(btcoexist, false); + btcoexist->btc_set(btcoexist, BTC_SET_ACT_LEAVE_LPS, NULL); + halbtc8812a1ant_PsTdma(btcoexist, NORMAL_EXEC, false, 9); + halbtc8812a1ant_CoexTable(btcoexist, NORMAL_EXEC, 0x55555555, 0x55555555, 0xffff, 0x3); + } + else + { + halbtc8812a1ant_PsTdmaCheckForPowerSaveState(btcoexist, true); + halbtc8812a1ant_LpsRpwm(btcoexist, NORMAL_EXEC, 0x0, 0x4); + // power save must executed before psTdma. + btcoexist->btc_set(btcoexist, BTC_SET_ACT_ENTER_LPS, NULL); + + // psTdma + if(BT_8812A_1ANT_BT_STATUS_INQ_PAGE == coex_dm->bt_status) + { + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], ActionConnectedScan(), bt is under inquiry/page scan\n")); + if(stack_info->sco_exist) + { + halbtc8812a1ant_PsTdma(btcoexist, NORMAL_EXEC, true, 32); + halbtc8812a1ant_CoexTable(btcoexist, NORMAL_EXEC, 0x55555555, 0x5afa5afa, 0xffff, 0x3); + } + else + { + halbtc8812a1ant_PsTdma(btcoexist, NORMAL_EXEC, true, 30); + halbtc8812a1ant_CoexTable(btcoexist, NORMAL_EXEC, 0x55555555, 0x55555555, 0xffff, 0x3); + } + } + else if( (BT_8812A_1ANT_BT_STATUS_NON_CONNECTED_IDLE == coex_dm->bt_status) || + (BT_8812A_1ANT_BT_STATUS_CONNECTED_IDLE == coex_dm->bt_status) ) + { + halbtc8812a1ant_PsTdma(btcoexist, NORMAL_EXEC, true, 5); + halbtc8812a1ant_CoexTable(btcoexist, NORMAL_EXEC, 0x55555555, 0x55555555, 0xffff, 0x3); + } + else if(BT_8812A_1ANT_BT_STATUS_ACL_BUSY == coex_dm->bt_status) + { + if(stack_info->hid_exist) + { + halbtc8812a1ant_PsTdma(btcoexist, NORMAL_EXEC, true, 34); + halbtc8812a1ant_CoexTable(btcoexist, NORMAL_EXEC, 0x55555555, 0x5afa5afa, 0xffff, 0x3); + } + else + { + halbtc8812a1ant_PsTdma(btcoexist, NORMAL_EXEC, true, 4); + halbtc8812a1ant_CoexTable(btcoexist, NORMAL_EXEC, 0x55555555, 0x55555555, 0xffff, 0x3); + } + } + else if( (BT_8812A_1ANT_BT_STATUS_SCO_BUSY == coex_dm->bt_status) || + (BT_8812A_1ANT_BT_STATUS_ACL_SCO_BUSY == coex_dm->bt_status) ) + { + halbtc8812a1ant_PsTdma(btcoexist, NORMAL_EXEC, true, 33); + halbtc8812a1ant_CoexTable(btcoexist, NORMAL_EXEC, 0x55555555, 0x5afa5afa, 0xffff, 0x3); + } + else + { + //error condition, should not reach here + coex_dm->error_condition = 2; + } + } + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], ActionConnectedScan()<===\n")); +} + +void +halbtc8812a1ant_ActionWifiConnectedSpecialPacket( + PBTC_COEXIST btcoexist + ) +{ + PBTC_STACK_INFO stack_info=&btcoexist->stack_info; + + halbtc8812a1ant_PsTdmaCheckForPowerSaveState(btcoexist, false); + btcoexist->btc_set(btcoexist, BTC_SET_ACT_LEAVE_LPS, NULL); + + if(btcoexist->bt_info.bt_disabled) + { + halbtc8812a1ant_PsTdma(btcoexist, NORMAL_EXEC, false, 9); + halbtc8812a1ant_CoexTable(btcoexist, NORMAL_EXEC, 0x55555555, 0x55555555, 0xffff, 0x3); + } + else + { + if(BT_8812A_1ANT_BT_STATUS_INQ_PAGE == coex_dm->bt_status) + { + if(stack_info->sco_exist) + { + halbtc8812a1ant_PsTdma(btcoexist, NORMAL_EXEC, true, 32); + halbtc8812a1ant_CoexTable(btcoexist, NORMAL_EXEC, 0x55555555, 0x5afa5afa, 0xffff, 0x3); + } + else + { + halbtc8812a1ant_PsTdma(btcoexist, NORMAL_EXEC, true, 30); + halbtc8812a1ant_CoexTable(btcoexist, NORMAL_EXEC, 0x55555555, 0x55555555, 0xffff, 0x3); + } + } + else if( (BT_8812A_1ANT_BT_STATUS_NON_CONNECTED_IDLE == coex_dm->bt_status) || + (BT_8812A_1ANT_BT_STATUS_CONNECTED_IDLE == coex_dm->bt_status) ) + { + halbtc8812a1ant_PsTdma(btcoexist, NORMAL_EXEC, true, 28); + halbtc8812a1ant_CoexTable(btcoexist, NORMAL_EXEC, 0x55555555, 0x55555555, 0xffff, 0x3); + } + else if(BT_8812A_1ANT_BT_STATUS_ACL_BUSY == coex_dm->bt_status) + { + if(stack_info->hid_exist) + halbtc8812a1ant_PsTdma(btcoexist, NORMAL_EXEC, true, 35); + else + halbtc8812a1ant_PsTdma(btcoexist, NORMAL_EXEC, true, 29); + halbtc8812a1ant_CoexTable(btcoexist, NORMAL_EXEC, 0x55555555, 0x5afa5afa, 0xffff, 0x3); + } + else if( (BT_8812A_1ANT_BT_STATUS_SCO_BUSY == coex_dm->bt_status) || + (BT_8812A_1ANT_BT_STATUS_ACL_SCO_BUSY == coex_dm->bt_status) ) + { + halbtc8812a1ant_PsTdma(btcoexist, NORMAL_EXEC, false, 8); + halbtc8812a1ant_CoexTable(btcoexist, NORMAL_EXEC, 0x5aea5aea, 0x5aea5aea, 0xffff, 0x3); + } + else + { + //error condition, should not reach here + coex_dm->error_condition = 3; + } + } +} + +void +halbtc8812a1ant_ActionWifiConnected( + PBTC_COEXIST btcoexist + ) +{ + PBTC_STACK_INFO stack_info=&btcoexist->stack_info; + BOOLEAN wifi_connected=false, wifi_busy=false, bt_hs_on=false; + BOOLEAN scan=false, link=false, roam=false; + BOOLEAN hs_connecting=false, under4way=false; + u4Byte wifi_bw; + + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], CoexForWifiConnect()===>\n")); + + btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED, &wifi_connected); + if(!wifi_connected) + { + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], CoexForWifiConnect(), return for wifi not connected<===\n")); + return; + } + + btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_4_WAY_PROGRESS, &under4way); + if(under4way) + { + halbtc8812a1ant_ActionWifiConnectedSpecialPacket(btcoexist); + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], CoexForWifiConnect(), return for wifi is under 4way<===\n")); + return; + } + + btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_CONNECTING, &hs_connecting); + btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION, &bt_hs_on); + btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_SCAN, &scan); + btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_LINK, &link); + btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_ROAM, &roam); + if(scan || link || roam) + { + halbtc8812a1ant_ActionWifiConnectedScan(btcoexist); + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], CoexForWifiConnect(), return for wifi is under scan<===\n")); + return; + } + + btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy); + if(!wifi_busy) + { + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], wifi associated-idle!!!\n")); + if(btcoexist->bt_info.bt_disabled) + { + halbtc8812a1ant_PsTdmaCheckForPowerSaveState(btcoexist, true); + halbtc8812a1ant_LpsRpwm(btcoexist, NORMAL_EXEC, 0x0, 0x4); + btcoexist->btc_set(btcoexist, BTC_SET_ACT_ENTER_LPS, NULL); + halbtc8812a1ant_PsTdma(btcoexist, NORMAL_EXEC, false, 9); + halbtc8812a1ant_CoexTable(btcoexist, NORMAL_EXEC, 0x55555555, 0x55555555, 0xffff, 0x3); + } + else + { + if(BT_8812A_1ANT_BT_STATUS_INQ_PAGE == coex_dm->bt_status) + { + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], bt is under inquiry/page scan!!!\n")); + if(stack_info->sco_exist) + { + halbtc8812a1ant_PsTdma(btcoexist, NORMAL_EXEC, true, 32); + halbtc8812a1ant_CoexTable(btcoexist, NORMAL_EXEC, 0x55555555, 0x5afa5afa, 0xffff, 0x3); + } + else + { + halbtc8812a1ant_PsTdmaCheckForPowerSaveState(btcoexist, true); + halbtc8812a1ant_LpsRpwm(btcoexist, NORMAL_EXEC, 0x0, 0x4); + // power save must executed before psTdma. + btcoexist->btc_set(btcoexist, BTC_SET_ACT_ENTER_LPS, NULL); + halbtc8812a1ant_PsTdma(btcoexist, NORMAL_EXEC, true, 30); + halbtc8812a1ant_CoexTable(btcoexist, NORMAL_EXEC, 0x55555555, 0x55555555, 0xffff, 0x3); + } + } + else if(BT_8812A_1ANT_BT_STATUS_NON_CONNECTED_IDLE == coex_dm->bt_status) + { + halbtc8812a1ant_PsTdmaCheckForPowerSaveState(btcoexist, true); + halbtc8812a1ant_LpsRpwm(btcoexist, NORMAL_EXEC, 0x26, 0x0); + // power save must executed before psTdma. + btcoexist->btc_set(btcoexist, BTC_SET_ACT_ENTER_LPS, NULL); + halbtc8812a1ant_PsTdma(btcoexist, NORMAL_EXEC, false, 9); + halbtc8812a1ant_CoexTable(btcoexist, NORMAL_EXEC, 0x55555555, 0x55555555, 0xffff, 0x3); + } + else if(BT_8812A_1ANT_BT_STATUS_CONNECTED_IDLE == coex_dm->bt_status) + { + halbtc8812a1ant_PsTdmaCheckForPowerSaveState(btcoexist, true); + halbtc8812a1ant_LpsRpwm(btcoexist, NORMAL_EXEC, 0x26, 0x0); + // power save must executed before psTdma. + btcoexist->btc_set(btcoexist, BTC_SET_ACT_ENTER_LPS, NULL); + halbtc8812a1ant_PsTdma(btcoexist, NORMAL_EXEC, false, 0); + halbtc8812a1ant_CoexTable(btcoexist, NORMAL_EXEC, 0x55555555, 0x55555555, 0xffff, 0x3); + } + else if(BT_8812A_1ANT_BT_STATUS_ACL_BUSY == coex_dm->bt_status) + { + if(stack_info->hid_exist && stack_info->numOfLink==1) + { + // hid only + halbtc8812a1ant_PsTdmaCheckForPowerSaveState(btcoexist, false); + // power save must executed before psTdma. + btcoexist->btc_set(btcoexist, BTC_SET_ACT_LEAVE_LPS, NULL); + + halbtc8812a1ant_PsTdma(btcoexist, NORMAL_EXEC, false, 8); + halbtc8812a1ant_CoexTable(btcoexist, NORMAL_EXEC, 0x5fff5fff, 0x5fff5fff, 0xffff, 0x3); + coex_dm->reset_tdma_adjust = true; + } + else + { + halbtc8812a1ant_PsTdmaCheckForPowerSaveState(btcoexist, true); + halbtc8812a1ant_LpsRpwm(btcoexist, NORMAL_EXEC, 0x0, 0x4); + // power save must executed before psTdma. + btcoexist->btc_set(btcoexist, BTC_SET_ACT_ENTER_LPS, NULL); + + if(stack_info->hid_exist) + { + if(stack_info->a2dp_exist) + { + // hid+a2dp + halbtc8812a1ant_PsTdma(btcoexist, NORMAL_EXEC, true, 2); + halbtc8812a1ant_CoexTable(btcoexist, NORMAL_EXEC, 0x55555555, 0x5afa5afa, 0xffff, 0x3); + } + else if(stack_info->pan_exist) + { + if(bt_hs_on) + { + // hid+hs + halbtc8812a1ant_PsTdma(btcoexist, NORMAL_EXEC, true, 2); + } + else + { + // hid+pan + halbtc8812a1ant_PsTdma(btcoexist, NORMAL_EXEC, true, 2); + } + halbtc8812a1ant_CoexTable(btcoexist, NORMAL_EXEC, 0x55555555, 0x5afa5afa, 0xffff, 0x3); + } + else + { + coex_dm->error_condition = 4; + } + coex_dm->reset_tdma_adjust = true; + } + else if(stack_info->a2dp_exist) + { + if(stack_info->pan_exist) + { + if(bt_hs_on) + { + // a2dp+hs + halbtc8812a1ant_PsTdma(btcoexist, NORMAL_EXEC, true, 2); + } + else + { + // a2dp+pan + halbtc8812a1ant_PsTdma(btcoexist, NORMAL_EXEC, true, 36); + } + halbtc8812a1ant_CoexTable(btcoexist, NORMAL_EXEC, 0x55555555, 0x5afa5afa, 0xffff, 0x3); + coex_dm->reset_tdma_adjust = true; + } + else + { + // a2dp only + halbtc8812a1ant_TdmaDurationAdjustForAcl(btcoexist); + halbtc8812a1ant_CoexTable(btcoexist, NORMAL_EXEC, 0x55555555, 0x5afa5afa, 0xffff, 0x3); + } + } + else if(stack_info->pan_exist) + { + // pan only + if(bt_hs_on) + { + coex_dm->error_condition = 5; + } + else + { + halbtc8812a1ant_PsTdma(btcoexist, NORMAL_EXEC, true, 2); + halbtc8812a1ant_CoexTable(btcoexist, NORMAL_EXEC, 0x55555555, 0x5afa5afa, 0xffff, 0x3); + } + coex_dm->reset_tdma_adjust = true; + } + else + { + // temp state, do nothing!!! + //DbgPrint("error 6, coex_dm->bt_status=%d\n", coex_dm->bt_status); + //DbgPrint("error 6, stack_info->numOfLink=%d, stack_info->hid_exist=%d, stack_info->a2dp_exist=%d, stack_info->pan_exist=%d, stack_info->sco_exist=%d\n", + //stack_info->numOfLink, stack_info->hid_exist, stack_info->a2dp_exist, stack_info->pan_exist, stack_info->sco_exist); + //coex_dm->error_condition = 6; + } + } + } + else if( (BT_8812A_1ANT_BT_STATUS_SCO_BUSY == coex_dm->bt_status) || + (BT_8812A_1ANT_BT_STATUS_ACL_SCO_BUSY == coex_dm->bt_status) ) + { + halbtc8812a1ant_PsTdmaCheckForPowerSaveState(btcoexist, false); + // power save must executed before psTdma. + btcoexist->btc_set(btcoexist, BTC_SET_ACT_LEAVE_LPS, NULL); + + halbtc8812a1ant_PsTdma(btcoexist, NORMAL_EXEC, false, 8); + halbtc8812a1ant_CoexTable(btcoexist, NORMAL_EXEC, 0x5aea5aea, 0x5aea5aea, 0xffff, 0x3); + } + else + { + //error condition, should not reach here + coex_dm->error_condition = 7; + } + } + } + else + { + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], wifi busy!!!\n")); + if(btcoexist->bt_info.bt_disabled) + { + halbtc8812a1ant_PsTdmaCheckForPowerSaveState(btcoexist, false); + btcoexist->btc_set(btcoexist, BTC_SET_ACT_LEAVE_LPS, NULL); + halbtc8812a1ant_PsTdma(btcoexist, NORMAL_EXEC, false, 9); + halbtc8812a1ant_CoexTable(btcoexist, NORMAL_EXEC, 0x55555555, 0x55555555, 0xffff, 0x3); + } + else + { + if(bt_hs_on) + { + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], HS is under progress!!!\n")); + //DbgPrint("coex_dm->bt_status = 0x%x\n", coex_dm->bt_status); + halbtc8812a1ant_ActionHs(btcoexist, hs_connecting); + } + else if(BT_8812A_1ANT_BT_STATUS_INQ_PAGE == coex_dm->bt_status) + { + if(stack_info->sco_exist) + { + halbtc8812a1ant_PsTdma(btcoexist, NORMAL_EXEC, true, 32); + halbtc8812a1ant_CoexTable(btcoexist, NORMAL_EXEC, 0x55555555, 0x5afa5afa, 0xffff, 0x3); + } + else + { + halbtc8812a1ant_PsTdmaCheckForPowerSaveState(btcoexist, true); + halbtc8812a1ant_LpsRpwm(btcoexist, NORMAL_EXEC, 0x0, 0x4); + // power save must executed before psTdma. + btcoexist->btc_set(btcoexist, BTC_SET_ACT_ENTER_LPS, NULL); + halbtc8812a1ant_PsTdma(btcoexist, NORMAL_EXEC, true, 30); + halbtc8812a1ant_CoexTable(btcoexist, NORMAL_EXEC, 0x55555555, 0x55555555, 0xffff, 0x3); + } + } + else if(BT_8812A_1ANT_BT_STATUS_NON_CONNECTED_IDLE == coex_dm->bt_status) + { + halbtc8812a1ant_PsTdmaCheckForPowerSaveState(btcoexist, false); + // power save must executed before psTdma. + btcoexist->btc_set(btcoexist, BTC_SET_ACT_LEAVE_LPS, NULL); + halbtc8812a1ant_PsTdma(btcoexist, NORMAL_EXEC, true, 5); + halbtc8812a1ant_CoexTable(btcoexist, NORMAL_EXEC, 0x5a5a5a5a, 0x5a5a5a5a, 0xffff, 0x3); + } + else if(BT_8812A_1ANT_BT_STATUS_CONNECTED_IDLE == coex_dm->bt_status) + { + halbtc8812a1ant_PsTdmaCheckForPowerSaveState(btcoexist, false); + // power save must executed before psTdma. + btcoexist->btc_set(btcoexist, BTC_SET_ACT_LEAVE_LPS, NULL); + if(bt_hs_on) + { + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], HS is under progress!!!\n")); + halbtc8812a1ant_ActionHs(btcoexist, hs_connecting); + } + else + { + halbtc8812a1ant_PsTdma(btcoexist, NORMAL_EXEC, true, 5); + halbtc8812a1ant_CoexTable(btcoexist, NORMAL_EXEC, 0x5a5a5a5a, 0x5a5a5a5a, 0xffff, 0x3); + } + } + else if(BT_8812A_1ANT_BT_STATUS_ACL_BUSY == coex_dm->bt_status) + { + if(stack_info->hid_exist && stack_info->numOfLink==1) + { + // hid only + halbtc8812a1ant_PsTdmaCheckForPowerSaveState(btcoexist, false); + // power save must executed before psTdma. + btcoexist->btc_set(btcoexist, BTC_SET_ACT_LEAVE_LPS, NULL); + + halbtc8812a1ant_PsTdma(btcoexist, NORMAL_EXEC, false, 8); + halbtc8812a1ant_CoexTable(btcoexist, NORMAL_EXEC, 0x5fff5fff, 0x5fff5fff, 0xffff, 0x3); + coex_dm->reset_tdma_adjust = true; + } + else + { + halbtc8812a1ant_PsTdmaCheckForPowerSaveState(btcoexist, true); + halbtc8812a1ant_LpsRpwm(btcoexist, NORMAL_EXEC, 0x0, 0x4); + // power save must executed before psTdma. + btcoexist->btc_set(btcoexist, BTC_SET_ACT_ENTER_LPS, NULL); + + if(stack_info->hid_exist) + { + if(stack_info->a2dp_exist) + { + // hid+a2dp + halbtc8812a1ant_PsTdma(btcoexist, NORMAL_EXEC, true, 2); + halbtc8812a1ant_CoexTable(btcoexist, NORMAL_EXEC, 0x55555555, 0x5afa5afa, 0xffff, 0x3); + } + else if(stack_info->pan_exist) + { + if(bt_hs_on) + { + // hid+hs + halbtc8812a1ant_PsTdma(btcoexist, NORMAL_EXEC, true, 2); + } + else + { + // hid+pan + halbtc8812a1ant_PsTdma(btcoexist, NORMAL_EXEC, true, 2); + } + halbtc8812a1ant_CoexTable(btcoexist, NORMAL_EXEC, 0x55555555, 0x5afa5afa, 0xffff, 0x3); + } + else + { + coex_dm->error_condition = 8; + } + coex_dm->reset_tdma_adjust = true; + } + else if(stack_info->a2dp_exist) + { + if(stack_info->pan_exist) + { + if(bt_hs_on) + { + // a2dp+hs + halbtc8812a1ant_PsTdma(btcoexist, NORMAL_EXEC, true, 2); + } + else + { + // a2dp+pan + halbtc8812a1ant_PsTdma(btcoexist, NORMAL_EXEC, true, 36); + } + halbtc8812a1ant_CoexTable(btcoexist, NORMAL_EXEC, 0x55555555, 0x5afa5afa, 0xffff, 0x3); + coex_dm->reset_tdma_adjust = true; + } + else + { + // a2dp only + halbtc8812a1ant_TdmaDurationAdjustForAcl(btcoexist); + halbtc8812a1ant_CoexTable(btcoexist, NORMAL_EXEC, 0x55555555, 0x5afa5afa, 0xffff, 0x3); + } + } + else if(stack_info->pan_exist) + { + // pan only + if(bt_hs_on) + { + coex_dm->error_condition = 9; + } + else + { + halbtc8812a1ant_PsTdma(btcoexist, NORMAL_EXEC, true, 2); + halbtc8812a1ant_CoexTable(btcoexist, NORMAL_EXEC, 0x55555555, 0x5afa5afa, 0xffff, 0x3); + } + coex_dm->reset_tdma_adjust = true; + } + else + { + //DbgPrint("error 10, stack_info->numOfLink=%d, stack_info->hid_exist=%d, stack_info->a2dp_exist=%d, stack_info->pan_exist=%d, stack_info->sco_exist=%d\n", + //stack_info->numOfLink, stack_info->hid_exist, stack_info->a2dp_exist, stack_info->pan_exist, stack_info->sco_exist); + coex_dm->error_condition = 10; + } + } + } + else if( (BT_8812A_1ANT_BT_STATUS_SCO_BUSY == coex_dm->bt_status) || + (BT_8812A_1ANT_BT_STATUS_ACL_SCO_BUSY == coex_dm->bt_status) ) + { + halbtc8812a1ant_PsTdmaCheckForPowerSaveState(btcoexist, false); + // power save must executed before psTdma. + btcoexist->btc_set(btcoexist, BTC_SET_ACT_LEAVE_LPS, NULL); + + halbtc8812a1ant_PsTdma(btcoexist, NORMAL_EXEC, false, 8); + halbtc8812a1ant_CoexTable(btcoexist, NORMAL_EXEC, 0x5aea5aea, 0x5aea5aea, 0xffff, 0x3); + } + else + { + //DbgPrint("error 11, coex_dm->bt_status=%d\n", coex_dm->bt_status); + //DbgPrint("error 11, stack_info->numOfLink=%d, stack_info->hid_exist=%d, stack_info->a2dp_exist=%d, stack_info->pan_exist=%d, stack_info->sco_exist=%d\n", + //stack_info->numOfLink, stack_info->hid_exist, stack_info->a2dp_exist, stack_info->pan_exist, stack_info->sco_exist); + //error condition, should not reach here + coex_dm->error_condition = 11; + } + } + } + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], CoexForWifiConnect()<===\n")); +} + +void +halbtc8812a1ant_RunSwCoexistMechanism( + PBTC_COEXIST btcoexist + ) +{ + PBTC_STACK_INFO stack_info=&btcoexist->stack_info; + BOOLEAN wifi_under5g=false, wifi_busy=false, wifi_connected=false; + u1Byte bt_info_original=0, bt_retry_cnt=0; + u1Byte algorithm=0; + + return; + if(stack_info->bProfileNotified) + { + algorithm = halbtc8812a1ant_ActionAlgorithm(btcoexist); + coex_dm->cur_algorithm = algorithm; + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], Algorithm = %d \n", coex_dm->cur_algorithm)); + + if(halbtc8812a1ant_IsCommonAction(btcoexist)) + { + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], Action common.\n")); + } + else + { + switch(coex_dm->cur_algorithm) + { + case BT_8812A_1ANT_COEX_ALGO_SCO: + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], Action algorithm = SCO.\n")); + halbtc8812a1ant_ActionSco(btcoexist); + break; + case BT_8812A_1ANT_COEX_ALGO_HID: + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], Action algorithm = HID.\n")); + halbtc8812a1ant_ActionHid(btcoexist); + break; + case BT_8812A_1ANT_COEX_ALGO_A2DP: + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], Action algorithm = A2DP.\n")); + halbtc8812a1ant_ActionA2dp(btcoexist); + break; + case BT_8812A_1ANT_COEX_ALGO_A2DP_PANHS: + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], Action algorithm = A2DP+PAN(HS).\n")); + halbtc8812a1ant_ActionA2dpPanHs(btcoexist); + break; + case BT_8812A_1ANT_COEX_ALGO_PANEDR: + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], Action algorithm = PAN(EDR).\n")); + halbtc8812a1ant_ActionPanEdr(btcoexist); + break; + case BT_8812A_1ANT_COEX_ALGO_PANHS: + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], Action algorithm = HS mode.\n")); + halbtc8812a1ant_ActionPanHs(btcoexist); + break; + case BT_8812A_1ANT_COEX_ALGO_PANEDR_A2DP: + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], Action algorithm = PAN+A2DP.\n")); + halbtc8812a1ant_ActionPanEdrA2dp(btcoexist); + break; + case BT_8812A_1ANT_COEX_ALGO_PANEDR_HID: + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], Action algorithm = PAN(EDR)+HID.\n")); + halbtc8812a1ant_ActionPanEdrHid(btcoexist); + break; + case BT_8812A_1ANT_COEX_ALGO_HID_A2DP_PANEDR: + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], Action algorithm = HID+A2DP+PAN.\n")); + halbtc8812a1ant_ActionHidA2dpPanEdr(btcoexist); + break; + case BT_8812A_1ANT_COEX_ALGO_HID_A2DP: + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], Action algorithm = HID+A2DP.\n")); + halbtc8812a1ant_ActionHidA2dp(btcoexist); + break; + default: + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], Action algorithm = coexist All Off!!\n")); + halbtc8812a1ant_CoexAllOff(btcoexist); + break; + } + coex_dm->pre_algorithm = coex_dm->cur_algorithm; + } + } +} + +void +halbtc8812a1ant_RunCoexistMechanism( + PBTC_COEXIST btcoexist + ) +{ + PBTC_STACK_INFO stack_info=&btcoexist->stack_info; + BOOLEAN wifi_under5g=false, wifi_busy=false, wifi_connected=false; + + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], RunCoexistMechanism()===>\n")); + + btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_UNDER_5G, &wifi_under5g); + + if(wifi_under5g) + { + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], RunCoexistMechanism(), return for 5G <===\n")); + return; + } + + if(btcoexist->manual_control) + { + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], RunCoexistMechanism(), return for Manual CTRL <===\n")); + return; + } + + if(btcoexist->stop_coex_dm) + { + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], RunCoexistMechanism(), return for Stop Coex DM <===\n")); + return; + } + + halbtc8812a1ant_RunSwCoexistMechanism(btcoexist); + + btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED, &wifi_connected); + if(btcoexist->bt_info.bt_disabled) + { + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], bt is disabled!!!\n")); + btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy); + if(wifi_busy) + { + halbtc8812a1ant_PsTdmaCheckForPowerSaveState(btcoexist, false); + btcoexist->btc_set(btcoexist, BTC_SET_ACT_LEAVE_LPS, NULL); + halbtc8812a1ant_PsTdma(btcoexist, NORMAL_EXEC, false, 9); + } + else + { + halbtc8812a1ant_PsTdmaCheckForPowerSaveState(btcoexist, true); + halbtc8812a1ant_LpsRpwm(btcoexist, NORMAL_EXEC, 0x0, 0x4); + // power save must executed before psTdma. + btcoexist->btc_set(btcoexist, BTC_SET_ACT_ENTER_LPS, NULL); + halbtc8812a1ant_PsTdma(btcoexist, NORMAL_EXEC, false, 9); + } + halbtc8812a1ant_CoexTable(btcoexist, NORMAL_EXEC, 0x55555555, 0x55555555, 0xffff, 0x3); + } + else if(coex_sta->under_ips) + { + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], wifi is under IPS !!!\n")); + halbtc8812a1ant_PsTdma(btcoexist, NORMAL_EXEC, false, 0); + halbtc8812a1ant_CoexTable(btcoexist, NORMAL_EXEC, 0x55555555, 0x55555555, 0xffff, 0x3); + halbtc8812a1ant_WifiParaAdjust(btcoexist, false); + } + else if(!wifi_connected) + { + BOOLEAN scan=false, link=false, roam=false; + + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], wifi is non connected-idle !!!\n")); + + btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_SCAN, &scan); + btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_LINK, &link); + btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_ROAM, &roam); + + if(scan || link || roam) + halbtc8812a1ant_ActionWifiNotConnectedAssoAuthScan(btcoexist); + else + halbtc8812a1ant_ActionWifiNotConnected(btcoexist); + } + else // wifi LPS/Busy + { + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], wifi is NOT under IPS!!!\n")); + halbtc8812a1ant_WifiParaAdjust(btcoexist, true); + halbtc8812a1ant_ActionWifiConnected(btcoexist); + } + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], RunCoexistMechanism()<===\n")); +} + +void +halbtc8812a1ant_InitCoexDm( + PBTC_COEXIST btcoexist + ) +{ + BOOLEAN wifi_connected=false; + // force to reset coex mechanism + + btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED, &wifi_connected); + if(!wifi_connected) // non-connected scan + { + halbtc8812a1ant_ActionWifiNotConnected(btcoexist); + } + else // wifi is connected + { + halbtc8812a1ant_ActionWifiConnected(btcoexist); + } + + halbtc8812a1ant_FwDacSwingLvl(btcoexist, FORCE_EXEC, 6); + halbtc8812a1ant_DecBtPwr(btcoexist, FORCE_EXEC, false); + + // sw all off + halbtc8812a1ant_SwMechanism1(btcoexist,false,false,false,false); + halbtc8812a1ant_SwMechanism2(btcoexist,false,false,false,0x18); + + halbtc8812a1ant_CoexTable(btcoexist, FORCE_EXEC, 0x55555555, 0x55555555, 0xffff, 0x3); +} + +//============================================================ +// work around function start with wa_halbtc8812a1ant_ +//============================================================ +//============================================================ +// extern function start with EXhalbtc8812a1ant_ +//============================================================ +void +EXhalbtc8812a1ant_InitHwConfig( + PBTC_COEXIST btcoexist + ) +{ + u4Byte u4_tmp=0; + u2Byte u2Tmp=0; + u1Byte u1_tmp=0; + + BTC_PRINT(BTC_MSG_INTERFACE, INTF_INIT, ("[BTCoex], 1Ant Init HW Config!!\n")); + + // backup rf 0x1e value + coex_dm->bt_rf0x1e_backup = + btcoexist->btc_get_rf_reg(btcoexist, BTC_RF_A, 0x1e, 0xfffff); + + //ant sw control to BT + btcoexist->btc_write_4byte(btcoexist, 0x900, 0x00000400); + btcoexist->btc_write_1byte(btcoexist, 0x76d, 0x1); + btcoexist->btc_write_1byte(btcoexist, 0xcb3, 0x77); + btcoexist->btc_write_1byte(btcoexist, 0xcb7, 0x40); + + // 0x790[5:0]=0x5 + u1_tmp = btcoexist->btc_read_1byte(btcoexist, 0x790); + u1_tmp &= 0xc0; + u1_tmp |= 0x5; + btcoexist->btc_write_1byte(btcoexist, 0x790, u1_tmp); + + // PTA parameter + btcoexist->btc_write_1byte(btcoexist, 0x6cc, 0x0); + btcoexist->btc_write_4byte(btcoexist, 0x6c8, 0xffff); + btcoexist->btc_write_4byte(btcoexist, 0x6c4, 0x55555555); + btcoexist->btc_write_4byte(btcoexist, 0x6c0, 0x55555555); + + // coex parameters + btcoexist->btc_write_1byte(btcoexist, 0x778, 0x1); + + // enable counter statistics + btcoexist->btc_write_1byte(btcoexist, 0x76e, 0x4); + + // enable PTA + btcoexist->btc_write_1byte(btcoexist, 0x40, 0x20); + + // bt clock related + u1_tmp = btcoexist->btc_read_1byte(btcoexist, 0x4); + u1_tmp |= BIT7; + btcoexist->btc_write_1byte(btcoexist, 0x4, u1_tmp); + + // bt clock related + u1_tmp = btcoexist->btc_read_1byte(btcoexist, 0x7); + u1_tmp |= BIT1; + btcoexist->btc_write_1byte(btcoexist, 0x7, u1_tmp); +} + +void +EXhalbtc8812a1ant_InitCoexDm( + PBTC_COEXIST btcoexist + ) +{ + BTC_PRINT(BTC_MSG_INTERFACE, INTF_INIT, ("[BTCoex], Coex Mechanism Init!!\n")); + + btcoexist->stop_coex_dm = false; + + halbtc8812a1ant_InitCoexDm(btcoexist); +} + +void +EXhalbtc8812a1ant_DisplayCoexInfo( + PBTC_COEXIST btcoexist + ) +{ + PBTC_BOARD_INFO board_info=&btcoexist->boardInfo; + PBTC_STACK_INFO stack_info=&btcoexist->stack_info; + pu1Byte cli_buf=btcoexist->cli_buf; + u1Byte u1_tmp[4], i, bt_info_ext, psTdmaCase=0; + u4Byte u4_tmp[4]; + BOOLEAN roam=false, scan=false, link=false, wifi_under5g=false; + BOOLEAN bt_hs_on=false, wifi_busy=false; + s4Byte wifi_rssi=0, bt_hs_rssi=0; + u4Byte wifi_bw, wifiTrafficDir; + u1Byte wifiDot11Chnl, wifiHsChnl; + + CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n ============[BT Coexist info]============"); + CL_PRINTF(cli_buf); + + if(btcoexist->manual_control) + { + CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n ============[Under Manual Control]============"); + CL_PRINTF(cli_buf); + CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n =========================================="); + CL_PRINTF(cli_buf); + } + if(btcoexist->stop_coex_dm) + { + CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n ============[Coex is STOPPED]============"); + CL_PRINTF(cli_buf); + CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n =========================================="); + CL_PRINTF(cli_buf); + } + + if(!board_info->bBtExist) + { + CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n BT not exists !!!"); + CL_PRINTF(cli_buf); + return; + } + + CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d/ %d ", "Ant PG number/ Ant mechanism:", \ + board_info->pgAntNum, board_info->btdmAntNum); + CL_PRINTF(cli_buf); + + CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %s / %d", "BT stack/ hci ext ver", \ + ((stack_info->bProfileNotified)? "Yes":"No"), stack_info->hciVersion); + CL_PRINTF(cli_buf); + btcoexist->btc_disp_dbg_msg(btcoexist, BTC_DBG_DISP_BT_FW_VER); + + btcoexist->btc_get(btcoexist, BTC_GET_BL_HS_OPERATION, &bt_hs_on); + btcoexist->btc_get(btcoexist, BTC_GET_U1_WIFI_DOT11_CHNL, &wifiDot11Chnl); + btcoexist->btc_get(btcoexist, BTC_GET_U1_WIFI_HS_CHNL, &wifiHsChnl); + CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d / %d(%d)", "Dot11 channel / HsChnl(HsMode)", \ + wifiDot11Chnl, wifiHsChnl, bt_hs_on); + CL_PRINTF(cli_buf); + + CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %02x %02x %02x ", "H2C Wifi inform bt chnl Info", \ + coex_dm->wifi_chnl_info[0], coex_dm->wifi_chnl_info[1], + coex_dm->wifi_chnl_info[2]); + CL_PRINTF(cli_buf); + + btcoexist->btc_get(btcoexist, BTC_GET_S4_WIFI_RSSI, &wifi_rssi); + btcoexist->btc_get(btcoexist, BTC_GET_S4_HS_RSSI, &bt_hs_rssi); + CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d/ %d", "Wifi rssi/ HS rssi", \ + wifi_rssi, bt_hs_rssi); + CL_PRINTF(cli_buf); + + btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_SCAN, &scan); + btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_LINK, &link); + btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_ROAM, &roam); + CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d/ %d/ %d ", "Wifi link/ roam/ scan", \ + link, roam, scan); + CL_PRINTF(cli_buf); + + btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_UNDER_5G, &wifi_under5g); + btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw); + btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_BUSY, &wifi_busy); + btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_TRAFFIC_DIRECTION, &wifiTrafficDir); + CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %s / %s/ %s ", "Wifi status", \ + (wifi_under5g? "5G":"2.4G"), + ((BTC_WIFI_BW_LEGACY==wifi_bw)? "Legacy": (((BTC_WIFI_BW_HT40==wifi_bw)? "HT40":"HT20"))), + ((!wifi_busy)? "idle": ((BTC_WIFI_TRAFFIC_TX==wifiTrafficDir)? "uplink":"downlink"))); + CL_PRINTF(cli_buf); + CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = [%s/ %d/ %d] ", "BT [status/ rssi/ retryCnt]", \ + ((coex_sta->c2h_bt_inquiry_page)?("inquiry/page scan"):((BT_8812A_1ANT_BT_STATUS_NON_CONNECTED_IDLE == coex_dm->bt_status)? "non-connected idle": + ( (BT_8812A_1ANT_BT_STATUS_CONNECTED_IDLE == coex_dm->bt_status)? "connected-idle":"busy"))), + coex_sta->bt_rssi, coex_sta->bt_retry_cnt); + CL_PRINTF(cli_buf); + + if(stack_info->bProfileNotified) + { + CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d / %d / %d / %d", "SCO/HID/PAN/A2DP", \ + stack_info->sco_exist, stack_info->hid_exist, stack_info->pan_exist, stack_info->a2dp_exist); + CL_PRINTF(cli_buf); + + btcoexist->btc_disp_dbg_msg(btcoexist, BTC_DBG_DISP_BT_LINK_INFO); + } + + bt_info_ext = coex_sta->bt_info_ext; + CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %s", "BT Info A2DP rate", \ + (bt_info_ext&BIT0)? "Basic rate":"EDR rate"); + CL_PRINTF(cli_buf); + + for(i=0; i<BT_INFO_SRC_8812A_1ANT_MAX; i++) + { + if(coex_sta->bt_info_c2h_cnt[i]) + { + CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %02x %02x %02x %02x %02x %02x %02x(%d)", GLBtInfoSrc8812a1Ant[i], \ + coex_sta->bt_info_c2h[i][0], coex_sta->bt_info_c2h[i][1], + coex_sta->bt_info_c2h[i][2], coex_sta->bt_info_c2h[i][3], + coex_sta->bt_info_c2h[i][4], coex_sta->bt_info_c2h[i][5], + coex_sta->bt_info_c2h[i][6], coex_sta->bt_info_c2h_cnt[i]); + CL_PRINTF(cli_buf); + } + } + CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %s/%s, (0x%x/0x%x)", "PS state, IPS/LPS, (lps/rpwm)", \ + ((coex_sta->under_ips? "IPS ON":"IPS OFF")), + ((coex_sta->under_lps? "LPS ON":"LPS OFF")), + btcoexist->bt_info.lps1Ant, + btcoexist->bt_info.rpwm1Ant); + CL_PRINTF(cli_buf); + btcoexist->btc_disp_dbg_msg(btcoexist, BTC_DBG_DISP_FW_PWR_MODE_CMD); + + if(!btcoexist->manual_control) + { + // Sw mechanism + CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s", "============[Sw mechanism]============"); + CL_PRINTF(cli_buf); + + CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d/ %d/ %d/ %d ", "SM1[ShRf/ LpRA/ LimDig/ btLna]", \ + coex_dm->cur_rf_rx_lpf_shrink, coex_dm->cur_low_penalty_ra, coex_dm->limited_dig, coex_dm->bCurBtLnaConstrain); + CL_PRINTF(cli_buf); + CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d/ %d/ %d(0x%x) ", "SM2[AgcT/ AdcB/ SwDacSwing(lvl)]", \ + coex_dm->cur_agc_table_en, coex_dm->cur_adc_back_off, coex_dm->cur_dac_swing_on, coex_dm->cur_dac_swing_lvl); + CL_PRINTF(cli_buf); + + // Fw mechanism + CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s", "============[Fw mechanism]============"); + CL_PRINTF(cli_buf); + + psTdmaCase = coex_dm->cur_ps_tdma; + CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %02x %02x %02x %02x %02x case-%d", "PS TDMA", \ + coex_dm->ps_tdma_para[0], coex_dm->ps_tdma_para[1], + coex_dm->ps_tdma_para[2], coex_dm->ps_tdma_para[3], + coex_dm->ps_tdma_para[4], psTdmaCase); + CL_PRINTF(cli_buf); + + CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = 0x%x ", "Latest error condition(should be 0)", \ + coex_dm->error_condition); + CL_PRINTF(cli_buf); + + CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d/ %d ", "DecBtPwr/ IgnWlanAct", \ + coex_dm->cur_dec_bt_pwr, coex_dm->cur_ignore_wlan_act); + CL_PRINTF(cli_buf); + } + + // Hw setting + CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s", "============[Hw setting]============"); + CL_PRINTF(cli_buf); + + CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = 0x%x", "RF-A, 0x1e initVal", \ + coex_dm->bt_rf0x1e_backup); + CL_PRINTF(cli_buf); + + u1_tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x778); + CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = 0x%x", "0x778", \ + u1_tmp[0]); + CL_PRINTF(cli_buf); + + u1_tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x92c); + u4_tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0x930); + CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = 0x%x/ 0x%x", "0x92c/ 0x930", \ + (u1_tmp[0]), u4_tmp[0]); + CL_PRINTF(cli_buf); + + u1_tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x40); + u1_tmp[1] = btcoexist->btc_read_1byte(btcoexist, 0x4f); + CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = 0x%x/ 0x%x", "0x40/ 0x4f", \ + u1_tmp[0], u1_tmp[1]); + CL_PRINTF(cli_buf); + + u4_tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0x550); + u1_tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x522); + CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = 0x%x/ 0x%x", "0x550(bcn ctrl)/0x522", \ + u4_tmp[0], u1_tmp[0]); + CL_PRINTF(cli_buf); + + u4_tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0xc50); + CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = 0x%x", "0xc50(dig)", \ + u4_tmp[0]); + CL_PRINTF(cli_buf); + +#if 0 + u4_tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0xf48); + u4_tmp[1] = btcoexist->btc_read_4byte(btcoexist, 0xf4c); + CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = 0x%x/ 0x%x", "0xf48/ 0xf4c (FA cnt)", \ + u4_tmp[0], u4_tmp[1]); + CL_PRINTF(cli_buf); +#endif + + u4_tmp[0] = btcoexist->btc_read_4byte(btcoexist, 0x6c0); + u4_tmp[1] = btcoexist->btc_read_4byte(btcoexist, 0x6c4); + u4_tmp[2] = btcoexist->btc_read_4byte(btcoexist, 0x6c8); + u1_tmp[0] = btcoexist->btc_read_1byte(btcoexist, 0x6cc); + CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = 0x%x/ 0x%x/ 0x%x/ 0x%x", "0x6c0/0x6c4/0x6c8/0x6cc(coexTable)", \ + u4_tmp[0], u4_tmp[1], u4_tmp[2], u1_tmp[0]); + CL_PRINTF(cli_buf); + + CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d/ %d", "0x770(hp rx[31:16]/tx[15:0])", \ + coex_sta->high_priority_rx, coex_sta->high_priority_tx); + CL_PRINTF(cli_buf); + CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d/ %d", "0x774(lp rx[31:16]/tx[15:0])", \ + coex_sta->low_priority_rx, coex_sta->low_priority_tx); + CL_PRINTF(cli_buf); + + btcoexist->btc_disp_dbg_msg(btcoexist, BTC_DBG_DISP_COEX_STATISTICS); +} + + +void +EXhalbtc8812a1ant_IpsNotify( + PBTC_COEXIST btcoexist, + u1Byte type + ) +{ + u4Byte u4_tmp=0; + + if(btcoexist->manual_control || btcoexist->stop_coex_dm) + return; + + if(BTC_IPS_ENTER == type) + { + BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY, ("[BTCoex], IPS ENTER notify\n")); + coex_sta->under_ips = true; + + // 0x4c[23]=1 + u4_tmp = btcoexist->btc_read_4byte(btcoexist, 0x4c); + u4_tmp |= BIT23; + btcoexist->btc_write_4byte(btcoexist, 0x4c, u4_tmp); + + halbtc8812a1ant_CoexAllOff(btcoexist); + } + else if(BTC_IPS_LEAVE == type) + { + BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY, ("[BTCoex], IPS LEAVE notify\n")); + coex_sta->under_ips = false; + //halbtc8812a1ant_InitCoexDm(btcoexist); + } +} + +void +EXhalbtc8812a1ant_LpsNotify( + PBTC_COEXIST btcoexist, + u1Byte type + ) +{ + if(btcoexist->manual_control || btcoexist->stop_coex_dm) + return; + + if(BTC_LPS_ENABLE == type) + { + BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY, ("[BTCoex], LPS ENABLE notify\n")); + coex_sta->under_lps = true; + } + else if(BTC_IPS_LEAVE == type) + { + BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY, ("[BTCoex], LPS DISABLE notify\n")); + coex_sta->under_lps = false; + } +} + +void +EXhalbtc8812a1ant_ScanNotify( + PBTC_COEXIST btcoexist, + u1Byte type + ) +{ + PBTC_STACK_INFO stack_info=&btcoexist->stack_info; + BOOLEAN wifi_connected=false; + + if(btcoexist->manual_control ||btcoexist->stop_coex_dm) + return; + + btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED, &wifi_connected); + if(BTC_SCAN_START == type) + { + BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY, ("[BTCoex], SCAN START notify\n")); + if(!wifi_connected) // non-connected scan + { + //set 0x550[3]=1 before PsTdma + //halbtc8812a1ant_Reg0x550Bit3(btcoexist, true); + halbtc8812a1ant_ActionWifiNotConnectedAssoAuthScan(btcoexist); + } + else // wifi is connected + { + halbtc8812a1ant_ActionWifiConnectedScan(btcoexist); + } + } + else if(BTC_SCAN_FINISH == type) + { + BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY, ("[BTCoex], SCAN FINISH notify\n")); + if(!wifi_connected) // non-connected scan + { + //halbtc8812a1ant_Reg0x550Bit3(btcoexist, false); + halbtc8812a1ant_ActionWifiNotConnected(btcoexist); + } + else + { + halbtc8812a1ant_ActionWifiConnected(btcoexist); + } + } +} + +void +EXhalbtc8812a1ant_ConnectNotify( + PBTC_COEXIST btcoexist, + u1Byte type + ) +{ + PBTC_STACK_INFO stack_info=&btcoexist->stack_info; + BOOLEAN wifi_connected=false; + + if(btcoexist->manual_control ||btcoexist->stop_coex_dm) + return; + + if(BTC_ASSOCIATE_START == type) + { + BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY, ("[BTCoex], CONNECT START notify\n")); + if(btcoexist->bt_info.bt_disabled) + { + halbtc8812a1ant_PsTdmaCheckForPowerSaveState(btcoexist, false); + btcoexist->btc_set(btcoexist, BTC_SET_ACT_LEAVE_LPS, NULL); + halbtc8812a1ant_PsTdma(btcoexist, NORMAL_EXEC, false, 9); + } + else + { + halbtc8812a1ant_ActionWifiNotConnectedAssoAuthScan(btcoexist); + } + } + else if(BTC_ASSOCIATE_FINISH == type) + { + BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY, ("[BTCoex], CONNECT FINISH notify\n")); + + btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED, &wifi_connected); + if(!wifi_connected) // non-connected scan + { + //halbtc8812a1ant_Reg0x550Bit3(btcoexist, false); + halbtc8812a1ant_ActionWifiNotConnected(btcoexist); + } + else + { + halbtc8812a1ant_ActionWifiConnected(btcoexist); + } + } +} + +void +EXhalbtc8812a1ant_MediaStatusNotify( + PBTC_COEXIST btcoexist, + u1Byte type + ) +{ + u1Byte dataLen=5; + u1Byte buf[6] = {0}; + u1Byte h2c_parameter[3] ={0}; + BOOLEAN wifi_under5g=false; + u4Byte wifi_bw; + u1Byte wifi_central_chnl; + + if(btcoexist->manual_control ||btcoexist->stop_coex_dm) + return; + + btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_UNDER_5G, &wifi_under5g); + + // only 2.4G we need to inform bt the chnl mask + if(!wifi_under5g) + { + if(BTC_MEDIA_CONNECT == type) + { + h2c_parameter[0] = 0x1; + } + btcoexist->btc_get(btcoexist, BTC_GET_U4_WIFI_BW, &wifi_bw); + btcoexist->btc_get(btcoexist, BTC_GET_U1_WIFI_CENTRAL_CHNL, &wifi_central_chnl); + h2c_parameter[1] = wifi_central_chnl; + if(BTC_WIFI_BW_HT40 == wifi_bw) + h2c_parameter[2] = 0x30; + else + h2c_parameter[2] = 0x20; + } + + coex_dm->wifi_chnl_info[0] = h2c_parameter[0]; + coex_dm->wifi_chnl_info[1] = h2c_parameter[1]; + coex_dm->wifi_chnl_info[2] = h2c_parameter[2]; + + buf[0] = dataLen; + buf[1] = 0x5; // OP_Code + buf[2] = 0x3; // OP_Code_Length + buf[3] = h2c_parameter[0]; // OP_Code_Content + buf[4] = h2c_parameter[1]; + buf[5] = h2c_parameter[2]; + + btcoexist->btc_set(btcoexist, BTC_SET_ACT_CTRL_BT_COEX, (PVOID)&buf[0]); +} + +void +EXhalbtc8812a1ant_SpecialPacketNotify( + PBTC_COEXIST btcoexist, + u1Byte type + ) +{ + BOOLEAN bSecurityLink=false; + + if(btcoexist->manual_control ||btcoexist->stop_coex_dm) + return; + + //if(type == BTC_PACKET_DHCP) + { + BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY, ("[BTCoex], special Packet(%d) notify\n", type)); + if(btcoexist->bt_info.bt_disabled) + { + halbtc8812a1ant_PsTdmaCheckForPowerSaveState(btcoexist, false); + btcoexist->btc_set(btcoexist, BTC_SET_ACT_LEAVE_LPS, NULL); + halbtc8812a1ant_PsTdma(btcoexist, NORMAL_EXEC, false, 9); + } + else + { + halbtc8812a1ant_ActionWifiConnectedSpecialPacket(btcoexist); + } + } +} + +void +EXhalbtc8812a1ant_BtInfoNotify( + PBTC_COEXIST btcoexist, + pu1Byte tmp_buf, + u1Byte length + ) +{ + u1Byte bt_info=0; + u1Byte i, rsp_source=0; + static u4Byte set_bt_lna_cnt=0, set_bt_psd_mode=0; + BOOLEAN bt_busy=false, limited_dig=false; + BOOLEAN wifi_connected=false; + BOOLEAN bRejApAggPkt=false; + + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], BtInfoNotify()===>\n")); + + + rsp_source = tmp_buf[0]&0xf; + if(rsp_source >= BT_INFO_SRC_8812A_1ANT_MAX) + rsp_source = BT_INFO_SRC_8812A_1ANT_WIFI_FW; + coex_sta->bt_info_c2h_cnt[rsp_source]++; + + BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY, ("[BTCoex], Bt info[%d], length=%d, hex data=[", rsp_source, length)); + for(i=0; i<length; i++) + { + coex_sta->bt_info_c2h[rsp_source][i] = tmp_buf[i]; + if(i == 1) + bt_info = tmp_buf[i]; + if(i == length-1) + { + BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY, ("0x%2x]\n", tmp_buf[i])); + } + else + { + BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY, ("0x%2x, ", tmp_buf[i])); + } + } + + if(btcoexist->manual_control) + { + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], BtInfoNotify(), return for Manual CTRL<===\n")); + return; + } + if(btcoexist->stop_coex_dm) + { + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], BtInfoNotify(), return for Coex STOPPED!!<===\n")); + return; + } + + if(BT_INFO_SRC_8812A_1ANT_WIFI_FW != rsp_source) + { + coex_sta->bt_retry_cnt = + coex_sta->bt_info_c2h[rsp_source][2]; + + coex_sta->bt_rssi = + coex_sta->bt_info_c2h[rsp_source][3]*2+10; + + coex_sta->bt_info_ext = + coex_sta->bt_info_c2h[rsp_source][4]; + + // Here we need to resend some wifi info to BT + // because bt is reset and loss of the info. + if( (coex_sta->bt_info_ext & BIT1) ) + { + btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_CONNECTED, &wifi_connected); + if(wifi_connected) + { + EXhalbtc8812a1ant_MediaStatusNotify(btcoexist, BTC_MEDIA_CONNECT); + } + else + { + EXhalbtc8812a1ant_MediaStatusNotify(btcoexist, BTC_MEDIA_DISCONNECT); + } + + set_bt_psd_mode = 0; + } + + // test-chip bt patch doesn't support, temporary remove. + // need to add back when mp-chip. 12/20/2012 +#if 0 + if(set_bt_psd_mode <= 3) + {
+ halbtc8812a1ant_SetBtPsdMode(btcoexist, FORCE_EXEC, 0xd); + set_bt_psd_mode++; + } + + if(coex_dm->bCurBtLnaConstrain) + { + if( (coex_sta->bt_info_ext & BIT2) ) + { + } + else + { + if(set_bt_lna_cnt <= 3) + { + halbtc8812a1ant_SetBtLnaConstrain(btcoexist, FORCE_EXEC, true); + set_bt_lna_cnt++; + } + } + } + else + { + set_bt_lna_cnt = 0; + } +#endif + // test-chip bt patch only rsp the status for BT_RSP, + // so temporary we consider the following only under BT_RSP + if(BT_INFO_SRC_8812A_1ANT_BT_RSP == rsp_source) + { + if( (coex_sta->bt_info_ext & BIT3) ) + { + #if 0// temp disable because bt patch report the wrong value. + halbtc8812a1ant_IgnoreWlanAct(btcoexist, FORCE_EXEC, false); + #endif + } + else + { + // BT already NOT ignore Wlan active, do nothing here. + } + + if( (coex_sta->bt_info_ext & BIT4) ) + { + // BT auto report already enabled, do nothing + } + else + { + halbtc8812a1ant_BtAutoReport(btcoexist, FORCE_EXEC, true); + } + } + } + + // check BIT2 first ==> check if bt is under inquiry or page scan + if(bt_info & BT_INFO_8812A_1ANT_B_INQ_PAGE) + { + coex_sta->c2h_bt_inquiry_page = true; + coex_dm->bt_status = BT_8812A_1ANT_BT_STATUS_INQ_PAGE; + } + else + { + coex_sta->c2h_bt_inquiry_page = false; + if(!(bt_info&BT_INFO_8812A_1ANT_B_CONNECTION)) + { + coex_dm->bt_status = BT_8812A_1ANT_BT_STATUS_NON_CONNECTED_IDLE; + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], BtInfoNotify(), bt non-connected idle!!!\n")); + } + else if(bt_info == BT_INFO_8812A_1ANT_B_CONNECTION) // connection exists but no busy + { + coex_dm->bt_status = BT_8812A_1ANT_BT_STATUS_CONNECTED_IDLE; + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], BtInfoNotify(), bt connected-idle!!!\n")); + } + else if((bt_info&BT_INFO_8812A_1ANT_B_SCO_ESCO) || + (bt_info&BT_INFO_8812A_1ANT_B_SCO_BUSY)) + { + coex_dm->bt_status = BT_8812A_1ANT_BT_STATUS_SCO_BUSY; + bRejApAggPkt = true; + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], BtInfoNotify(), bt sco busy!!!\n")); + } + else if(bt_info&BT_INFO_8812A_1ANT_B_ACL_BUSY) + { + if(BT_8812A_1ANT_BT_STATUS_ACL_BUSY != coex_dm->bt_status) + coex_dm->reset_tdma_adjust = true; + coex_dm->bt_status = BT_8812A_1ANT_BT_STATUS_ACL_BUSY; + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], BtInfoNotify(), bt acl busy!!!\n")); + } +#if 0 + else if(bt_info&BT_INFO_8812A_1ANT_B_SCO_ESCO) + { + coex_dm->bt_status = BT_8812A_1ANT_BT_STATUS_ACL_SCO_BUSY; + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], BtInfoNotify(), bt acl/sco busy!!!\n")); + } +#endif + else + { + //DbgPrint("error, undefined bt_info=0x%x\n", bt_info); + coex_dm->bt_status = BT_8812A_1ANT_BT_STATUS_MAX; + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], BtInfoNotify(), bt non-defined state!!!\n")); + } + + // send delete BA to disable aggregation + //btcoexist->btc_set(btcoexist, BTC_SET_BL_TO_REJ_AP_AGG_PKT, &bRejApAggPkt); + } + + if( (BT_8812A_1ANT_BT_STATUS_ACL_BUSY == coex_dm->bt_status) || + (BT_8812A_1ANT_BT_STATUS_SCO_BUSY == coex_dm->bt_status) || + (BT_8812A_1ANT_BT_STATUS_ACL_SCO_BUSY == coex_dm->bt_status) ) + { + bt_busy = true; + } + else + { + bt_busy = false; + } + btcoexist->btc_set(btcoexist, BTC_SET_BL_BT_TRAFFIC_BUSY, &bt_busy); + + if(bt_busy) + { + limited_dig = true; + } + else + { + limited_dig = false; + } + coex_dm->limited_dig = limited_dig; + btcoexist->btc_set(btcoexist, BTC_SET_BL_BT_LIMITED_DIG, &limited_dig); + + halbtc8812a1ant_RunCoexistMechanism(btcoexist); + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], BtInfoNotify()<===\n")); +} + +void +EXhalbtc8812a1ant_StackOperationNotify( + PBTC_COEXIST btcoexist, + u1Byte type + ) +{ + if(BTC_STACK_OP_INQ_PAGE_PAIR_START == type) + { + BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY, ("[BTCoex], StackOP Inquiry/page/pair start notify\n")); + } + else if(BTC_STACK_OP_INQ_PAGE_PAIR_FINISH == type) + { + BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY, ("[BTCoex], StackOP Inquiry/page/pair finish notify\n")); + } +} + +void +EXhalbtc8812a1ant_HaltNotify( + PBTC_COEXIST btcoexist + ) +{ + BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY, ("[BTCoex], Halt notify\n")); + + halbtc8812a1ant_IgnoreWlanAct(btcoexist, FORCE_EXEC, true); + halbtc8812a1ant_PsTdma(btcoexist, FORCE_EXEC, false, 0); + btcoexist->btc_write_1byte(btcoexist, 0x4f, 0xf); + halbtc8812a1ant_WifiParaAdjust(btcoexist, false); +} + +void +EXhalbtc8812a1ant_PnpNotify( + PBTC_COEXIST btcoexist, + u1Byte pnpState + ) +{ + BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY, ("[BTCoex], Pnp notify\n")); + + if(BTC_WIFI_PNP_SLEEP == pnpState) + { + btcoexist->stop_coex_dm = true; + halbtc8812a1ant_IgnoreWlanAct(btcoexist, FORCE_EXEC, true); + halbtc8812a1ant_PsTdmaCheckForPowerSaveState(btcoexist, false); + btcoexist->btc_set(btcoexist, BTC_SET_ACT_LEAVE_LPS, NULL); + halbtc8812a1ant_PsTdma(btcoexist, NORMAL_EXEC, false, 9); + } + else if(BTC_WIFI_PNP_WAKE_UP == pnpState) + { + + } +} + +void +EXhalbtc8812a1ant_Periodical( + PBTC_COEXIST btcoexist + ) +{ + BOOLEAN wifi_under5g=false; + + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], Periodical()===>\n")); + BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY, ("[BTCoex], 1Ant Periodical!!\n")); + + btcoexist->btc_get(btcoexist, BTC_GET_BL_WIFI_UNDER_5G, &wifi_under5g); + + if(wifi_under5g) + { + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], Periodical(), return for 5G<===\n")); + halbtc8812a1ant_CoexAllOff(btcoexist); + return; + } + + halbtc8812a1ant_QueryBtInfo(btcoexist); + halbtc8812a1ant_MonitorBtCtr(btcoexist); + halbtc8812a1ant_MonitorBtEnableDisable(btcoexist); + BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], Periodical()<===\n")); +} + +void +EXhalbtc8812a1ant_DbgControl( + PBTC_COEXIST btcoexist, + u1Byte opCode, + u1Byte opLen, + pu1Byte pData + ) +{ + switch(opCode) + { + case BTC_DBG_SET_COEX_NORMAL: + btcoexist->manual_control = false; + halbtc8812a1ant_InitCoexDm(btcoexist); + break; + case BTC_DBG_SET_COEX_WIFI_ONLY: + btcoexist->manual_control = true; + halbtc8812a1ant_PsTdmaCheckForPowerSaveState(btcoexist, false); + btcoexist->btc_set(btcoexist, BTC_SET_ACT_LEAVE_LPS, NULL); + halbtc8812a1ant_PsTdma(btcoexist, NORMAL_EXEC, false, 9); + break; + case BTC_DBG_SET_COEX_BT_ONLY: + // todo + break; + default: + break; + } +} +#endif + |