--- /dev/null
+/******************************************************************************
+ *
+ * Copyright(c) 2013 Realtek Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of version 2 of the GNU General Public License as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
+ *
+ *
+ ******************************************************************************/
+#define __HAL_BTCOEX_C__
+
+#ifdef CONFIG_BT_COEXIST
+
+#include <hal_data.h>
+#include <hal_btcoex.h>
+#include <Mp_Precomp.h>
+
+//====================================
+// Global variables
+//====================================
+const char *const BtProfileString[] =
+{
+ "NONE",
+ "A2DP",
+ "PAN",
+ "HID",
+ "SCO",
+};
+
+const char *const BtSpecString[] =
+{
+ "1.0b",
+ "1.1",
+ "1.2",
+ "2.0+EDR",
+ "2.1+EDR",
+ "3.0+HS",
+ "4.0",
+};
+
+const char *const BtLinkRoleString[] =
+{
+ "Master",
+ "Slave",
+};
+
+const char *const h2cStaString[] =
+{
+ "successful",
+ "h2c busy",
+ "rf off",
+ "fw not read",
+};
+
+const char *const ioStaString[] =
+{
+ "success",
+ "can not IO",
+ "rf off",
+ "fw not read",
+ "wait io timeout",
+ "invalid len",
+ "idle Q empty",
+ "insert waitQ fail",
+ "unknown fail",
+ "wrong level",
+ "h2c stopped",
+};
+
+const char *const GLBtcWifiBwString[]={
+ "11bg",
+ "HT20",
+ "HT40",
+ "HT80",
+ "HT160"
+};
+
+const char *const GLBtcWifiFreqString[]={
+ "2.4G",
+ "5G"
+};
+
+const char *const GLBtcIotPeerString[] = {
+ "UNKNOWN",
+ "REALTEK",
+ "REALTEK_92SE",
+ "BROADCOM",
+ "RALINK",
+ "ATHEROS",
+ "CISCO",
+ "MERU",
+ "MARVELL",
+ "REALTEK_SOFTAP", /* peer is RealTek SOFT_AP, by Bohn, 2009.12.17 */
+ "SELF_SOFTAP", /* Self is SoftAP */
+ "AIRGO",
+ "INTEL",
+ "RTK_APCLIENT",
+ "REALTEK_81XX",
+ "REALTEK_WOW",
+ "REALTEK_JAGUAR_BCUTAP",
+ "REALTEK_JAGUAR_CCUTAP"
+};
+
+#define HALBTCOUTSRC_AGG_CHK_WINDOW_IN_MS 8000
+
+BTC_COEXIST GLBtCoexist;
+u8 GLBtcWiFiInScanState;
+u8 GLBtcWiFiInIQKState;
+u8 GLBtcWiFiInIPS;
+u8 GLBtcWiFiInLPS;
+u8 GLBtcBtCoexAliveRegistered;
+
+/*
+ * BT control H2C/C2H
+ */
+/* EXT_EID */
+typedef enum _bt_ext_eid {
+ C2H_WIFI_FW_ACTIVE_RSP = 0,
+ C2H_TRIG_BY_BT_FW
+} BT_EXT_EID;
+
+/* C2H_STATUS */
+typedef enum _bt_c2h_status {
+ BT_STATUS_OK = 0,
+ BT_STATUS_VERSION_MISMATCH,
+ BT_STATUS_UNKNOWN_OPCODE,
+ BT_STATUS_ERROR_PARAMETER
+} BT_C2H_STATUS;
+
+/* C2H BT OP CODES */
+typedef enum _bt_op_code {
+ BT_OP_GET_BT_VERSION = 0,
+ BT_OP_WRITE_REG_ADDR = 12,
+ BT_OP_WRITE_REG_VALUE,
+ BT_OP_READ_REG = 17
+} BT_OP_CODE;
+
+#define BTC_MPOPER_TIMEOUT 50 /* unit: ms */
+
+#define C2H_MAX_SIZE 16
+u8 GLBtcBtMpOperSeq;
+_mutex GLBtcBtMpOperLock;
+_timer GLBtcBtMpOperTimer;
+_sema GLBtcBtMpRptSema;
+u8 GLBtcBtMpRptSeq;
+u8 GLBtcBtMpRptStatus;
+u8 GLBtcBtMpRptRsp[C2H_MAX_SIZE];
+u8 GLBtcBtMpRptRspSize;
+u8 GLBtcBtMpRptWait;
+u8 GLBtcBtMpRptWiFiOK;
+u8 GLBtcBtMpRptBTOK;
+
+/*
+ * Debug
+ */
+u32 GLBtcDbgType[COMP_MAX];
+u8 GLBtcDbgBuf[BT_TMP_BUF_SIZE];
+
+typedef struct _btcoexdbginfo
+{
+ u8 *info;
+ u32 size; // buffer total size
+ u32 len; // now used length
+} BTCDBGINFO, *PBTCDBGINFO;
+
+BTCDBGINFO GLBtcDbgInfo;
+
+#define BT_Operation(Adapter) _FALSE
+
+static void DBG_BT_INFO_INIT(PBTCDBGINFO pinfo, u8 *pbuf, u32 size)
+{
+ if (NULL == pinfo) return;
+
+ _rtw_memset(pinfo, 0, sizeof(BTCDBGINFO));
+
+ if (pbuf && size) {
+ pinfo->info = pbuf;
+ pinfo->size = size;
+ }
+}
+
+void DBG_BT_INFO(u8 *dbgmsg)
+{
+ PBTCDBGINFO pinfo;
+ u32 msglen, buflen;
+ u8 *pbuf;
+
+
+ pinfo = &GLBtcDbgInfo;
+
+ if (NULL == pinfo->info)
+ return;
+
+ msglen = strlen(dbgmsg);
+ if (pinfo->len + msglen > pinfo->size)
+ return;
+
+ pbuf = pinfo->info + pinfo->len;
+ _rtw_memcpy(pbuf, dbgmsg, msglen);
+ pinfo->len += msglen;
+}
+
+//====================================
+// Debug related function
+//====================================
+static u8 halbtcoutsrc_IsBtCoexistAvailable(PBTC_COEXIST pBtCoexist)
+{
+ if (!pBtCoexist->bBinded ||
+ NULL == pBtCoexist->Adapter)
+ {
+ return _FALSE;
+ }
+ return _TRUE;
+}
+
+static void halbtcoutsrc_DbgInit(void)
+{
+ u8 i;
+
+ for (i = 0; i < COMP_MAX; i++)
+ GLBtcDbgType[i] = 0;
+}
+
+static u8 halbtcoutsrc_IsCsrBtCoex(PBTC_COEXIST pBtCoexist)
+{
+ if (pBtCoexist->boardInfo.btChipType == BTC_CHIP_CSR_BC4
+ || pBtCoexist->boardInfo.btChipType == BTC_CHIP_CSR_BC8
+ ){
+ return _TRUE;
+ }
+ return _FALSE;
+}
+
+static u8 halbtcoutsrc_IsHwMailboxExist(PBTC_COEXIST pBtCoexist)
+{
+ if (pBtCoexist->boardInfo.btChipType == BTC_CHIP_CSR_BC4
+ || pBtCoexist->boardInfo.btChipType == BTC_CHIP_CSR_BC8
+ ){
+ return _FALSE;
+ }
+ else if (IS_HARDWARE_TYPE_8812(pBtCoexist->Adapter))
+ {
+ return _FALSE;
+ }
+ else
+ return _TRUE;
+}
+
+static void halbtcoutsrc_LeaveLps(PBTC_COEXIST pBtCoexist)
+{
+ PADAPTER padapter;
+
+
+ padapter = pBtCoexist->Adapter;
+
+ pBtCoexist->btInfo.bBtCtrlLps = _TRUE;
+ pBtCoexist->btInfo.bBtLpsOn = _FALSE;
+
+ rtw_btcoex_LPS_Leave(padapter);
+}
+
+void halbtcoutsrc_EnterLps(PBTC_COEXIST pBtCoexist)
+{
+ PADAPTER padapter;
+
+
+ padapter = pBtCoexist->Adapter;
+
+ pBtCoexist->btInfo.bBtCtrlLps = _TRUE;
+ pBtCoexist->btInfo.bBtLpsOn = _TRUE;
+
+ rtw_btcoex_LPS_Enter(padapter);
+}
+
+void halbtcoutsrc_NormalLps(PBTC_COEXIST pBtCoexist)
+{
+ PADAPTER padapter;
+
+
+ RT_TRACE(COMP_COEX, DBG_LOUD, ("[BTCoex], Normal LPS behavior!!!\n"));
+
+ padapter = pBtCoexist->Adapter;
+
+ if (pBtCoexist->btInfo.bBtCtrlLps)
+ {
+ pBtCoexist->btInfo.bBtLpsOn = _FALSE;
+ rtw_btcoex_LPS_Leave(padapter);
+ pBtCoexist->btInfo.bBtCtrlLps = _FALSE;
+
+ // recover the LPS state to the original
+#if 0
+ padapter->HalFunc.UpdateLPSStatusHandler(
+ padapter,
+ pPSC->RegLeisurePsMode,
+ pPSC->RegPowerSaveMode);
+#endif
+ }
+}
+
+/*
+ * Constraint:
+ * 1. this function will request pwrctrl->lock
+ */
+void halbtcoutsrc_LeaveLowPower(PBTC_COEXIST pBtCoexist)
+{
+#ifdef CONFIG_LPS_LCLK
+ PADAPTER padapter;
+ PHAL_DATA_TYPE pHalData;
+ struct pwrctrl_priv *pwrctrl;
+ s32 ready;
+ u32 stime;
+ s32 utime;
+ u32 timeout; // unit: ms
+
+
+ padapter = pBtCoexist->Adapter;
+ pHalData = GET_HAL_DATA(padapter);
+ pwrctrl = adapter_to_pwrctl(padapter);
+ ready = _FAIL;
+#ifdef LPS_RPWM_WAIT_MS
+ timeout = LPS_RPWM_WAIT_MS;
+#else // !LPS_RPWM_WAIT_MS
+ timeout = 30;
+#endif // !LPS_RPWM_WAIT_MS
+
+ if (GLBtcBtCoexAliveRegistered == _TRUE)
+ return;
+
+ stime = rtw_get_current_time();
+ do {
+ ready = rtw_register_task_alive(padapter, BTCOEX_ALIVE);
+ if (_SUCCESS == ready)
+ break;
+
+ utime = rtw_get_passing_time_ms(stime);
+ if (utime > timeout)
+ break;
+
+ rtw_msleep_os(1);
+ } while (1);
+
+ GLBtcBtCoexAliveRegistered = _TRUE;
+#endif // CONFIG_LPS_LCLK
+}
+
+/*
+ * Constraint:
+ * 1. this function will request pwrctrl->lock
+ */
+void halbtcoutsrc_NormalLowPower(PBTC_COEXIST pBtCoexist)
+{
+#ifdef CONFIG_LPS_LCLK
+ PADAPTER padapter;
+
+ if (GLBtcBtCoexAliveRegistered == _FALSE)
+ return;
+
+ padapter = pBtCoexist->Adapter;
+ rtw_unregister_task_alive(padapter, BTCOEX_ALIVE);
+
+ GLBtcBtCoexAliveRegistered = _FALSE;
+#endif // CONFIG_LPS_LCLK
+}
+
+void halbtcoutsrc_DisableLowPower(PBTC_COEXIST pBtCoexist, u8 bLowPwrDisable)
+{
+ pBtCoexist->btInfo.bBtDisableLowPwr = bLowPwrDisable;
+ if (bLowPwrDisable)
+ halbtcoutsrc_LeaveLowPower(pBtCoexist); // leave 32k low power.
+ else
+ halbtcoutsrc_NormalLowPower(pBtCoexist); // original 32k low power behavior.
+}
+
+void halbtcoutsrc_AggregationCheck(PBTC_COEXIST pBtCoexist)
+{
+ PADAPTER padapter;
+ BOOLEAN bNeedToAct = _FALSE;
+ static u32 preTime = 0;
+ u32 curTime = 0;
+
+ padapter = pBtCoexist->Adapter;
+
+ //=====================================
+ // To void continuous deleteBA=>addBA=>deleteBA=>addBA
+ // This function is not allowed to continuous called.
+ // It can only be called after 8 seconds.
+ //=====================================
+
+ curTime = rtw_systime_to_ms(rtw_get_current_time());
+ if((curTime - preTime) < HALBTCOUTSRC_AGG_CHK_WINDOW_IN_MS) // over 8 seconds you can execute this function again.
+ {
+ return;
+ }
+ else
+ {
+ preTime = curTime;
+ }
+
+ if (pBtCoexist->btInfo.bRejectAggPkt)
+ {
+ bNeedToAct = _TRUE;
+ pBtCoexist->btInfo.bPreRejectAggPkt = pBtCoexist->btInfo.bRejectAggPkt;
+ }
+ else
+ {
+ if(pBtCoexist->btInfo.bPreRejectAggPkt)
+ {
+ bNeedToAct = _TRUE;
+ pBtCoexist->btInfo.bPreRejectAggPkt = pBtCoexist->btInfo.bRejectAggPkt;
+ }
+
+ if (pBtCoexist->btInfo.bPreBtCtrlAggBufSize !=
+ pBtCoexist->btInfo.bBtCtrlAggBufSize)
+ {
+ bNeedToAct = _TRUE;
+ pBtCoexist->btInfo.bPreBtCtrlAggBufSize = pBtCoexist->btInfo.bBtCtrlAggBufSize;
+ }
+
+ if (pBtCoexist->btInfo.bBtCtrlAggBufSize)
+ {
+ if (pBtCoexist->btInfo.preAggBufSize !=
+ pBtCoexist->btInfo.aggBufSize)
+ {
+ bNeedToAct = _TRUE;
+ }
+ pBtCoexist->btInfo.preAggBufSize = pBtCoexist->btInfo.aggBufSize;
+ }
+ }
+
+ if (bNeedToAct)
+ rtw_btcoex_rx_ampdu_apply(padapter);
+}
+
+u8 halbtcoutsrc_IsWifiBusy(PADAPTER padapter)
+{
+ struct mlme_priv *pmlmepriv;
+
+
+ pmlmepriv = &padapter->mlmepriv;
+
+ if (check_fwstate(pmlmepriv, WIFI_ASOC_STATE) == _TRUE)
+ {
+ if (check_fwstate(pmlmepriv, WIFI_AP_STATE) == _TRUE)
+ return _TRUE;
+ if (_TRUE == pmlmepriv->LinkDetectInfo.bBusyTraffic)
+ return _TRUE;
+ }
+
+#if defined(CONFIG_CONCURRENT_MODE)
+ pmlmepriv = &padapter->pbuddy_adapter->mlmepriv;
+
+ if (check_fwstate(pmlmepriv, WIFI_ASOC_STATE) == _TRUE)
+ {
+ if (check_fwstate(pmlmepriv, WIFI_AP_STATE) == _TRUE)
+ return _TRUE;
+ if (_TRUE == pmlmepriv->LinkDetectInfo.bBusyTraffic)
+ return _TRUE;
+ }
+#endif
+
+ return _FALSE;
+}
+
+static u32 _halbtcoutsrc_GetWifiLinkStatus(PADAPTER padapter)
+{
+ struct mlme_priv *pmlmepriv;
+ u8 bp2p;
+ u32 portConnectedStatus;
+
+
+ pmlmepriv = &padapter->mlmepriv;
+ bp2p = _FALSE;
+ portConnectedStatus = 0;
+
+#ifdef CONFIG_P2P
+ if (!rtw_p2p_chk_state(&padapter->wdinfo, P2P_STATE_NONE))
+ bp2p = _TRUE;
+#endif // CONFIG_P2P
+
+ if (check_fwstate(pmlmepriv, WIFI_ASOC_STATE) == _TRUE)
+ {
+ if (check_fwstate(pmlmepriv, WIFI_AP_STATE) == _TRUE)
+ {
+ if (_TRUE == bp2p)
+ portConnectedStatus |= WIFI_P2P_GO_CONNECTED;
+ else
+ portConnectedStatus |= WIFI_AP_CONNECTED;
+ }
+ else
+ {
+ if (_TRUE == bp2p)
+ portConnectedStatus |= WIFI_P2P_GC_CONNECTED;
+ else
+ portConnectedStatus |= WIFI_STA_CONNECTED;
+ }
+ }
+
+ return portConnectedStatus;
+}
+
+u32 halbtcoutsrc_GetWifiLinkStatus(PBTC_COEXIST pBtCoexist)
+{
+ //=================================
+ // return value:
+ // [31:16]=> connected port number
+ // [15:0]=> port connected bit define
+ //================================
+
+ PADAPTER padapter;
+ u32 retVal;
+ u32 portConnectedStatus, numOfConnectedPort;
+
+
+ padapter = pBtCoexist->Adapter;
+ retVal = 0;
+ portConnectedStatus = 0;
+ numOfConnectedPort = 0;
+
+ retVal = _halbtcoutsrc_GetWifiLinkStatus(padapter);
+ if (retVal)
+ {
+ portConnectedStatus |= retVal;
+ numOfConnectedPort++;
+ }
+
+#ifdef CONFIG_CONCURRENT_MODE
+ if (padapter->pbuddy_adapter)
+ {
+ retVal = _halbtcoutsrc_GetWifiLinkStatus(padapter->pbuddy_adapter);
+ if (retVal)
+ {
+ portConnectedStatus |= retVal;
+ numOfConnectedPort++;
+ }
+ }
+#endif // CONFIG_CONCURRENT_MODE
+
+ retVal = (numOfConnectedPort << 16) | portConnectedStatus;
+
+ return retVal;
+}
+
+static u8 _is_btfwver_valid(PBTC_COEXIST pBtCoexist, u16 btfwver)
+{
+ if (!btfwver)
+ return _FALSE;
+
+ if (IS_HARDWARE_TYPE_8723B(pBtCoexist->Adapter))
+ if (btfwver == 0x8723)
+ return _FALSE;
+
+ return _TRUE;
+}
+
+static void _btmpoper_timer_hdl(void *p)
+{
+ if (GLBtcBtMpRptWait) {
+ GLBtcBtMpRptWait = 0;
+ _rtw_up_sema(&GLBtcBtMpRptSema);
+ }
+}
+
+/*
+ * !IMPORTANT!
+ * Before call this function, caller should acquire "GLBtcBtMpOperLock"!
+ * Othrewise there will be racing problem and something may go wrong.
+ */
+static u8 _btmpoper_cmd(PBTC_COEXIST pBtCoexist, u8 opcode, u8 opcodever, u8 *cmd, u8 size)
+{
+ PADAPTER padapter;
+ u8 buf[H2C_BTMP_OPER_LEN] = {0};
+ u8 buflen;
+ u8 seq;
+ u8 timer_cancelled;
+ s32 ret;
+
+
+ if (!cmd && size)
+ size = 0;
+ if ((size + 2) > H2C_BTMP_OPER_LEN)
+ return BT_STATUS_H2C_LENGTH_EXCEEDED;
+ buflen = size + 2;
+
+ seq = GLBtcBtMpOperSeq & 0xF;
+ GLBtcBtMpOperSeq++;
+
+ buf[0] = (opcodever & 0xF) | (seq << 4);
+ buf[1] = opcode;
+ if (cmd && size)
+ _rtw_memcpy(buf+2, cmd, size);
+
+ GLBtcBtMpRptWait = 1;
+ GLBtcBtMpRptWiFiOK = 0;
+ GLBtcBtMpRptBTOK = 0;
+ GLBtcBtMpRptStatus = 0;
+ padapter = pBtCoexist->Adapter;
+ _set_timer(&GLBtcBtMpOperTimer, BTC_MPOPER_TIMEOUT);
+ if (rtw_hal_fill_h2c_cmd(padapter, H2C_BT_MP_OPER, buflen, buf) == _FAIL) {
+ _cancel_timer(&GLBtcBtMpOperTimer, &timer_cancelled);
+ ret = BT_STATUS_H2C_FAIL;
+ goto exit;
+ }
+
+ _rtw_down_sema(&GLBtcBtMpRptSema);
+ /* GLBtcBtMpRptWait should be 0 here*/
+
+ if (!GLBtcBtMpRptWiFiOK) {
+ DBG_871X("%s: Didn't get H2C Rsp Event!\n", __FUNCTION__);
+ ret = BT_STATUS_H2C_TIMTOUT;
+ goto exit;
+ }
+ if (!GLBtcBtMpRptBTOK) {
+ DBG_871X("%s: Didn't get BT response!\n", __FUNCTION__);
+ ret = BT_STATUS_H2C_BT_NO_RSP;
+ goto exit;
+ }
+ if (seq != GLBtcBtMpRptSeq) {
+ DBG_871X("%s: Sequence number not match!(%d!=%d)!\n",
+ __FUNCTION__, seq, GLBtcBtMpRptSeq);
+ ret = BT_STATUS_C2H_REQNUM_MISMATCH;
+ goto exit;
+ }
+
+ switch (GLBtcBtMpRptStatus) {
+ /* Examine the status reported from C2H */
+ case BT_STATUS_OK:
+ ret = BT_STATUS_BT_OP_SUCCESS;
+ DBG_871X("%s: C2H status = BT_STATUS_BT_OP_SUCCESS\n", __FUNCTION__);
+ break;
+ case BT_STATUS_VERSION_MISMATCH:
+ ret = BT_STATUS_OPCODE_L_VERSION_MISMATCH;
+ DBG_871X("%s: C2H status = BT_STATUS_OPCODE_L_VERSION_MISMATCH\n", __FUNCTION__);
+ break;
+ case BT_STATUS_UNKNOWN_OPCODE:
+ ret = BT_STATUS_UNKNOWN_OPCODE_L;
+ DBG_871X("%s: C2H status = MP_BT_STATUS_UNKNOWN_OPCODE_L\n", __FUNCTION__);
+ break;
+ case BT_STATUS_ERROR_PARAMETER:
+ ret = BT_STATUS_PARAMETER_FORMAT_ERROR_L;
+ DBG_871X("%s: C2H status = MP_BT_STATUS_PARAMETER_FORMAT_ERROR_L\n", __FUNCTION__);
+ break;
+ default:
+ ret = BT_STATUS_UNKNOWN_STATUS_L;
+ DBG_871X("%s: C2H status = MP_BT_STATUS_UNKNOWN_STATUS_L\n", __FUNCTION__);
+ break;
+ }
+
+exit:
+ return ret;
+}
+
+u32 halbtcoutsrc_GetBtPatchVer(PBTC_COEXIST pBtCoexist)
+{
+ if (_is_btfwver_valid(pBtCoexist, pBtCoexist->btInfo.btRealFwVer) == _TRUE)
+ goto exit;
+
+ if (halbtcoutsrc_IsHwMailboxExist(pBtCoexist) == _TRUE) {
+ _irqL irqL;
+ u8 ret;
+
+
+ _enter_critical_mutex(&GLBtcBtMpOperLock, &irqL);
+
+ ret = _btmpoper_cmd(pBtCoexist, BT_OP_GET_BT_VERSION, 0, NULL, 0);
+ if (BT_STATUS_BT_OP_SUCCESS == ret) {
+ pBtCoexist->btInfo.btRealFwVer = le16_to_cpu(*(u16 *)GLBtcBtMpRptRsp);
+ pBtCoexist->btInfo.btFwVer = *(GLBtcBtMpRptRsp+2);
+ }
+ pBtCoexist->btInfo.getBtFwVerCnt++;
+
+ _exit_critical_mutex(&GLBtcBtMpOperLock, &irqL);
+ } else {
+#ifdef CONFIG_BT_COEXIST_SOCKET_TRX
+ u1Byte dataLen = 2;
+ u1Byte buf[4] = {0};
+
+ buf[0] = 0x0; /* OP_Code */
+ buf[1] = 0x0; /* OP_Code_Length */
+ BT_SendEventExtBtCoexControl(pBtCoexist->Adapter, _FALSE, dataLen, &buf[0]);
+#endif /* !CONFIG_BT_COEXIST_SOCKET_TRX */
+ }
+
+exit:
+ return pBtCoexist->btInfo.btRealFwVer;
+}
+
+s32 halbtcoutsrc_GetWifiRssi(PADAPTER padapter)
+{
+ PHAL_DATA_TYPE pHalData;
+ s32 UndecoratedSmoothedPWDB = 0;
+
+ pHalData = GET_HAL_DATA(padapter);
+
+ UndecoratedSmoothedPWDB = pHalData->EntryMinUndecoratedSmoothedPWDB;
+
+ return UndecoratedSmoothedPWDB;
+}
+
+static u8 halbtcoutsrc_GetWifiScanAPNum(PADAPTER padapter)
+{
+ struct mlme_priv *pmlmepriv;
+ struct mlme_ext_priv *pmlmeext;
+ static u8 scan_AP_num = 0;
+
+
+ pmlmepriv = &padapter->mlmepriv;
+ pmlmeext = &padapter->mlmeextpriv;
+
+ if (GLBtcWiFiInScanState == _FALSE) {
+ if (pmlmepriv->num_of_scanned > 0xFF)
+ scan_AP_num = 0xFF;
+ else
+ scan_AP_num = (u8)pmlmepriv->num_of_scanned;
+ }
+
+ return scan_AP_num;
+}
+
+u8 halbtcoutsrc_Get(void *pBtcContext, u8 getType, void *pOutBuf)
+{
+ PBTC_COEXIST pBtCoexist;
+ PADAPTER padapter;
+ PHAL_DATA_TYPE pHalData;
+ struct mlme_ext_priv *mlmeext;
+ u8 bSoftApExist, bVwifiExist;
+ u8 *pu8;
+ s32 *pS4Tmp;
+ u32 *pU4Tmp;
+ u8 *pU1Tmp;
+ u8 ret;
+
+
+ pBtCoexist = (PBTC_COEXIST)pBtcContext;
+ if (!halbtcoutsrc_IsBtCoexistAvailable(pBtCoexist))
+ return _FALSE;
+
+ padapter = pBtCoexist->Adapter;
+ pHalData = GET_HAL_DATA(padapter);
+ mlmeext = &padapter->mlmeextpriv;
+ bSoftApExist = _FALSE;
+ bVwifiExist = _FALSE;
+ pu8 = (u8*)pOutBuf;
+ pS4Tmp = (s32*)pOutBuf;
+ pU4Tmp = (u32*)pOutBuf;
+ pU1Tmp = (u8*)pOutBuf;
+ ret = _TRUE;
+
+ switch (getType)
+ {
+ case BTC_GET_BL_HS_OPERATION:
+ *pu8 = _FALSE;
+ ret = _FALSE;
+ break;
+
+ case BTC_GET_BL_HS_CONNECTING:
+ *pu8 = _FALSE;
+ ret = _FALSE;
+ break;
+
+ case BTC_GET_BL_WIFI_CONNECTED:
+ *pu8 = check_fwstate(&padapter->mlmepriv, WIFI_ASOC_STATE);
+#ifdef CONFIG_CONCURRENT_MODE
+ if ((_FALSE == *pu8) && padapter->pbuddy_adapter)
+ {
+ *pu8 = check_fwstate(&padapter->pbuddy_adapter->mlmepriv, WIFI_ASOC_STATE);
+ }
+#endif // CONFIG_CONCURRENT_MODE
+ break;
+
+ case BTC_GET_BL_WIFI_BUSY:
+ *pu8 = halbtcoutsrc_IsWifiBusy(padapter);
+ break;
+
+ case BTC_GET_BL_WIFI_SCAN:
+#if 0
+ *pu8 = check_fwstate(&padapter->mlmepriv, WIFI_SITE_MONITOR);
+#ifdef CONFIG_CONCURRENT_MODE
+ if ((_FALSE == *pu8) && padapter->pbuddy_adapter)
+ {
+ *pu8 = check_fwstate(&padapter->pbuddy_adapter->mlmepriv, WIFI_SITE_MONITOR);
+ }
+#endif // CONFIG_CONCURRENT_MODE
+#else
+ /* Use the value of the new variable GLBtcWiFiInScanState to judge whether WiFi is in scan state or not, since the originally used flag
+ WIFI_SITE_MONITOR in fwstate may not be cleared in time */
+ *pu8 = GLBtcWiFiInScanState;
+#endif
+ break;
+
+ case BTC_GET_BL_WIFI_LINK:
+ *pu8 = check_fwstate(&padapter->mlmepriv, WIFI_UNDER_LINKING);
+#ifdef CONFIG_CONCURRENT_MODE
+ if ((_FALSE == *pu8) && padapter->pbuddy_adapter)
+ {
+ *pu8 = check_fwstate(&padapter->pbuddy_adapter->mlmepriv, WIFI_UNDER_LINKING);
+ }
+#endif // CONFIG_CONCURRENT_MODE
+ break;
+
+ case BTC_GET_BL_WIFI_ROAM:
+ *pu8 = check_fwstate(&padapter->mlmepriv, WIFI_UNDER_LINKING);
+#ifdef CONFIG_CONCURRENT_MODE
+ if ((_FALSE == *pu8) && padapter->pbuddy_adapter)
+ {
+ *pu8 = check_fwstate(&padapter->pbuddy_adapter->mlmepriv, WIFI_UNDER_LINKING);
+ }
+#endif // CONFIG_CONCURRENT_MODE
+ break;
+
+ case BTC_GET_BL_WIFI_4_WAY_PROGRESS:
+ *pu8 = _FALSE;
+ break;
+
+ case BTC_GET_BL_WIFI_UNDER_5G:
+ *pu8 = (pHalData->CurrentBandType == 1)? _TRUE : _FALSE;
+ break;
+
+ case BTC_GET_BL_WIFI_AP_MODE_ENABLE:
+ *pu8 = check_fwstate(&padapter->mlmepriv, WIFI_AP_STATE);
+#ifdef CONFIG_CONCURRENT_MODE
+ if ((_FALSE == *pu8) && padapter->pbuddy_adapter)
+ {
+ *pu8 = check_fwstate(&padapter->pbuddy_adapter->mlmepriv, WIFI_AP_STATE);
+ }
+#endif // CONFIG_CONCURRENT_MODE
+ break;
+
+ case BTC_GET_BL_WIFI_ENABLE_ENCRYPTION:
+ *pu8 = padapter->securitypriv.dot11PrivacyAlgrthm == 0? _FALSE: _TRUE;
+ break;
+
+ case BTC_GET_BL_WIFI_UNDER_B_MODE:
+ if (mlmeext->cur_wireless_mode == WIRELESS_11B)
+ *pu8 = _TRUE;
+ else
+ *pu8 = _FALSE;
+ break;
+
+ case BTC_GET_BL_WIFI_IS_IN_MP_MODE:
+ if (padapter->registrypriv.mp_mode == 0)
+ {
+ *pu8 = _FALSE;
+ }
+ else
+ {
+ *pu8 = _TRUE;
+ }
+ break;
+
+ case BTC_GET_BL_EXT_SWITCH:
+ *pu8 = _FALSE;
+ break;
+ case BTC_GET_BL_IS_ASUS_8723B:
+ /* Always return FALSE in linux driver since this case is added only for windows driver */
+ *pu8 = _FALSE;
+ break;
+
+ case BTC_GET_S4_WIFI_RSSI:
+ *pS4Tmp = halbtcoutsrc_GetWifiRssi(padapter);
+ break;
+
+ case BTC_GET_S4_HS_RSSI:
+ *pS4Tmp = 0;
+ ret = _FALSE;
+ break;
+
+ case BTC_GET_U4_WIFI_BW:
+ if (IsLegacyOnly(mlmeext->cur_wireless_mode))
+ *pU4Tmp = BTC_WIFI_BW_LEGACY;
+ else if (pHalData->CurrentChannelBW == CHANNEL_WIDTH_20)
+ *pU4Tmp = BTC_WIFI_BW_HT20;
+ else if (pHalData->CurrentChannelBW == CHANNEL_WIDTH_40)
+ *pU4Tmp = BTC_WIFI_BW_HT40;
+ else
+ *pU4Tmp = BTC_WIFI_BW_HT40; /* todo */
+ break;
+
+ case BTC_GET_U4_WIFI_TRAFFIC_DIRECTION:
+ {
+ PRT_LINK_DETECT_T plinkinfo;
+ plinkinfo = &padapter->mlmepriv.LinkDetectInfo;
+
+ if (plinkinfo->NumTxOkInPeriod > plinkinfo->NumRxOkInPeriod)
+ *pU4Tmp = BTC_WIFI_TRAFFIC_TX;
+ else
+ *pU4Tmp = BTC_WIFI_TRAFFIC_RX;
+ }
+ break;
+
+ case BTC_GET_U4_WIFI_FW_VER:
+ *pU4Tmp = pHalData->FirmwareVersion << 16;
+ *pU4Tmp |= pHalData->FirmwareSubVersion;
+ break;
+
+ case BTC_GET_U4_WIFI_LINK_STATUS:
+ *pU4Tmp = halbtcoutsrc_GetWifiLinkStatus(pBtCoexist);
+ break;
+
+ case BTC_GET_U4_BT_PATCH_VER:
+ *pU4Tmp = halbtcoutsrc_GetBtPatchVer(pBtCoexist);
+ break;
+
+ case BTC_GET_U1_WIFI_DOT11_CHNL:
+ *pU1Tmp = padapter->mlmeextpriv.cur_channel;
+ break;
+
+ case BTC_GET_U1_WIFI_CENTRAL_CHNL:
+ *pU1Tmp = pHalData->CurrentChannel;
+ break;
+
+ case BTC_GET_U1_WIFI_HS_CHNL:
+ *pU1Tmp = 0;
+ ret = _FALSE;
+ break;
+
+ case BTC_GET_U1_MAC_PHY_MODE:
+// *pU1Tmp = BTC_SMSP;
+// *pU1Tmp = BTC_DMSP;
+// *pU1Tmp = BTC_DMDP;
+// *pU1Tmp = BTC_MP_UNKNOWN;
+ break;
+
+ case BTC_GET_U1_AP_NUM:
+ *pU1Tmp = halbtcoutsrc_GetWifiScanAPNum(padapter);
+ break;
+ case BTC_GET_U1_ANT_TYPE:
+ switch(pHalData->bt_coexist.btAntisolation)
+ {
+ case 0:
+ *pU1Tmp = (u1Byte)BTC_ANT_TYPE_0;
+ pBtCoexist->boardInfo.antType = (u1Byte)BTC_ANT_TYPE_0;
+ break;
+ case 1:
+ *pU1Tmp = (u1Byte)BTC_ANT_TYPE_1;
+ pBtCoexist->boardInfo.antType = (u1Byte)BTC_ANT_TYPE_1;
+ break;
+ case 2:
+ *pU1Tmp = (u1Byte)BTC_ANT_TYPE_2;
+ pBtCoexist->boardInfo.antType = (u1Byte)BTC_ANT_TYPE_2;
+ break;
+ case 3:
+ *pU1Tmp = (u1Byte)BTC_ANT_TYPE_3;
+ pBtCoexist->boardInfo.antType = (u1Byte)BTC_ANT_TYPE_3;
+ break;
+ case 4:
+ *pU1Tmp = (u1Byte)BTC_ANT_TYPE_4;
+ pBtCoexist->boardInfo.antType = (u1Byte)BTC_ANT_TYPE_4;
+ break;
+ }
+ break;
+ case BTC_GET_U1_IOT_PEER:
+ *pU1Tmp = mlmeext->mlmext_info.assoc_AP_vendor;
+ break;
+
+ //=======1Ant===========
+ case BTC_GET_U1_LPS_MODE:
+ *pU1Tmp = padapter->dvobj->pwrctl_priv.pwr_mode;
+ break;
+
+ default:
+ ret = _FALSE;
+ break;
+ }
+
+ return ret;
+}
+
+u8 halbtcoutsrc_Set(void *pBtcContext, u8 setType, void *pInBuf)
+{
+ PBTC_COEXIST pBtCoexist;
+ PADAPTER padapter;
+ PHAL_DATA_TYPE pHalData;
+ u8 *pu8;
+ u8 *pU1Tmp;
+ u32 *pU4Tmp;
+ u8 ret;
+
+
+ pBtCoexist = (PBTC_COEXIST)pBtcContext;
+ padapter = pBtCoexist->Adapter;
+ pHalData = GET_HAL_DATA(padapter);
+ pu8 = (u8*)pInBuf;
+ pU1Tmp = (u8*)pInBuf;
+ pU4Tmp = (u32*)pInBuf;
+ ret = _TRUE;
+
+ if (!halbtcoutsrc_IsBtCoexistAvailable(pBtCoexist))
+ return _FALSE;
+
+ switch (setType)
+ {
+ // set some u8 type variables.
+ case BTC_SET_BL_BT_DISABLE:
+ pBtCoexist->btInfo.bBtDisabled = *pu8;
+ break;
+
+ case BTC_SET_BL_BT_TRAFFIC_BUSY:
+ pBtCoexist->btInfo.bBtBusy = *pu8;
+ break;
+
+ case BTC_SET_BL_BT_LIMITED_DIG:
+ pBtCoexist->btInfo.bLimitedDig = *pu8;
+ break;
+
+ case BTC_SET_BL_FORCE_TO_ROAM:
+ pBtCoexist->btInfo.bForceToRoam = *pu8;
+ break;
+
+ case BTC_SET_BL_TO_REJ_AP_AGG_PKT:
+ pBtCoexist->btInfo.bRejectAggPkt = *pu8;
+ break;
+
+ case BTC_SET_BL_BT_CTRL_AGG_SIZE:
+ pBtCoexist->btInfo.bBtCtrlAggBufSize = *pu8;
+ break;
+
+ case BTC_SET_BL_INC_SCAN_DEV_NUM:
+ pBtCoexist->btInfo.bIncreaseScanDevNum = *pu8;
+ break;
+
+ case BTC_SET_BL_BT_TX_RX_MASK:
+ pBtCoexist->btInfo.bBtTxRxMask = *pu8;
+ break;
+
+ case BTC_SET_BL_MIRACAST_PLUS_BT:
+ pBtCoexist->btInfo.bMiracastPlusBt = *pu8;
+ break;
+
+ // set some u8 type variables.
+ case BTC_SET_U1_RSSI_ADJ_VAL_FOR_AGC_TABLE_ON:
+ pBtCoexist->btInfo.rssiAdjustForAgcTableOn = *pU1Tmp;
+ break;
+
+ case BTC_SET_U1_AGG_BUF_SIZE:
+ pBtCoexist->btInfo.aggBufSize = *pU1Tmp;
+ break;
+
+ // the following are some action which will be triggered
+ case BTC_SET_ACT_GET_BT_RSSI:
+#if 0
+ BT_SendGetBtRssiEvent(padapter);
+#else
+ ret = _FALSE;
+#endif
+ break;
+
+ case BTC_SET_ACT_AGGREGATE_CTRL:
+ halbtcoutsrc_AggregationCheck(pBtCoexist);
+ break;
+
+ //=======1Ant===========
+ // set some u8 type variables.
+ case BTC_SET_U1_RSSI_ADJ_VAL_FOR_1ANT_COEX_TYPE:
+ pBtCoexist->btInfo.rssiAdjustFor1AntCoexType = *pU1Tmp;
+ break;
+
+ case BTC_SET_U1_LPS_VAL:
+ pBtCoexist->btInfo.lpsVal = *pU1Tmp;
+ break;
+
+ case BTC_SET_U1_RPWM_VAL:
+ pBtCoexist->btInfo.rpwmVal = *pU1Tmp;
+ break;
+
+ // the following are some action which will be triggered
+ case BTC_SET_ACT_LEAVE_LPS:
+ halbtcoutsrc_LeaveLps(pBtCoexist);
+ break;
+
+ case BTC_SET_ACT_ENTER_LPS:
+ halbtcoutsrc_EnterLps(pBtCoexist);
+ break;
+
+ case BTC_SET_ACT_NORMAL_LPS:
+ halbtcoutsrc_NormalLps(pBtCoexist);
+ break;
+
+ case BTC_SET_ACT_DISABLE_LOW_POWER:
+ halbtcoutsrc_DisableLowPower(pBtCoexist, *pu8);
+ break;
+
+ case BTC_SET_ACT_UPDATE_RAMASK:
+ pBtCoexist->btInfo.raMask = *pU4Tmp;
+
+ if (check_fwstate(&padapter->mlmepriv, WIFI_ASOC_STATE) == _TRUE)
+ {
+ struct sta_info *psta;
+ PWLAN_BSSID_EX cur_network;
+
+ cur_network = &padapter->mlmeextpriv.mlmext_info.network;
+ psta = rtw_get_stainfo(&padapter->stapriv, cur_network->MacAddress);
+ rtw_hal_update_ra_mask(psta, 0);
+ }
+ break;
+
+ case BTC_SET_ACT_SEND_MIMO_PS:
+ {
+ u8 newMimoPsMode = 3;
+ struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
+ struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
+
+ /* *pU1Tmp = 0 use SM_PS static type */
+ /* *pU1Tmp = 1 disable SM_PS */
+ if (*pU1Tmp == 0)
+ newMimoPsMode = WLAN_HT_CAP_SM_PS_STATIC;
+ else if (*pU1Tmp == 1)
+ newMimoPsMode = WLAN_HT_CAP_SM_PS_DISABLED;
+
+ if (check_fwstate(&padapter->mlmepriv , WIFI_ASOC_STATE) == _TRUE) {
+ /* issue_action_SM_PS(padapter, get_my_bssid(&(pmlmeinfo->network)), newMimoPsMode); */
+ issue_action_SM_PS_wait_ack(padapter , get_my_bssid(&(pmlmeinfo->network)) , newMimoPsMode, 3 , 1);
+ }
+ }
+ break;
+
+ case BTC_SET_ACT_CTRL_BT_INFO:
+#ifdef CONFIG_BT_COEXIST_SOCKET_TRX
+ {
+ u8 dataLen = *pU1Tmp;
+ u8 tmpBuf[20];
+ if (dataLen)
+ {
+ _rtw_memcpy(tmpBuf, pU1Tmp+1, dataLen);
+ }
+ BT_SendEventExtBtInfoControl(padapter, dataLen, &tmpBuf[0]);
+ }
+#else //!CONFIG_BT_COEXIST_SOCKET_TRX
+ ret = _FALSE;
+#endif //CONFIG_BT_COEXIST_SOCKET_TRX
+ break;
+
+ case BTC_SET_ACT_CTRL_BT_COEX:
+#ifdef CONFIG_BT_COEXIST_SOCKET_TRX
+ {
+ u8 dataLen = *pU1Tmp;
+ u8 tmpBuf[20];
+ if (dataLen)
+ {
+ _rtw_memcpy(tmpBuf, pU1Tmp+1, dataLen);
+ }
+ BT_SendEventExtBtCoexControl(padapter, _FALSE, dataLen, &tmpBuf[0]);
+ }
+#else //!CONFIG_BT_COEXIST_SOCKET_TRX
+ ret = _FALSE;
+#endif //CONFIG_BT_COEXIST_SOCKET_TRX
+ break;
+ case BTC_SET_ACT_CTRL_8723B_ANT:
+#if 0
+ {
+ u1Byte dataLen=*pU1Tmp;
+ u1Byte tmpBuf[20];
+ if(dataLen)
+ {
+ PlatformMoveMemory(&tmpBuf[0], pU1Tmp+1, dataLen);
+ }
+ BT_Set8723bAnt(Adapter, dataLen, &tmpBuf[0]);
+ }
+#else
+ ret = _FALSE;
+#endif
+ break;
+ //=====================
+ default:
+ ret = _FALSE;
+ break;
+ }
+
+ return ret;
+}
+
+u8 halbtcoutsrc_UnderIps(PBTC_COEXIST pBtCoexist)
+{
+ PADAPTER padapter;
+ struct pwrctrl_priv *pwrpriv;
+ u8 bMacPwrCtrlOn;
+
+ padapter = pBtCoexist->Adapter;
+ pwrpriv = &padapter->dvobj->pwrctl_priv;
+ bMacPwrCtrlOn = _FALSE;
+
+ if ((_TRUE == pwrpriv->bips_processing)
+ && (IPS_NONE != pwrpriv->ips_mode_req)
+ )
+ {
+ return _TRUE;
+ }
+
+ if (rf_off == pwrpriv->rf_pwrstate)
+ {
+ return _TRUE;
+ }
+
+ rtw_hal_get_hwreg(padapter, HW_VAR_APFM_ON_MAC, &bMacPwrCtrlOn);
+ if (_FALSE == bMacPwrCtrlOn)
+ {
+ return _TRUE;
+ }
+
+ return _FALSE;
+}
+
+u8 halbtcoutsrc_UnderLps(PBTC_COEXIST pBtCoexist)
+{
+ return GLBtcWiFiInLPS;
+}
+
+u8 halbtcoutsrc_Under32K(PBTC_COEXIST pBtCoexist)
+{
+ /* todo: the method to check whether wifi is under 32K or not */
+ return _FALSE;
+}
+
+void halbtcoutsrc_DisplayCoexStatistics(PBTC_COEXIST pBtCoexist)
+{
+#if 0
+ PADAPTER padapter = (PADAPTER)pBtCoexist->Adapter;
+ PBT_MGNT pBtMgnt = &padapter->MgntInfo.BtInfo.BtMgnt;
+ PHAL_DATA_TYPE pHalData = GET_HAL_DATA(padapter);
+ u8 *cliBuf = pBtCoexist->cliBuf;
+ u8 i;
+
+ CL_SPRINTF(cliBuf, BT_TMP_BUF_SIZE, "\r\n %-35s", "============[Statistics]============");
+ CL_PRINTF(cliBuf);
+
+#if (H2C_USE_IO_THREAD != 1)
+ for(i=0; i<H2C_STATUS_MAX; i++)
+ {
+ if (pHalData->h2cStatistics[i])
+ {
+ CL_SPRINTF(cliBuf, BT_TMP_BUF_SIZE, "\r\n %-35s = [%s] = %d", "H2C statistics", \
+ h2cStaString[i], pHalData->h2cStatistics[i]);
+ CL_PRINTF(cliBuf);
+ }
+ }
+#else
+ for(i=0; i<IO_STATUS_MAX; i++)
+ {
+ if(Adapter->ioComStr.ioH2cStatistics[i])
+ {
+ CL_SPRINTF(cliBuf, BT_TMP_BUF_SIZE, "\r\n %-35s = [%s] = %d", "H2C statistics", \
+ ioStaString[i], Adapter->ioComStr.ioH2cStatistics[i]);
+ CL_PRINTF(cliBuf);
+ }
+ }
+#endif
+#if 0
+ CL_SPRINTF(cliBuf, BT_TMP_BUF_SIZE, "\r\n %-35s = 0x%x", "lastHMEBoxNum", \
+ pHalData->LastHMEBoxNum);
+ CL_PRINTF(cliBuf);
+ CL_SPRINTF(cliBuf, BT_TMP_BUF_SIZE, "\r\n %-35s = 0x%x / 0x%x", "LastOkH2c/FirstFailH2c(fwNotRead)", \
+ pHalData->lastSuccessH2cEid, pHalData->firstFailedH2cEid);
+ CL_PRINTF(cliBuf);
+
+ CL_SPRINTF(cliBuf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d/ %d/ %d/ %d/ %d", "c2hIsr/c2hIntr/clr1AF/noRdy/noBuf", \
+ pHalData->InterruptLog.nIMR_C2HCMD, DBG_Var.c2hInterruptCnt, DBG_Var.c2hClrReadC2hCnt,
+ DBG_Var.c2hNotReadyCnt, DBG_Var.c2hBufAlloFailCnt);
+ CL_PRINTF(cliBuf);
+
+ CL_SPRINTF(cliBuf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d", "c2hPacket", \
+ DBG_Var.c2hPacketCnt);
+ CL_PRINTF(cliBuf);
+#endif
+ CL_SPRINTF(cliBuf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d/ %d", "Periodical/ DbgCtrl", \
+ pBtCoexist->statistics.cntPeriodical, pBtCoexist->statistics.cntDbgCtrl);
+ CL_PRINTF(cliBuf);
+ CL_SPRINTF(cliBuf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d/ %d/ %d/ %d", "PowerOn/InitHw/InitCoexDm/RfStatus", \
+ pBtCoexist->statistics.cntPowerOn, pBtCoexist->statistics.cntInitHwConfig, pBtCoexist->statistics.cntInitCoexDm,
+ pBtCoexist->statistics.cntRfStatusNotify);
+ CL_PRINTF(cliBuf);
+ CL_SPRINTF(cliBuf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d/ %d/ %d/ %d/ %d", "Ips/Lps/Scan/Connect/Mstatus", \
+ pBtCoexist->statistics.cntIpsNotify, pBtCoexist->statistics.cntLpsNotify,
+ pBtCoexist->statistics.cntScanNotify, pBtCoexist->statistics.cntConnectNotify,
+ pBtCoexist->statistics.cntMediaStatusNotify);
+ CL_PRINTF(cliBuf);
+ CL_SPRINTF(cliBuf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d/ %d/ %d", "Special pkt/Bt info/ bind",
+ pBtCoexist->statistics.cntSpecialPacketNotify, pBtCoexist->statistics.cntBtInfoNotify,
+ pBtCoexist->statistics.cntBind);
+ CL_PRINTF(cliBuf);
+#endif
+}
+
+void halbtcoutsrc_DisplayBtLinkInfo(PBTC_COEXIST pBtCoexist)
+{
+#if 0
+ PADAPTER padapter = (PADAPTER)pBtCoexist->Adapter;
+ PBT_MGNT pBtMgnt = &padapter->MgntInfo.BtInfo.BtMgnt;
+ u8 *cliBuf = pBtCoexist->cliBuf;
+ u8 i;
+
+
+ if (pBtCoexist->stackInfo.bProfileNotified)
+ {
+ for (i=0; i<pBtMgnt->ExtConfig.NumberOfACL; i++)
+ {
+ if (pBtMgnt->ExtConfig.HCIExtensionVer >= 1)
+ {
+ CL_SPRINTF(cliBuf, BT_TMP_BUF_SIZE, "\r\n %-35s = %s/ %s/ %s", "Bt link type/spec/role", \
+ BtProfileString[pBtMgnt->ExtConfig.aclLink[i].BTProfile],
+ BtSpecString[pBtMgnt->ExtConfig.aclLink[i].BTCoreSpec],
+ BtLinkRoleString[pBtMgnt->ExtConfig.aclLink[i].linkRole]);
+ CL_PRINTF(cliBuf); }
+ else
+ {
+ CL_SPRINTF(cliBuf, BT_TMP_BUF_SIZE, "\r\n %-35s = %s/ %s", "Bt link type/spec", \
+ BtProfileString[pBtMgnt->ExtConfig.aclLink[i].BTProfile],
+ BtSpecString[pBtMgnt->ExtConfig.aclLink[i].BTCoreSpec]);
+ CL_PRINTF(cliBuf);
+ }
+ }
+ }
+#endif
+}
+
+void halbtcoutsrc_DisplayWifiStatus(PBTC_COEXIST pBtCoexist)
+{
+ PADAPTER padapter = pBtCoexist->Adapter;
+ struct pwrctrl_priv *pwrpriv = adapter_to_pwrctl(padapter);
+ u8* cliBuf=pBtCoexist->cliBuf;
+ s32 wifiRssi=0, btHsRssi=0;
+ BOOLEAN bScan=_FALSE, bLink=_FALSE, bRoam=_FALSE, bWifiBusy=_FALSE, bWifiUnderBMode=_FALSE;
+ u32 wifiBw=BTC_WIFI_BW_HT20, wifiTrafficDir=BTC_WIFI_TRAFFIC_TX, wifiFreq=BTC_FREQ_2_4G;
+ u32 wifiLinkStatus=0x0;
+ BOOLEAN bBtHsOn=_FALSE, bLowPower=_FALSE;
+ u8 wifiChnl=0, wifiHsChnl=0, nScanAPNum = 0, FwPSState;
+
+ wifiLinkStatus = halbtcoutsrc_GetWifiLinkStatus(pBtCoexist);
+ CL_SPRINTF(cliBuf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d/ %d/ %d/ %d/ %d", "STA/vWifi/HS/p2pGo/p2pGc", \
+ ((wifiLinkStatus&WIFI_STA_CONNECTED)? 1:0), ((wifiLinkStatus&WIFI_AP_CONNECTED)? 1:0),
+ ((wifiLinkStatus&WIFI_HS_CONNECTED)? 1:0), ((wifiLinkStatus&WIFI_P2P_GO_CONNECTED)? 1:0),
+ ((wifiLinkStatus&WIFI_P2P_GC_CONNECTED)? 1:0) );
+ CL_PRINTF(cliBuf);
+
+ if (wifiLinkStatus&WIFI_STA_CONNECTED) {
+ CL_SPRINTF(cliBuf, BT_TMP_BUF_SIZE, "\r\n %-35s = %s", "IOT Peer", GLBtcIotPeerString[padapter->mlmeextpriv.mlmext_info.assoc_AP_vendor]);
+ CL_PRINTF(cliBuf);
+ }
+
+ pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_HS_OPERATION, &bBtHsOn);
+ pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_U1_WIFI_DOT11_CHNL, &wifiChnl);
+ pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_U1_WIFI_HS_CHNL, &wifiHsChnl); CL_SPRINTF(cliBuf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d / %d(%d)", "Dot11 channel / HsChnl(High Speed)", \
+ wifiChnl, wifiHsChnl, bBtHsOn);
+ CL_PRINTF(cliBuf);
+
+ pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_S4_WIFI_RSSI, &wifiRssi);
+ pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_S4_HS_RSSI, &btHsRssi);
+ CL_SPRINTF(cliBuf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d/ %d", "Wifi rssi/ HS rssi", \
+ wifiRssi-100, btHsRssi-100);
+ CL_PRINTF(cliBuf);
+
+
+ pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_WIFI_SCAN, &bScan);
+ pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_WIFI_LINK, &bLink);
+ pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_WIFI_ROAM, &bRoam);
+ CL_SPRINTF(cliBuf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d/ %d/ %d ", "Wifi bLink/ bRoam/ bScan", \
+ bLink, bRoam, bScan);
+ CL_PRINTF(cliBuf);
+
+ pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_WIFI_UNDER_5G, &wifiFreq);
+ pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_U4_WIFI_BW, &wifiBw);
+ pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_WIFI_BUSY, &bWifiBusy);
+ pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_U4_WIFI_TRAFFIC_DIRECTION, &wifiTrafficDir);
+ pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_WIFI_UNDER_B_MODE, &bWifiUnderBMode);
+ pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_U1_AP_NUM, &nScanAPNum);
+ CL_SPRINTF(cliBuf, BT_TMP_BUF_SIZE, "\r\n %-35s = %s / %s/ %s/ AP=%d ", "Wifi freq/ bw/ traffic", \
+ GLBtcWifiFreqString[wifiFreq], ((bWifiUnderBMode)? "11b": GLBtcWifiBwString[wifiBw]),
+ ((!bWifiBusy)? "idle": ((BTC_WIFI_TRAFFIC_TX==wifiTrafficDir)? "uplink":"downlink")),
+ nScanAPNum);
+ CL_PRINTF(cliBuf);
+
+ // power status
+ CL_SPRINTF(cliBuf, BT_TMP_BUF_SIZE, "\r\n %-35s = %s%s%s", "Power Status", \
+ ((halbtcoutsrc_UnderIps(pBtCoexist) == _TRUE)? "IPS ON":"IPS OFF"),
+ ((halbtcoutsrc_UnderLps(pBtCoexist) == _TRUE)? ", LPS ON":", LPS OFF"),
+ ((halbtcoutsrc_Under32K(pBtCoexist) == _TRUE)? ", 32k":""));
+ CL_PRINTF(cliBuf);
+
+ CL_SPRINTF(cliBuf, BT_TMP_BUF_SIZE, "\r\n %-35s = %02x %02x %02x %02x %02x %02x (0x%x/0x%x)", "Power mode cmd(lps/rpwm)", \
+ pBtCoexist->pwrModeVal[0], pBtCoexist->pwrModeVal[1],
+ pBtCoexist->pwrModeVal[2], pBtCoexist->pwrModeVal[3],
+ pBtCoexist->pwrModeVal[4], pBtCoexist->pwrModeVal[5],
+ pBtCoexist->btInfo.lpsVal,
+ pBtCoexist->btInfo.rpwmVal);
+ CL_PRINTF(cliBuf);
+}
+
+void halbtcoutsrc_DisplayDbgMsg(void *pBtcContext, u8 dispType)
+{
+ PBTC_COEXIST pBtCoexist;
+
+
+ pBtCoexist = (PBTC_COEXIST)pBtcContext;
+ switch(dispType)
+ {
+ case BTC_DBG_DISP_COEX_STATISTICS:
+ halbtcoutsrc_DisplayCoexStatistics(pBtCoexist);
+ break;
+ case BTC_DBG_DISP_BT_LINK_INFO:
+ halbtcoutsrc_DisplayBtLinkInfo(pBtCoexist);
+ break;
+ case BTC_DBG_DISP_WIFI_STATUS:
+ halbtcoutsrc_DisplayWifiStatus(pBtCoexist);
+ break;
+ default:
+ break;
+ }
+}
+
+//====================================
+// IO related function
+//====================================
+u8 halbtcoutsrc_Read1Byte(void *pBtcContext, u32 RegAddr)
+{
+ PBTC_COEXIST pBtCoexist;
+ PADAPTER padapter;
+
+
+ pBtCoexist = (PBTC_COEXIST)pBtcContext;
+ padapter = pBtCoexist->Adapter;
+
+ return rtw_read8(padapter, RegAddr);
+}
+
+u16 halbtcoutsrc_Read2Byte(void *pBtcContext, u32 RegAddr)
+{
+ PBTC_COEXIST pBtCoexist;
+ PADAPTER padapter;
+
+
+ pBtCoexist = (PBTC_COEXIST)pBtcContext;
+ padapter = pBtCoexist->Adapter;
+
+ return rtw_read16(padapter, RegAddr);
+}
+
+u32 halbtcoutsrc_Read4Byte(void *pBtcContext, u32 RegAddr)
+{
+ PBTC_COEXIST pBtCoexist;
+ PADAPTER padapter;
+
+
+ pBtCoexist = (PBTC_COEXIST)pBtcContext;
+ padapter = pBtCoexist->Adapter;
+
+ return rtw_read32(padapter, RegAddr);
+}
+
+void halbtcoutsrc_Write1Byte(void *pBtcContext, u32 RegAddr, u8 Data)
+{
+ PBTC_COEXIST pBtCoexist;
+ PADAPTER padapter;
+
+
+ pBtCoexist = (PBTC_COEXIST)pBtcContext;
+ padapter = pBtCoexist->Adapter;
+
+ rtw_write8(padapter, RegAddr, Data);
+}
+
+void halbtcoutsrc_BitMaskWrite1Byte(void *pBtcContext, u32 regAddr, u8 bitMask, u8 data1b)
+{
+ PBTC_COEXIST pBtCoexist;
+ PADAPTER padapter;
+ u8 originalValue, bitShift;
+ u8 i;
+
+
+ pBtCoexist = (PBTC_COEXIST)pBtcContext;
+ padapter = pBtCoexist->Adapter;
+ originalValue = 0;
+ bitShift = 0;
+
+ if(bitMask != 0xff)
+ {
+ originalValue = rtw_read8(padapter, regAddr);
+
+ for (i=0; i<=7; i++)
+ {
+ if ((bitMask>>i)&0x1)
+ break;
+ }
+ bitShift = i;
+
+ data1b = (originalValue & ~bitMask) | ((data1b << bitShift) & bitMask);
+ }
+
+ rtw_write8(padapter, regAddr, data1b);
+}
+
+void halbtcoutsrc_Write2Byte(void *pBtcContext, u32 RegAddr, u16 Data)
+{
+ PBTC_COEXIST pBtCoexist;
+ PADAPTER padapter;
+
+
+ pBtCoexist = (PBTC_COEXIST)pBtcContext;
+ padapter = pBtCoexist->Adapter;
+
+ rtw_write16(padapter, RegAddr, Data);
+}
+
+void halbtcoutsrc_Write4Byte(void *pBtcContext, u32 RegAddr, u32 Data)
+{
+ PBTC_COEXIST pBtCoexist;
+ PADAPTER padapter;
+
+
+ pBtCoexist = (PBTC_COEXIST)pBtcContext;
+ padapter = pBtCoexist->Adapter;
+
+ rtw_write32(padapter, RegAddr, Data);
+}
+
+void halbtcoutsrc_WriteLocalReg1Byte(void *pBtcContext, u32 RegAddr, u8 Data)
+{
+ PBTC_COEXIST pBtCoexist=(PBTC_COEXIST)pBtcContext;
+ PADAPTER Adapter=pBtCoexist->Adapter;
+
+ if(BTC_INTF_SDIO == pBtCoexist->chipInterface)
+ {
+ rtw_write8(Adapter, SDIO_LOCAL_BASE | RegAddr, Data);
+ }
+ else
+ {
+ rtw_write8(Adapter, RegAddr, Data);
+ }
+}
+
+void halbtcoutsrc_SetBbReg(void *pBtcContext, u32 RegAddr, u32 BitMask, u32 Data)
+{
+ PBTC_COEXIST pBtCoexist;
+ PADAPTER padapter;
+
+
+ pBtCoexist = (PBTC_COEXIST)pBtcContext;
+ padapter = pBtCoexist->Adapter;
+
+ PHY_SetBBReg(padapter, RegAddr, BitMask, Data);
+}
+
+
+u32 halbtcoutsrc_GetBbReg(void *pBtcContext, u32 RegAddr, u32 BitMask)
+{
+ PBTC_COEXIST pBtCoexist;
+ PADAPTER padapter;
+
+
+ pBtCoexist = (PBTC_COEXIST)pBtcContext;
+ padapter = pBtCoexist->Adapter;
+
+ return PHY_QueryBBReg(padapter, RegAddr, BitMask);
+}
+
+void halbtcoutsrc_SetRfReg(void *pBtcContext, u8 eRFPath, u32 RegAddr, u32 BitMask, u32 Data)
+{
+ PBTC_COEXIST pBtCoexist;
+ PADAPTER padapter;
+
+
+ pBtCoexist = (PBTC_COEXIST)pBtcContext;
+ padapter = pBtCoexist->Adapter;
+
+ PHY_SetRFReg(padapter, eRFPath, RegAddr, BitMask, Data);
+}
+
+u32 halbtcoutsrc_GetRfReg(void *pBtcContext, u8 eRFPath, u32 RegAddr, u32 BitMask)
+{
+ PBTC_COEXIST pBtCoexist;
+ PADAPTER padapter;
+
+
+ pBtCoexist = (PBTC_COEXIST)pBtcContext;
+ padapter = pBtCoexist->Adapter;
+
+ return PHY_QueryRFReg(padapter, eRFPath, RegAddr, BitMask);
+}
+
+u16 halbtcoutsrc_SetBtReg(void *pBtcContext, u8 RegType, u32 RegAddr, u32 Data)
+{
+ PBTC_COEXIST pBtCoexist;
+ u16 ret = BT_STATUS_BT_OP_SUCCESS;
+
+ pBtCoexist = (PBTC_COEXIST)pBtcContext;
+
+ if (halbtcoutsrc_IsHwMailboxExist(pBtCoexist) == _TRUE) {
+ u8 buf[3] = {0};
+ _irqL irqL;
+ u8 op_code;
+ u8 status;
+
+ _enter_critical_mutex(&GLBtcBtMpOperLock, &irqL);
+
+ Data = cpu_to_le32(Data);
+ op_code = BT_OP_WRITE_REG_VALUE;
+ status = _btmpoper_cmd(pBtCoexist, op_code, 0, (u8 *)&Data, 3);
+ if (status != BT_STATUS_BT_OP_SUCCESS)
+ ret = SET_BT_MP_OPER_RET(op_code, status);
+ else {
+ buf[0] = RegType;
+ *(u16 *)(buf+1) = cpu_to_le16((u16)RegAddr);
+ op_code = BT_OP_WRITE_REG_ADDR;
+ status = _btmpoper_cmd(pBtCoexist, op_code, 0, buf, 3);
+ if (status != BT_STATUS_BT_OP_SUCCESS)
+ ret = SET_BT_MP_OPER_RET(op_code, status);
+ }
+
+ _exit_critical_mutex(&GLBtcBtMpOperLock, &irqL);
+ } else
+ ret = BT_STATUS_NOT_IMPLEMENT;
+
+ return ret;
+}
+
+u8 halbtcoutsrc_SetBtAntDetection(void *pBtcContext, u8 txTime, u8 btChnl)
+{
+/* Always return _FALSE since we don't implement this yet */
+#if 0
+ PBTC_COEXIST pBtCoexist = (PBTC_COEXIST)pBtcContext;
+ PADAPTER Adapter = pBtCoexist->Adapter;
+ u1Byte btCanTx = 0;
+ BOOLEAN bStatus = FALSE;
+
+ bStatus = NDBG_SetBtAntDetection(Adapter, txTime, btChnl, &btCanTx);
+ if (bStatus && btCanTx)
+ return _TRUE;
+ else
+ return _FALSE;
+#else
+ return _FALSE;
+#endif
+}
+
+u16 halbtcoutsrc_GetBtReg(void *pBtcContext, u8 RegType, u32 RegAddr, u32 *data)
+{
+ PBTC_COEXIST pBtCoexist;
+ u16 ret = BT_STATUS_BT_OP_SUCCESS;
+
+ pBtCoexist = (PBTC_COEXIST)pBtcContext;
+
+ if (halbtcoutsrc_IsHwMailboxExist(pBtCoexist) == _TRUE) {
+ u8 buf[3] = {0};
+ _irqL irqL;
+ u8 op_code;
+ u8 status;
+
+ buf[0] = RegType;
+ *(u16 *)(buf+1) = cpu_to_le16((u16)RegAddr);
+
+ _enter_critical_mutex(&GLBtcBtMpOperLock, &irqL);
+
+ op_code = BT_OP_READ_REG;
+ status = _btmpoper_cmd(pBtCoexist, op_code, 0, buf, 3);
+ if (status == BT_STATUS_BT_OP_SUCCESS)
+ *data = le16_to_cpu(*(u16 *)GLBtcBtMpRptRsp);
+ else
+ ret = SET_BT_MP_OPER_RET(op_code, status);
+
+ _exit_critical_mutex(&GLBtcBtMpOperLock, &irqL);
+
+ } else
+ ret = BT_STATUS_NOT_IMPLEMENT;
+
+ return ret;
+}
+
+void halbtcoutsrc_FillH2cCmd(void *pBtcContext, u8 elementId, u32 cmdLen, u8 *pCmdBuffer)
+{
+ PBTC_COEXIST pBtCoexist;
+ PADAPTER padapter;
+
+
+ pBtCoexist = (PBTC_COEXIST)pBtcContext;
+ padapter = pBtCoexist->Adapter;
+
+ rtw_hal_fill_h2c_cmd(padapter, elementId, cmdLen, pCmdBuffer);
+}
+
+//====================================
+// Extern functions called by other module
+//====================================
+u8 EXhalbtcoutsrc_IsTfbgaPackageType(PADAPTER padapter)
+{
+ HAL_DATA_TYPE *pHalData = GET_HAL_DATA(padapter);
+
+#ifdef CONFIG_RTL8723B
+ if ((pHalData->PackageType == PACKAGE_TFBGA79) || (pHalData->PackageType == PACKAGE_TFBGA80)
+ || (pHalData->PackageType == PACKAGE_TFBGA90)) {
+ return _TRUE;
+ }
+#endif
+
+ return _FALSE;
+}
+
+u8 EXhalbtcoutsrc_BindBtCoexWithAdapter(void *padapter)
+{
+ PBTC_COEXIST pBtCoexist=&GLBtCoexist;
+ u1Byte antNum=2, chipType;
+
+ if(pBtCoexist->bBinded)
+ return _FALSE;
+ else
+ pBtCoexist->bBinded = _TRUE;
+
+ pBtCoexist->statistics.cntBind++;
+
+ pBtCoexist->Adapter = padapter;
+
+ pBtCoexist->stackInfo.bProfileNotified = _FALSE;
+
+ pBtCoexist->btInfo.bBtCtrlAggBufSize = _FALSE;
+ pBtCoexist->btInfo.aggBufSize = 5;
+
+ pBtCoexist->btInfo.bIncreaseScanDevNum = _FALSE;
+ pBtCoexist->btInfo.bMiracastPlusBt = _FALSE;
+
+#if 0
+ chipType = HALBT_GetBtChipType(Adapter);
+ EXhalbtcoutsrc_SetChipType(chipType);
+ antNum = HALBT_GetPgAntNum(Adapter);
+ EXhalbtcoutsrc_SetAntNum(BT_COEX_ANT_TYPE_PG, antNum);
+#endif
+ // set default antenna position to main port
+ pBtCoexist->boardInfo.btdmAntPos = BTC_ANTENNA_AT_MAIN_PORT;
+
+ pBtCoexist->boardInfo.btdmAntDetFinish = _FALSE;
+ pBtCoexist->boardInfo.btdmAntNumByAntDet = 1;
+
+ pBtCoexist->boardInfo.bTfbgaPackage = EXhalbtcoutsrc_IsTfbgaPackageType((PADAPTER)padapter);
+
+ if (pBtCoexist->boardInfo.bTfbgaPackage)
+ RT_TRACE(COMP_COEX, DBG_LOUD, ("[BTCoex], Package Type = TFBGA\n"));
+ else
+ RT_TRACE(COMP_COEX, DBG_LOUD, ("[BTCoex], Package Type = Non-TFBGA\n"));
+
+ return _TRUE;
+}
+
+u8 EXhalbtcoutsrc_InitlizeVariables(void *padapter)
+{
+ PBTC_COEXIST pBtCoexist = &GLBtCoexist;
+
+ //pBtCoexist->statistics.cntBind++;
+
+ halbtcoutsrc_DbgInit();
+
+#ifdef CONFIG_PCI_HCI
+ pBtCoexist->chipInterface = BTC_INTF_PCI;
+#elif defined(CONFIG_USB_HCI)
+ pBtCoexist->chipInterface = BTC_INTF_USB;
+#elif defined(CONFIG_SDIO_HCI) || defined(CONFIG_GSPI_HCI)
+ pBtCoexist->chipInterface = BTC_INTF_SDIO;
+#else
+ pBtCoexist->chipInterface = BTC_INTF_UNKNOWN;
+#endif
+
+ EXhalbtcoutsrc_BindBtCoexWithAdapter(padapter);
+
+ pBtCoexist->fBtcRead1Byte = halbtcoutsrc_Read1Byte;
+ pBtCoexist->fBtcWrite1Byte = halbtcoutsrc_Write1Byte;
+ pBtCoexist->fBtcWrite1ByteBitMask = halbtcoutsrc_BitMaskWrite1Byte;
+ pBtCoexist->fBtcRead2Byte = halbtcoutsrc_Read2Byte;
+ pBtCoexist->fBtcWrite2Byte = halbtcoutsrc_Write2Byte;
+ pBtCoexist->fBtcRead4Byte = halbtcoutsrc_Read4Byte;
+ pBtCoexist->fBtcWrite4Byte = halbtcoutsrc_Write4Byte;
+ pBtCoexist->fBtcWriteLocalReg1Byte = halbtcoutsrc_WriteLocalReg1Byte;
+
+ pBtCoexist->fBtcSetBbReg = halbtcoutsrc_SetBbReg;
+ pBtCoexist->fBtcGetBbReg = halbtcoutsrc_GetBbReg;
+
+ pBtCoexist->fBtcSetRfReg = halbtcoutsrc_SetRfReg;
+ pBtCoexist->fBtcGetRfReg = halbtcoutsrc_GetRfReg;
+
+ pBtCoexist->fBtcFillH2c = halbtcoutsrc_FillH2cCmd;
+ pBtCoexist->fBtcDispDbgMsg = halbtcoutsrc_DisplayDbgMsg;
+
+ pBtCoexist->fBtcGet = halbtcoutsrc_Get;
+ pBtCoexist->fBtcSet = halbtcoutsrc_Set;
+ pBtCoexist->fBtcGetBtReg = halbtcoutsrc_GetBtReg;
+ pBtCoexist->fBtcSetBtReg = halbtcoutsrc_SetBtReg;
+ pBtCoexist->fBtcSetBtAntDetection = halbtcoutsrc_SetBtAntDetection;
+
+ pBtCoexist->cliBuf = &GLBtcDbgBuf[0];
+
+ pBtCoexist->boardInfo.singleAntPath = 0;
+
+ GLBtcWiFiInScanState = _FALSE;
+
+ GLBtcWiFiInIQKState = _FALSE;
+
+ GLBtcWiFiInIPS = _FALSE;
+
+ GLBtcWiFiInLPS = _FALSE;
+
+ GLBtcBtCoexAliveRegistered = _FALSE;
+
+ /* BT Control H2C/C2H*/
+ GLBtcBtMpOperSeq = 0;
+ _rtw_mutex_init(&GLBtcBtMpOperLock);
+ _init_timer(&GLBtcBtMpOperTimer, ((PADAPTER)padapter)->pnetdev, _btmpoper_timer_hdl, pBtCoexist);
+ _rtw_init_sema(&GLBtcBtMpRptSema, 0);
+ GLBtcBtMpRptSeq = 0;
+ GLBtcBtMpRptStatus = 0;
+ _rtw_memset(GLBtcBtMpRptRsp, 0, C2H_MAX_SIZE);
+ GLBtcBtMpRptRspSize = 0;
+ GLBtcBtMpRptWait = 0;
+ GLBtcBtMpRptWiFiOK = 0;
+ GLBtcBtMpRptBTOK = 0;
+
+ return _TRUE;
+}
+
+void EXhalbtcoutsrc_PowerOnSetting(PBTC_COEXIST pBtCoexist)
+{
+ if (!halbtcoutsrc_IsBtCoexistAvailable(pBtCoexist))
+ return;
+
+ /* Power on setting function is only added in 8723B currently */
+ if (IS_HARDWARE_TYPE_8723B(pBtCoexist->Adapter))
+ {
+ if (pBtCoexist->boardInfo.btdmAntNum == 2)
+ EXhalbtc8723b2ant_PowerOnSetting(pBtCoexist);
+ else if (pBtCoexist->boardInfo.btdmAntNum == 1)
+ EXhalbtc8723b1ant_PowerOnSetting(pBtCoexist);
+ }
+}
+
+void EXhalbtcoutsrc_PreLoadFirmware(PBTC_COEXIST pBtCoexist)
+{
+ if(!halbtcoutsrc_IsBtCoexistAvailable(pBtCoexist))
+ return;
+
+ pBtCoexist->statistics.cntPreLoadFirmware++;
+
+ if(IS_HARDWARE_TYPE_8723B(pBtCoexist->Adapter))
+ {
+ if(pBtCoexist->boardInfo.btdmAntNum == 2)
+ EXhalbtc8723b2ant_PreLoadFirmware(pBtCoexist);
+ else if(pBtCoexist->boardInfo.btdmAntNum == 1)
+ EXhalbtc8723b1ant_PreLoadFirmware(pBtCoexist);
+ }
+}
+
+void EXhalbtcoutsrc_InitHwConfig(PBTC_COEXIST pBtCoexist, u8 bWifiOnly)
+{
+ if (!halbtcoutsrc_IsBtCoexistAvailable(pBtCoexist))
+ return;
+
+ pBtCoexist->statistics.cntInitHwConfig++;
+
+ if (IS_HARDWARE_TYPE_8821(pBtCoexist->Adapter))
+ {
+ if (halbtcoutsrc_IsCsrBtCoex(pBtCoexist) == _TRUE)
+ EXhalbtc8821aCsr2ant_InitHwConfig(pBtCoexist, bWifiOnly);
+ else if (pBtCoexist->boardInfo.btdmAntNum == 2)
+ EXhalbtc8821a2ant_InitHwConfig(pBtCoexist, bWifiOnly);
+ else if (pBtCoexist->boardInfo.btdmAntNum == 1)
+ EXhalbtc8821a1ant_InitHwConfig(pBtCoexist, bWifiOnly);
+ }
+ else if (IS_HARDWARE_TYPE_8723B(pBtCoexist->Adapter))
+ {
+ if (pBtCoexist->boardInfo.btdmAntNum == 2)
+ EXhalbtc8723b2ant_InitHwConfig(pBtCoexist, bWifiOnly);
+ else if (pBtCoexist->boardInfo.btdmAntNum == 1)
+ EXhalbtc8723b1ant_InitHwConfig(pBtCoexist, bWifiOnly);
+ }
+ else if (IS_HARDWARE_TYPE_8703B(pBtCoexist->Adapter))
+ {
+ if (pBtCoexist->boardInfo.btdmAntNum == 2)
+ EXhalbtc8703b2ant_InitHwConfig(pBtCoexist, bWifiOnly);
+ else if (pBtCoexist->boardInfo.btdmAntNum == 1)
+ EXhalbtc8703b1ant_InitHwConfig(pBtCoexist, bWifiOnly);
+ }
+ else if (IS_HARDWARE_TYPE_8192E(pBtCoexist->Adapter))
+ {
+ if (pBtCoexist->boardInfo.btdmAntNum == 2)
+ EXhalbtc8192e2ant_InitHwConfig(pBtCoexist, bWifiOnly);
+ else if (pBtCoexist->boardInfo.btdmAntNum == 1)
+ EXhalbtc8192e1ant_InitHwConfig(pBtCoexist, bWifiOnly);
+ }
+ else if (IS_HARDWARE_TYPE_8812(pBtCoexist->Adapter))
+ {
+ if (pBtCoexist->boardInfo.btdmAntNum == 2)
+ EXhalbtc8812a2ant_InitHwConfig(pBtCoexist, bWifiOnly);
+ else if (pBtCoexist->boardInfo.btdmAntNum == 1)
+ EXhalbtc8812a1ant_InitHwConfig(pBtCoexist, bWifiOnly);
+ }
+}
+
+void EXhalbtcoutsrc_InitCoexDm(PBTC_COEXIST pBtCoexist)
+{
+ if (!halbtcoutsrc_IsBtCoexistAvailable(pBtCoexist))
+ return;
+
+ pBtCoexist->statistics.cntInitCoexDm++;
+
+ if (IS_HARDWARE_TYPE_8821(pBtCoexist->Adapter))
+ {
+ if (halbtcoutsrc_IsCsrBtCoex(pBtCoexist) == _TRUE)
+ EXhalbtc8821aCsr2ant_InitCoexDm(pBtCoexist);
+ else if (pBtCoexist->boardInfo.btdmAntNum == 2)
+ EXhalbtc8821a2ant_InitCoexDm(pBtCoexist);
+ else if (pBtCoexist->boardInfo.btdmAntNum == 1)
+ EXhalbtc8821a1ant_InitCoexDm(pBtCoexist);
+ }
+ else if (IS_HARDWARE_TYPE_8723B(pBtCoexist->Adapter))
+ {
+ if (pBtCoexist->boardInfo.btdmAntNum == 2)
+ EXhalbtc8723b2ant_InitCoexDm(pBtCoexist);
+ else if (pBtCoexist->boardInfo.btdmAntNum == 1)
+ EXhalbtc8723b1ant_InitCoexDm(pBtCoexist);
+ }
+ else if (IS_HARDWARE_TYPE_8703B(pBtCoexist->Adapter))
+ {
+ if (pBtCoexist->boardInfo.btdmAntNum == 2)
+ EXhalbtc8703b2ant_InitCoexDm(pBtCoexist);
+ else if (pBtCoexist->boardInfo.btdmAntNum == 1)
+ EXhalbtc8703b1ant_InitCoexDm(pBtCoexist);
+ }
+ else if (IS_HARDWARE_TYPE_8192E(pBtCoexist->Adapter))
+ {
+ if (pBtCoexist->boardInfo.btdmAntNum == 2)
+ EXhalbtc8192e2ant_InitCoexDm(pBtCoexist);
+ else if (pBtCoexist->boardInfo.btdmAntNum == 1)
+ EXhalbtc8192e1ant_InitCoexDm(pBtCoexist);
+ }
+ else if (IS_HARDWARE_TYPE_8812(pBtCoexist->Adapter))
+ {
+ if (pBtCoexist->boardInfo.btdmAntNum == 2)
+ EXhalbtc8812a2ant_InitCoexDm(pBtCoexist);
+ else if (pBtCoexist->boardInfo.btdmAntNum == 1)
+ EXhalbtc8812a1ant_InitCoexDm(pBtCoexist);
+ }
+
+ pBtCoexist->bInitilized = _TRUE;
+}
+
+void EXhalbtcoutsrc_IpsNotify(PBTC_COEXIST pBtCoexist, u8 type)
+{
+ u8 ipsType;
+
+ if (!halbtcoutsrc_IsBtCoexistAvailable(pBtCoexist))
+ return;
+
+ pBtCoexist->statistics.cntIpsNotify++;
+ if (pBtCoexist->bManualControl)
+ return;
+
+ if (IPS_NONE == type)
+ {
+ ipsType = BTC_IPS_LEAVE;
+ GLBtcWiFiInIPS = _FALSE;
+ }
+ else
+ {
+ ipsType = BTC_IPS_ENTER;
+ GLBtcWiFiInIPS = _TRUE;
+ }
+
+ // All notify is called in cmd thread, don't need to leave low power again
+// halbtcoutsrc_LeaveLowPower(pBtCoexist);
+
+ if (IS_HARDWARE_TYPE_8821(pBtCoexist->Adapter))
+ {
+ if (halbtcoutsrc_IsCsrBtCoex(pBtCoexist) == _TRUE)
+ EXhalbtc8821aCsr2ant_IpsNotify(pBtCoexist, ipsType);
+ else if (pBtCoexist->boardInfo.btdmAntNum == 2)
+ EXhalbtc8821a2ant_IpsNotify(pBtCoexist, ipsType);
+ else if (pBtCoexist->boardInfo.btdmAntNum == 1)
+ EXhalbtc8821a1ant_IpsNotify(pBtCoexist, ipsType);
+ }
+ else if (IS_HARDWARE_TYPE_8723B(pBtCoexist->Adapter))
+ {
+ if (pBtCoexist->boardInfo.btdmAntNum == 2)
+ EXhalbtc8723b2ant_IpsNotify(pBtCoexist, ipsType);
+ else if (pBtCoexist->boardInfo.btdmAntNum == 1)
+ EXhalbtc8723b1ant_IpsNotify(pBtCoexist, ipsType);
+ }
+ else if (IS_HARDWARE_TYPE_8703B(pBtCoexist->Adapter))
+ {
+ if (pBtCoexist->boardInfo.btdmAntNum == 2)
+ EXhalbtc8703b2ant_IpsNotify(pBtCoexist, ipsType);
+ else if (pBtCoexist->boardInfo.btdmAntNum == 1)
+ EXhalbtc8703b1ant_IpsNotify(pBtCoexist, ipsType);
+ }
+ else if (IS_HARDWARE_TYPE_8192E(pBtCoexist->Adapter))
+ {
+ if (pBtCoexist->boardInfo.btdmAntNum == 2)
+ EXhalbtc8192e2ant_IpsNotify(pBtCoexist, ipsType);
+ else if (pBtCoexist->boardInfo.btdmAntNum == 1)
+ EXhalbtc8192e1ant_IpsNotify(pBtCoexist, ipsType);
+ }
+ else if (IS_HARDWARE_TYPE_8812(pBtCoexist->Adapter))
+ {
+ if (pBtCoexist->boardInfo.btdmAntNum == 2)
+ EXhalbtc8812a2ant_IpsNotify(pBtCoexist, ipsType);
+ else if (pBtCoexist->boardInfo.btdmAntNum == 1)
+ EXhalbtc8812a1ant_IpsNotify(pBtCoexist, ipsType);
+ }
+
+// halbtcoutsrc_NormalLowPower(pBtCoexist);
+}
+
+void EXhalbtcoutsrc_LpsNotify(PBTC_COEXIST pBtCoexist, u8 type)
+{
+ u8 lpsType;
+
+
+ if (!halbtcoutsrc_IsBtCoexistAvailable(pBtCoexist))
+ return;
+
+ pBtCoexist->statistics.cntLpsNotify++;
+ if (pBtCoexist->bManualControl)
+ return;
+
+ if (PS_MODE_ACTIVE == type)
+ {
+ lpsType = BTC_LPS_DISABLE;
+ GLBtcWiFiInLPS = _FALSE;
+ }
+ else
+ {
+ lpsType = BTC_LPS_ENABLE;
+ GLBtcWiFiInLPS = _TRUE;
+ }
+
+ if (IS_HARDWARE_TYPE_8821(pBtCoexist->Adapter))
+ {
+ if (halbtcoutsrc_IsCsrBtCoex(pBtCoexist) == _TRUE)
+ EXhalbtc8821aCsr2ant_LpsNotify(pBtCoexist, lpsType);
+ else if (pBtCoexist->boardInfo.btdmAntNum == 2)
+ EXhalbtc8821a2ant_LpsNotify(pBtCoexist, lpsType);
+ else if (pBtCoexist->boardInfo.btdmAntNum == 1)
+ EXhalbtc8821a1ant_LpsNotify(pBtCoexist, lpsType);
+ }
+ else if (IS_HARDWARE_TYPE_8723B(pBtCoexist->Adapter))
+ {
+ if (pBtCoexist->boardInfo.btdmAntNum == 2)
+ EXhalbtc8723b2ant_LpsNotify(pBtCoexist, lpsType);
+ else if (pBtCoexist->boardInfo.btdmAntNum == 1)
+ EXhalbtc8723b1ant_LpsNotify(pBtCoexist, lpsType);
+ }
+ else if (IS_HARDWARE_TYPE_8703B(pBtCoexist->Adapter))
+ {
+ if (pBtCoexist->boardInfo.btdmAntNum == 2)
+ EXhalbtc8703b2ant_LpsNotify(pBtCoexist, lpsType);
+ else if (pBtCoexist->boardInfo.btdmAntNum == 1)
+ EXhalbtc8703b1ant_LpsNotify(pBtCoexist, lpsType);
+ }
+ else if (IS_HARDWARE_TYPE_8192E(pBtCoexist->Adapter))
+ {
+ if (pBtCoexist->boardInfo.btdmAntNum == 2)
+ EXhalbtc8192e2ant_LpsNotify(pBtCoexist, lpsType);
+ else if (pBtCoexist->boardInfo.btdmAntNum == 1)
+ EXhalbtc8192e1ant_LpsNotify(pBtCoexist, lpsType);
+ }
+ else if (IS_HARDWARE_TYPE_8812(pBtCoexist->Adapter))
+ {
+ if (pBtCoexist->boardInfo.btdmAntNum == 2)
+ EXhalbtc8812a2ant_LpsNotify(pBtCoexist, lpsType);
+ else if (pBtCoexist->boardInfo.btdmAntNum == 1)
+ EXhalbtc8812a1ant_LpsNotify(pBtCoexist, lpsType);
+ }
+}
+
+void EXhalbtcoutsrc_ScanNotify(PBTC_COEXIST pBtCoexist, u8 type)
+{
+ u8 scanType;
+
+ if (!halbtcoutsrc_IsBtCoexistAvailable(pBtCoexist))
+ return;
+ pBtCoexist->statistics.cntScanNotify++;
+ if (pBtCoexist->bManualControl)
+ return;
+
+ if (type)
+ {
+ scanType = BTC_SCAN_START;
+ GLBtcWiFiInScanState = _TRUE;
+ }
+ else
+ {
+ scanType = BTC_SCAN_FINISH;
+ GLBtcWiFiInScanState = _FALSE;
+ }
+
+ // All notify is called in cmd thread, don't need to leave low power again
+// halbtcoutsrc_LeaveLowPower(pBtCoexist);
+
+ if (IS_HARDWARE_TYPE_8821(pBtCoexist->Adapter))
+ {
+ if (halbtcoutsrc_IsCsrBtCoex(pBtCoexist) == _TRUE)
+ EXhalbtc8821aCsr2ant_ScanNotify(pBtCoexist, scanType);
+ else if (pBtCoexist->boardInfo.btdmAntNum == 2)
+ EXhalbtc8821a2ant_ScanNotify(pBtCoexist, scanType);
+ else if (pBtCoexist->boardInfo.btdmAntNum == 1)
+ EXhalbtc8821a1ant_ScanNotify(pBtCoexist, scanType);
+ }
+ else if (IS_HARDWARE_TYPE_8723B(pBtCoexist->Adapter))
+ {
+ if (pBtCoexist->boardInfo.btdmAntNum == 2)
+ EXhalbtc8723b2ant_ScanNotify(pBtCoexist, scanType);
+ else if (pBtCoexist->boardInfo.btdmAntNum == 1)
+ EXhalbtc8723b1ant_ScanNotify(pBtCoexist, scanType);
+ }
+ else if (IS_HARDWARE_TYPE_8703B(pBtCoexist->Adapter))
+ {
+ if (pBtCoexist->boardInfo.btdmAntNum == 2)
+ EXhalbtc8703b2ant_ScanNotify(pBtCoexist, scanType);
+ else if (pBtCoexist->boardInfo.btdmAntNum == 1)
+ EXhalbtc8703b1ant_ScanNotify(pBtCoexist, scanType);
+ }
+ else if (IS_HARDWARE_TYPE_8192E(pBtCoexist->Adapter))
+ {
+ if (pBtCoexist->boardInfo.btdmAntNum == 2)
+ EXhalbtc8192e2ant_ScanNotify(pBtCoexist, scanType);
+ else if (pBtCoexist->boardInfo.btdmAntNum == 1)
+ EXhalbtc8192e1ant_ScanNotify(pBtCoexist, scanType);
+ }
+ else if (IS_HARDWARE_TYPE_8812(pBtCoexist->Adapter))
+ {
+ if (pBtCoexist->boardInfo.btdmAntNum == 2)
+ EXhalbtc8812a2ant_ScanNotify(pBtCoexist, scanType);
+ else if (pBtCoexist->boardInfo.btdmAntNum == 1)
+ EXhalbtc8812a1ant_ScanNotify(pBtCoexist, scanType);
+ }
+
+// halbtcoutsrc_NormalLowPower(pBtCoexist);
+}
+
+void EXhalbtcoutsrc_ConnectNotify(PBTC_COEXIST pBtCoexist, u8 action)
+{
+ u8 assoType;
+
+ if (!halbtcoutsrc_IsBtCoexistAvailable(pBtCoexist))
+ return;
+ pBtCoexist->statistics.cntConnectNotify++;
+ if (pBtCoexist->bManualControl)
+ return;
+
+ if (action)
+ assoType = BTC_ASSOCIATE_START;
+ else
+ assoType = BTC_ASSOCIATE_FINISH;
+
+ // All notify is called in cmd thread, don't need to leave low power again
+// halbtcoutsrc_LeaveLowPower(pBtCoexist);
+
+ if (IS_HARDWARE_TYPE_8821(pBtCoexist->Adapter))
+ {
+ if (halbtcoutsrc_IsCsrBtCoex(pBtCoexist) == _TRUE)
+ EXhalbtc8821aCsr2ant_ConnectNotify(pBtCoexist, assoType);
+ else if (pBtCoexist->boardInfo.btdmAntNum == 2)
+ EXhalbtc8821a2ant_ConnectNotify(pBtCoexist, assoType);
+ else if (pBtCoexist->boardInfo.btdmAntNum == 1)
+ EXhalbtc8821a1ant_ConnectNotify(pBtCoexist, assoType);
+ }
+ else if (IS_HARDWARE_TYPE_8723B(pBtCoexist->Adapter))
+ {
+ if (pBtCoexist->boardInfo.btdmAntNum == 2)
+ EXhalbtc8723b2ant_ConnectNotify(pBtCoexist, assoType);
+ else if (pBtCoexist->boardInfo.btdmAntNum == 1)
+ EXhalbtc8723b1ant_ConnectNotify(pBtCoexist, assoType);
+ }
+ else if (IS_HARDWARE_TYPE_8703B(pBtCoexist->Adapter))
+ {
+ if (pBtCoexist->boardInfo.btdmAntNum == 2)
+ EXhalbtc8703b2ant_ConnectNotify(pBtCoexist, assoType);
+ else if (pBtCoexist->boardInfo.btdmAntNum == 1)
+ EXhalbtc8703b1ant_ConnectNotify(pBtCoexist, assoType);
+ }
+ else if (IS_HARDWARE_TYPE_8192E(pBtCoexist->Adapter))
+ {
+ if (pBtCoexist->boardInfo.btdmAntNum == 2)
+ EXhalbtc8192e2ant_ConnectNotify(pBtCoexist, assoType);
+ else if (pBtCoexist->boardInfo.btdmAntNum == 1)
+ EXhalbtc8192e1ant_ConnectNotify(pBtCoexist, assoType);
+ }
+ else if (IS_HARDWARE_TYPE_8812(pBtCoexist->Adapter))
+ {
+ if (pBtCoexist->boardInfo.btdmAntNum == 2)
+ EXhalbtc8812a2ant_ConnectNotify(pBtCoexist, assoType);
+ else if (pBtCoexist->boardInfo.btdmAntNum == 1)
+ EXhalbtc8812a1ant_ConnectNotify(pBtCoexist, assoType);
+ }
+
+// halbtcoutsrc_NormalLowPower(pBtCoexist);
+}
+
+void EXhalbtcoutsrc_MediaStatusNotify(PBTC_COEXIST pBtCoexist, RT_MEDIA_STATUS mediaStatus)
+{
+ u8 mStatus;
+
+ if (!halbtcoutsrc_IsBtCoexistAvailable(pBtCoexist))
+ return;
+
+ pBtCoexist->statistics.cntMediaStatusNotify++;
+ if (pBtCoexist->bManualControl)
+ return;
+
+ if (RT_MEDIA_CONNECT == mediaStatus)
+ mStatus = BTC_MEDIA_CONNECT;
+ else
+ mStatus = BTC_MEDIA_DISCONNECT;
+
+ // All notify is called in cmd thread, don't need to leave low power again
+// halbtcoutsrc_LeaveLowPower(pBtCoexist);
+
+ if (IS_HARDWARE_TYPE_8821(pBtCoexist->Adapter))
+ {
+ if (halbtcoutsrc_IsCsrBtCoex(pBtCoexist) == _TRUE)
+ EXhalbtc8821aCsr2ant_MediaStatusNotify(pBtCoexist, mStatus);
+ else if (pBtCoexist->boardInfo.btdmAntNum == 2)
+ EXhalbtc8821a2ant_MediaStatusNotify(pBtCoexist, mStatus);
+ else if (pBtCoexist->boardInfo.btdmAntNum == 1)
+ EXhalbtc8821a1ant_MediaStatusNotify(pBtCoexist, mStatus);
+ }
+ else if (IS_HARDWARE_TYPE_8723B(pBtCoexist->Adapter))
+ {
+ if (pBtCoexist->boardInfo.btdmAntNum == 2)
+ EXhalbtc8723b2ant_MediaStatusNotify(pBtCoexist, mStatus);
+ else if (pBtCoexist->boardInfo.btdmAntNum == 1)
+ EXhalbtc8723b1ant_MediaStatusNotify(pBtCoexist, mStatus);
+ }
+ else if (IS_HARDWARE_TYPE_8703B(pBtCoexist->Adapter))
+ {
+ if (pBtCoexist->boardInfo.btdmAntNum == 2)
+ EXhalbtc8703b2ant_MediaStatusNotify(pBtCoexist, mStatus);
+ else if (pBtCoexist->boardInfo.btdmAntNum == 1)
+ EXhalbtc8703b1ant_MediaStatusNotify(pBtCoexist, mStatus);
+ }
+ else if (IS_HARDWARE_TYPE_8192E(pBtCoexist->Adapter))
+ {
+ if (pBtCoexist->boardInfo.btdmAntNum == 2)
+ EXhalbtc8192e2ant_MediaStatusNotify(pBtCoexist, mStatus);
+ else if (pBtCoexist->boardInfo.btdmAntNum == 1)
+ EXhalbtc8192e1ant_MediaStatusNotify(pBtCoexist, mStatus);
+ }
+ else if (IS_HARDWARE_TYPE_8812(pBtCoexist->Adapter))
+ {
+ if (pBtCoexist->boardInfo.btdmAntNum == 2)
+ EXhalbtc8812a2ant_MediaStatusNotify(pBtCoexist, mStatus);
+ else if (pBtCoexist->boardInfo.btdmAntNum == 1)
+ EXhalbtc8812a1ant_MediaStatusNotify(pBtCoexist, mStatus);
+ }
+
+// halbtcoutsrc_NormalLowPower(pBtCoexist);
+}
+
+void EXhalbtcoutsrc_SpecialPacketNotify(PBTC_COEXIST pBtCoexist, u8 pktType)
+{
+ u8 packetType;
+
+ if (!halbtcoutsrc_IsBtCoexistAvailable(pBtCoexist))
+ return;
+ pBtCoexist->statistics.cntSpecialPacketNotify++;
+ if (pBtCoexist->bManualControl)
+ return;
+
+ if (PACKET_DHCP == pktType)
+ packetType = BTC_PACKET_DHCP;
+ else if (PACKET_EAPOL == pktType)
+ packetType = BTC_PACKET_EAPOL;
+ else if (PACKET_ARP == pktType)
+ packetType = BTC_PACKET_ARP;
+ else
+ {
+ packetType = BTC_PACKET_UNKNOWN;
+ return;
+ }
+
+ // All notify is called in cmd thread, don't need to leave low power again
+// halbtcoutsrc_LeaveLowPower(pBtCoexist);
+
+ if (IS_HARDWARE_TYPE_8821(pBtCoexist->Adapter))
+ {
+ if (halbtcoutsrc_IsCsrBtCoex(pBtCoexist) == _TRUE)
+ EXhalbtc8821aCsr2ant_SpecialPacketNotify(pBtCoexist, packetType);
+ else if (pBtCoexist->boardInfo.btdmAntNum == 2)
+ EXhalbtc8821a2ant_SpecialPacketNotify(pBtCoexist, packetType);
+ else if (pBtCoexist->boardInfo.btdmAntNum == 1)
+ EXhalbtc8821a1ant_SpecialPacketNotify(pBtCoexist, packetType);
+ }
+ else if (IS_HARDWARE_TYPE_8723B(pBtCoexist->Adapter))
+ {
+ if (pBtCoexist->boardInfo.btdmAntNum == 2)
+ EXhalbtc8723b2ant_SpecialPacketNotify(pBtCoexist, packetType);
+ else if (pBtCoexist->boardInfo.btdmAntNum == 1)
+ EXhalbtc8723b1ant_SpecialPacketNotify(pBtCoexist, packetType);
+ }
+ else if (IS_HARDWARE_TYPE_8703B(pBtCoexist->Adapter))
+ {
+ if (pBtCoexist->boardInfo.btdmAntNum == 2)
+ EXhalbtc8703b2ant_SpecialPacketNotify(pBtCoexist, packetType);
+ else if (pBtCoexist->boardInfo.btdmAntNum == 1)
+ EXhalbtc8703b1ant_SpecialPacketNotify(pBtCoexist, packetType);
+ }
+ else if (IS_HARDWARE_TYPE_8192E(pBtCoexist->Adapter))
+ {
+ if (pBtCoexist->boardInfo.btdmAntNum == 2)
+ EXhalbtc8192e2ant_SpecialPacketNotify(pBtCoexist, packetType);
+ else if (pBtCoexist->boardInfo.btdmAntNum == 1)
+ EXhalbtc8192e1ant_SpecialPacketNotify(pBtCoexist, packetType);
+ }
+ else if (IS_HARDWARE_TYPE_8812(pBtCoexist->Adapter))
+ {
+ if (pBtCoexist->boardInfo.btdmAntNum == 2)
+ EXhalbtc8812a2ant_SpecialPacketNotify(pBtCoexist, packetType);
+ else if (pBtCoexist->boardInfo.btdmAntNum == 1)
+ EXhalbtc8812a1ant_SpecialPacketNotify(pBtCoexist, packetType);
+ }
+
+// halbtcoutsrc_NormalLowPower(pBtCoexist);
+}
+
+void EXhalbtcoutsrc_BtInfoNotify(PBTC_COEXIST pBtCoexist, u8 *tmpBuf, u8 length)
+{
+ if (!halbtcoutsrc_IsBtCoexistAvailable(pBtCoexist))
+ return;
+
+ pBtCoexist->statistics.cntBtInfoNotify++;
+
+ // All notify is called in cmd thread, don't need to leave low power again
+// halbtcoutsrc_LeaveLowPower(pBtCoexist);
+
+ if (IS_HARDWARE_TYPE_8821(pBtCoexist->Adapter))
+ {
+ if (halbtcoutsrc_IsCsrBtCoex(pBtCoexist) == _TRUE)
+ EXhalbtc8821aCsr2ant_BtInfoNotify(pBtCoexist, tmpBuf, length);
+ else if (pBtCoexist->boardInfo.btdmAntNum == 2)
+ EXhalbtc8821a2ant_BtInfoNotify(pBtCoexist, tmpBuf, length);
+ else if (pBtCoexist->boardInfo.btdmAntNum == 1)
+ EXhalbtc8821a1ant_BtInfoNotify(pBtCoexist, tmpBuf, length);
+ }
+ else if (IS_HARDWARE_TYPE_8723B(pBtCoexist->Adapter))
+ {
+ if (pBtCoexist->boardInfo.btdmAntNum == 2)
+ EXhalbtc8723b2ant_BtInfoNotify(pBtCoexist, tmpBuf, length);
+ else if (pBtCoexist->boardInfo.btdmAntNum == 1)
+ EXhalbtc8723b1ant_BtInfoNotify(pBtCoexist, tmpBuf, length);
+ }
+ else if (IS_HARDWARE_TYPE_8703B(pBtCoexist->Adapter))
+ {
+ if (pBtCoexist->boardInfo.btdmAntNum == 2)
+ EXhalbtc8703b2ant_BtInfoNotify(pBtCoexist, tmpBuf, length);
+ else if (pBtCoexist->boardInfo.btdmAntNum == 1)
+ EXhalbtc8703b1ant_BtInfoNotify(pBtCoexist, tmpBuf, length);
+ }
+ else if (IS_HARDWARE_TYPE_8192E(pBtCoexist->Adapter))
+ {
+ if (pBtCoexist->boardInfo.btdmAntNum == 2)
+ EXhalbtc8192e2ant_BtInfoNotify(pBtCoexist, tmpBuf, length);
+ else if (pBtCoexist->boardInfo.btdmAntNum == 1)
+ EXhalbtc8192e1ant_BtInfoNotify(pBtCoexist, tmpBuf, length);
+ }
+ else if (IS_HARDWARE_TYPE_8812(pBtCoexist->Adapter))
+ {
+ if (pBtCoexist->boardInfo.btdmAntNum == 2)
+ EXhalbtc8812a2ant_BtInfoNotify(pBtCoexist, tmpBuf, length);
+ else if (pBtCoexist->boardInfo.btdmAntNum == 1)
+ EXhalbtc8812a1ant_BtInfoNotify(pBtCoexist, tmpBuf, length);
+ }
+
+// halbtcoutsrc_NormalLowPower(pBtCoexist);
+}
+
+VOID
+EXhalbtcoutsrc_RfStatusNotify(
+ IN PBTC_COEXIST pBtCoexist,
+ IN u1Byte type
+ )
+{
+ if(!halbtcoutsrc_IsBtCoexistAvailable(pBtCoexist))
+ return;
+ pBtCoexist->statistics.cntRfStatusNotify++;
+
+ if(IS_HARDWARE_TYPE_8821(pBtCoexist->Adapter))
+ {
+ }
+ else if(IS_HARDWARE_TYPE_8723B(pBtCoexist->Adapter))
+ {
+ if(pBtCoexist->boardInfo.btdmAntNum == 1)
+ EXhalbtc8723b1ant_RfStatusNotify(pBtCoexist, type);
+ }
+ else if(IS_HARDWARE_TYPE_8703B(pBtCoexist->Adapter))
+ {
+ if(pBtCoexist->boardInfo.btdmAntNum == 1)
+ EXhalbtc8703b1ant_RfStatusNotify(pBtCoexist, type);
+ }
+ else if(IS_HARDWARE_TYPE_8192E(pBtCoexist->Adapter))
+ {
+ }
+ else if(IS_HARDWARE_TYPE_8812(pBtCoexist->Adapter))
+ {
+ }
+}
+
+void EXhalbtcoutsrc_StackOperationNotify(PBTC_COEXIST pBtCoexist, u8 type)
+{
+#if 0
+ u8 stackOpType;
+
+ if (!halbtcoutsrc_IsBtCoexistAvailable(pBtCoexist))
+ return;
+ pBtCoexist->statistics.cntStackOperationNotify++;
+ if (pBtCoexist->bManualControl)
+ return;
+
+ if ((HCI_BT_OP_INQUIRY_START == type) ||
+ (HCI_BT_OP_PAGING_START == type) ||
+ (HCI_BT_OP_PAIRING_START == type))
+ {
+ stackOpType = BTC_STACK_OP_INQ_PAGE_PAIR_START;
+ }
+ else if ((HCI_BT_OP_INQUIRY_FINISH == type) ||
+ (HCI_BT_OP_PAGING_SUCCESS == type) ||
+ (HCI_BT_OP_PAGING_UNSUCCESS == type) ||
+ (HCI_BT_OP_PAIRING_FINISH == type) )
+ {
+ stackOpType = BTC_STACK_OP_INQ_PAGE_PAIR_FINISH;
+ }
+ else
+ {
+ stackOpType = BTC_STACK_OP_NONE;
+ }
+
+#endif
+}
+
+void EXhalbtcoutsrc_HaltNotify(PBTC_COEXIST pBtCoexist)
+{
+ if (!halbtcoutsrc_IsBtCoexistAvailable(pBtCoexist))
+ return;
+
+ if (IS_HARDWARE_TYPE_8821(pBtCoexist->Adapter))
+ {
+ if (halbtcoutsrc_IsCsrBtCoex(pBtCoexist) == _TRUE)
+ EXhalbtc8821aCsr2ant_HaltNotify(pBtCoexist);
+ else if (pBtCoexist->boardInfo.btdmAntNum == 2)
+ EXhalbtc8821a2ant_HaltNotify(pBtCoexist);
+ else if (pBtCoexist->boardInfo.btdmAntNum == 1)
+ EXhalbtc8821a1ant_HaltNotify(pBtCoexist);
+ }
+ else if (IS_HARDWARE_TYPE_8723B(pBtCoexist->Adapter))
+ {
+ if (pBtCoexist->boardInfo.btdmAntNum == 2)
+ EXhalbtc8723b2ant_HaltNotify(pBtCoexist);
+ else if (pBtCoexist->boardInfo.btdmAntNum == 1)
+ EXhalbtc8723b1ant_HaltNotify(pBtCoexist);
+ }
+ else if (IS_HARDWARE_TYPE_8703B(pBtCoexist->Adapter))
+ {
+ if (pBtCoexist->boardInfo.btdmAntNum == 2)
+ EXhalbtc8703b2ant_HaltNotify(pBtCoexist);
+ else if (pBtCoexist->boardInfo.btdmAntNum == 1)
+ EXhalbtc8703b1ant_HaltNotify(pBtCoexist);
+ }
+ else if (IS_HARDWARE_TYPE_8192E(pBtCoexist->Adapter))
+ {
+ if (pBtCoexist->boardInfo.btdmAntNum == 2)
+ EXhalbtc8192e2ant_HaltNotify(pBtCoexist);
+ else if (pBtCoexist->boardInfo.btdmAntNum == 1)
+ EXhalbtc8192e1ant_HaltNotify(pBtCoexist);
+ }
+ else if (IS_HARDWARE_TYPE_8812(pBtCoexist->Adapter))
+ {
+ if (pBtCoexist->boardInfo.btdmAntNum == 2)
+ EXhalbtc8812a2ant_HaltNotify(pBtCoexist);
+ else if (pBtCoexist->boardInfo.btdmAntNum == 1)
+ EXhalbtc8812a1ant_HaltNotify(pBtCoexist);
+ }
+
+ pBtCoexist->bBinded = FALSE;
+}
+
+void EXhalbtcoutsrc_SwitchBtTRxMask(PBTC_COEXIST pBtCoexist)
+{
+ if (IS_HARDWARE_TYPE_8723B(pBtCoexist->Adapter))
+ {
+ if (pBtCoexist->boardInfo.btdmAntNum == 2)
+ {
+ halbtcoutsrc_SetBtReg(pBtCoexist, 0, 0x3c, 0x01); //BT goto standby while GNT_BT 1-->0
+ }
+ else if (pBtCoexist->boardInfo.btdmAntNum == 1)
+ {
+ halbtcoutsrc_SetBtReg(pBtCoexist, 0, 0x3c, 0x15); //BT goto standby while GNT_BT 1-->0
+ }
+ }
+}
+
+void EXhalbtcoutsrc_PnpNotify(PBTC_COEXIST pBtCoexist, u8 pnpState)
+{
+ if (!halbtcoutsrc_IsBtCoexistAvailable(pBtCoexist))
+ return;
+
+ //
+ // currently only 1ant we have to do the notification,
+ // once pnp is notified to sleep state, we have to leave LPS that we can sleep normally.
+ //
+
+ if (IS_HARDWARE_TYPE_8723B(pBtCoexist->Adapter))
+ {
+ if (pBtCoexist->boardInfo.btdmAntNum == 1)
+ EXhalbtc8723b1ant_PnpNotify(pBtCoexist,pnpState);
+ else if(pBtCoexist->boardInfo.btdmAntNum == 2)
+ EXhalbtc8723b2ant_PnpNotify(pBtCoexist,pnpState);
+ }
+ else if (IS_HARDWARE_TYPE_8703B(pBtCoexist->Adapter))
+ {
+ if (pBtCoexist->boardInfo.btdmAntNum == 1)
+ EXhalbtc8703b1ant_PnpNotify(pBtCoexist,pnpState);
+ else if(pBtCoexist->boardInfo.btdmAntNum == 2)
+ EXhalbtc8703b2ant_PnpNotify(pBtCoexist,pnpState);
+ }
+ else if (IS_HARDWARE_TYPE_8821(pBtCoexist->Adapter))
+ {
+ if (halbtcoutsrc_IsCsrBtCoex(pBtCoexist) == _TRUE)
+ EXhalbtc8821aCsr2ant_PnpNotify(pBtCoexist, pnpState);
+ else if (pBtCoexist->boardInfo.btdmAntNum == 1)
+ EXhalbtc8821a1ant_PnpNotify(pBtCoexist,pnpState);
+ else if(pBtCoexist->boardInfo.btdmAntNum == 2)
+ EXhalbtc8821a2ant_PnpNotify(pBtCoexist,pnpState);
+ }
+ else if (IS_HARDWARE_TYPE_8192E(pBtCoexist->Adapter))
+ {
+ if (pBtCoexist->boardInfo.btdmAntNum == 1)
+ EXhalbtc8192e1ant_PnpNotify(pBtCoexist, pnpState);
+ }
+ else if (IS_HARDWARE_TYPE_8812(pBtCoexist->Adapter))
+ {
+ if (pBtCoexist->boardInfo.btdmAntNum == 1)
+ EXhalbtc8812a1ant_PnpNotify(pBtCoexist, pnpState);
+ }
+}
+
+void EXhalbtcoutsrc_ScoreBoardStatusNotify(PBTC_COEXIST pBtCoexist, u8 *tmpBuf, u8 length)
+{
+ if (IS_HARDWARE_TYPE_8703B(pBtCoexist->Adapter)) {
+ if (pBtCoexist->boardInfo.btdmAntNum == 1)
+ EXhalbtc8703b1ant_ScoreBoardStatusNotify(pBtCoexist, tmpBuf, length);
+ }
+}
+
+void EXhalbtcoutsrc_CoexDmSwitch(PBTC_COEXIST pBtCoexist)
+{
+ if (!halbtcoutsrc_IsBtCoexistAvailable(pBtCoexist))
+ return;
+ pBtCoexist->statistics.cntCoexDmSwitch++;
+
+ halbtcoutsrc_LeaveLowPower(pBtCoexist);
+
+ if (IS_HARDWARE_TYPE_8723B(pBtCoexist->Adapter))
+ {
+ if (pBtCoexist->boardInfo.btdmAntNum == 1)
+ {
+ pBtCoexist->bStopCoexDm = TRUE;
+ EXhalbtc8723b1ant_CoexDmReset(pBtCoexist);
+ EXhalbtcoutsrc_SetAntNum(BT_COEX_ANT_TYPE_DETECTED, 2);
+ EXhalbtc8723b2ant_InitHwConfig(pBtCoexist, FALSE);
+ EXhalbtc8723b2ant_InitCoexDm(pBtCoexist);
+ pBtCoexist->bStopCoexDm = FALSE;
+ }
+ }
+
+ halbtcoutsrc_NormalLowPower(pBtCoexist);
+}
+
+void EXhalbtcoutsrc_Periodical(PBTC_COEXIST pBtCoexist)
+{
+ if (!halbtcoutsrc_IsBtCoexistAvailable(pBtCoexist))
+ return;
+ pBtCoexist->statistics.cntPeriodical++;
+
+ // Periodical should be called in cmd thread,
+ // don't need to leave low power again
+// halbtcoutsrc_LeaveLowPower(pBtCoexist);
+
+ if (IS_HARDWARE_TYPE_8821(pBtCoexist->Adapter))
+ {
+ if (halbtcoutsrc_IsCsrBtCoex(pBtCoexist) == _TRUE)
+ EXhalbtc8821aCsr2ant_Periodical(pBtCoexist);
+ else if (pBtCoexist->boardInfo.btdmAntNum == 2)
+ EXhalbtc8821a2ant_Periodical(pBtCoexist);
+ else if (pBtCoexist->boardInfo.btdmAntNum == 1)
+ {
+ if (!halbtcoutsrc_UnderIps(pBtCoexist))
+ {
+ EXhalbtc8821a1ant_Periodical(pBtCoexist);
+ }
+ }
+ }
+ else if (IS_HARDWARE_TYPE_8723B(pBtCoexist->Adapter))
+ {
+ if (pBtCoexist->boardInfo.btdmAntNum == 2)
+ EXhalbtc8723b2ant_Periodical(pBtCoexist);
+ else if (pBtCoexist->boardInfo.btdmAntNum == 1)
+ EXhalbtc8723b1ant_Periodical(pBtCoexist);
+ }
+ else if (IS_HARDWARE_TYPE_8703B(pBtCoexist->Adapter))
+ {
+ if (pBtCoexist->boardInfo.btdmAntNum == 2)
+ EXhalbtc8703b2ant_Periodical(pBtCoexist);
+ else if (pBtCoexist->boardInfo.btdmAntNum == 1)
+ EXhalbtc8703b1ant_Periodical(pBtCoexist);
+ }
+ else if (IS_HARDWARE_TYPE_8192E(pBtCoexist->Adapter))
+ {
+ if (pBtCoexist->boardInfo.btdmAntNum == 2)
+ EXhalbtc8192e2ant_Periodical(pBtCoexist);
+ else if (pBtCoexist->boardInfo.btdmAntNum == 1)
+ EXhalbtc8192e1ant_Periodical(pBtCoexist);
+ }
+ else if (IS_HARDWARE_TYPE_8812(pBtCoexist->Adapter))
+ {
+ if (pBtCoexist->boardInfo.btdmAntNum == 2)
+ EXhalbtc8812a2ant_Periodical(pBtCoexist);
+ else if (pBtCoexist->boardInfo.btdmAntNum == 1)
+ EXhalbtc8812a1ant_Periodical(pBtCoexist);
+ }
+
+// halbtcoutsrc_NormalLowPower(pBtCoexist);
+}
+
+void EXhalbtcoutsrc_DbgControl(PBTC_COEXIST pBtCoexist, u8 opCode, u8 opLen, u8 *pData)
+{
+ if (!halbtcoutsrc_IsBtCoexistAvailable(pBtCoexist))
+ return;
+
+ pBtCoexist->statistics.cntDbgCtrl++;
+
+ // This function doesn't be called yet,
+ // default no need to leave low power to avoid deadlock
+// halbtcoutsrc_LeaveLowPower(pBtCoexist);
+
+ if (IS_HARDWARE_TYPE_8192E(pBtCoexist->Adapter))
+ {
+ if (pBtCoexist->boardInfo.btdmAntNum == 1)
+ EXhalbtc8192e1ant_DbgControl(pBtCoexist, opCode, opLen, pData);
+ }
+ else if (IS_HARDWARE_TYPE_8812(pBtCoexist->Adapter))
+ {
+ if (pBtCoexist->boardInfo.btdmAntNum == 2)
+ EXhalbtc8812a2ant_DbgControl(pBtCoexist, opCode, opLen, pData);
+ else if (pBtCoexist->boardInfo.btdmAntNum == 1)
+ EXhalbtc8812a1ant_DbgControl(pBtCoexist, opCode, opLen, pData);
+ }
+
+// halbtcoutsrc_NormalLowPower(pBtCoexist);
+}
+
+#if 0
+VOID
+EXhalbtcoutsrc_AntennaDetection(
+ IN PBTC_COEXIST pBtCoexist,
+ IN u4Byte centFreq,
+ IN u4Byte offset,
+ IN u4Byte span,
+ IN u4Byte seconds
+ )
+{
+ if(!halbtcoutsrc_IsBtCoexistAvailable(pBtCoexist))
+ return;
+
+ /* Need to refine the following power save operations to enable this function in the future */
+#if 0
+ IPSDisable(pBtCoexist->Adapter, FALSE, 0);
+ LeisurePSLeave(pBtCoexist->Adapter, LPS_DISABLE_BT_COEX);
+#endif
+
+ if(IS_HARDWARE_TYPE_8723B(pBtCoexist->Adapter))
+ {
+ if(pBtCoexist->boardInfo.btdmAntNum == 1)
+ EXhalbtc8723b1ant_AntennaDetection(pBtCoexist, centFreq, offset, span, seconds);
+ }
+
+ //IPSReturn(pBtCoexist->Adapter, 0xff);
+}
+#endif
+
+void EXhalbtcoutsrc_StackUpdateProfileInfo(void)
+{
+#ifdef CONFIG_BT_COEXIST_SOCKET_TRX
+ PBTC_COEXIST pBtCoexist = &GLBtCoexist;
+ PADAPTER padapter = (PADAPTER)GLBtCoexist.Adapter;
+ PBT_MGNT pBtMgnt = &padapter->coex_info.BtMgnt;
+ u8 i;
+
+ if (!halbtcoutsrc_IsBtCoexistAvailable(pBtCoexist))
+ return;
+
+ pBtCoexist->stackInfo.bProfileNotified = _TRUE;
+
+ pBtCoexist->stackInfo.numOfLink =
+ pBtMgnt->ExtConfig.NumberOfACL+pBtMgnt->ExtConfig.NumberOfSCO;
+
+ // reset first
+ pBtCoexist->stackInfo.bBtLinkExist = _FALSE;
+ pBtCoexist->stackInfo.bScoExist = _FALSE;
+ pBtCoexist->stackInfo.bAclExist = _FALSE;
+ pBtCoexist->stackInfo.bA2dpExist = _FALSE;
+ pBtCoexist->stackInfo.bHidExist = _FALSE;
+ pBtCoexist->stackInfo.numOfHid = 0;
+ pBtCoexist->stackInfo.bPanExist = _FALSE;
+
+ if (!pBtMgnt->ExtConfig.NumberOfACL)
+ pBtCoexist->stackInfo.minBtRssi = 0;
+
+ if (pBtCoexist->stackInfo.numOfLink)
+ {
+ pBtCoexist->stackInfo.bBtLinkExist = _TRUE;
+ if (pBtMgnt->ExtConfig.NumberOfSCO)
+ pBtCoexist->stackInfo.bScoExist = _TRUE;
+ if (pBtMgnt->ExtConfig.NumberOfACL)
+ pBtCoexist->stackInfo.bAclExist = _TRUE;
+ }
+
+ for (i=0; i<pBtMgnt->ExtConfig.NumberOfACL; i++)
+ {
+ if (BT_PROFILE_A2DP == pBtMgnt->ExtConfig.aclLink[i].BTProfile)
+ {
+ pBtCoexist->stackInfo.bA2dpExist = _TRUE;
+ }
+ else if (BT_PROFILE_PAN == pBtMgnt->ExtConfig.aclLink[i].BTProfile)
+ {
+ pBtCoexist->stackInfo.bPanExist = _TRUE;
+ }
+ else if (BT_PROFILE_HID == pBtMgnt->ExtConfig.aclLink[i].BTProfile)
+ {
+ pBtCoexist->stackInfo.bHidExist = _TRUE;
+ pBtCoexist->stackInfo.numOfHid++;
+ }
+ else
+ {
+ pBtCoexist->stackInfo.bUnknownAclExist = _TRUE;
+ }
+ }
+#endif //CONFIG_BT_COEXIST_SOCKET_TRX
+}
+
+void EXhalbtcoutsrc_UpdateMinBtRssi(s8 btRssi)
+{
+ PBTC_COEXIST pBtCoexist = &GLBtCoexist;
+
+ if (!halbtcoutsrc_IsBtCoexistAvailable(pBtCoexist))
+ return;
+
+ pBtCoexist->stackInfo.minBtRssi = btRssi;
+}
+
+void EXhalbtcoutsrc_SetHciVersion(u16 hciVersion)
+{
+ PBTC_COEXIST pBtCoexist = &GLBtCoexist;
+
+ if (!halbtcoutsrc_IsBtCoexistAvailable(pBtCoexist))
+ return;
+
+ pBtCoexist->stackInfo.hciVersion = hciVersion;
+}
+
+void EXhalbtcoutsrc_SetBtPatchVersion(u16 btHciVersion, u16 btPatchVersion)
+{
+ PBTC_COEXIST pBtCoexist = &GLBtCoexist;
+
+ if (!halbtcoutsrc_IsBtCoexistAvailable(pBtCoexist))
+ return;
+
+ pBtCoexist->btInfo.btRealFwVer = btPatchVersion;
+ pBtCoexist->btInfo.btHciVer = btHciVersion;
+}
+
+#if 0
+void EXhalbtcoutsrc_SetBtExist(u8 bBtExist)
+{
+ GLBtCoexist.boardInfo.bBtExist = bBtExist;
+}
+#endif
+void EXhalbtcoutsrc_SetChipType(u8 chipType)
+{
+ switch(chipType)
+ {
+ default:
+ case BT_2WIRE:
+ case BT_ISSC_3WIRE:
+ case BT_ACCEL:
+ case BT_RTL8756:
+ GLBtCoexist.boardInfo.btChipType = BTC_CHIP_UNDEF;
+ break;
+ case BT_CSR_BC4:
+ GLBtCoexist.boardInfo.btChipType = BTC_CHIP_CSR_BC4;
+ break;
+ case BT_CSR_BC8:
+ GLBtCoexist.boardInfo.btChipType = BTC_CHIP_CSR_BC8;
+ break;
+ case BT_RTL8723A:
+ GLBtCoexist.boardInfo.btChipType = BTC_CHIP_RTL8723A;
+ break;
+ case BT_RTL8821:
+ GLBtCoexist.boardInfo.btChipType = BTC_CHIP_RTL8821;
+ break;
+ case BT_RTL8723B:
+ GLBtCoexist.boardInfo.btChipType = BTC_CHIP_RTL8723B;
+ break;
+ }
+}
+
+void EXhalbtcoutsrc_SetAntNum(u8 type, u8 antNum)
+{
+ if (BT_COEX_ANT_TYPE_PG == type)
+ {
+ GLBtCoexist.boardInfo.pgAntNum = antNum;
+ GLBtCoexist.boardInfo.btdmAntNum = antNum;
+#if 0
+ //The antenna position: Main (default) or Aux for pgAntNum=2 && btdmAntNum =1
+ //The antenna position should be determined by auto-detect mechanism
+ // The following is assumed to main, and those must be modified if y auto-detect mechanism is ready
+ if ((GLBtCoexist.boardInfo.pgAntNum == 2) && (GLBtCoexist.boardInfo.btdmAntNum == 1) )
+ GLBtCoexist.boardInfo.btdmAntPos = BTC_ANTENNA_AT_MAIN_PORT;
+ else
+ GLBtCoexist.boardInfo.btdmAntPos = BTC_ANTENNA_AT_MAIN_PORT;
+#endif
+ }
+ else if (BT_COEX_ANT_TYPE_ANTDIV == type)
+ {
+ GLBtCoexist.boardInfo.btdmAntNum = antNum;
+ //GLBtCoexist.boardInfo.btdmAntPos = BTC_ANTENNA_AT_MAIN_PORT;
+ }
+ else if (BT_COEX_ANT_TYPE_DETECTED == type)
+ {
+ GLBtCoexist.boardInfo.btdmAntNum = antNum;
+ //GLBtCoexist.boardInfo.btdmAntPos = BTC_ANTENNA_AT_MAIN_PORT;
+ }
+}
+
+//
+// Currently used by 8723b only, S0 or S1
+//
+void EXhalbtcoutsrc_SetSingleAntPath(u8 singleAntPath)
+{
+ GLBtCoexist.boardInfo.singleAntPath = singleAntPath;
+}
+
+void EXhalbtcoutsrc_DisplayBtCoexInfo(PBTC_COEXIST pBtCoexist)
+{
+ if (!halbtcoutsrc_IsBtCoexistAvailable(pBtCoexist))
+ return;
+
+ halbtcoutsrc_LeaveLowPower(pBtCoexist);
+
+ if (IS_HARDWARE_TYPE_8821(pBtCoexist->Adapter))
+ {
+ if (halbtcoutsrc_IsCsrBtCoex(pBtCoexist) == _TRUE)
+ EXhalbtc8821aCsr2ant_DisplayCoexInfo(pBtCoexist);
+ else if (pBtCoexist->boardInfo.btdmAntNum == 2)
+ EXhalbtc8821a2ant_DisplayCoexInfo(pBtCoexist);
+ else if (pBtCoexist->boardInfo.btdmAntNum == 1)
+ EXhalbtc8821a1ant_DisplayCoexInfo(pBtCoexist);
+ }
+ else if (IS_HARDWARE_TYPE_8723B(pBtCoexist->Adapter))
+ {
+ if (pBtCoexist->boardInfo.btdmAntNum == 2)
+ EXhalbtc8723b2ant_DisplayCoexInfo(pBtCoexist);
+ else if (pBtCoexist->boardInfo.btdmAntNum == 1)
+ EXhalbtc8723b1ant_DisplayCoexInfo(pBtCoexist);
+ }
+ else if (IS_HARDWARE_TYPE_8703B(pBtCoexist->Adapter))
+ {
+ if (pBtCoexist->boardInfo.btdmAntNum == 2)
+ EXhalbtc8703b2ant_DisplayCoexInfo(pBtCoexist);
+ else if (pBtCoexist->boardInfo.btdmAntNum == 1)
+ EXhalbtc8703b1ant_DisplayCoexInfo(pBtCoexist);
+ }
+ else if (IS_HARDWARE_TYPE_8192E(pBtCoexist->Adapter))
+ {
+ if (pBtCoexist->boardInfo.btdmAntNum == 2)
+ EXhalbtc8192e2ant_DisplayCoexInfo(pBtCoexist);
+ else if (pBtCoexist->boardInfo.btdmAntNum == 1)
+ EXhalbtc8192e1ant_DisplayCoexInfo(pBtCoexist);
+ }
+ else if (IS_HARDWARE_TYPE_8812(pBtCoexist->Adapter))
+ {
+ if (pBtCoexist->boardInfo.btdmAntNum == 2)
+ EXhalbtc8812a2ant_DisplayCoexInfo(pBtCoexist);
+ else if (pBtCoexist->boardInfo.btdmAntNum == 1)
+ EXhalbtc8812a1ant_DisplayCoexInfo(pBtCoexist);
+ }
+
+ halbtcoutsrc_NormalLowPower(pBtCoexist);
+}
+
+void EXhalbtcoutsrc_DisplayAntDetection(PBTC_COEXIST pBtCoexist)
+{
+ if(!halbtcoutsrc_IsBtCoexistAvailable(pBtCoexist))
+ return;
+
+ halbtcoutsrc_LeaveLowPower(pBtCoexist);
+
+ if(IS_HARDWARE_TYPE_8723B(pBtCoexist->Adapter))
+ {
+ if(pBtCoexist->boardInfo.btdmAntNum == 1)
+ EXhalbtc8723b1ant_DisplayAntDetection(pBtCoexist);
+ }
+
+ halbtcoutsrc_NormalLowPower(pBtCoexist);
+}
+
+void EXhalbtcoutsrc_BTOffOnNotify(PBTC_COEXIST pBtCoexist, u8 bBTON)
+{
+
+ if (IS_HARDWARE_TYPE_8812(pBtCoexist->Adapter)) {
+ if (pBtCoexist->boardInfo.btdmAntNum == 2)
+ EXhalbtc8812a2ant_BTOffOnNotify(pBtCoexist, (bBTON == _TRUE)?BTC_BT_ON:BTC_BT_OFF);
+ }
+
+}
+
+static void halbt_InitHwConfig92C(PADAPTER padapter)
+{
+ PHAL_DATA_TYPE pHalData;
+ u8 u1Tmp;
+
+
+ pHalData = GET_HAL_DATA(padapter);
+ if( (pHalData->bt_coexist.btChipType == BT_CSR_BC4) ||
+ (pHalData->bt_coexist.btChipType == BT_CSR_BC8))
+ {
+ if (pHalData->rf_type == RF_1T1R)
+ {
+ // Config to 1T1R
+ u1Tmp = rtw_read8(padapter, rOFDM0_TRxPathEnable);
+ u1Tmp &= ~BIT(1);
+ rtw_write8(padapter, rOFDM0_TRxPathEnable, u1Tmp);
+ RT_DISP(FBT, BT_TRACE, ("[BTCoex], BT write 0xC04 = 0x%x\n", u1Tmp));
+
+ u1Tmp = rtw_read8(padapter, rOFDM1_TRxPathEnable);
+ u1Tmp &= ~BIT(1);
+ rtw_write8(padapter, rOFDM1_TRxPathEnable, u1Tmp);
+ RT_DISP(FBT, BT_TRACE, ("[BTCoex], BT write 0xD04 = 0x%x\n", u1Tmp));
+ }
+ }
+}
+
+static void halbt_InitHwConfig92D(PADAPTER padapter)
+{
+ PHAL_DATA_TYPE pHalData;
+ u8 u1Tmp;
+
+ pHalData = GET_HAL_DATA(padapter);
+ if ((pHalData->bt_coexist.btChipType == BT_CSR_BC4) ||
+ (pHalData->bt_coexist.btChipType == BT_CSR_BC8))
+ {
+ if (pHalData->rf_type == RF_1T1R)
+ {
+ // Config to 1T1R
+ u1Tmp = rtw_read8(padapter, rOFDM0_TRxPathEnable);
+ u1Tmp &= ~BIT(1);
+ rtw_write8(padapter, rOFDM0_TRxPathEnable, u1Tmp);
+ RT_DISP(FBT, BT_TRACE, ("[BTCoex], BT write 0xC04 = 0x%x\n", u1Tmp));
+
+ u1Tmp = rtw_read8(padapter, rOFDM1_TRxPathEnable);
+ u1Tmp &= ~BIT(1);
+ rtw_write8(padapter, rOFDM1_TRxPathEnable, u1Tmp);
+ RT_DISP(FBT, BT_TRACE, ("[BTCoex], BT write 0xD04 = 0x%x\n", u1Tmp));
+ }
+ }
+}
+
+/*
+ * Description:
+ * Run BT-Coexist mechansim or not
+ *
+ */
+void hal_btcoex_SetBTCoexist(PADAPTER padapter, u8 bBtExist)
+{
+ PHAL_DATA_TYPE pHalData;
+
+
+ pHalData = GET_HAL_DATA(padapter);
+ pHalData->bt_coexist.bBtExist = bBtExist;
+
+ //EXhalbtcoutsrc_SetBtExist(bBtExist);
+}
+
+/*
+ * Dewcription:
+ * Check is co-exist mechanism enabled or not
+ *
+ * Return:
+ * _TRUE Enable BT co-exist mechanism
+ * _FALSE Disable BT co-exist mechanism
+ */
+u8 hal_btcoex_IsBtExist(PADAPTER padapter)
+{
+ PHAL_DATA_TYPE pHalData;
+
+
+ pHalData = GET_HAL_DATA(padapter);
+ return pHalData->bt_coexist.bBtExist;
+}
+
+u8 hal_btcoex_IsBtDisabled(PADAPTER padapter)
+{
+ if (!hal_btcoex_IsBtExist(padapter))
+ return _TRUE;
+
+ if (GLBtCoexist.btInfo.bBtDisabled)
+ return _TRUE;
+ else
+ return _FALSE;
+}
+
+void hal_btcoex_SetChipType(PADAPTER padapter, u8 chipType)
+{
+ PHAL_DATA_TYPE pHalData;
+
+
+ pHalData = GET_HAL_DATA(padapter);
+ pHalData->bt_coexist.btChipType = chipType;
+
+ EXhalbtcoutsrc_SetChipType(chipType);
+}
+
+u8 hal_btcoex_GetChipType(PADAPTER padapter)
+{
+ PHAL_DATA_TYPE pHalData;
+
+
+ pHalData = GET_HAL_DATA(padapter);
+ return pHalData->bt_coexist.btChipType;
+}
+
+void hal_btcoex_SetPgAntNum(PADAPTER padapter, u8 antNum)
+{
+ PHAL_DATA_TYPE pHalData;
+
+
+ pHalData = GET_HAL_DATA(padapter);
+
+ pHalData->bt_coexist.btTotalAntNum = antNum;
+ EXhalbtcoutsrc_SetAntNum(BT_COEX_ANT_TYPE_PG, antNum);
+}
+
+u8 hal_btcoex_GetPgAntNum(PADAPTER padapter)
+{
+ PHAL_DATA_TYPE pHalData;
+
+
+ pHalData = GET_HAL_DATA(padapter);
+
+ return pHalData->bt_coexist.btTotalAntNum;
+}
+
+void hal_btcoex_SetSingleAntPath(PADAPTER padapter, u8 singleAntPath)
+{
+ EXhalbtcoutsrc_SetSingleAntPath(singleAntPath);
+}
+
+u8 hal_btcoex_Initialize(PADAPTER padapter)
+{
+ u8 ret1;
+ u8 ret2;
+
+
+ _rtw_memset(&GLBtCoexist, 0, sizeof(GLBtCoexist));
+ ret1 = EXhalbtcoutsrc_InitlizeVariables((void*)padapter);
+ ret2 = (ret1==_TRUE) ? _TRUE : _FALSE;
+
+ return ret2;
+}
+
+void hal_btcoex_PowerOnSetting(PADAPTER padapter)
+{
+ EXhalbtcoutsrc_PowerOnSetting(&GLBtCoexist);
+}
+
+void hal_btcoex_PreLoadFirmware(PADAPTER padapter)
+{
+ EXhalbtcoutsrc_PreLoadFirmware(&GLBtCoexist);
+}
+
+void hal_btcoex_InitHwConfig(PADAPTER padapter, u8 bWifiOnly)
+{
+ if (!hal_btcoex_IsBtExist(padapter))
+ return;
+
+ EXhalbtcoutsrc_InitHwConfig(&GLBtCoexist, bWifiOnly);
+ EXhalbtcoutsrc_InitCoexDm(&GLBtCoexist);
+}
+
+void hal_btcoex_IpsNotify(PADAPTER padapter, u8 type)
+{
+ EXhalbtcoutsrc_IpsNotify(&GLBtCoexist, type);
+}
+
+void hal_btcoex_LpsNotify(PADAPTER padapter, u8 type)
+{
+ EXhalbtcoutsrc_LpsNotify(&GLBtCoexist, type);
+}
+
+void hal_btcoex_ScanNotify(PADAPTER padapter, u8 type)
+{
+ EXhalbtcoutsrc_ScanNotify(&GLBtCoexist, type);
+}
+
+void hal_btcoex_ConnectNotify(PADAPTER padapter, u8 action)
+{
+ EXhalbtcoutsrc_ConnectNotify(&GLBtCoexist, action);
+}
+
+void hal_btcoex_MediaStatusNotify(PADAPTER padapter, u8 mediaStatus)
+{
+ EXhalbtcoutsrc_MediaStatusNotify(&GLBtCoexist, mediaStatus);
+}
+
+void hal_btcoex_SpecialPacketNotify(PADAPTER padapter, u8 pktType)
+{
+ EXhalbtcoutsrc_SpecialPacketNotify(&GLBtCoexist, pktType);
+}
+
+void hal_btcoex_IQKNotify(PADAPTER padapter, u8 state)
+{
+ GLBtcWiFiInIQKState = state;
+}
+
+void hal_btcoex_BtInfoNotify(PADAPTER padapter, u8 length, u8 *tmpBuf)
+{
+ if (GLBtcWiFiInIQKState == _TRUE)
+ return;
+
+ EXhalbtcoutsrc_BtInfoNotify(&GLBtCoexist, tmpBuf, length);
+}
+
+void hal_btcoex_BtMpRptNotify(PADAPTER padapter, u8 length, u8 *tmpBuf)
+{
+ u8 extid, status, len, seq;
+
+
+ if (!GLBtcBtMpRptWait)
+ return;
+
+ if ((length < 3) || (!tmpBuf))
+ return;
+
+ extid = tmpBuf[0];
+ /* not response from BT FW then exit*/
+ switch (extid) {
+ case C2H_WIFI_FW_ACTIVE_RSP:
+ GLBtcBtMpRptWiFiOK = 1;
+ return;
+
+ case C2H_TRIG_BY_BT_FW:
+ _cancel_timer_ex(&GLBtcBtMpOperTimer);
+ GLBtcBtMpRptWait = 0;
+ GLBtcBtMpRptBTOK = 1;
+ break;
+
+ default:
+ return;
+ }
+
+ status = tmpBuf[1] & 0xF;
+ len = tmpBuf[1] >> 4;
+ seq = tmpBuf[2] >> 4;
+
+ GLBtcBtMpRptSeq = seq;
+ GLBtcBtMpRptStatus = status;
+ _rtw_memcpy(GLBtcBtMpRptRsp, tmpBuf+3, len);
+ GLBtcBtMpRptRspSize = len;
+ _rtw_up_sema(&GLBtcBtMpRptSema);
+}
+
+void hal_btcoex_SuspendNotify(PADAPTER padapter, u8 state)
+{
+ if (state == 1)
+ state = BTC_WIFI_PNP_SLEEP;
+ else
+ state = BTC_WIFI_PNP_WAKE_UP;
+
+ EXhalbtcoutsrc_PnpNotify(&GLBtCoexist, state);
+}
+
+void hal_btcoex_HaltNotify(PADAPTER padapter)
+{
+ EXhalbtcoutsrc_HaltNotify(&GLBtCoexist);
+}
+
+void hal_btcoex_ScoreBoardStatusNotify(PADAPTER padapter, u8 length, u8 *tmpBuf)
+{
+ EXhalbtcoutsrc_ScoreBoardStatusNotify(&GLBtCoexist, tmpBuf, length);
+}
+
+void hal_btcoex_SwitchBtTRxMask(PADAPTER padapter)
+{
+ EXhalbtcoutsrc_SwitchBtTRxMask(&GLBtCoexist);
+}
+
+void hal_btcoex_Hanlder(PADAPTER padapter)
+{
+ EXhalbtcoutsrc_Periodical(&GLBtCoexist);
+}
+
+s32 hal_btcoex_IsBTCoexRejectAMPDU(PADAPTER padapter)
+{
+ return (s32)GLBtCoexist.btInfo.bRejectAggPkt;
+}
+
+s32 hal_btcoex_IsBTCoexCtrlAMPDUSize(PADAPTER padapter)
+{
+ return (s32)GLBtCoexist.btInfo.bBtCtrlAggBufSize;
+}
+
+u32 hal_btcoex_GetAMPDUSize(PADAPTER padapter)
+{
+ return (u32)GLBtCoexist.btInfo.aggBufSize;
+}
+
+void hal_btcoex_SetManualControl(PADAPTER padapter, u8 bmanual)
+{
+ GLBtCoexist.bManualControl = bmanual;
+}
+
+u8 hal_btcoex_1Ant(PADAPTER padapter)
+{
+ if (hal_btcoex_IsBtExist(padapter) == _FALSE)
+ return _FALSE;
+
+ if (GLBtCoexist.boardInfo.btdmAntNum == 1)
+ return _TRUE;
+
+ return _FALSE;
+}
+
+u8 hal_btcoex_IsBtControlLps(PADAPTER padapter)
+{
+ if (hal_btcoex_IsBtExist(padapter) == _FALSE)
+ return _FALSE;
+
+ if (GLBtCoexist.btInfo.bBtDisabled)
+ return _FALSE;
+
+ if (GLBtCoexist.btInfo.bBtCtrlLps)
+ return _TRUE;
+
+ return _FALSE;
+}
+
+u8 hal_btcoex_IsLpsOn(PADAPTER padapter)
+{
+ if (hal_btcoex_IsBtExist(padapter) == _FALSE)
+ return _FALSE;
+
+ if (GLBtCoexist.btInfo.bBtDisabled)
+ return _FALSE;
+
+ if (GLBtCoexist.btInfo.bBtLpsOn)
+ return _TRUE;
+
+ return _FALSE;
+}
+
+u8 hal_btcoex_RpwmVal(PADAPTER padapter)
+{
+ return GLBtCoexist.btInfo.rpwmVal;
+}
+
+u8 hal_btcoex_LpsVal(PADAPTER padapter)
+{
+ return GLBtCoexist.btInfo.lpsVal;
+}
+
+u32 hal_btcoex_GetRaMask(PADAPTER padapter)
+{
+ if (!hal_btcoex_IsBtExist(padapter))
+ return 0;
+
+ if (GLBtCoexist.btInfo.bBtDisabled)
+ return 0;
+
+ /* Modify by YiWei , suggest by Cosa and Jenyu
+ * Remove the limit antenna number , because 2 antenna case (ex: 8192eu)also want to get BT coex report rate mask.
+ */
+ /*if (GLBtCoexist.boardInfo.btdmAntNum != 1)
+ return 0;*/
+
+ return GLBtCoexist.btInfo.raMask;
+}
+
+void hal_btcoex_RecordPwrMode(PADAPTER padapter, u8 *pCmdBuf, u8 cmdLen)
+{
+ RT_TRACE(COMP_COEX, DBG_LOUD, ("[BTCoex], FW write pwrModeCmd=0x%04x%08x\n",
+ pCmdBuf[0]<<8|pCmdBuf[1],
+ pCmdBuf[2]<<24|pCmdBuf[3]<<16|pCmdBuf[4]<<8|pCmdBuf[5]));
+
+ _rtw_memcpy(GLBtCoexist.pwrModeVal, pCmdBuf, cmdLen);
+}
+
+void hal_btcoex_DisplayBtCoexInfo(PADAPTER padapter, u8 *pbuf, u32 bufsize)
+{
+ PBTCDBGINFO pinfo;
+
+
+ pinfo = &GLBtcDbgInfo;
+ DBG_BT_INFO_INIT(pinfo, pbuf, bufsize);
+ EXhalbtcoutsrc_DisplayBtCoexInfo(&GLBtCoexist);
+ DBG_BT_INFO_INIT(pinfo, NULL, 0);
+}
+
+void hal_btcoex_SetDBG(PADAPTER padapter, u32 *pDbgModule)
+{
+ u32 i;
+
+
+ if (NULL == pDbgModule)
+ return;
+
+ for (i = 0; i < COMP_MAX; i++)
+ GLBtcDbgType[i] = pDbgModule[i];
+}
+
+u32 hal_btcoex_GetDBG(PADAPTER padapter, u8 *pStrBuf, u32 bufSize)
+{
+ s32 count;
+ u8 *pstr;
+ u32 leftSize;
+
+
+ if ((NULL == pStrBuf) || (0 == bufSize))
+ return 0;
+
+ count = 0;
+ pstr = pStrBuf;
+ leftSize = bufSize;
+// DBG_871X(FUNC_ADPT_FMT ": bufsize=%d\n", FUNC_ADPT_ARG(padapter), bufSize);
+
+ count = rtw_sprintf(pstr, leftSize, "#define DBG\t%d\n", DBG);
+ if ((count < 0) || (count >= leftSize))
+ goto exit;
+ pstr += count;
+ leftSize -= count;
+
+ count = rtw_sprintf(pstr, leftSize, "BTCOEX Debug Setting:\n");
+ if ((count < 0) || (count >= leftSize))
+ goto exit;
+ pstr += count;
+ leftSize -= count;
+
+ count = rtw_sprintf(pstr, leftSize,
+ "COMP_COEX: 0x%08X\n\n",
+ GLBtcDbgType[COMP_COEX]);
+ if ((count < 0) || (count >= leftSize))
+ goto exit;
+ pstr += count;
+ leftSize -= count;
+
+#if 0
+ count = rtw_sprintf(pstr, leftSize, "INTERFACE Debug Setting Definition:\n");
+ if ((count < 0) || (count >= leftSize))
+ goto exit;
+ pstr += count;
+ leftSize -= count;
+ count = rtw_sprintf(pstr, leftSize, "\tbit[0]=%d for INTF_INIT\n",
+ GLBtcDbgType[BTC_MSG_INTERFACE]&INTF_INIT?1:0);
+ if ((count < 0) || (count >= leftSize))
+ goto exit;
+ pstr += count;
+ leftSize -= count;
+ count = rtw_sprintf(pstr, leftSize, "\tbit[2]=%d for INTF_NOTIFY\n\n",
+ GLBtcDbgType[BTC_MSG_INTERFACE]&INTF_NOTIFY?1:0);
+ if ((count < 0) || (count >= leftSize))
+ goto exit;
+ pstr += count;
+ leftSize -= count;
+
+ count = rtw_sprintf(pstr, leftSize, "ALGORITHM Debug Setting Definition:\n");
+ if ((count < 0) || (count >= leftSize))
+ goto exit;
+ pstr += count;
+ leftSize -= count;
+ count = rtw_sprintf(pstr, leftSize, "\tbit[0]=%d for BT_RSSI_STATE\n",
+ GLBtcDbgType[BTC_MSG_ALGORITHM]&ALGO_BT_RSSI_STATE?1:0);
+ if ((count < 0) || (count >= leftSize))
+ goto exit;
+ pstr += count;
+ leftSize -= count;
+ count = rtw_sprintf(pstr, leftSize, "\tbit[1]=%d for WIFI_RSSI_STATE\n",
+ GLBtcDbgType[BTC_MSG_ALGORITHM]&ALGO_WIFI_RSSI_STATE?1:0);
+ if ((count < 0) || (count >= leftSize))
+ goto exit;
+ pstr += count;
+ leftSize -= count;
+ count = rtw_sprintf(pstr, leftSize, "\tbit[2]=%d for BT_MONITOR\n",
+ GLBtcDbgType[BTC_MSG_ALGORITHM]&ALGO_BT_MONITOR?1:0);
+ if ((count < 0) || (count >= leftSize))
+ goto exit;
+ pstr += count;
+ leftSize -= count;
+ count = rtw_sprintf(pstr, leftSize, "\tbit[3]=%d for TRACE\n",
+ GLBtcDbgType[BTC_MSG_ALGORITHM]&ALGO_TRACE?1:0);
+ if ((count < 0) || (count >= leftSize))
+ goto exit;
+ pstr += count;
+ leftSize -= count;
+ count = rtw_sprintf(pstr, leftSize, "\tbit[4]=%d for TRACE_FW\n",
+ GLBtcDbgType[BTC_MSG_ALGORITHM]&ALGO_TRACE_FW?1:0);
+ if ((count < 0) || (count >= leftSize))
+ goto exit;
+ pstr += count;
+ leftSize -= count;
+ count = rtw_sprintf(pstr, leftSize, "\tbit[5]=%d for TRACE_FW_DETAIL\n",
+ GLBtcDbgType[BTC_MSG_ALGORITHM]&ALGO_TRACE_FW_DETAIL?1:0);
+ if ((count < 0) || (count >= leftSize))
+ goto exit;
+ pstr += count;
+ leftSize -= count;
+ count = rtw_sprintf(pstr, leftSize, "\tbit[6]=%d for TRACE_FW_EXEC\n",
+ GLBtcDbgType[BTC_MSG_ALGORITHM]&ALGO_TRACE_FW_EXEC?1:0);
+ if ((count < 0) || (count >= leftSize))
+ goto exit;
+ pstr += count;
+ leftSize -= count;
+ count = rtw_sprintf(pstr, leftSize, "\tbit[7]=%d for TRACE_SW\n",
+ GLBtcDbgType[BTC_MSG_ALGORITHM]&ALGO_TRACE_SW?1:0);
+ if ((count < 0) || (count >= leftSize))
+ goto exit;
+ pstr += count;
+ leftSize -= count;
+ count = rtw_sprintf(pstr, leftSize, "\tbit[8]=%d for TRACE_SW_DETAIL\n",
+ GLBtcDbgType[BTC_MSG_ALGORITHM]&ALGO_TRACE_SW_DETAIL?1:0);
+ if ((count < 0) || (count >= leftSize))
+ goto exit;
+ pstr += count;
+ leftSize -= count;
+ count = rtw_sprintf(pstr, leftSize, "\tbit[9]=%d for TRACE_SW_EXEC\n",
+ GLBtcDbgType[BTC_MSG_ALGORITHM]&ALGO_TRACE_SW_EXEC?1:0);
+ if ((count < 0) || (count >= leftSize))
+ goto exit;
+ pstr += count;
+ leftSize -= count;
+#endif
+
+exit:
+ count = pstr - pStrBuf;
+// DBG_871X(FUNC_ADPT_FMT ": usedsize=%d\n", FUNC_ADPT_ARG(padapter), count);
+
+ return count;
+}
+
+u8 hal_btcoex_IncreaseScanDeviceNum(PADAPTER padapter)
+{
+ if (!hal_btcoex_IsBtExist(padapter))
+ return _FALSE;
+
+ if (GLBtCoexist.btInfo.bIncreaseScanDevNum)
+ return _TRUE;
+
+ return _FALSE;
+}
+
+u8 hal_btcoex_IsBtLinkExist(PADAPTER padapter)
+{
+ if (GLBtCoexist.btLinkInfo.bBtLinkExist)
+ return _TRUE;
+
+ return _FALSE;
+}
+
+void hal_btcoex_SetBtPatchVersion(PADAPTER padapter,u16 btHciVer,u16 btPatchVer)
+{
+ EXhalbtcoutsrc_SetBtPatchVersion(btHciVer,btPatchVer);
+}
+
+void hal_btcoex_SetHciVersion(PADAPTER padapter, u16 hciVersion)
+{
+ EXhalbtcoutsrc_SetHciVersion(hciVersion);
+}
+
+void hal_btcoex_StackUpdateProfileInfo(void)
+{
+ EXhalbtcoutsrc_StackUpdateProfileInfo();
+}
+
+void hal_btcoex_BTOffOnNotify(PADAPTER padapter, u8 bBTON)
+{
+ EXhalbtcoutsrc_BTOffOnNotify(&GLBtCoexist, bBTON);
+}
+
+/*
+ * Description:
+ * Setting BT coex antenna isolation type .
+ * coex mechanisn/ spital stream/ best throughput
+ * anttype = 0 , PSTDMA / 2SS / 0.5T , bad isolation , WiFi/BT ANT Distance<15cm , (<20dB) for 2,3 antenna
+ * anttype = 1 , PSTDMA / 1SS / 0.5T , normal isolaiton , 50cm>WiFi/BT ANT Distance>15cm , (>20dB) for 2 antenna
+ * anttype = 2 , TDMA / 2SS / T , normal isolaiton , 50cm>WiFi/BT ANT Distance>15cm , (>20dB) for 3 antenna
+ * anttype = 3 , no TDMA / 1SS / 0.5T , good isolation , WiFi/BT ANT Distance >50cm , (>40dB) for 2 antenna
+ * anttype = 4 , no TDMA / 2SS / T , good isolation , WiFi/BT ANT Distance >50cm , (>40dB) for 3 antenna
+ * wifi only throughput ~ T
+ * wifi/BT share one antenna with SPDT
+ */
+void hal_btcoex_SetAntIsolationType(PADAPTER padapter, u8 anttype)
+{
+ PHAL_DATA_TYPE pHalData;
+ PBTC_COEXIST pBtCoexist = &GLBtCoexist;
+
+ /*DBG_871X("####%s , anttype = %d , %d\n" , __func__ , anttype , __LINE__); */
+ pHalData = GET_HAL_DATA(padapter);
+
+
+ pHalData->bt_coexist.btAntisolation = anttype;
+
+ switch (pHalData->bt_coexist.btAntisolation) {
+ case 0:
+ pBtCoexist->boardInfo.antType = (u1Byte)BTC_ANT_TYPE_0;
+ break;
+ case 1:
+ pBtCoexist->boardInfo.antType = (u1Byte)BTC_ANT_TYPE_1;
+ break;
+ case 2:
+ pBtCoexist->boardInfo.antType = (u1Byte)BTC_ANT_TYPE_2;
+ break;
+ case 3:
+ pBtCoexist->boardInfo.antType = (u1Byte)BTC_ANT_TYPE_3;
+ break;
+ case 4:
+ pBtCoexist->boardInfo.antType = (u1Byte)BTC_ANT_TYPE_4;
+ break;
+ }
+
+}
+
+#ifdef CONFIG_LOAD_PHY_PARA_FROM_FILE
+int
+hal_btcoex_ParseAntIsolationConfigFile(
+ PADAPTER Adapter,
+ char* buffer
+)
+{
+ HAL_DATA_TYPE *pHalData = GET_HAL_DATA(Adapter);
+ u32 i = 0 , j = 0;
+ char *szLine , *ptmp;
+ int rtStatus = _SUCCESS;
+ char param_value_string[10];
+ u8 param_value;
+ u8 anttype = 4;
+
+ u8 ant_num = 3 , ant_distance = 50 , rfe_type = 1;
+
+ typedef struct ant_isolation {
+ char *param_name; /* antenna isolation config parameter name */
+ u8 *value; /* antenna isolation config parameter value */
+ } ANT_ISOLATION;
+
+ ANT_ISOLATION ant_isolation_param[] = {
+ {"ANT_NUMBER" , &ant_num},
+ {"ANT_DISTANCE" , &ant_distance},
+ {"RFE_TYPE" , &rfe_type},
+ {NULL , 0}
+ };
+
+
+
+ /* DBG_871X("===>Hal_ParseAntIsolationConfigFile()\n" ); */
+
+ ptmp = buffer;
+ for (szLine = GetLineFromBuffer(ptmp) ; szLine != NULL; szLine = GetLineFromBuffer(ptmp)) {
+ /* skip comment */
+ if (IsCommentString(szLine))
+ continue;
+
+ /* DBG_871X("%s : szLine = %s , strlen(szLine) = %d\n" , __func__ , szLine , strlen(szLine));*/
+ for (j = 0 ; ant_isolation_param[j].param_name != NULL ; j++) {
+ if (strstr(szLine , ant_isolation_param[j].param_name) != NULL) {
+ i = 0;
+ while (i < strlen(szLine)) {
+ if (szLine[i] != '"')
+ ++i;
+ else {
+ /* skip only has one " */
+ if (strpbrk(szLine , "\"") == strrchr(szLine , '"')) {
+ DBG_871X("Fail to parse parameters , format error!\n");
+ break;
+ }
+ _rtw_memset((PVOID)param_value_string , 0 , 10);
+ if (!ParseQualifiedString(szLine , &i , param_value_string , '"' , '"')) {
+ DBG_871X("Fail to parse parameters\n");
+ return _FAIL;
+ } else if (!GetU1ByteIntegerFromStringInDecimal(param_value_string , ant_isolation_param[j].value))
+ DBG_871X("Fail to GetU1ByteIntegerFromStringInDecimal\n");
+
+ break;
+ }
+ }
+ }
+ }
+ }
+
+ /* YiWei 20140716 , for BT coex antenna isolation control */
+ /* rfe_type = 0 was SPDT , rfe_type = 1 was coupler */
+ if (ant_num == 3 && ant_distance >= 50)
+ anttype = 3;
+ else if (ant_num == 2 && ant_distance >= 50 && rfe_type == 1)
+ anttype = 2;
+ else if (ant_num == 3 && ant_distance >= 15 && ant_distance < 50)
+ anttype = 2;
+ else if (ant_num == 2 && ant_distance >= 15 && ant_distance < 50 && rfe_type == 1)
+ anttype = 2;
+ else if ((ant_num == 2 && ant_distance < 15 && rfe_type == 1) || (ant_num == 3 && ant_distance < 15))
+ anttype = 1;
+ else if (ant_num == 2 && rfe_type == 0)
+ anttype = 0;
+ else
+ anttype = 0;
+
+ hal_btcoex_SetAntIsolationType(Adapter, anttype);
+
+ DBG_871X("%s : ant_num = %d\n" , __func__ , ant_num);
+ DBG_871X("%s : ant_distance = %d\n" , __func__ , ant_distance);
+ DBG_871X("%s : rfe_type = %d\n" , __func__ , rfe_type);
+ /* DBG_871X("<===Hal_ParseAntIsolationConfigFile()\n"); */
+ return rtStatus;
+}
+
+
+int
+hal_btcoex_AntIsolationConfig_ParaFile(
+ IN PADAPTER Adapter,
+ IN char* pFileName
+)
+{
+ HAL_DATA_TYPE *pHalData = GET_HAL_DATA(Adapter);
+ int rlen = 0 , rtStatus = _FAIL;
+
+ _rtw_memset(pHalData->para_file_buf , 0 , MAX_PARA_FILE_BUF_LEN);
+
+ rtw_get_phy_file_path(Adapter, pFileName);
+ if (rtw_is_file_readable(rtw_phy_para_file_path) == _TRUE)
+ {
+ rlen = rtw_retrieve_from_file(rtw_phy_para_file_path, pHalData->para_file_buf, MAX_PARA_FILE_BUF_LEN);
+ if (rlen > 0)
+ {
+ rtStatus = _SUCCESS;
+ }
+ }
+
+
+ if (rtStatus == _SUCCESS) {
+ /*DBG_871X("%s(): read %s ok\n", __func__ , pFileName);*/
+ rtStatus = hal_btcoex_ParseAntIsolationConfigFile(Adapter , pHalData->para_file_buf);
+ } else {
+ DBG_871X("%s(): No File %s, Load from *** Array!\n" , __func__ , pFileName);
+ }
+
+ return rtStatus;
+}
+#endif // CONFIG_LOAD_PHY_PARA_FROM_FILE
+
+u16 hal_btcoex_btreg_read(PADAPTER padapter, u8 type, u16 addr, u32 *data)
+{
+ u16 ret = 0;
+
+ halbtcoutsrc_LeaveLowPower(&GLBtCoexist);
+
+ ret = halbtcoutsrc_GetBtReg(&GLBtCoexist, type, addr, data);
+
+ halbtcoutsrc_NormalLowPower(&GLBtCoexist);
+
+ return ret;
+}
+
+u16 hal_btcoex_btreg_write(PADAPTER padapter, u8 type, u16 addr, u16 val)
+{
+ u16 ret = 0;
+
+ halbtcoutsrc_LeaveLowPower(&GLBtCoexist);
+
+ ret = halbtcoutsrc_SetBtReg(&GLBtCoexist, type, addr, val);
+
+ halbtcoutsrc_NormalLowPower(&GLBtCoexist);
+
+ return ret;
+}
+#endif // CONFIG_BT_COEXIST
+
projects / firefly-linux-kernel-4.4.55.git / blobdiff