1 /****************************************************************************** 2 * 3 * Copyright(c) 2007 - 2012 Realtek Corporation. All rights reserved. 4 * 5 * This program is free software; you can redistribute it and/or modify it 6 * under the terms of version 2 of the GNU General Public License as 7 * published by the Free Software Foundation. 8 * 9 * This program is distributed in the hope that it will be useful, but WITHOUT 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for 12 * more details. 13 * 14 ******************************************************************************/ 15 16 #include "Mp_Precomp.h" 17 18 /* Global variables, these are static variables */ 19 static COEX_DM_8723B_2ANT GLCoexDm8723b2Ant; 20 static PCOEX_DM_8723B_2ANT pCoexDm = &GLCoexDm8723b2Ant; 21 static COEX_STA_8723B_2ANT GLCoexSta8723b2Ant; 22 static PCOEX_STA_8723B_2ANT pCoexSta = &GLCoexSta8723b2Ant; 23 24 static const char *const GLBtInfoSrc8723b2Ant[] = { 25 "BT Info[wifi fw]", 26 "BT Info[bt rsp]", 27 "BT Info[bt auto report]", 28 }; 29 30 static u32 GLCoexVerDate8723b2Ant = 20131211; 31 static u32 GLCoexVer8723b2Ant = 0x40; 32 33 /* local function start with halbtc8723b2ant_ */ 34 static u8 halbtc8723b2ant_BtRssiState( 35 u8 levelNum, u8 rssiThresh, u8 rssiThresh1 36 ) 37 { 38 s32 btRssi = 0; 39 u8 btRssiState = pCoexSta->preBtRssiState; 40 41 btRssi = pCoexSta->btRssi; 42 43 if (levelNum == 2) { 44 if ( 45 (pCoexSta->preBtRssiState == BTC_RSSI_STATE_LOW) || 46 (pCoexSta->preBtRssiState == BTC_RSSI_STATE_STAY_LOW) 47 ) { 48 if (btRssi >= (rssiThresh+BTC_RSSI_COEX_THRESH_TOL_8723B_2ANT)) { 49 btRssiState = BTC_RSSI_STATE_HIGH; 50 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE, ("[BTCoex], BT Rssi state switch to High\n")); 51 } else { 52 btRssiState = BTC_RSSI_STATE_STAY_LOW; 53 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE, ("[BTCoex], BT Rssi state stay at Low\n")); 54 } 55 } else { 56 if (btRssi < rssiThresh) { 57 btRssiState = BTC_RSSI_STATE_LOW; 58 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE, ("[BTCoex], BT Rssi state switch to Low\n")); 59 } else { 60 btRssiState = BTC_RSSI_STATE_STAY_HIGH; 61 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE, ("[BTCoex], BT Rssi state stay at High\n")); 62 } 63 } 64 } else if (levelNum == 3) { 65 if (rssiThresh > rssiThresh1) { 66 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE, ("[BTCoex], BT Rssi thresh error!!\n")); 67 return pCoexSta->preBtRssiState; 68 } 69 70 if ( 71 (pCoexSta->preBtRssiState == BTC_RSSI_STATE_LOW) || 72 (pCoexSta->preBtRssiState == BTC_RSSI_STATE_STAY_LOW) 73 ) { 74 if (btRssi >= (rssiThresh+BTC_RSSI_COEX_THRESH_TOL_8723B_2ANT)) { 75 btRssiState = BTC_RSSI_STATE_MEDIUM; 76 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE, ("[BTCoex], BT Rssi state switch to Medium\n")); 77 } else { 78 btRssiState = BTC_RSSI_STATE_STAY_LOW; 79 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE, ("[BTCoex], BT Rssi state stay at Low\n")); 80 } 81 } else if ( 82 (pCoexSta->preBtRssiState == BTC_RSSI_STATE_MEDIUM) || 83 (pCoexSta->preBtRssiState == BTC_RSSI_STATE_STAY_MEDIUM) 84 ) { 85 if (btRssi >= (rssiThresh1+BTC_RSSI_COEX_THRESH_TOL_8723B_2ANT)) { 86 btRssiState = BTC_RSSI_STATE_HIGH; 87 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE, ("[BTCoex], BT Rssi state switch to High\n")); 88 } else if (btRssi < rssiThresh) { 89 btRssiState = BTC_RSSI_STATE_LOW; 90 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE, ("[BTCoex], BT Rssi state switch to Low\n")); 91 } else { 92 btRssiState = BTC_RSSI_STATE_STAY_MEDIUM; 93 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE, ("[BTCoex], BT Rssi state stay at Medium\n")); 94 } 95 } else { 96 if (btRssi < rssiThresh1) { 97 btRssiState = BTC_RSSI_STATE_MEDIUM; 98 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE, ("[BTCoex], BT Rssi state switch to Medium\n")); 99 } else { 100 btRssiState = BTC_RSSI_STATE_STAY_HIGH; 101 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_BT_RSSI_STATE, ("[BTCoex], BT Rssi state stay at High\n")); 102 } 103 } 104 } 105 106 pCoexSta->preBtRssiState = btRssiState; 107 108 return btRssiState; 109 } 110 111 static u8 halbtc8723b2ant_WifiRssiState( 112 PBTC_COEXIST pBtCoexist, 113 u8 index, 114 u8 levelNum, 115 u8 rssiThresh, 116 u8 rssiThresh1 117 ) 118 { 119 s32 wifiRssi = 0; 120 u8 wifiRssiState = pCoexSta->preWifiRssiState[index]; 121 122 pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_S4_WIFI_RSSI, &wifiRssi); 123 124 if (levelNum == 2) { 125 if ( 126 (pCoexSta->preWifiRssiState[index] == BTC_RSSI_STATE_LOW) || 127 (pCoexSta->preWifiRssiState[index] == BTC_RSSI_STATE_STAY_LOW) 128 ) { 129 if (wifiRssi >= (rssiThresh+BTC_RSSI_COEX_THRESH_TOL_8723B_2ANT)) { 130 wifiRssiState = BTC_RSSI_STATE_HIGH; 131 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_WIFI_RSSI_STATE, ("[BTCoex], wifi RSSI state switch to High\n")); 132 } else { 133 wifiRssiState = BTC_RSSI_STATE_STAY_LOW; 134 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_WIFI_RSSI_STATE, ("[BTCoex], wifi RSSI state stay at Low\n")); 135 } 136 } else { 137 if (wifiRssi < rssiThresh) { 138 wifiRssiState = BTC_RSSI_STATE_LOW; 139 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_WIFI_RSSI_STATE, ("[BTCoex], wifi RSSI state switch to Low\n")); 140 } else { 141 wifiRssiState = BTC_RSSI_STATE_STAY_HIGH; 142 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_WIFI_RSSI_STATE, ("[BTCoex], wifi RSSI state stay at High\n")); 143 } 144 } 145 } else if (levelNum == 3) { 146 if (rssiThresh > rssiThresh1) { 147 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_WIFI_RSSI_STATE, ("[BTCoex], wifi RSSI thresh error!!\n")); 148 return pCoexSta->preWifiRssiState[index]; 149 } 150 151 if ( 152 (pCoexSta->preWifiRssiState[index] == BTC_RSSI_STATE_LOW) || 153 (pCoexSta->preWifiRssiState[index] == BTC_RSSI_STATE_STAY_LOW) 154 ) { 155 if (wifiRssi >= (rssiThresh+BTC_RSSI_COEX_THRESH_TOL_8723B_2ANT)) { 156 wifiRssiState = BTC_RSSI_STATE_MEDIUM; 157 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_WIFI_RSSI_STATE, ("[BTCoex], wifi RSSI state switch to Medium\n")); 158 } else { 159 wifiRssiState = BTC_RSSI_STATE_STAY_LOW; 160 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_WIFI_RSSI_STATE, ("[BTCoex], wifi RSSI state stay at Low\n")); 161 } 162 } else if ( 163 (pCoexSta->preWifiRssiState[index] == BTC_RSSI_STATE_MEDIUM) || 164 (pCoexSta->preWifiRssiState[index] == BTC_RSSI_STATE_STAY_MEDIUM) 165 ) { 166 if (wifiRssi >= (rssiThresh1+BTC_RSSI_COEX_THRESH_TOL_8723B_2ANT)) { 167 wifiRssiState = BTC_RSSI_STATE_HIGH; 168 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_WIFI_RSSI_STATE, ("[BTCoex], wifi RSSI state switch to High\n")); 169 } else if (wifiRssi < rssiThresh) { 170 wifiRssiState = BTC_RSSI_STATE_LOW; 171 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_WIFI_RSSI_STATE, ("[BTCoex], wifi RSSI state switch to Low\n")); 172 } else { 173 wifiRssiState = BTC_RSSI_STATE_STAY_MEDIUM; 174 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_WIFI_RSSI_STATE, ("[BTCoex], wifi RSSI state stay at Medium\n")); 175 } 176 } else { 177 if (wifiRssi < rssiThresh1) { 178 wifiRssiState = BTC_RSSI_STATE_MEDIUM; 179 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_WIFI_RSSI_STATE, ("[BTCoex], wifi RSSI state switch to Medium\n")); 180 } else { 181 wifiRssiState = BTC_RSSI_STATE_STAY_HIGH; 182 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_WIFI_RSSI_STATE, ("[BTCoex], wifi RSSI state stay at High\n")); 183 } 184 } 185 } 186 187 pCoexSta->preWifiRssiState[index] = wifiRssiState; 188 189 return wifiRssiState; 190 } 191 192 static void halbtc8723b2ant_LimitedRx( 193 PBTC_COEXIST pBtCoexist, 194 bool bForceExec, 195 bool bRejApAggPkt, 196 bool bBtCtrlAggBufSize, 197 u8 aggBufSize 198 ) 199 { 200 bool bRejectRxAgg = bRejApAggPkt; 201 bool bBtCtrlRxAggSize = bBtCtrlAggBufSize; 202 u8 rxAggSize = aggBufSize; 203 204 /* */ 205 /* Rx Aggregation related setting */ 206 /* */ 207 pBtCoexist->fBtcSet(pBtCoexist, BTC_SET_BL_TO_REJ_AP_AGG_PKT, &bRejectRxAgg); 208 /* decide BT control aggregation buf size or not */ 209 pBtCoexist->fBtcSet(pBtCoexist, BTC_SET_BL_BT_CTRL_AGG_SIZE, &bBtCtrlRxAggSize); 210 /* aggregation buf size, only work when BT control Rx aggregation size. */ 211 pBtCoexist->fBtcSet(pBtCoexist, BTC_SET_U1_AGG_BUF_SIZE, &rxAggSize); 212 /* real update aggregation setting */ 213 pBtCoexist->fBtcSet(pBtCoexist, BTC_SET_ACT_AGGREGATE_CTRL, NULL); 214 } 215 216 static void halbtc8723b2ant_MonitorBtCtr(PBTC_COEXIST pBtCoexist) 217 { 218 u32 regHPTxRx, regLPTxRx, u4Tmp; 219 u32 regHPTx = 0, regHPRx = 0, regLPTx = 0, regLPRx = 0; 220 221 regHPTxRx = 0x770; 222 regLPTxRx = 0x774; 223 224 u4Tmp = pBtCoexist->fBtcRead4Byte(pBtCoexist, regHPTxRx); 225 regHPTx = u4Tmp & bMaskLWord; 226 regHPRx = (u4Tmp & bMaskHWord)>>16; 227 228 u4Tmp = pBtCoexist->fBtcRead4Byte(pBtCoexist, regLPTxRx); 229 regLPTx = u4Tmp & bMaskLWord; 230 regLPRx = (u4Tmp & bMaskHWord)>>16; 231 232 pCoexSta->highPriorityTx = regHPTx; 233 pCoexSta->highPriorityRx = regHPRx; 234 pCoexSta->lowPriorityTx = regLPTx; 235 pCoexSta->lowPriorityRx = regLPRx; 236 237 BTC_PRINT( 238 BTC_MSG_ALGORITHM, 239 ALGO_BT_MONITOR, 240 ( 241 "[BTCoex], High Priority Tx/Rx (reg 0x%x) = 0x%x(%d)/0x%x(%d)\n", 242 regHPTxRx, 243 regHPTx, 244 regHPTx, 245 regHPRx, 246 regHPRx 247 ) 248 ); 249 BTC_PRINT( 250 BTC_MSG_ALGORITHM, 251 ALGO_BT_MONITOR, 252 ( 253 "[BTCoex], Low Priority Tx/Rx (reg 0x%x) = 0x%x(%d)/0x%x(%d)\n", 254 regLPTxRx, 255 regLPTx, 256 regLPTx, 257 regLPRx, 258 regLPRx 259 ) 260 ); 261 262 /* reset counter */ 263 pBtCoexist->fBtcWrite1Byte(pBtCoexist, 0x76e, 0xc); 264 } 265 266 static void halbtc8723b2ant_QueryBtInfo(PBTC_COEXIST pBtCoexist) 267 { 268 u8 H2C_Parameter[1] = {0}; 269 270 pCoexSta->bC2hBtInfoReqSent = true; 271 272 H2C_Parameter[0] |= BIT0; /* trigger */ 273 274 BTC_PRINT( 275 BTC_MSG_ALGORITHM, 276 ALGO_TRACE_FW_EXEC, 277 ("[BTCoex], Query Bt Info, FW write 0x61 = 0x%x\n", H2C_Parameter[0]) 278 ); 279 280 pBtCoexist->fBtcFillH2c(pBtCoexist, 0x61, 1, H2C_Parameter); 281 } 282 283 static bool halbtc8723b2ant_IsWifiStatusChanged(PBTC_COEXIST pBtCoexist) 284 { 285 static bool bPreWifiBusy, bPreUnder4way, bPreBtHsOn; 286 bool bWifiBusy = false, bUnder4way = false, bBtHsOn = false; 287 bool bWifiConnected = false; 288 289 pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_WIFI_CONNECTED, &bWifiConnected); 290 pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_WIFI_BUSY, &bWifiBusy); 291 pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_HS_OPERATION, &bBtHsOn); 292 pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_WIFI_4_WAY_PROGRESS, &bUnder4way); 293 294 if (bWifiConnected) { 295 if (bWifiBusy != bPreWifiBusy) { 296 bPreWifiBusy = bWifiBusy; 297 return true; 298 } 299 300 if (bUnder4way != bPreUnder4way) { 301 bPreUnder4way = bUnder4way; 302 return true; 303 } 304 305 if (bBtHsOn != bPreBtHsOn) { 306 bPreBtHsOn = bBtHsOn; 307 return true; 308 } 309 } 310 311 return false; 312 } 313 314 static void halbtc8723b2ant_UpdateBtLinkInfo(PBTC_COEXIST pBtCoexist) 315 { 316 PBTC_BT_LINK_INFO pBtLinkInfo = &pBtCoexist->btLinkInfo; 317 bool bBtHsOn = false; 318 319 pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_HS_OPERATION, &bBtHsOn); 320 321 pBtLinkInfo->bBtLinkExist = pCoexSta->bBtLinkExist; 322 pBtLinkInfo->bScoExist = pCoexSta->bScoExist; 323 pBtLinkInfo->bA2dpExist = pCoexSta->bA2dpExist; 324 pBtLinkInfo->bPanExist = pCoexSta->bPanExist; 325 pBtLinkInfo->bHidExist = pCoexSta->bHidExist; 326 327 /* work around for HS mode. */ 328 if (bBtHsOn) { 329 pBtLinkInfo->bPanExist = true; 330 pBtLinkInfo->bBtLinkExist = true; 331 } 332 333 /* check if Sco only */ 334 if ( 335 pBtLinkInfo->bScoExist && 336 !pBtLinkInfo->bA2dpExist && 337 !pBtLinkInfo->bPanExist && 338 !pBtLinkInfo->bHidExist 339 ) 340 pBtLinkInfo->bScoOnly = true; 341 else 342 pBtLinkInfo->bScoOnly = false; 343 344 /* check if A2dp only */ 345 if ( 346 !pBtLinkInfo->bScoExist && 347 pBtLinkInfo->bA2dpExist && 348 !pBtLinkInfo->bPanExist && 349 !pBtLinkInfo->bHidExist 350 ) 351 pBtLinkInfo->bA2dpOnly = true; 352 else 353 pBtLinkInfo->bA2dpOnly = false; 354 355 /* check if Pan only */ 356 if ( 357 !pBtLinkInfo->bScoExist && 358 !pBtLinkInfo->bA2dpExist && 359 pBtLinkInfo->bPanExist && 360 !pBtLinkInfo->bHidExist 361 ) 362 pBtLinkInfo->bPanOnly = true; 363 else 364 pBtLinkInfo->bPanOnly = false; 365 366 /* check if Hid only */ 367 if ( 368 !pBtLinkInfo->bScoExist && 369 !pBtLinkInfo->bA2dpExist && 370 !pBtLinkInfo->bPanExist && 371 pBtLinkInfo->bHidExist 372 ) 373 pBtLinkInfo->bHidOnly = true; 374 else 375 pBtLinkInfo->bHidOnly = false; 376 } 377 378 static u8 halbtc8723b2ant_ActionAlgorithm(PBTC_COEXIST pBtCoexist) 379 { 380 PBTC_BT_LINK_INFO pBtLinkInfo = &pBtCoexist->btLinkInfo; 381 bool bBtHsOn = false; 382 u8 algorithm = BT_8723B_2ANT_COEX_ALGO_UNDEFINED; 383 u8 numOfDiffProfile = 0; 384 385 pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_HS_OPERATION, &bBtHsOn); 386 387 if (!pBtLinkInfo->bBtLinkExist) { 388 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], No BT link exists!!!\n")); 389 return algorithm; 390 } 391 392 if (pBtLinkInfo->bScoExist) 393 numOfDiffProfile++; 394 395 if (pBtLinkInfo->bHidExist) 396 numOfDiffProfile++; 397 398 if (pBtLinkInfo->bPanExist) 399 numOfDiffProfile++; 400 401 if (pBtLinkInfo->bA2dpExist) 402 numOfDiffProfile++; 403 404 if (numOfDiffProfile == 1) { 405 if (pBtLinkInfo->bScoExist) { 406 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], SCO only\n")); 407 algorithm = BT_8723B_2ANT_COEX_ALGO_SCO; 408 } else { 409 if (pBtLinkInfo->bHidExist) { 410 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], HID only\n")); 411 algorithm = BT_8723B_2ANT_COEX_ALGO_HID; 412 } else if (pBtLinkInfo->bA2dpExist) { 413 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], A2DP only\n")); 414 algorithm = BT_8723B_2ANT_COEX_ALGO_A2DP; 415 } else if (pBtLinkInfo->bPanExist) { 416 if (bBtHsOn) { 417 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], PAN(HS) only\n")); 418 algorithm = BT_8723B_2ANT_COEX_ALGO_PANHS; 419 } else { 420 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], PAN(EDR) only\n")); 421 algorithm = BT_8723B_2ANT_COEX_ALGO_PANEDR; 422 } 423 } 424 } 425 } else if (numOfDiffProfile == 2) { 426 if (pBtLinkInfo->bScoExist) { 427 if (pBtLinkInfo->bHidExist) { 428 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], SCO + HID\n")); 429 algorithm = BT_8723B_2ANT_COEX_ALGO_PANEDR_HID; 430 } else if (pBtLinkInfo->bA2dpExist) { 431 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], SCO + A2DP ==> SCO\n")); 432 algorithm = BT_8723B_2ANT_COEX_ALGO_PANEDR_HID; 433 } else if (pBtLinkInfo->bPanExist) { 434 if (bBtHsOn) { 435 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], SCO + PAN(HS)\n")); 436 algorithm = BT_8723B_2ANT_COEX_ALGO_SCO; 437 } else { 438 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], SCO + PAN(EDR)\n")); 439 algorithm = BT_8723B_2ANT_COEX_ALGO_PANEDR_HID; 440 } 441 } 442 } else { 443 if ( 444 pBtLinkInfo->bHidExist && 445 pBtLinkInfo->bA2dpExist 446 ) { 447 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], HID + A2DP\n")); 448 algorithm = BT_8723B_2ANT_COEX_ALGO_HID_A2DP; 449 } else if ( 450 pBtLinkInfo->bHidExist && 451 pBtLinkInfo->bPanExist 452 ) { 453 if (bBtHsOn) { 454 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], HID + PAN(HS)\n")); 455 algorithm = BT_8723B_2ANT_COEX_ALGO_HID; 456 } else { 457 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], HID + PAN(EDR)\n")); 458 algorithm = BT_8723B_2ANT_COEX_ALGO_PANEDR_HID; 459 } 460 } else if ( 461 pBtLinkInfo->bPanExist && 462 pBtLinkInfo->bA2dpExist 463 ) { 464 if (bBtHsOn) { 465 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], A2DP + PAN(HS)\n")); 466 algorithm = BT_8723B_2ANT_COEX_ALGO_A2DP_PANHS; 467 } else { 468 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], A2DP + PAN(EDR)\n")); 469 algorithm = BT_8723B_2ANT_COEX_ALGO_PANEDR_A2DP; 470 } 471 } 472 } 473 } else if (numOfDiffProfile == 3) { 474 if (pBtLinkInfo->bScoExist) { 475 if ( 476 pBtLinkInfo->bHidExist && 477 pBtLinkInfo->bA2dpExist 478 ) { 479 BTC_PRINT( 480 BTC_MSG_ALGORITHM, 481 ALGO_TRACE, 482 ("[BTCoex], SCO + HID + A2DP ==> HID\n") 483 ); 484 algorithm = BT_8723B_2ANT_COEX_ALGO_PANEDR_HID; 485 } else if ( 486 pBtLinkInfo->bHidExist && 487 pBtLinkInfo->bPanExist 488 ) { 489 if (bBtHsOn) { 490 BTC_PRINT( 491 BTC_MSG_ALGORITHM, 492 ALGO_TRACE, 493 ("[BTCoex], SCO + HID + PAN(HS)\n") 494 ); 495 algorithm = BT_8723B_2ANT_COEX_ALGO_PANEDR_HID; 496 } else { 497 BTC_PRINT( 498 BTC_MSG_ALGORITHM, 499 ALGO_TRACE, 500 ("[BTCoex], SCO + HID + PAN(EDR)\n") 501 ); 502 algorithm = BT_8723B_2ANT_COEX_ALGO_PANEDR_HID; 503 } 504 } else if ( 505 pBtLinkInfo->bPanExist && 506 pBtLinkInfo->bA2dpExist 507 ) { 508 if (bBtHsOn) { 509 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], SCO + A2DP + PAN(HS)\n")); 510 algorithm = BT_8723B_2ANT_COEX_ALGO_PANEDR_HID; 511 } else { 512 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], SCO + A2DP + PAN(EDR) ==> HID\n")); 513 algorithm = BT_8723B_2ANT_COEX_ALGO_PANEDR_HID; 514 } 515 } 516 } else { 517 if ( 518 pBtLinkInfo->bHidExist && 519 pBtLinkInfo->bPanExist && 520 pBtLinkInfo->bA2dpExist 521 ) { 522 if (bBtHsOn) { 523 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], HID + A2DP + PAN(HS)\n")); 524 algorithm = BT_8723B_2ANT_COEX_ALGO_HID_A2DP; 525 } else { 526 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], HID + A2DP + PAN(EDR)\n")); 527 algorithm = BT_8723B_2ANT_COEX_ALGO_HID_A2DP_PANEDR; 528 } 529 } 530 } 531 } else if (numOfDiffProfile >= 3) { 532 if (pBtLinkInfo->bScoExist) { 533 if ( 534 pBtLinkInfo->bHidExist && 535 pBtLinkInfo->bPanExist && 536 pBtLinkInfo->bA2dpExist 537 ) { 538 if (bBtHsOn) { 539 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], Error!!! SCO + HID + A2DP + PAN(HS)\n")); 540 541 } else { 542 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], SCO + HID + A2DP + PAN(EDR) ==>PAN(EDR)+HID\n")); 543 algorithm = BT_8723B_2ANT_COEX_ALGO_PANEDR_HID; 544 } 545 } 546 } 547 } 548 549 return algorithm; 550 } 551 552 static void halbtc8723b2ant_SetFwDacSwingLevel( 553 PBTC_COEXIST pBtCoexist, u8 dacSwingLvl 554 ) 555 { 556 u8 H2C_Parameter[1] = {0}; 557 558 /* There are several type of dacswing */ 559 /* 0x18/ 0x10/ 0xc/ 0x8/ 0x4/ 0x6 */ 560 H2C_Parameter[0] = dacSwingLvl; 561 562 BTC_PRINT( 563 BTC_MSG_ALGORITHM, 564 ALGO_TRACE_FW_EXEC, 565 ("[BTCoex], Set Dac Swing Level = 0x%x\n", dacSwingLvl) 566 ); 567 BTC_PRINT( 568 BTC_MSG_ALGORITHM, 569 ALGO_TRACE_FW_EXEC, 570 ("[BTCoex], FW write 0x64 = 0x%x\n", H2C_Parameter[0]) 571 ); 572 573 pBtCoexist->fBtcFillH2c(pBtCoexist, 0x64, 1, H2C_Parameter); 574 } 575 576 static void halbtc8723b2ant_SetFwDecBtPwr( 577 PBTC_COEXIST pBtCoexist, u8 decBtPwrLvl 578 ) 579 { 580 u8 H2C_Parameter[1] = {0}; 581 582 H2C_Parameter[0] = decBtPwrLvl; 583 584 BTC_PRINT( 585 BTC_MSG_ALGORITHM, 586 ALGO_TRACE_FW_EXEC, 587 ( 588 "[BTCoex], decrease Bt Power level = %d, FW write 0x62 = 0x%x\n", 589 decBtPwrLvl, 590 H2C_Parameter[0] 591 ) 592 ); 593 594 pBtCoexist->fBtcFillH2c(pBtCoexist, 0x62, 1, H2C_Parameter); 595 } 596 597 static void halbtc8723b2ant_DecBtPwr( 598 PBTC_COEXIST pBtCoexist, bool bForceExec, u8 decBtPwrLvl 599 ) 600 { 601 BTC_PRINT( 602 BTC_MSG_ALGORITHM, 603 ALGO_TRACE_FW, 604 ( 605 "[BTCoex], %s Dec BT power level = %d\n", 606 (bForceExec ? "force to" : ""), 607 decBtPwrLvl 608 ) 609 ); 610 pCoexDm->curBtDecPwrLvl = decBtPwrLvl; 611 612 if (!bForceExec) { 613 BTC_PRINT( 614 BTC_MSG_ALGORITHM, 615 ALGO_TRACE_FW_DETAIL, 616 ( 617 "[BTCoex], preBtDecPwrLvl =%d, curBtDecPwrLvl =%d\n", 618 pCoexDm->preBtDecPwrLvl, 619 pCoexDm->curBtDecPwrLvl 620 ) 621 ); 622 623 if (pCoexDm->preBtDecPwrLvl == pCoexDm->curBtDecPwrLvl) 624 return; 625 } 626 halbtc8723b2ant_SetFwDecBtPwr(pBtCoexist, pCoexDm->curBtDecPwrLvl); 627 628 pCoexDm->preBtDecPwrLvl = pCoexDm->curBtDecPwrLvl; 629 } 630 631 static void halbtc8723b2ant_FwDacSwingLvl( 632 PBTC_COEXIST pBtCoexist, bool bForceExec, u8 fwDacSwingLvl 633 ) 634 { 635 BTC_PRINT( 636 BTC_MSG_ALGORITHM, 637 ALGO_TRACE_FW, 638 ( 639 "[BTCoex], %s set FW Dac Swing level = %d\n", 640 (bForceExec ? "force to" : ""), 641 fwDacSwingLvl 642 ) 643 ); 644 pCoexDm->curFwDacSwingLvl = fwDacSwingLvl; 645 646 if (!bForceExec) { 647 BTC_PRINT( 648 BTC_MSG_ALGORITHM, 649 ALGO_TRACE_FW_DETAIL, 650 ( 651 "[BTCoex], preFwDacSwingLvl =%d, curFwDacSwingLvl =%d\n", 652 pCoexDm->preFwDacSwingLvl, 653 pCoexDm->curFwDacSwingLvl 654 ) 655 ); 656 657 if (pCoexDm->preFwDacSwingLvl == pCoexDm->curFwDacSwingLvl) 658 return; 659 } 660 661 halbtc8723b2ant_SetFwDacSwingLevel(pBtCoexist, pCoexDm->curFwDacSwingLvl); 662 663 pCoexDm->preFwDacSwingLvl = pCoexDm->curFwDacSwingLvl; 664 } 665 666 static void halbtc8723b2ant_SetSwRfRxLpfCorner( 667 PBTC_COEXIST pBtCoexist, 668 bool bRxRfShrinkOn 669 ) 670 { 671 if (bRxRfShrinkOn) { 672 /* Shrink RF Rx LPF corner */ 673 BTC_PRINT( 674 BTC_MSG_ALGORITHM, 675 ALGO_TRACE_SW_EXEC, 676 ("[BTCoex], Shrink RF Rx LPF corner!!\n") 677 ); 678 pBtCoexist->fBtcSetRfReg(pBtCoexist, BTC_RF_A, 0x1e, 0xfffff, 0xffffc); 679 } else { 680 /* Resume RF Rx LPF corner */ 681 /* After initialized, we can use pCoexDm->btRf0x1eBackup */ 682 if (pBtCoexist->bInitilized) { 683 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_EXEC, ("[BTCoex], Resume RF Rx LPF corner!!\n")); 684 pBtCoexist->fBtcSetRfReg(pBtCoexist, BTC_RF_A, 0x1e, 0xfffff, pCoexDm->btRf0x1eBackup); 685 } 686 } 687 } 688 689 static void halbtc8723b2ant_RfShrink( 690 PBTC_COEXIST pBtCoexist, bool bForceExec, bool bRxRfShrinkOn 691 ) 692 { 693 BTC_PRINT( 694 BTC_MSG_ALGORITHM, 695 ALGO_TRACE_SW, 696 ( 697 "[BTCoex], %s turn Rx RF Shrink = %s\n", 698 (bForceExec ? "force to" : ""), 699 (bRxRfShrinkOn ? "ON" : "OFF") 700 ) 701 ); 702 pCoexDm->bCurRfRxLpfShrink = bRxRfShrinkOn; 703 704 if (!bForceExec) { 705 BTC_PRINT( 706 BTC_MSG_ALGORITHM, 707 ALGO_TRACE_SW_DETAIL, 708 ( 709 "[BTCoex], bPreRfRxLpfShrink =%d, bCurRfRxLpfShrink =%d\n", 710 pCoexDm->bPreRfRxLpfShrink, 711 pCoexDm->bCurRfRxLpfShrink 712 ) 713 ); 714 715 if (pCoexDm->bPreRfRxLpfShrink == pCoexDm->bCurRfRxLpfShrink) 716 return; 717 } 718 halbtc8723b2ant_SetSwRfRxLpfCorner(pBtCoexist, pCoexDm->bCurRfRxLpfShrink); 719 720 pCoexDm->bPreRfRxLpfShrink = pCoexDm->bCurRfRxLpfShrink; 721 } 722 723 static void halbtc8723b2ant_SetSwPenaltyTxRateAdaptive( 724 PBTC_COEXIST pBtCoexist, bool bLowPenaltyRa 725 ) 726 { 727 u8 H2C_Parameter[6] = {0}; 728 729 H2C_Parameter[0] = 0x6; /* opCode, 0x6 = Retry_Penalty */ 730 731 if (bLowPenaltyRa) { 732 H2C_Parameter[1] |= BIT0; 733 H2C_Parameter[2] = 0x00; /* normal rate except MCS7/6/5, OFDM54/48/36 */ 734 H2C_Parameter[3] = 0xf7; /* MCS7 or OFDM54 */ 735 H2C_Parameter[4] = 0xf8; /* MCS6 or OFDM48 */ 736 H2C_Parameter[5] = 0xf9; /* MCS5 or OFDM36 */ 737 } 738 739 BTC_PRINT( 740 BTC_MSG_ALGORITHM, 741 ALGO_TRACE_FW_EXEC, 742 ( 743 "[BTCoex], set WiFi Low-Penalty Retry: %s", 744 (bLowPenaltyRa ? "ON!!" : "OFF!!") 745 ) 746 ); 747 748 pBtCoexist->fBtcFillH2c(pBtCoexist, 0x69, 6, H2C_Parameter); 749 } 750 751 static void halbtc8723b2ant_LowPenaltyRa( 752 PBTC_COEXIST pBtCoexist, bool bForceExec, bool bLowPenaltyRa 753 ) 754 { 755 /* return; */ 756 BTC_PRINT( 757 BTC_MSG_ALGORITHM, 758 ALGO_TRACE_SW, 759 ( 760 "[BTCoex], %s turn LowPenaltyRA = %s\n", 761 (bForceExec ? "force to" : ""), 762 (bLowPenaltyRa ? "ON" : "OFF") 763 ) 764 ); 765 pCoexDm->bCurLowPenaltyRa = bLowPenaltyRa; 766 767 if (!bForceExec) { 768 BTC_PRINT( 769 BTC_MSG_ALGORITHM, 770 ALGO_TRACE_SW_DETAIL, 771 ( 772 "[BTCoex], bPreLowPenaltyRa =%d, bCurLowPenaltyRa =%d\n", 773 pCoexDm->bPreLowPenaltyRa, 774 pCoexDm->bCurLowPenaltyRa 775 ) 776 ); 777 778 if (pCoexDm->bPreLowPenaltyRa == pCoexDm->bCurLowPenaltyRa) 779 return; 780 } 781 halbtc8723b2ant_SetSwPenaltyTxRateAdaptive(pBtCoexist, pCoexDm->bCurLowPenaltyRa); 782 783 pCoexDm->bPreLowPenaltyRa = pCoexDm->bCurLowPenaltyRa; 784 } 785 786 static void halbtc8723b2ant_SetDacSwingReg(PBTC_COEXIST pBtCoexist, u32 level) 787 { 788 u8 val = (u8)level; 789 790 BTC_PRINT( 791 BTC_MSG_ALGORITHM, 792 ALGO_TRACE_SW_EXEC, 793 ("[BTCoex], Write SwDacSwing = 0x%x\n", level) 794 ); 795 pBtCoexist->fBtcWrite1ByteBitMask(pBtCoexist, 0x883, 0x3e, val); 796 } 797 798 static void halbtc8723b2ant_SetSwFullTimeDacSwing( 799 PBTC_COEXIST pBtCoexist, bool bSwDacSwingOn, u32 swDacSwingLvl 800 ) 801 { 802 if (bSwDacSwingOn) 803 halbtc8723b2ant_SetDacSwingReg(pBtCoexist, swDacSwingLvl); 804 else 805 halbtc8723b2ant_SetDacSwingReg(pBtCoexist, 0x18); 806 } 807 808 809 static void halbtc8723b2ant_DacSwing( 810 PBTC_COEXIST pBtCoexist, 811 bool bForceExec, 812 bool bDacSwingOn, 813 u32 dacSwingLvl 814 ) 815 { 816 BTC_PRINT( 817 BTC_MSG_ALGORITHM, 818 ALGO_TRACE_SW, 819 ( 820 "[BTCoex], %s turn DacSwing =%s, dacSwingLvl = 0x%x\n", 821 (bForceExec ? "force to" : ""), 822 (bDacSwingOn ? "ON" : "OFF"), 823 dacSwingLvl 824 ) 825 ); 826 pCoexDm->bCurDacSwingOn = bDacSwingOn; 827 pCoexDm->curDacSwingLvl = dacSwingLvl; 828 829 if (!bForceExec) { 830 BTC_PRINT( 831 BTC_MSG_ALGORITHM, 832 ALGO_TRACE_SW_DETAIL, 833 ( 834 "[BTCoex], bPreDacSwingOn =%d, preDacSwingLvl = 0x%x, bCurDacSwingOn =%d, curDacSwingLvl = 0x%x\n", 835 pCoexDm->bPreDacSwingOn, 836 pCoexDm->preDacSwingLvl, 837 pCoexDm->bCurDacSwingOn, 838 pCoexDm->curDacSwingLvl 839 ) 840 ); 841 842 if ((pCoexDm->bPreDacSwingOn == pCoexDm->bCurDacSwingOn) && 843 (pCoexDm->preDacSwingLvl == pCoexDm->curDacSwingLvl)) 844 return; 845 } 846 mdelay(30); 847 halbtc8723b2ant_SetSwFullTimeDacSwing(pBtCoexist, bDacSwingOn, dacSwingLvl); 848 849 pCoexDm->bPreDacSwingOn = pCoexDm->bCurDacSwingOn; 850 pCoexDm->preDacSwingLvl = pCoexDm->curDacSwingLvl; 851 } 852 853 static void halbtc8723b2ant_SetAgcTable( 854 PBTC_COEXIST pBtCoexist, bool bAgcTableEn 855 ) 856 { 857 u8 rssiAdjustVal = 0; 858 859 /* BB AGC Gain Table */ 860 if (bAgcTableEn) { 861 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_EXEC, ("[BTCoex], BB Agc Table On!\n")); 862 pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0xc78, 0x6e1A0001); 863 pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0xc78, 0x6d1B0001); 864 pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0xc78, 0x6c1C0001); 865 pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0xc78, 0x6b1D0001); 866 pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0xc78, 0x6a1E0001); 867 pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0xc78, 0x691F0001); 868 pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0xc78, 0x68200001); 869 } else { 870 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_EXEC, ("[BTCoex], BB Agc Table Off!\n")); 871 pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0xc78, 0xaa1A0001); 872 pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0xc78, 0xa91B0001); 873 pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0xc78, 0xa81C0001); 874 pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0xc78, 0xa71D0001); 875 pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0xc78, 0xa61E0001); 876 pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0xc78, 0xa51F0001); 877 pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0xc78, 0xa4200001); 878 } 879 880 881 /* RF Gain */ 882 pBtCoexist->fBtcSetRfReg(pBtCoexist, BTC_RF_A, 0xef, 0xfffff, 0x02000); 883 if (bAgcTableEn) { 884 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_EXEC, ("[BTCoex], Agc Table On!\n")); 885 pBtCoexist->fBtcSetRfReg(pBtCoexist, BTC_RF_A, 0x3b, 0xfffff, 0x38fff); 886 pBtCoexist->fBtcSetRfReg(pBtCoexist, BTC_RF_A, 0x3b, 0xfffff, 0x38ffe); 887 } else { 888 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_EXEC, ("[BTCoex], Agc Table Off!\n")); 889 pBtCoexist->fBtcSetRfReg(pBtCoexist, BTC_RF_A, 0x3b, 0xfffff, 0x380c3); 890 pBtCoexist->fBtcSetRfReg(pBtCoexist, BTC_RF_A, 0x3b, 0xfffff, 0x28ce6); 891 } 892 pBtCoexist->fBtcSetRfReg(pBtCoexist, BTC_RF_A, 0xef, 0xfffff, 0x0); 893 894 pBtCoexist->fBtcSetRfReg(pBtCoexist, BTC_RF_A, 0xed, 0xfffff, 0x1); 895 if (bAgcTableEn) { 896 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_EXEC, ("[BTCoex], Agc Table On!\n")); 897 pBtCoexist->fBtcSetRfReg(pBtCoexist, BTC_RF_A, 0x40, 0xfffff, 0x38fff); 898 pBtCoexist->fBtcSetRfReg(pBtCoexist, BTC_RF_A, 0x40, 0xfffff, 0x38ffe); 899 } else { 900 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_SW_EXEC, ("[BTCoex], Agc Table Off!\n")); 901 pBtCoexist->fBtcSetRfReg(pBtCoexist, BTC_RF_A, 0x40, 0xfffff, 0x380c3); 902 pBtCoexist->fBtcSetRfReg(pBtCoexist, BTC_RF_A, 0x40, 0xfffff, 0x28ce6); 903 } 904 pBtCoexist->fBtcSetRfReg(pBtCoexist, BTC_RF_A, 0xed, 0xfffff, 0x0); 905 906 /* set rssiAdjustVal for wifi module. */ 907 if (bAgcTableEn) 908 rssiAdjustVal = 8; 909 910 pBtCoexist->fBtcSet(pBtCoexist, BTC_SET_U1_RSSI_ADJ_VAL_FOR_AGC_TABLE_ON, &rssiAdjustVal); 911 } 912 913 static void halbtc8723b2ant_AgcTable( 914 PBTC_COEXIST pBtCoexist, bool bForceExec, bool bAgcTableEn 915 ) 916 { 917 BTC_PRINT( 918 BTC_MSG_ALGORITHM, 919 ALGO_TRACE_SW, 920 ( 921 "[BTCoex], %s %s Agc Table\n", 922 (bForceExec ? "force to" : ""), 923 (bAgcTableEn ? "Enable" : "Disable") 924 ) 925 ); 926 pCoexDm->bCurAgcTableEn = bAgcTableEn; 927 928 if (!bForceExec) { 929 BTC_PRINT( 930 BTC_MSG_ALGORITHM, 931 ALGO_TRACE_SW_DETAIL, 932 ( 933 "[BTCoex], bPreAgcTableEn =%d, bCurAgcTableEn =%d\n", 934 pCoexDm->bPreAgcTableEn, 935 pCoexDm->bCurAgcTableEn 936 ) 937 ); 938 939 if (pCoexDm->bPreAgcTableEn == pCoexDm->bCurAgcTableEn) 940 return; 941 } 942 halbtc8723b2ant_SetAgcTable(pBtCoexist, bAgcTableEn); 943 944 pCoexDm->bPreAgcTableEn = pCoexDm->bCurAgcTableEn; 945 } 946 947 static void halbtc8723b2ant_SetCoexTable( 948 PBTC_COEXIST pBtCoexist, 949 u32 val0x6c0, 950 u32 val0x6c4, 951 u32 val0x6c8, 952 u8 val0x6cc 953 ) 954 { 955 BTC_PRINT( 956 BTC_MSG_ALGORITHM, 957 ALGO_TRACE_SW_EXEC, 958 ("[BTCoex], set coex table, set 0x6c0 = 0x%x\n", val0x6c0) 959 ); 960 pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0x6c0, val0x6c0); 961 962 BTC_PRINT( 963 BTC_MSG_ALGORITHM, 964 ALGO_TRACE_SW_EXEC, 965 ("[BTCoex], set coex table, set 0x6c4 = 0x%x\n", val0x6c4) 966 ); 967 pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0x6c4, val0x6c4); 968 969 BTC_PRINT( 970 BTC_MSG_ALGORITHM, 971 ALGO_TRACE_SW_EXEC, 972 ("[BTCoex], set coex table, set 0x6c8 = 0x%x\n", val0x6c8) 973 ); 974 pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0x6c8, val0x6c8); 975 976 BTC_PRINT( 977 BTC_MSG_ALGORITHM, 978 ALGO_TRACE_SW_EXEC, 979 ("[BTCoex], set coex table, set 0x6cc = 0x%x\n", val0x6cc) 980 ); 981 pBtCoexist->fBtcWrite1Byte(pBtCoexist, 0x6cc, val0x6cc); 982 } 983 984 static void halbtc8723b2ant_CoexTable( 985 PBTC_COEXIST pBtCoexist, 986 bool bForceExec, 987 u32 val0x6c0, 988 u32 val0x6c4, 989 u32 val0x6c8, 990 u8 val0x6cc 991 ) 992 { 993 BTC_PRINT( 994 BTC_MSG_ALGORITHM, 995 ALGO_TRACE_SW, 996 ( 997 "[BTCoex], %s write Coex Table 0x6c0 = 0x%x, 0x6c4 = 0x%x, 0x6c8 = 0x%x, 0x6cc = 0x%x\n", 998 (bForceExec ? "force to" : ""), 999 val0x6c0, 1000 val0x6c4, 1001 val0x6c8, 1002 val0x6cc 1003 ) 1004 ); 1005 pCoexDm->curVal0x6c0 = val0x6c0; 1006 pCoexDm->curVal0x6c4 = val0x6c4; 1007 pCoexDm->curVal0x6c8 = val0x6c8; 1008 pCoexDm->curVal0x6cc = val0x6cc; 1009 1010 if (!bForceExec) { 1011 BTC_PRINT( 1012 BTC_MSG_ALGORITHM, 1013 ALGO_TRACE_SW_DETAIL, 1014 ( 1015 "[BTCoex], preVal0x6c0 = 0x%x, preVal0x6c4 = 0x%x, preVal0x6c8 = 0x%x, preVal0x6cc = 0x%x !!\n", 1016 pCoexDm->preVal0x6c0, 1017 pCoexDm->preVal0x6c4, 1018 pCoexDm->preVal0x6c8, 1019 pCoexDm->preVal0x6cc 1020 ) 1021 ); 1022 BTC_PRINT( 1023 BTC_MSG_ALGORITHM, 1024 ALGO_TRACE_SW_DETAIL, 1025 ( 1026 "[BTCoex], curVal0x6c0 = 0x%x, curVal0x6c4 = 0x%x, curVal0x6c8 = 0x%x, curVal0x6cc = 0x%x !!\n", 1027 pCoexDm->curVal0x6c0, 1028 pCoexDm->curVal0x6c4, 1029 pCoexDm->curVal0x6c8, 1030 pCoexDm->curVal0x6cc 1031 ) 1032 ); 1033 1034 if ( 1035 (pCoexDm->preVal0x6c0 == pCoexDm->curVal0x6c0) && 1036 (pCoexDm->preVal0x6c4 == pCoexDm->curVal0x6c4) && 1037 (pCoexDm->preVal0x6c8 == pCoexDm->curVal0x6c8) && 1038 (pCoexDm->preVal0x6cc == pCoexDm->curVal0x6cc) 1039 ) 1040 return; 1041 } 1042 halbtc8723b2ant_SetCoexTable(pBtCoexist, val0x6c0, val0x6c4, val0x6c8, val0x6cc); 1043 1044 pCoexDm->preVal0x6c0 = pCoexDm->curVal0x6c0; 1045 pCoexDm->preVal0x6c4 = pCoexDm->curVal0x6c4; 1046 pCoexDm->preVal0x6c8 = pCoexDm->curVal0x6c8; 1047 pCoexDm->preVal0x6cc = pCoexDm->curVal0x6cc; 1048 } 1049 1050 static void halbtc8723b2ant_CoexTableWithType( 1051 PBTC_COEXIST pBtCoexist, bool bForceExec, u8 type 1052 ) 1053 { 1054 switch (type) { 1055 case 0: 1056 halbtc8723b2ant_CoexTable(pBtCoexist, bForceExec, 0x55555555, 0x55555555, 0xffff, 0x3); 1057 break; 1058 case 1: 1059 halbtc8723b2ant_CoexTable(pBtCoexist, bForceExec, 0x55555555, 0x5afa5afa, 0xffff, 0x3); 1060 break; 1061 case 2: 1062 halbtc8723b2ant_CoexTable(pBtCoexist, bForceExec, 0x5a5a5a5a, 0x5a5a5a5a, 0xffff, 0x3); 1063 break; 1064 case 3: 1065 halbtc8723b2ant_CoexTable(pBtCoexist, bForceExec, 0xaaaaaaaa, 0xaaaaaaaa, 0xffff, 0x3); 1066 break; 1067 case 4: 1068 halbtc8723b2ant_CoexTable(pBtCoexist, bForceExec, 0xffffffff, 0xffffffff, 0xffff, 0x3); 1069 break; 1070 case 5: 1071 halbtc8723b2ant_CoexTable(pBtCoexist, bForceExec, 0x5fff5fff, 0x5fff5fff, 0xffff, 0x3); 1072 break; 1073 case 6: 1074 halbtc8723b2ant_CoexTable(pBtCoexist, bForceExec, 0x55ff55ff, 0x5a5a5a5a, 0xffff, 0x3); 1075 break; 1076 case 7: 1077 halbtc8723b2ant_CoexTable(pBtCoexist, bForceExec, 0x55ff55ff, 0xfafafafa, 0xffff, 0x3); 1078 break; 1079 case 8: 1080 halbtc8723b2ant_CoexTable(pBtCoexist, bForceExec, 0x5aea5aea, 0x5aea5aea, 0xffff, 0x3); 1081 break; 1082 case 9: 1083 halbtc8723b2ant_CoexTable(pBtCoexist, bForceExec, 0x55ff55ff, 0x5aea5aea, 0xffff, 0x3); 1084 break; 1085 case 10: 1086 halbtc8723b2ant_CoexTable(pBtCoexist, bForceExec, 0x55ff55ff, 0x5aff5aff, 0xffff, 0x3); 1087 break; 1088 case 11: 1089 halbtc8723b2ant_CoexTable(pBtCoexist, bForceExec, 0x55ff55ff, 0x5a5f5a5f, 0xffff, 0x3); 1090 break; 1091 case 12: 1092 halbtc8723b2ant_CoexTable(pBtCoexist, bForceExec, 0x55ff55ff, 0x5f5f5f5f, 0xffff, 0x3); 1093 break; 1094 default: 1095 break; 1096 } 1097 } 1098 1099 static void halbtc8723b2ant_SetFwIgnoreWlanAct( 1100 PBTC_COEXIST pBtCoexist, bool bEnable 1101 ) 1102 { 1103 u8 H2C_Parameter[1] = {0}; 1104 1105 if (bEnable) 1106 H2C_Parameter[0] |= BIT0; /* function enable */ 1107 1108 BTC_PRINT( 1109 BTC_MSG_ALGORITHM, 1110 ALGO_TRACE_FW_EXEC, 1111 ( 1112 "[BTCoex], set FW for BT Ignore Wlan_Act, FW write 0x63 = 0x%x\n", 1113 H2C_Parameter[0] 1114 ) 1115 ); 1116 1117 pBtCoexist->fBtcFillH2c(pBtCoexist, 0x63, 1, H2C_Parameter); 1118 } 1119 1120 static void halbtc8723b2ant_IgnoreWlanAct( 1121 PBTC_COEXIST pBtCoexist, bool bForceExec, bool bEnable 1122 ) 1123 { 1124 BTC_PRINT( 1125 BTC_MSG_ALGORITHM, 1126 ALGO_TRACE_FW, 1127 ( 1128 "[BTCoex], %s turn Ignore WlanAct %s\n", 1129 (bForceExec ? "force to" : ""), 1130 (bEnable ? "ON" : "OFF") 1131 ) 1132 ); 1133 1134 pCoexDm->bCurIgnoreWlanAct = bEnable; 1135 1136 if (!bForceExec) { 1137 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL, ("[BTCoex], bPreIgnoreWlanAct = %d, bCurIgnoreWlanAct = %d!!\n", 1138 pCoexDm->bPreIgnoreWlanAct, pCoexDm->bCurIgnoreWlanAct)); 1139 1140 if (pCoexDm->bPreIgnoreWlanAct == pCoexDm->bCurIgnoreWlanAct) 1141 return; 1142 } 1143 halbtc8723b2ant_SetFwIgnoreWlanAct(pBtCoexist, bEnable); 1144 1145 pCoexDm->bPreIgnoreWlanAct = pCoexDm->bCurIgnoreWlanAct; 1146 } 1147 1148 static void halbtc8723b2ant_SetFwPstdma( 1149 PBTC_COEXIST pBtCoexist, 1150 u8 byte1, 1151 u8 byte2, 1152 u8 byte3, 1153 u8 byte4, 1154 u8 byte5 1155 ) 1156 { 1157 u8 H2C_Parameter[5] = {0}; 1158 1159 H2C_Parameter[0] = byte1; 1160 H2C_Parameter[1] = byte2; 1161 H2C_Parameter[2] = byte3; 1162 H2C_Parameter[3] = byte4; 1163 H2C_Parameter[4] = byte5; 1164 1165 pCoexDm->psTdmaPara[0] = byte1; 1166 pCoexDm->psTdmaPara[1] = byte2; 1167 pCoexDm->psTdmaPara[2] = byte3; 1168 pCoexDm->psTdmaPara[3] = byte4; 1169 pCoexDm->psTdmaPara[4] = byte5; 1170 1171 BTC_PRINT( 1172 BTC_MSG_ALGORITHM, 1173 ALGO_TRACE_FW_EXEC, 1174 ( 1175 "[BTCoex], FW write 0x60(5bytes) = 0x%x%08x\n", 1176 H2C_Parameter[0], 1177 H2C_Parameter[1]<<24| 1178 H2C_Parameter[2]<<16| 1179 H2C_Parameter[3]<<8| 1180 H2C_Parameter[4] 1181 ) 1182 ); 1183 1184 pBtCoexist->fBtcFillH2c(pBtCoexist, 0x60, 5, H2C_Parameter); 1185 } 1186 1187 static void halbtc8723b2ant_SwMechanism1( 1188 PBTC_COEXIST pBtCoexist, 1189 bool bShrinkRxLPF, 1190 bool bLowPenaltyRA, 1191 bool bLimitedDIG, 1192 bool bBTLNAConstrain 1193 ) 1194 { 1195 halbtc8723b2ant_RfShrink(pBtCoexist, NORMAL_EXEC, bShrinkRxLPF); 1196 halbtc8723b2ant_LowPenaltyRa(pBtCoexist, NORMAL_EXEC, bLowPenaltyRA); 1197 } 1198 1199 static void halbtc8723b2ant_SwMechanism2( 1200 PBTC_COEXIST pBtCoexist, 1201 bool bAGCTableShift, 1202 bool bADCBackOff, 1203 bool bSWDACSwing, 1204 u32 dacSwingLvl 1205 ) 1206 { 1207 halbtc8723b2ant_AgcTable(pBtCoexist, NORMAL_EXEC, bAGCTableShift); 1208 halbtc8723b2ant_DacSwing(pBtCoexist, NORMAL_EXEC, bSWDACSwing, dacSwingLvl); 1209 } 1210 1211 static void halbtc8723b2ant_SetAntPath( 1212 PBTC_COEXIST pBtCoexist, u8 antPosType, bool bInitHwCfg, bool bWifiOff 1213 ) 1214 { 1215 PBTC_BOARD_INFO pBoardInfo = &pBtCoexist->boardInfo; 1216 u32 fwVer = 0, u4Tmp = 0; 1217 bool bPgExtSwitch = false; 1218 bool bUseExtSwitch = false; 1219 u8 H2C_Parameter[2] = {0}; 1220 1221 pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_EXT_SWITCH, &bPgExtSwitch); 1222 pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_U4_WIFI_FW_VER, &fwVer); /* [31:16]=fw ver, [15:0]=fw sub ver */ 1223 1224 if ((fwVer > 0 && fwVer < 0xc0000) || bPgExtSwitch) 1225 bUseExtSwitch = true; 1226 1227 if (bInitHwCfg) { 1228 pBtCoexist->fBtcWrite1ByteBitMask(pBtCoexist, 0x39, 0x8, 0x1); 1229 pBtCoexist->fBtcWrite1Byte(pBtCoexist, 0x974, 0xff); 1230 pBtCoexist->fBtcWrite1ByteBitMask(pBtCoexist, 0x944, 0x3, 0x3); 1231 pBtCoexist->fBtcWrite1Byte(pBtCoexist, 0x930, 0x77); 1232 pBtCoexist->fBtcWrite1ByteBitMask(pBtCoexist, 0x67, 0x20, 0x1); 1233 1234 if (fwVer >= 0x180000) { 1235 /* Use H2C to set GNT_BT to LOW */ 1236 H2C_Parameter[0] = 0; 1237 pBtCoexist->fBtcFillH2c(pBtCoexist, 0x6E, 1, H2C_Parameter); 1238 } else { 1239 pBtCoexist->fBtcWrite1Byte(pBtCoexist, 0x765, 0x0); 1240 } 1241 1242 pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0x948, 0x0); 1243 1244 pBtCoexist->fBtcSetRfReg(pBtCoexist, BTC_RF_A, 0x1, 0xfffff, 0x0); /* WiFi TRx Mask off */ 1245 pBtCoexist->fBtcSetBtReg(pBtCoexist, BTC_BT_REG_RF, 0x3c, 0x01); /* BT TRx Mask off */ 1246 1247 if (pBoardInfo->btdmAntPos == BTC_ANTENNA_AT_MAIN_PORT) { 1248 /* tell firmware "no antenna inverse" */ 1249 H2C_Parameter[0] = 0; 1250 } else { 1251 /* tell firmware "antenna inverse" */ 1252 H2C_Parameter[0] = 1; 1253 } 1254 1255 if (bUseExtSwitch) { 1256 /* ext switch type */ 1257 H2C_Parameter[1] = 1; 1258 } else { 1259 /* int switch type */ 1260 H2C_Parameter[1] = 0; 1261 } 1262 pBtCoexist->fBtcFillH2c(pBtCoexist, 0x65, 2, H2C_Parameter); 1263 } 1264 1265 /* ext switch setting */ 1266 if (bUseExtSwitch) { 1267 if (bInitHwCfg) { 1268 /* 0x4c[23]= 0, 0x4c[24]= 1 Antenna control by WL/BT */ 1269 u4Tmp = pBtCoexist->fBtcRead4Byte(pBtCoexist, 0x4c); 1270 u4Tmp &= ~BIT23; 1271 u4Tmp |= BIT24; 1272 pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0x4c, u4Tmp); 1273 } 1274 1275 pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0x948, 0x0); /* fixed internal switch S1->WiFi, S0->BT */ 1276 switch (antPosType) { 1277 case BTC_ANT_WIFI_AT_MAIN: 1278 pBtCoexist->fBtcWrite1ByteBitMask(pBtCoexist, 0x92c, 0x3, 0x1); /* ext switch main at wifi */ 1279 break; 1280 case BTC_ANT_WIFI_AT_AUX: 1281 pBtCoexist->fBtcWrite1ByteBitMask(pBtCoexist, 0x92c, 0x3, 0x2); /* ext switch aux at wifi */ 1282 break; 1283 } 1284 } else { /* internal switch */ 1285 if (bInitHwCfg) { 1286 /* 0x4c[23]= 0, 0x4c[24]= 1 Antenna control by WL/BT */ 1287 u4Tmp = pBtCoexist->fBtcRead4Byte(pBtCoexist, 0x4c); 1288 u4Tmp |= BIT23; 1289 u4Tmp &= ~BIT24; 1290 pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0x4c, u4Tmp); 1291 } 1292 1293 pBtCoexist->fBtcWrite1ByteBitMask(pBtCoexist, 0x64, 0x1, 0x0); /* fixed external switch S1->Main, S0->Aux */ 1294 switch (antPosType) { 1295 case BTC_ANT_WIFI_AT_MAIN: 1296 pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0x948, 0x0); /* fixed internal switch S1->WiFi, S0->BT */ 1297 break; 1298 case BTC_ANT_WIFI_AT_AUX: 1299 pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0x948, 0x280); /* fixed internal switch S0->WiFi, S1->BT */ 1300 break; 1301 } 1302 } 1303 } 1304 1305 static void halbtc8723b2ant_PsTdma( 1306 PBTC_COEXIST pBtCoexist, bool bForceExec, bool bTurnOn, u8 type 1307 ) 1308 { 1309 BTC_PRINT( 1310 BTC_MSG_ALGORITHM, 1311 ALGO_TRACE_FW, 1312 ( 1313 "[BTCoex], %s turn %s PS TDMA, type =%d\n", 1314 (bForceExec ? "force to" : ""), 1315 (bTurnOn ? "ON" : "OFF"), 1316 type 1317 ) 1318 ); 1319 pCoexDm->bCurPsTdmaOn = bTurnOn; 1320 pCoexDm->curPsTdma = type; 1321 1322 if (!bForceExec) { 1323 BTC_PRINT( 1324 BTC_MSG_ALGORITHM, 1325 ALGO_TRACE_FW_DETAIL, 1326 ( 1327 "[BTCoex], bPrePsTdmaOn = %d, bCurPsTdmaOn = %d!!\n", 1328 pCoexDm->bPrePsTdmaOn, 1329 pCoexDm->bCurPsTdmaOn 1330 ) 1331 ); 1332 BTC_PRINT( 1333 BTC_MSG_ALGORITHM, 1334 ALGO_TRACE_FW_DETAIL, 1335 ( 1336 "[BTCoex], prePsTdma = %d, curPsTdma = %d!!\n", 1337 pCoexDm->prePsTdma, pCoexDm->curPsTdma 1338 ) 1339 ); 1340 1341 if ( 1342 (pCoexDm->bPrePsTdmaOn == pCoexDm->bCurPsTdmaOn) && 1343 (pCoexDm->prePsTdma == pCoexDm->curPsTdma) 1344 ) 1345 return; 1346 } 1347 1348 if (bTurnOn) { 1349 switch (type) { 1350 case 1: 1351 default: 1352 halbtc8723b2ant_SetFwPstdma(pBtCoexist, 0xe3, 0x1a, 0x1a, 0xe1, 0x90); 1353 break; 1354 case 2: 1355 halbtc8723b2ant_SetFwPstdma(pBtCoexist, 0xe3, 0x12, 0x12, 0xe1, 0x90); 1356 break; 1357 case 3: 1358 halbtc8723b2ant_SetFwPstdma(pBtCoexist, 0xe3, 0x1c, 0x3, 0xf1, 0x90); 1359 break; 1360 case 4: 1361 halbtc8723b2ant_SetFwPstdma(pBtCoexist, 0xe3, 0x10, 0x03, 0xf1, 0x90); 1362 break; 1363 case 5: 1364 halbtc8723b2ant_SetFwPstdma(pBtCoexist, 0xe3, 0x1a, 0x1a, 0x60, 0x90); 1365 break; 1366 case 6: 1367 halbtc8723b2ant_SetFwPstdma(pBtCoexist, 0xe3, 0x12, 0x12, 0x60, 0x90); 1368 break; 1369 case 7: 1370 halbtc8723b2ant_SetFwPstdma(pBtCoexist, 0xe3, 0x1c, 0x3, 0x70, 0x90); 1371 break; 1372 case 8: 1373 halbtc8723b2ant_SetFwPstdma(pBtCoexist, 0xa3, 0x10, 0x3, 0x70, 0x90); 1374 break; 1375 case 9: 1376 halbtc8723b2ant_SetFwPstdma(pBtCoexist, 0xe3, 0x1a, 0x1a, 0xe1, 0x90); 1377 break; 1378 case 10: 1379 halbtc8723b2ant_SetFwPstdma(pBtCoexist, 0xe3, 0x12, 0x12, 0xe1, 0x90); 1380 break; 1381 case 11: 1382 halbtc8723b2ant_SetFwPstdma(pBtCoexist, 0xe3, 0xa, 0xa, 0xe1, 0x90); 1383 break; 1384 case 12: 1385 halbtc8723b2ant_SetFwPstdma(pBtCoexist, 0xe3, 0x5, 0x5, 0xe1, 0x90); 1386 break; 1387 case 13: 1388 halbtc8723b2ant_SetFwPstdma(pBtCoexist, 0xe3, 0x1a, 0x1a, 0x60, 0x90); 1389 break; 1390 case 14: 1391 halbtc8723b2ant_SetFwPstdma(pBtCoexist, 0xe3, 0x12, 0x12, 0x60, 0x90); 1392 break; 1393 case 15: 1394 halbtc8723b2ant_SetFwPstdma(pBtCoexist, 0xe3, 0xa, 0xa, 0x60, 0x90); 1395 break; 1396 case 16: 1397 halbtc8723b2ant_SetFwPstdma(pBtCoexist, 0xe3, 0x5, 0x5, 0x60, 0x90); 1398 break; 1399 case 17: 1400 halbtc8723b2ant_SetFwPstdma(pBtCoexist, 0xa3, 0x2f, 0x2f, 0x60, 0x90); 1401 break; 1402 case 18: 1403 halbtc8723b2ant_SetFwPstdma(pBtCoexist, 0xe3, 0x5, 0x5, 0xe1, 0x90); 1404 break; 1405 case 19: 1406 halbtc8723b2ant_SetFwPstdma(pBtCoexist, 0xe3, 0x25, 0x25, 0xe1, 0x90); 1407 break; 1408 case 20: 1409 halbtc8723b2ant_SetFwPstdma(pBtCoexist, 0xe3, 0x25, 0x25, 0x60, 0x90); 1410 break; 1411 case 21: 1412 halbtc8723b2ant_SetFwPstdma(pBtCoexist, 0xe3, 0x15, 0x03, 0x70, 0x90); 1413 break; 1414 case 71: 1415 halbtc8723b2ant_SetFwPstdma(pBtCoexist, 0xe3, 0x1a, 0x1a, 0xe1, 0x90); 1416 break; 1417 } 1418 } else { 1419 /* disable PS tdma */ 1420 switch (type) { 1421 case 0: 1422 halbtc8723b2ant_SetFwPstdma(pBtCoexist, 0x0, 0x0, 0x0, 0x40, 0x0); 1423 break; 1424 case 1: 1425 halbtc8723b2ant_SetFwPstdma(pBtCoexist, 0x0, 0x0, 0x0, 0x48, 0x0); 1426 break; 1427 default: 1428 halbtc8723b2ant_SetFwPstdma(pBtCoexist, 0x0, 0x0, 0x0, 0x40, 0x0); 1429 break; 1430 } 1431 } 1432 1433 /* update pre state */ 1434 pCoexDm->bPrePsTdmaOn = pCoexDm->bCurPsTdmaOn; 1435 pCoexDm->prePsTdma = pCoexDm->curPsTdma; 1436 } 1437 1438 static void halbtc8723b2ant_CoexAllOff(PBTC_COEXIST pBtCoexist) 1439 { 1440 /* fw all off */ 1441 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, false, 1); 1442 halbtc8723b2ant_FwDacSwingLvl(pBtCoexist, NORMAL_EXEC, 6); 1443 halbtc8723b2ant_DecBtPwr(pBtCoexist, NORMAL_EXEC, 0); 1444 1445 /* sw all off */ 1446 halbtc8723b2ant_SwMechanism1(pBtCoexist, false, false, false, false); 1447 halbtc8723b2ant_SwMechanism2(pBtCoexist, false, false, false, 0x18); 1448 1449 /* hw all off */ 1450 /* pBtCoexist->fBtcSetRfReg(pBtCoexist, BTC_RF_A, 0x1, 0xfffff, 0x0); */ 1451 halbtc8723b2ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 0); 1452 } 1453 1454 static void halbtc8723b2ant_InitCoexDm(PBTC_COEXIST pBtCoexist) 1455 { 1456 /* force to reset coex mechanism */ 1457 1458 halbtc8723b2ant_PsTdma(pBtCoexist, FORCE_EXEC, false, 1); 1459 halbtc8723b2ant_FwDacSwingLvl(pBtCoexist, FORCE_EXEC, 6); 1460 halbtc8723b2ant_DecBtPwr(pBtCoexist, FORCE_EXEC, 0); 1461 1462 halbtc8723b2ant_SwMechanism1(pBtCoexist, false, false, false, false); 1463 halbtc8723b2ant_SwMechanism2(pBtCoexist, false, false, false, 0x18); 1464 } 1465 1466 static void halbtc8723b2ant_ActionBtInquiry(PBTC_COEXIST pBtCoexist) 1467 { 1468 bool bWifiConnected = false; 1469 bool bLowPwrDisable = true; 1470 1471 pBtCoexist->fBtcSet(pBtCoexist, BTC_SET_ACT_DISABLE_LOW_POWER, &bLowPwrDisable); 1472 pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_WIFI_CONNECTED, &bWifiConnected); 1473 1474 if (bWifiConnected) { 1475 halbtc8723b2ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 7); 1476 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 3); 1477 } else { 1478 halbtc8723b2ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 0); 1479 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, false, 1); 1480 } 1481 1482 halbtc8723b2ant_FwDacSwingLvl(pBtCoexist, FORCE_EXEC, 6); 1483 halbtc8723b2ant_DecBtPwr(pBtCoexist, NORMAL_EXEC, 0); 1484 1485 halbtc8723b2ant_SwMechanism1(pBtCoexist, false, false, false, false); 1486 halbtc8723b2ant_SwMechanism2(pBtCoexist, false, false, false, 0x18); 1487 1488 pCoexDm->bNeedRecover0x948 = true; 1489 pCoexDm->backup0x948 = pBtCoexist->fBtcRead4Byte(pBtCoexist, 0x948); 1490 1491 halbtc8723b2ant_SetAntPath(pBtCoexist, BTC_ANT_WIFI_AT_AUX, false, false); 1492 } 1493 1494 static bool halbtc8723b2ant_IsCommonAction(PBTC_COEXIST pBtCoexist) 1495 { 1496 u8 btRssiState = BTC_RSSI_STATE_HIGH; 1497 bool bCommon = false, bWifiConnected = false, bWifiBusy = false; 1498 bool bBtHsOn = false, bLowPwrDisable = false; 1499 1500 pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_HS_OPERATION, &bBtHsOn); 1501 pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_WIFI_CONNECTED, &bWifiConnected); 1502 pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_WIFI_BUSY, &bWifiBusy); 1503 1504 if (!bWifiConnected) { 1505 bLowPwrDisable = false; 1506 pBtCoexist->fBtcSet(pBtCoexist, BTC_SET_ACT_DISABLE_LOW_POWER, &bLowPwrDisable); 1507 halbtc8723b2ant_LimitedRx(pBtCoexist, NORMAL_EXEC, false, false, 0x8); 1508 1509 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], Wifi non-connected idle!!\n")); 1510 1511 pBtCoexist->fBtcSetRfReg(pBtCoexist, BTC_RF_A, 0x1, 0xfffff, 0x0); 1512 halbtc8723b2ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 0); 1513 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, false, 1); 1514 halbtc8723b2ant_FwDacSwingLvl(pBtCoexist, NORMAL_EXEC, 6); 1515 halbtc8723b2ant_DecBtPwr(pBtCoexist, NORMAL_EXEC, 0); 1516 1517 halbtc8723b2ant_SwMechanism1(pBtCoexist, false, false, false, false); 1518 halbtc8723b2ant_SwMechanism2(pBtCoexist, false, false, false, 0x18); 1519 1520 bCommon = true; 1521 } else { 1522 if (BT_8723B_2ANT_BT_STATUS_NON_CONNECTED_IDLE == pCoexDm->btStatus) { 1523 bLowPwrDisable = false; 1524 pBtCoexist->fBtcSet(pBtCoexist, BTC_SET_ACT_DISABLE_LOW_POWER, &bLowPwrDisable); 1525 halbtc8723b2ant_LimitedRx(pBtCoexist, NORMAL_EXEC, false, false, 0x8); 1526 1527 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], Wifi connected + BT non connected-idle!!\n")); 1528 1529 pBtCoexist->fBtcSetRfReg(pBtCoexist, BTC_RF_A, 0x1, 0xfffff, 0x0); 1530 halbtc8723b2ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 0); 1531 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, false, 1); 1532 halbtc8723b2ant_FwDacSwingLvl(pBtCoexist, NORMAL_EXEC, 0xb); 1533 halbtc8723b2ant_DecBtPwr(pBtCoexist, NORMAL_EXEC, 0); 1534 1535 halbtc8723b2ant_SwMechanism1(pBtCoexist, false, false, false, false); 1536 halbtc8723b2ant_SwMechanism2(pBtCoexist, false, false, false, 0x18); 1537 1538 bCommon = true; 1539 } else if (BT_8723B_2ANT_BT_STATUS_CONNECTED_IDLE == pCoexDm->btStatus) { 1540 bLowPwrDisable = true; 1541 pBtCoexist->fBtcSet(pBtCoexist, BTC_SET_ACT_DISABLE_LOW_POWER, &bLowPwrDisable); 1542 1543 if (bBtHsOn) 1544 return false; 1545 1546 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], Wifi connected + BT connected-idle!!\n")); 1547 halbtc8723b2ant_LimitedRx(pBtCoexist, NORMAL_EXEC, false, false, 0x8); 1548 1549 pBtCoexist->fBtcSetRfReg(pBtCoexist, BTC_RF_A, 0x1, 0xfffff, 0x0); 1550 halbtc8723b2ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 0); 1551 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, false, 1); 1552 halbtc8723b2ant_FwDacSwingLvl(pBtCoexist, NORMAL_EXEC, 0xb); 1553 halbtc8723b2ant_DecBtPwr(pBtCoexist, NORMAL_EXEC, 0); 1554 1555 halbtc8723b2ant_SwMechanism1(pBtCoexist, true, false, false, false); 1556 halbtc8723b2ant_SwMechanism2(pBtCoexist, false, false, false, 0x18); 1557 1558 bCommon = true; 1559 } else { 1560 bLowPwrDisable = true; 1561 pBtCoexist->fBtcSet(pBtCoexist, BTC_SET_ACT_DISABLE_LOW_POWER, &bLowPwrDisable); 1562 1563 if (bWifiBusy) { 1564 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], Wifi Connected-Busy + BT Busy!!\n")); 1565 bCommon = false; 1566 } else { 1567 if (bBtHsOn) 1568 return false; 1569 1570 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], Wifi Connected-Idle + BT Busy!!\n")); 1571 btRssiState = halbtc8723b2ant_BtRssiState(2, 29, 0); 1572 halbtc8723b2ant_LimitedRx(pBtCoexist, NORMAL_EXEC, false, false, 0x8); 1573 1574 pBtCoexist->fBtcSetRfReg(pBtCoexist, BTC_RF_A, 0x1, 0xfffff, 0x0); 1575 halbtc8723b2ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 7); 1576 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 21); 1577 halbtc8723b2ant_FwDacSwingLvl(pBtCoexist, NORMAL_EXEC, 0xb); 1578 1579 if (BTC_RSSI_HIGH(btRssiState)) 1580 halbtc8723b2ant_DecBtPwr(pBtCoexist, NORMAL_EXEC, 2); 1581 else 1582 halbtc8723b2ant_DecBtPwr(pBtCoexist, NORMAL_EXEC, 0); 1583 1584 halbtc8723b2ant_SwMechanism1(pBtCoexist, false, false, false, false); 1585 halbtc8723b2ant_SwMechanism2(pBtCoexist, false, false, false, 0x18); 1586 bCommon = true; 1587 } 1588 } 1589 } 1590 1591 return bCommon; 1592 } 1593 1594 static void halbtc8723b2ant_TdmaDurationAdjust( 1595 PBTC_COEXIST pBtCoexist, bool bScoHid, bool bTxPause, u8 maxInterval 1596 ) 1597 { 1598 static s32 up, dn, m, n, WaitCount; 1599 s32 result; /* 0: no change, +1: increase WiFi duration, -1: decrease WiFi duration */ 1600 u8 retryCount = 0; 1601 1602 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW, ("[BTCoex], TdmaDurationAdjust()\n")); 1603 1604 if (!pCoexDm->bAutoTdmaAdjust) { 1605 pCoexDm->bAutoTdmaAdjust = true; 1606 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL, ("[BTCoex], first run TdmaDurationAdjust()!!\n")); 1607 { 1608 if (bScoHid) { 1609 if (bTxPause) { 1610 if (maxInterval == 1) { 1611 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 13); 1612 pCoexDm->psTdmaDuAdjType = 13; 1613 } else if (maxInterval == 2) { 1614 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 14); 1615 pCoexDm->psTdmaDuAdjType = 14; 1616 } else if (maxInterval == 3) { 1617 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 15); 1618 pCoexDm->psTdmaDuAdjType = 15; 1619 } else { 1620 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 15); 1621 pCoexDm->psTdmaDuAdjType = 15; 1622 } 1623 } else { 1624 if (maxInterval == 1) { 1625 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 9); 1626 pCoexDm->psTdmaDuAdjType = 9; 1627 } else if (maxInterval == 2) { 1628 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 10); 1629 pCoexDm->psTdmaDuAdjType = 10; 1630 } else if (maxInterval == 3) { 1631 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 11); 1632 pCoexDm->psTdmaDuAdjType = 11; 1633 } else { 1634 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 11); 1635 pCoexDm->psTdmaDuAdjType = 11; 1636 } 1637 } 1638 } else { 1639 if (bTxPause) { 1640 if (maxInterval == 1) { 1641 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 5); 1642 pCoexDm->psTdmaDuAdjType = 5; 1643 } else if (maxInterval == 2) { 1644 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 6); 1645 pCoexDm->psTdmaDuAdjType = 6; 1646 } else if (maxInterval == 3) { 1647 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 7); 1648 pCoexDm->psTdmaDuAdjType = 7; 1649 } else { 1650 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 7); 1651 pCoexDm->psTdmaDuAdjType = 7; 1652 } 1653 } else { 1654 if (maxInterval == 1) { 1655 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 1); 1656 pCoexDm->psTdmaDuAdjType = 1; 1657 } else if (maxInterval == 2) { 1658 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 2); 1659 pCoexDm->psTdmaDuAdjType = 2; 1660 } else if (maxInterval == 3) { 1661 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 3); 1662 pCoexDm->psTdmaDuAdjType = 3; 1663 } else { 1664 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 3); 1665 pCoexDm->psTdmaDuAdjType = 3; 1666 } 1667 } 1668 } 1669 } 1670 /* */ 1671 up = 0; 1672 dn = 0; 1673 m = 1; 1674 n = 3; 1675 result = 0; 1676 WaitCount = 0; 1677 } else { 1678 /* accquire the BT TRx retry count from BT_Info byte2 */ 1679 retryCount = pCoexSta->btRetryCnt; 1680 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL, ("[BTCoex], retryCount = %d\n", retryCount)); 1681 BTC_PRINT( 1682 BTC_MSG_ALGORITHM, 1683 ALGO_TRACE_FW_DETAIL, 1684 ( 1685 "[BTCoex], up =%d, dn =%d, m =%d, n =%d, WaitCount =%d\n", 1686 up, dn, m, n, WaitCount 1687 ) 1688 ); 1689 result = 0; 1690 WaitCount++; 1691 1692 if (retryCount == 0) { /* no retry in the last 2-second duration */ 1693 up++; 1694 dn--; 1695 1696 if (dn <= 0) 1697 dn = 0; 1698 1699 if (up >= n) { /* if 連續 n 個2秒 retry count為0, 則調寬WiFi duration */ 1700 WaitCount = 0; 1701 n = 3; 1702 up = 0; 1703 dn = 0; 1704 result = 1; 1705 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL, ("[BTCoex], Increase wifi duration!!\n")); 1706 } 1707 } else if (retryCount <= 3) { /* <=3 retry in the last 2-second duration */ 1708 up--; 1709 dn++; 1710 1711 if (up <= 0) 1712 up = 0; 1713 1714 if (dn == 2) { /* if 連續 2 個2秒 retry count< 3, 則調窄WiFi duration */ 1715 if (WaitCount <= 2) 1716 m++; /* 避免一直在兩個level中來回 */ 1717 else 1718 m = 1; 1719 1720 if (m >= 20) /* m 最大值 = 20 ' 最大120秒 recheck是否調整 WiFi duration. */ 1721 m = 20; 1722 1723 n = 3*m; 1724 up = 0; 1725 dn = 0; 1726 WaitCount = 0; 1727 result = -1; 1728 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL, ("[BTCoex], Decrease wifi duration for retryCounter<3!!\n")); 1729 } 1730 } else { /* retry count > 3, 只要1次 retry count > 3, 則調窄WiFi duration */ 1731 if (WaitCount == 1) 1732 m++; /* 避免一直在兩個level中來回 */ 1733 else 1734 m = 1; 1735 1736 if (m >= 20) /* m 最大值 = 20 ' 最大120秒 recheck是否調整 WiFi duration. */ 1737 m = 20; 1738 1739 n = 3*m; 1740 up = 0; 1741 dn = 0; 1742 WaitCount = 0; 1743 result = -1; 1744 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL, ("[BTCoex], Decrease wifi duration for retryCounter>3!!\n")); 1745 } 1746 1747 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL, ("[BTCoex], max Interval = %d\n", maxInterval)); 1748 if (maxInterval == 1) { 1749 if (bTxPause) { 1750 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL, ("[BTCoex], TxPause = 1\n")); 1751 1752 if (pCoexDm->curPsTdma == 71) { 1753 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 5); 1754 pCoexDm->psTdmaDuAdjType = 5; 1755 } else if (pCoexDm->curPsTdma == 1) { 1756 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 5); 1757 pCoexDm->psTdmaDuAdjType = 5; 1758 } else if (pCoexDm->curPsTdma == 2) { 1759 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 6); 1760 pCoexDm->psTdmaDuAdjType = 6; 1761 } else if (pCoexDm->curPsTdma == 3) { 1762 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 7); 1763 pCoexDm->psTdmaDuAdjType = 7; 1764 } else if (pCoexDm->curPsTdma == 4) { 1765 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 8); 1766 pCoexDm->psTdmaDuAdjType = 8; 1767 } 1768 1769 if (pCoexDm->curPsTdma == 9) { 1770 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 13); 1771 pCoexDm->psTdmaDuAdjType = 13; 1772 } else if (pCoexDm->curPsTdma == 10) { 1773 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 14); 1774 pCoexDm->psTdmaDuAdjType = 14; 1775 } else if (pCoexDm->curPsTdma == 11) { 1776 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 15); 1777 pCoexDm->psTdmaDuAdjType = 15; 1778 } else if (pCoexDm->curPsTdma == 12) { 1779 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 16); 1780 pCoexDm->psTdmaDuAdjType = 16; 1781 } 1782 1783 if (result == -1) { 1784 if (pCoexDm->curPsTdma == 5) { 1785 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 6); 1786 pCoexDm->psTdmaDuAdjType = 6; 1787 } else if (pCoexDm->curPsTdma == 6) { 1788 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 7); 1789 pCoexDm->psTdmaDuAdjType = 7; 1790 } else if (pCoexDm->curPsTdma == 7) { 1791 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 8); 1792 pCoexDm->psTdmaDuAdjType = 8; 1793 } else if (pCoexDm->curPsTdma == 13) { 1794 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 14); 1795 pCoexDm->psTdmaDuAdjType = 14; 1796 } else if (pCoexDm->curPsTdma == 14) { 1797 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 15); 1798 pCoexDm->psTdmaDuAdjType = 15; 1799 } else if (pCoexDm->curPsTdma == 15) { 1800 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 16); 1801 pCoexDm->psTdmaDuAdjType = 16; 1802 } 1803 } else if (result == 1) { 1804 if (pCoexDm->curPsTdma == 8) { 1805 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 7); 1806 pCoexDm->psTdmaDuAdjType = 7; 1807 } else if (pCoexDm->curPsTdma == 7) { 1808 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 6); 1809 pCoexDm->psTdmaDuAdjType = 6; 1810 } else if (pCoexDm->curPsTdma == 6) { 1811 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 5); 1812 pCoexDm->psTdmaDuAdjType = 5; 1813 } else if (pCoexDm->curPsTdma == 16) { 1814 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 15); 1815 pCoexDm->psTdmaDuAdjType = 15; 1816 } else if (pCoexDm->curPsTdma == 15) { 1817 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 14); 1818 pCoexDm->psTdmaDuAdjType = 14; 1819 } else if (pCoexDm->curPsTdma == 14) { 1820 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 13); 1821 pCoexDm->psTdmaDuAdjType = 13; 1822 } 1823 } 1824 } else { 1825 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL, ("[BTCoex], TxPause = 0\n")); 1826 if (pCoexDm->curPsTdma == 5) { 1827 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 71); 1828 pCoexDm->psTdmaDuAdjType = 71; 1829 } else if (pCoexDm->curPsTdma == 6) { 1830 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 2); 1831 pCoexDm->psTdmaDuAdjType = 2; 1832 } else if (pCoexDm->curPsTdma == 7) { 1833 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 3); 1834 pCoexDm->psTdmaDuAdjType = 3; 1835 } else if (pCoexDm->curPsTdma == 8) { 1836 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 4); 1837 pCoexDm->psTdmaDuAdjType = 4; 1838 } 1839 1840 if (pCoexDm->curPsTdma == 13) { 1841 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 9); 1842 pCoexDm->psTdmaDuAdjType = 9; 1843 } else if (pCoexDm->curPsTdma == 14) { 1844 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 10); 1845 pCoexDm->psTdmaDuAdjType = 10; 1846 } else if (pCoexDm->curPsTdma == 15) { 1847 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 11); 1848 pCoexDm->psTdmaDuAdjType = 11; 1849 } else if (pCoexDm->curPsTdma == 16) { 1850 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 12); 1851 pCoexDm->psTdmaDuAdjType = 12; 1852 } 1853 1854 if (result == -1) { 1855 if (pCoexDm->curPsTdma == 71) { 1856 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 1); 1857 pCoexDm->psTdmaDuAdjType = 1; 1858 } else if (pCoexDm->curPsTdma == 1) { 1859 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 2); 1860 pCoexDm->psTdmaDuAdjType = 2; 1861 } else if (pCoexDm->curPsTdma == 2) { 1862 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 3); 1863 pCoexDm->psTdmaDuAdjType = 3; 1864 } else if (pCoexDm->curPsTdma == 3) { 1865 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 4); 1866 pCoexDm->psTdmaDuAdjType = 4; 1867 } else if (pCoexDm->curPsTdma == 9) { 1868 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 10); 1869 pCoexDm->psTdmaDuAdjType = 10; 1870 } else if (pCoexDm->curPsTdma == 10) { 1871 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 11); 1872 pCoexDm->psTdmaDuAdjType = 11; 1873 } else if (pCoexDm->curPsTdma == 11) { 1874 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 12); 1875 pCoexDm->psTdmaDuAdjType = 12; 1876 } 1877 } else if (result == 1) { 1878 if (pCoexDm->curPsTdma == 4) { 1879 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 3); 1880 pCoexDm->psTdmaDuAdjType = 3; 1881 } else if (pCoexDm->curPsTdma == 3) { 1882 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 2); 1883 pCoexDm->psTdmaDuAdjType = 2; 1884 } else if (pCoexDm->curPsTdma == 2) { 1885 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 1); 1886 pCoexDm->psTdmaDuAdjType = 1; 1887 } else if (pCoexDm->curPsTdma == 1) { 1888 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 71); 1889 pCoexDm->psTdmaDuAdjType = 71; 1890 } else if (pCoexDm->curPsTdma == 12) { 1891 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 11); 1892 pCoexDm->psTdmaDuAdjType = 11; 1893 } else if (pCoexDm->curPsTdma == 11) { 1894 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 10); 1895 pCoexDm->psTdmaDuAdjType = 10; 1896 } else if (pCoexDm->curPsTdma == 10) { 1897 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 9); 1898 pCoexDm->psTdmaDuAdjType = 9; 1899 } 1900 } 1901 } 1902 } else if (maxInterval == 2) { 1903 if (bTxPause) { 1904 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL, ("[BTCoex], TxPause = 1\n")); 1905 if (pCoexDm->curPsTdma == 1) { 1906 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 6); 1907 pCoexDm->psTdmaDuAdjType = 6; 1908 } else if (pCoexDm->curPsTdma == 2) { 1909 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 6); 1910 pCoexDm->psTdmaDuAdjType = 6; 1911 } else if (pCoexDm->curPsTdma == 3) { 1912 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 7); 1913 pCoexDm->psTdmaDuAdjType = 7; 1914 } else if (pCoexDm->curPsTdma == 4) { 1915 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 8); 1916 pCoexDm->psTdmaDuAdjType = 8; 1917 } 1918 1919 if (pCoexDm->curPsTdma == 9) { 1920 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 14); 1921 pCoexDm->psTdmaDuAdjType = 14; 1922 } else if (pCoexDm->curPsTdma == 10) { 1923 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 14); 1924 pCoexDm->psTdmaDuAdjType = 14; 1925 } else if (pCoexDm->curPsTdma == 11) { 1926 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 15); 1927 pCoexDm->psTdmaDuAdjType = 15; 1928 } else if (pCoexDm->curPsTdma == 12) { 1929 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 16); 1930 pCoexDm->psTdmaDuAdjType = 16; 1931 } 1932 1933 if (result == -1) { 1934 if (pCoexDm->curPsTdma == 5) { 1935 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 6); 1936 pCoexDm->psTdmaDuAdjType = 6; 1937 } else if (pCoexDm->curPsTdma == 6) { 1938 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 7); 1939 pCoexDm->psTdmaDuAdjType = 7; 1940 } else if (pCoexDm->curPsTdma == 7) { 1941 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 8); 1942 pCoexDm->psTdmaDuAdjType = 8; 1943 } else if (pCoexDm->curPsTdma == 13) { 1944 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 14); 1945 pCoexDm->psTdmaDuAdjType = 14; 1946 } else if (pCoexDm->curPsTdma == 14) { 1947 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 15); 1948 pCoexDm->psTdmaDuAdjType = 15; 1949 } else if (pCoexDm->curPsTdma == 15) { 1950 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 16); 1951 pCoexDm->psTdmaDuAdjType = 16; 1952 } 1953 } else if (result == 1) { 1954 if (pCoexDm->curPsTdma == 8) { 1955 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 7); 1956 pCoexDm->psTdmaDuAdjType = 7; 1957 } else if (pCoexDm->curPsTdma == 7) { 1958 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 6); 1959 pCoexDm->psTdmaDuAdjType = 6; 1960 } else if (pCoexDm->curPsTdma == 6) { 1961 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 6); 1962 pCoexDm->psTdmaDuAdjType = 6; 1963 } else if (pCoexDm->curPsTdma == 16) { 1964 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 15); 1965 pCoexDm->psTdmaDuAdjType = 15; 1966 } else if (pCoexDm->curPsTdma == 15) { 1967 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 14); 1968 pCoexDm->psTdmaDuAdjType = 14; 1969 } else if (pCoexDm->curPsTdma == 14) { 1970 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 14); 1971 pCoexDm->psTdmaDuAdjType = 14; 1972 } 1973 } 1974 } else { 1975 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL, ("[BTCoex], TxPause = 0\n")); 1976 if (pCoexDm->curPsTdma == 5) { 1977 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 2); 1978 pCoexDm->psTdmaDuAdjType = 2; 1979 } else if (pCoexDm->curPsTdma == 6) { 1980 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 2); 1981 pCoexDm->psTdmaDuAdjType = 2; 1982 } else if (pCoexDm->curPsTdma == 7) { 1983 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 3); 1984 pCoexDm->psTdmaDuAdjType = 3; 1985 } else if (pCoexDm->curPsTdma == 8) { 1986 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 4); 1987 pCoexDm->psTdmaDuAdjType = 4; 1988 } 1989 1990 if (pCoexDm->curPsTdma == 13) { 1991 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 10); 1992 pCoexDm->psTdmaDuAdjType = 10; 1993 } else if (pCoexDm->curPsTdma == 14) { 1994 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 10); 1995 pCoexDm->psTdmaDuAdjType = 10; 1996 } else if (pCoexDm->curPsTdma == 15) { 1997 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 11); 1998 pCoexDm->psTdmaDuAdjType = 11; 1999 } else if (pCoexDm->curPsTdma == 16) { 2000 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 12); 2001 pCoexDm->psTdmaDuAdjType = 12; 2002 } 2003 2004 if (result == -1) { 2005 if (pCoexDm->curPsTdma == 1) { 2006 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 2); 2007 pCoexDm->psTdmaDuAdjType = 2; 2008 } else if (pCoexDm->curPsTdma == 2) { 2009 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 3); 2010 pCoexDm->psTdmaDuAdjType = 3; 2011 } else if (pCoexDm->curPsTdma == 3) { 2012 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 4); 2013 pCoexDm->psTdmaDuAdjType = 4; 2014 } else if (pCoexDm->curPsTdma == 9) { 2015 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 10); 2016 pCoexDm->psTdmaDuAdjType = 10; 2017 } else if (pCoexDm->curPsTdma == 10) { 2018 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 11); 2019 pCoexDm->psTdmaDuAdjType = 11; 2020 } else if (pCoexDm->curPsTdma == 11) { 2021 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 12); 2022 pCoexDm->psTdmaDuAdjType = 12; 2023 } 2024 } else if (result == 1) { 2025 if (pCoexDm->curPsTdma == 4) { 2026 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 3); 2027 pCoexDm->psTdmaDuAdjType = 3; 2028 } else if (pCoexDm->curPsTdma == 3) { 2029 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 2); 2030 pCoexDm->psTdmaDuAdjType = 2; 2031 } else if (pCoexDm->curPsTdma == 2) { 2032 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 2); 2033 pCoexDm->psTdmaDuAdjType = 2; 2034 } else if (pCoexDm->curPsTdma == 12) { 2035 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 11); 2036 pCoexDm->psTdmaDuAdjType = 11; 2037 } else if (pCoexDm->curPsTdma == 11) { 2038 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 10); 2039 pCoexDm->psTdmaDuAdjType = 10; 2040 } else if (pCoexDm->curPsTdma == 10) { 2041 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 10); 2042 pCoexDm->psTdmaDuAdjType = 10; 2043 } 2044 } 2045 } 2046 } else if (maxInterval == 3) { 2047 if (bTxPause) { 2048 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL, ("[BTCoex], TxPause = 1\n")); 2049 if (pCoexDm->curPsTdma == 1) { 2050 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 7); 2051 pCoexDm->psTdmaDuAdjType = 7; 2052 } else if (pCoexDm->curPsTdma == 2) { 2053 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 7); 2054 pCoexDm->psTdmaDuAdjType = 7; 2055 } else if (pCoexDm->curPsTdma == 3) { 2056 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 7); 2057 pCoexDm->psTdmaDuAdjType = 7; 2058 } else if (pCoexDm->curPsTdma == 4) { 2059 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 8); 2060 pCoexDm->psTdmaDuAdjType = 8; 2061 } 2062 2063 if (pCoexDm->curPsTdma == 9) { 2064 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 15); 2065 pCoexDm->psTdmaDuAdjType = 15; 2066 } else if (pCoexDm->curPsTdma == 10) { 2067 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 15); 2068 pCoexDm->psTdmaDuAdjType = 15; 2069 } else if (pCoexDm->curPsTdma == 11) { 2070 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 15); 2071 pCoexDm->psTdmaDuAdjType = 15; 2072 } else if (pCoexDm->curPsTdma == 12) { 2073 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 16); 2074 pCoexDm->psTdmaDuAdjType = 16; 2075 } 2076 2077 if (result == -1) { 2078 if (pCoexDm->curPsTdma == 5) { 2079 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 7); 2080 pCoexDm->psTdmaDuAdjType = 7; 2081 } else if (pCoexDm->curPsTdma == 6) { 2082 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 7); 2083 pCoexDm->psTdmaDuAdjType = 7; 2084 } else if (pCoexDm->curPsTdma == 7) { 2085 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 8); 2086 pCoexDm->psTdmaDuAdjType = 8; 2087 } else if (pCoexDm->curPsTdma == 13) { 2088 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 15); 2089 pCoexDm->psTdmaDuAdjType = 15; 2090 } else if (pCoexDm->curPsTdma == 14) { 2091 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 15); 2092 pCoexDm->psTdmaDuAdjType = 15; 2093 } else if (pCoexDm->curPsTdma == 15) { 2094 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 16); 2095 pCoexDm->psTdmaDuAdjType = 16; 2096 } 2097 } else if (result == 1) { 2098 if (pCoexDm->curPsTdma == 8) { 2099 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 7); 2100 pCoexDm->psTdmaDuAdjType = 7; 2101 } else if (pCoexDm->curPsTdma == 7) { 2102 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 7); 2103 pCoexDm->psTdmaDuAdjType = 7; 2104 } else if (pCoexDm->curPsTdma == 6) { 2105 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 7); 2106 pCoexDm->psTdmaDuAdjType = 7; 2107 } else if (pCoexDm->curPsTdma == 16) { 2108 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 15); 2109 pCoexDm->psTdmaDuAdjType = 15; 2110 } else if (pCoexDm->curPsTdma == 15) { 2111 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 15); 2112 pCoexDm->psTdmaDuAdjType = 15; 2113 } else if (pCoexDm->curPsTdma == 14) { 2114 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 15); 2115 pCoexDm->psTdmaDuAdjType = 15; 2116 } 2117 } 2118 } else { 2119 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL, ("[BTCoex], TxPause = 0\n")); 2120 if (pCoexDm->curPsTdma == 5) { 2121 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 3); 2122 pCoexDm->psTdmaDuAdjType = 3; 2123 } else if (pCoexDm->curPsTdma == 6) { 2124 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 3); 2125 pCoexDm->psTdmaDuAdjType = 3; 2126 } else if (pCoexDm->curPsTdma == 7) { 2127 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 3); 2128 pCoexDm->psTdmaDuAdjType = 3; 2129 } else if (pCoexDm->curPsTdma == 8) { 2130 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 4); 2131 pCoexDm->psTdmaDuAdjType = 4; 2132 } 2133 2134 if (pCoexDm->curPsTdma == 13) { 2135 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 11); 2136 pCoexDm->psTdmaDuAdjType = 11; 2137 } else if (pCoexDm->curPsTdma == 14) { 2138 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 11); 2139 pCoexDm->psTdmaDuAdjType = 11; 2140 } else if (pCoexDm->curPsTdma == 15) { 2141 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 11); 2142 pCoexDm->psTdmaDuAdjType = 11; 2143 } else if (pCoexDm->curPsTdma == 16) { 2144 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 12); 2145 pCoexDm->psTdmaDuAdjType = 12; 2146 } 2147 2148 if (result == -1) { 2149 if (pCoexDm->curPsTdma == 1) { 2150 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 3); 2151 pCoexDm->psTdmaDuAdjType = 3; 2152 } else if (pCoexDm->curPsTdma == 2) { 2153 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 3); 2154 pCoexDm->psTdmaDuAdjType = 3; 2155 } else if (pCoexDm->curPsTdma == 3) { 2156 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 4); 2157 pCoexDm->psTdmaDuAdjType = 4; 2158 } else if (pCoexDm->curPsTdma == 9) { 2159 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 11); 2160 pCoexDm->psTdmaDuAdjType = 11; 2161 } else if (pCoexDm->curPsTdma == 10) { 2162 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 11); 2163 pCoexDm->psTdmaDuAdjType = 11; 2164 } else if (pCoexDm->curPsTdma == 11) { 2165 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 12); 2166 pCoexDm->psTdmaDuAdjType = 12; 2167 } 2168 } else if (result == 1) { 2169 if (pCoexDm->curPsTdma == 4) { 2170 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 3); 2171 pCoexDm->psTdmaDuAdjType = 3; 2172 } else if (pCoexDm->curPsTdma == 3) { 2173 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 3); 2174 pCoexDm->psTdmaDuAdjType = 3; 2175 } else if (pCoexDm->curPsTdma == 2) { 2176 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 3); 2177 pCoexDm->psTdmaDuAdjType = 3; 2178 } else if (pCoexDm->curPsTdma == 12) { 2179 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 11); 2180 pCoexDm->psTdmaDuAdjType = 11; 2181 } else if (pCoexDm->curPsTdma == 11) { 2182 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 11); 2183 pCoexDm->psTdmaDuAdjType = 11; 2184 } else if (pCoexDm->curPsTdma == 10) { 2185 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 11); 2186 pCoexDm->psTdmaDuAdjType = 11; 2187 } 2188 } 2189 } 2190 } 2191 } 2192 2193 /* if current PsTdma not match with the recorded one (when scan, dhcp...), */ 2194 /* then we have to adjust it back to the previous record one. */ 2195 if (pCoexDm->curPsTdma != pCoexDm->psTdmaDuAdjType) { 2196 bool bScan = false, bLink = false, bRoam = false; 2197 BTC_PRINT( 2198 BTC_MSG_ALGORITHM, 2199 ALGO_TRACE_FW_DETAIL, 2200 ( 2201 "[BTCoex], PsTdma type dismatch!!!, curPsTdma =%d, recordPsTdma =%d\n", 2202 pCoexDm->curPsTdma, 2203 pCoexDm->psTdmaDuAdjType 2204 ) 2205 ); 2206 2207 pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_WIFI_SCAN, &bScan); 2208 pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_WIFI_LINK, &bLink); 2209 pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_WIFI_ROAM, &bRoam); 2210 2211 if (!bScan && !bLink && !bRoam) 2212 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, pCoexDm->psTdmaDuAdjType); 2213 else { 2214 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_DETAIL, ("[BTCoex], roaming/link/scan is under progress, will adjust next time!!!\n")); 2215 } 2216 } 2217 } 2218 2219 /* SCO only or SCO+PAN(HS) */ 2220 static void halbtc8723b2ant_ActionSco(PBTC_COEXIST pBtCoexist) 2221 { 2222 u8 wifiRssiState, btRssiState; 2223 u32 wifiBw; 2224 2225 wifiRssiState = halbtc8723b2ant_WifiRssiState(pBtCoexist, 0, 2, 15, 0); 2226 btRssiState = halbtc8723b2ant_BtRssiState(2, 29, 0); 2227 2228 pBtCoexist->fBtcSetRfReg(pBtCoexist, BTC_RF_A, 0x1, 0xfffff, 0x0); 2229 2230 halbtc8723b2ant_LimitedRx(pBtCoexist, NORMAL_EXEC, false, false, 0x8); 2231 2232 halbtc8723b2ant_FwDacSwingLvl(pBtCoexist, NORMAL_EXEC, 4); 2233 2234 if (BTC_RSSI_HIGH(btRssiState)) 2235 halbtc8723b2ant_DecBtPwr(pBtCoexist, NORMAL_EXEC, 2); 2236 else 2237 halbtc8723b2ant_DecBtPwr(pBtCoexist, NORMAL_EXEC, 0); 2238 2239 pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_U4_WIFI_BW, &wifiBw); 2240 2241 if (BTC_WIFI_BW_LEGACY == wifiBw) /* for SCO quality at 11b/g mode */ 2242 halbtc8723b2ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 2); 2243 else /* for SCO quality & wifi performance balance at 11n mode */ 2244 halbtc8723b2ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 8); 2245 2246 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, false, 0); /* for voice quality */ 2247 2248 /* sw mechanism */ 2249 if (BTC_WIFI_BW_HT40 == wifiBw) { 2250 if ( 2251 (wifiRssiState == BTC_RSSI_STATE_HIGH) || 2252 (wifiRssiState == BTC_RSSI_STATE_STAY_HIGH) 2253 ) { 2254 halbtc8723b2ant_SwMechanism1(pBtCoexist, true, true, false, false); 2255 halbtc8723b2ant_SwMechanism2(pBtCoexist, true, false, true, 0x4); 2256 } else { 2257 halbtc8723b2ant_SwMechanism1(pBtCoexist, true, true, false, false); 2258 halbtc8723b2ant_SwMechanism2(pBtCoexist, false, false, true, 0x4); 2259 } 2260 } else { 2261 if ( 2262 (wifiRssiState == BTC_RSSI_STATE_HIGH) || 2263 (wifiRssiState == BTC_RSSI_STATE_STAY_HIGH) 2264 ) { 2265 halbtc8723b2ant_SwMechanism1(pBtCoexist, false, true, false, false); 2266 halbtc8723b2ant_SwMechanism2(pBtCoexist, true, false, true, 0x4); 2267 } else { 2268 halbtc8723b2ant_SwMechanism1(pBtCoexist, false, true, false, false); 2269 halbtc8723b2ant_SwMechanism2(pBtCoexist, false, false, true, 0x4); 2270 } 2271 } 2272 } 2273 2274 2275 static void halbtc8723b2ant_ActionHid(PBTC_COEXIST pBtCoexist) 2276 { 2277 u8 wifiRssiState, btRssiState; 2278 u32 wifiBw; 2279 2280 wifiRssiState = halbtc8723b2ant_WifiRssiState(pBtCoexist, 0, 2, 15, 0); 2281 btRssiState = halbtc8723b2ant_BtRssiState(2, 29, 0); 2282 2283 pBtCoexist->fBtcSetRfReg(pBtCoexist, BTC_RF_A, 0x1, 0xfffff, 0x0); 2284 2285 halbtc8723b2ant_LimitedRx(pBtCoexist, NORMAL_EXEC, false, false, 0x8); 2286 2287 halbtc8723b2ant_FwDacSwingLvl(pBtCoexist, NORMAL_EXEC, 6); 2288 2289 if (BTC_RSSI_HIGH(btRssiState)) 2290 halbtc8723b2ant_DecBtPwr(pBtCoexist, NORMAL_EXEC, 2); 2291 else 2292 halbtc8723b2ant_DecBtPwr(pBtCoexist, NORMAL_EXEC, 0); 2293 2294 pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_U4_WIFI_BW, &wifiBw); 2295 2296 if (BTC_WIFI_BW_LEGACY == wifiBw) /* for HID at 11b/g mode */ 2297 halbtc8723b2ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 7); 2298 else /* for HID quality & wifi performance balance at 11n mode */ 2299 halbtc8723b2ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 9); 2300 2301 if ( 2302 (btRssiState == BTC_RSSI_STATE_HIGH) || 2303 (btRssiState == BTC_RSSI_STATE_STAY_HIGH) 2304 ) 2305 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 9); 2306 else 2307 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 13); 2308 2309 /* sw mechanism */ 2310 if (BTC_WIFI_BW_HT40 == wifiBw) { 2311 if ( 2312 (wifiRssiState == BTC_RSSI_STATE_HIGH) || 2313 (wifiRssiState == BTC_RSSI_STATE_STAY_HIGH) 2314 ) { 2315 halbtc8723b2ant_SwMechanism1(pBtCoexist, true, true, false, false); 2316 halbtc8723b2ant_SwMechanism2(pBtCoexist, true, false, false, 0x18); 2317 } else { 2318 halbtc8723b2ant_SwMechanism1(pBtCoexist, true, true, false, false); 2319 halbtc8723b2ant_SwMechanism2(pBtCoexist, false, false, false, 0x18); 2320 } 2321 } else { 2322 if ( 2323 (wifiRssiState == BTC_RSSI_STATE_HIGH) || 2324 (wifiRssiState == BTC_RSSI_STATE_STAY_HIGH) 2325 ) { 2326 halbtc8723b2ant_SwMechanism1(pBtCoexist, false, true, false, false); 2327 halbtc8723b2ant_SwMechanism2(pBtCoexist, true, false, false, 0x18); 2328 } else { 2329 halbtc8723b2ant_SwMechanism1(pBtCoexist, false, true, false, false); 2330 halbtc8723b2ant_SwMechanism2(pBtCoexist, false, false, false, 0x18); 2331 } 2332 } 2333 } 2334 2335 /* A2DP only / PAN(EDR) only/ A2DP+PAN(HS) */ 2336 static void halbtc8723b2ant_ActionA2dp(PBTC_COEXIST pBtCoexist) 2337 { 2338 u8 wifiRssiState, wifiRssiState1, btRssiState; 2339 u32 wifiBw; 2340 u8 apNum = 0; 2341 2342 wifiRssiState = halbtc8723b2ant_WifiRssiState(pBtCoexist, 0, 2, 15, 0); 2343 wifiRssiState1 = halbtc8723b2ant_WifiRssiState(pBtCoexist, 1, 2, 40, 0); 2344 btRssiState = halbtc8723b2ant_BtRssiState(2, 29, 0); 2345 2346 pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_U1_AP_NUM, &apNum); 2347 2348 /* define the office environment */ 2349 if (apNum >= 10 && BTC_RSSI_HIGH(wifiRssiState1)) { 2350 /* DbgPrint(" AP#>10(%d)\n", apNum); */ 2351 pBtCoexist->fBtcSetRfReg(pBtCoexist, BTC_RF_A, 0x1, 0xfffff, 0x0); 2352 halbtc8723b2ant_LimitedRx(pBtCoexist, NORMAL_EXEC, false, false, 0x8); 2353 halbtc8723b2ant_FwDacSwingLvl(pBtCoexist, NORMAL_EXEC, 6); 2354 halbtc8723b2ant_DecBtPwr(pBtCoexist, NORMAL_EXEC, 0); 2355 halbtc8723b2ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 0); 2356 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, false, 1); 2357 2358 /* sw mechanism */ 2359 pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_U4_WIFI_BW, &wifiBw); 2360 if (BTC_WIFI_BW_HT40 == wifiBw) { 2361 halbtc8723b2ant_SwMechanism1(pBtCoexist, true, false, false, false); 2362 halbtc8723b2ant_SwMechanism2(pBtCoexist, true, false, true, 0x18); 2363 } else { 2364 halbtc8723b2ant_SwMechanism1(pBtCoexist, false, false, false, false); 2365 halbtc8723b2ant_SwMechanism2(pBtCoexist, true, false, true, 0x18); 2366 } 2367 return; 2368 } 2369 2370 pBtCoexist->fBtcSetRfReg(pBtCoexist, BTC_RF_A, 0x1, 0xfffff, 0x0); 2371 halbtc8723b2ant_LimitedRx(pBtCoexist, NORMAL_EXEC, false, false, 0x8); 2372 2373 halbtc8723b2ant_FwDacSwingLvl(pBtCoexist, NORMAL_EXEC, 6); 2374 2375 if (BTC_RSSI_HIGH(btRssiState)) 2376 halbtc8723b2ant_DecBtPwr(pBtCoexist, NORMAL_EXEC, 2); 2377 else 2378 halbtc8723b2ant_DecBtPwr(pBtCoexist, NORMAL_EXEC, 0); 2379 2380 halbtc8723b2ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 7); 2381 2382 if ( 2383 (btRssiState == BTC_RSSI_STATE_HIGH) || 2384 (btRssiState == BTC_RSSI_STATE_STAY_HIGH) 2385 ) 2386 halbtc8723b2ant_TdmaDurationAdjust(pBtCoexist, false, false, 1); 2387 else 2388 halbtc8723b2ant_TdmaDurationAdjust(pBtCoexist, false, true, 1); 2389 2390 /* sw mechanism */ 2391 pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_U4_WIFI_BW, &wifiBw); 2392 if (BTC_WIFI_BW_HT40 == wifiBw) { 2393 if ( 2394 (wifiRssiState == BTC_RSSI_STATE_HIGH) || 2395 (wifiRssiState == BTC_RSSI_STATE_STAY_HIGH) 2396 ) { 2397 halbtc8723b2ant_SwMechanism1(pBtCoexist, true, false, false, false); 2398 halbtc8723b2ant_SwMechanism2(pBtCoexist, true, false, false, 0x18); 2399 } else { 2400 halbtc8723b2ant_SwMechanism1(pBtCoexist, true, false, false, false); 2401 halbtc8723b2ant_SwMechanism2(pBtCoexist, false, false, false, 0x18); 2402 } 2403 } else { 2404 if ( 2405 (wifiRssiState == BTC_RSSI_STATE_HIGH) || 2406 (wifiRssiState == BTC_RSSI_STATE_STAY_HIGH) 2407 ) { 2408 halbtc8723b2ant_SwMechanism1(pBtCoexist, false, false, false, false); 2409 halbtc8723b2ant_SwMechanism2(pBtCoexist, true, false, false, 0x18); 2410 } else { 2411 halbtc8723b2ant_SwMechanism1(pBtCoexist, false, false, false, false); 2412 halbtc8723b2ant_SwMechanism2(pBtCoexist, false, false, false, 0x18); 2413 } 2414 } 2415 } 2416 2417 static void halbtc8723b2ant_ActionA2dpPanHs(PBTC_COEXIST pBtCoexist) 2418 { 2419 u8 wifiRssiState, btRssiState; 2420 u32 wifiBw; 2421 2422 wifiRssiState = halbtc8723b2ant_WifiRssiState(pBtCoexist, 0, 2, 15, 0); 2423 btRssiState = halbtc8723b2ant_BtRssiState(2, 29, 0); 2424 2425 pBtCoexist->fBtcSetRfReg(pBtCoexist, BTC_RF_A, 0x1, 0xfffff, 0x0); 2426 2427 halbtc8723b2ant_LimitedRx(pBtCoexist, NORMAL_EXEC, false, false, 0x8); 2428 2429 halbtc8723b2ant_FwDacSwingLvl(pBtCoexist, NORMAL_EXEC, 6); 2430 2431 if (BTC_RSSI_HIGH(btRssiState)) 2432 halbtc8723b2ant_DecBtPwr(pBtCoexist, NORMAL_EXEC, 2); 2433 else 2434 halbtc8723b2ant_DecBtPwr(pBtCoexist, NORMAL_EXEC, 0); 2435 2436 halbtc8723b2ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 7); 2437 2438 halbtc8723b2ant_TdmaDurationAdjust(pBtCoexist, false, true, 2); 2439 2440 /* sw mechanism */ 2441 pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_U4_WIFI_BW, &wifiBw); 2442 if (BTC_WIFI_BW_HT40 == wifiBw) { 2443 if ( 2444 (wifiRssiState == BTC_RSSI_STATE_HIGH) || 2445 (wifiRssiState == BTC_RSSI_STATE_STAY_HIGH) 2446 ) { 2447 halbtc8723b2ant_SwMechanism1(pBtCoexist, true, false, false, false); 2448 halbtc8723b2ant_SwMechanism2(pBtCoexist, true, false, false, 0x18); 2449 } else { 2450 halbtc8723b2ant_SwMechanism1(pBtCoexist, true, false, false, false); 2451 halbtc8723b2ant_SwMechanism2(pBtCoexist, false, false, false, 0x18); 2452 } 2453 } else { 2454 if ( 2455 (wifiRssiState == BTC_RSSI_STATE_HIGH) || 2456 (wifiRssiState == BTC_RSSI_STATE_STAY_HIGH) 2457 ) { 2458 halbtc8723b2ant_SwMechanism1(pBtCoexist, false, false, false, false); 2459 halbtc8723b2ant_SwMechanism2(pBtCoexist, true, false, false, 0x18); 2460 } else { 2461 halbtc8723b2ant_SwMechanism1(pBtCoexist, false, false, false, false); 2462 halbtc8723b2ant_SwMechanism2(pBtCoexist, false, false, false, 0x18); 2463 } 2464 } 2465 } 2466 2467 static void halbtc8723b2ant_ActionPanEdr(PBTC_COEXIST pBtCoexist) 2468 { 2469 u8 wifiRssiState, btRssiState; 2470 u32 wifiBw; 2471 2472 wifiRssiState = halbtc8723b2ant_WifiRssiState(pBtCoexist, 0, 2, 15, 0); 2473 btRssiState = halbtc8723b2ant_BtRssiState(2, 29, 0); 2474 2475 pBtCoexist->fBtcSetRfReg(pBtCoexist, BTC_RF_A, 0x1, 0xfffff, 0x0); 2476 2477 halbtc8723b2ant_LimitedRx(pBtCoexist, NORMAL_EXEC, false, false, 0x8); 2478 2479 halbtc8723b2ant_FwDacSwingLvl(pBtCoexist, NORMAL_EXEC, 6); 2480 2481 if (BTC_RSSI_HIGH(btRssiState)) 2482 halbtc8723b2ant_DecBtPwr(pBtCoexist, NORMAL_EXEC, 2); 2483 else 2484 halbtc8723b2ant_DecBtPwr(pBtCoexist, NORMAL_EXEC, 0); 2485 2486 halbtc8723b2ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 10); 2487 2488 if ( 2489 (btRssiState == BTC_RSSI_STATE_HIGH) || 2490 (btRssiState == BTC_RSSI_STATE_STAY_HIGH) 2491 ) 2492 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 1); 2493 else 2494 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 5); 2495 2496 /* sw mechanism */ 2497 pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_U4_WIFI_BW, &wifiBw); 2498 if (BTC_WIFI_BW_HT40 == wifiBw) { 2499 if ( 2500 (wifiRssiState == BTC_RSSI_STATE_HIGH) || 2501 (wifiRssiState == BTC_RSSI_STATE_STAY_HIGH) 2502 ) { 2503 halbtc8723b2ant_SwMechanism1(pBtCoexist, true, false, false, false); 2504 halbtc8723b2ant_SwMechanism2(pBtCoexist, true, false, false, 0x18); 2505 } else { 2506 halbtc8723b2ant_SwMechanism1(pBtCoexist, true, false, false, false); 2507 halbtc8723b2ant_SwMechanism2(pBtCoexist, false, false, false, 0x18); 2508 } 2509 } else { 2510 if ( 2511 (wifiRssiState == BTC_RSSI_STATE_HIGH) || 2512 (wifiRssiState == BTC_RSSI_STATE_STAY_HIGH) 2513 ) { 2514 halbtc8723b2ant_SwMechanism1(pBtCoexist, false, false, false, false); 2515 halbtc8723b2ant_SwMechanism2(pBtCoexist, true, false, false, 0x18); 2516 } else { 2517 halbtc8723b2ant_SwMechanism1(pBtCoexist, false, false, false, false); 2518 halbtc8723b2ant_SwMechanism2(pBtCoexist, false, false, false, 0x18); 2519 } 2520 } 2521 } 2522 2523 2524 /* PAN(HS) only */ 2525 static void halbtc8723b2ant_ActionPanHs(PBTC_COEXIST pBtCoexist) 2526 { 2527 u8 wifiRssiState, btRssiState; 2528 u32 wifiBw; 2529 2530 wifiRssiState = halbtc8723b2ant_WifiRssiState(pBtCoexist, 0, 2, 15, 0); 2531 btRssiState = halbtc8723b2ant_BtRssiState(2, 29, 0); 2532 2533 pBtCoexist->fBtcSetRfReg(pBtCoexist, BTC_RF_A, 0x1, 0xfffff, 0x0); 2534 2535 halbtc8723b2ant_LimitedRx(pBtCoexist, NORMAL_EXEC, false, false, 0x8); 2536 2537 halbtc8723b2ant_FwDacSwingLvl(pBtCoexist, NORMAL_EXEC, 6); 2538 2539 if (BTC_RSSI_HIGH(btRssiState)) 2540 halbtc8723b2ant_DecBtPwr(pBtCoexist, NORMAL_EXEC, 2); 2541 else 2542 halbtc8723b2ant_DecBtPwr(pBtCoexist, NORMAL_EXEC, 0); 2543 2544 halbtc8723b2ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 7); 2545 2546 halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, false, 1); 2547 2548 pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_U4_WIFI_BW, &wifiBw); 2549 if (BTC_WIFI_BW_HT40 == wifiBw) { 2550 if ( 2551 (wifiRssiState == BTC_RSSI_STATE_HIGH) || 2552 (wifiRssiState == BTC_RSSI_STATE_STAY_HIGH) 2553 ) { 2554 halbtc8723b2ant_SwMechanism1(pBtCoexist, true, false, false, false); 2555 halbtc8723b2ant_SwMechanism2(pBtCoexist, true, false, false, 0x18); 2556 } else { 2557 halbtc8723b2ant_SwMechanism1(pBtCoexist, true, false, false, false); 2558 halbtc8723b2ant_SwMechanism2(pBtCoexist, false, false, false, 0x18); 2559 } 2560 } else { 2561 if ( 2562 (wifiRssiState == BTC_RSSI_STATE_HIGH) || 2563 (wifiRssiState == BTC_RSSI_STATE_STAY_HIGH) 2564 ) { 2565 halbtc8723b2ant_SwMechanism1(pBtCoexist, false, false, false, false); 2566 halbtc8723b2ant_SwMechanism2(pBtCoexist, true, false, false, 0x18); 2567 } else { 2568 halbtc8723b2ant_SwMechanism1(pBtCoexist, false, false, false, false); 2569 halbtc8723b2ant_SwMechanism2(pBtCoexist, false, false, false, 0x18); 2570 } 2571 } 2572 } 2573 2574 /* PAN(EDR)+A2DP */ 2575 static void halbtc8723b2ant_ActionPanEdrA2dp(PBTC_COEXIST pBtCoexist) 2576 { 2577 u8 wifiRssiState, btRssiState; 2578 u32 wifiBw; 2579 2580 wifiRssiState = halbtc8723b2ant_WifiRssiState(pBtCoexist, 0, 2, 15, 0); 2581 btRssiState = halbtc8723b2ant_BtRssiState(2, 29, 0); 2582 2583 pBtCoexist->fBtcSetRfReg(pBtCoexist, BTC_RF_A, 0x1, 0xfffff, 0x0); 2584 2585 halbtc8723b2ant_LimitedRx(pBtCoexist, NORMAL_EXEC, false, false, 0x8); 2586 2587 halbtc8723b2ant_FwDacSwingLvl(pBtCoexist, NORMAL_EXEC, 6); 2588 2589 if (BTC_RSSI_HIGH(btRssiState)) 2590 halbtc8723b2ant_DecBtPwr(pBtCoexist, NORMAL_EXEC, 2); 2591 else 2592 halbtc8723b2ant_DecBtPwr(pBtCoexist, NORMAL_EXEC, 0); 2593 2594 pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_U4_WIFI_BW, &wifiBw); 2595 2596 if ( 2597 (btRssiState == BTC_RSSI_STATE_HIGH) || 2598 (btRssiState == BTC_RSSI_STATE_STAY_HIGH) 2599 ) { 2600 halbtc8723b2ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 12); 2601 if (BTC_WIFI_BW_HT40 == wifiBw) 2602 halbtc8723b2ant_TdmaDurationAdjust(pBtCoexist, false, true, 3); 2603 else 2604 halbtc8723b2ant_TdmaDurationAdjust(pBtCoexist, false, false, 3); 2605 } else { 2606 halbtc8723b2ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 7); 2607 halbtc8723b2ant_TdmaDurationAdjust(pBtCoexist, false, true, 3); 2608 } 2609 2610 /* sw mechanism */ 2611 if (BTC_WIFI_BW_HT40 == wifiBw) { 2612 if ( 2613 (wifiRssiState == BTC_RSSI_STATE_HIGH) || 2614 (wifiRssiState == BTC_RSSI_STATE_STAY_HIGH) 2615 ) { 2616 halbtc8723b2ant_SwMechanism1(pBtCoexist, true, false, false, false); 2617 halbtc8723b2ant_SwMechanism2(pBtCoexist, true, false, false, 0x18); 2618 } else { 2619 halbtc8723b2ant_SwMechanism1(pBtCoexist, true, false, false, false); 2620 halbtc8723b2ant_SwMechanism2(pBtCoexist, false, false, false, 0x18); 2621 } 2622 } else { 2623 if ( 2624 (wifiRssiState == BTC_RSSI_STATE_HIGH) || 2625 (wifiRssiState == BTC_RSSI_STATE_STAY_HIGH) 2626 ) { 2627 halbtc8723b2ant_SwMechanism1(pBtCoexist, false, false, false, false); 2628 halbtc8723b2ant_SwMechanism2(pBtCoexist, true, false, false, 0x18); 2629 } else { 2630 halbtc8723b2ant_SwMechanism1(pBtCoexist, false, false, false, false); 2631 halbtc8723b2ant_SwMechanism2(pBtCoexist, false, false, false, 0x18); 2632 } 2633 } 2634 } 2635 2636 static void halbtc8723b2ant_ActionPanEdrHid(PBTC_COEXIST pBtCoexist) 2637 { 2638 u8 wifiRssiState, btRssiState; 2639 u32 wifiBw; 2640 2641 wifiRssiState = halbtc8723b2ant_WifiRssiState(pBtCoexist, 0, 2, 15, 0); 2642 btRssiState = halbtc8723b2ant_BtRssiState(2, 29, 0); 2643 pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_U4_WIFI_BW, &wifiBw); 2644 2645 halbtc8723b2ant_LimitedRx(pBtCoexist, NORMAL_EXEC, false, false, 0x8); 2646 2647 if (BTC_RSSI_HIGH(btRssiState)) 2648 halbtc8723b2ant_DecBtPwr(pBtCoexist, NORMAL_EXEC, 2); 2649 else 2650 halbtc8723b2ant_DecBtPwr(pBtCoexist, NORMAL_EXEC, 0); 2651 2652 if ( 2653 (btRssiState == BTC_RSSI_STATE_HIGH) || 2654 (btRssiState == BTC_RSSI_STATE_STAY_HIGH) 2655 ) { 2656 if (BTC_WIFI_BW_HT40 == wifiBw) { 2657 halbtc8723b2ant_FwDacSwingLvl(pBtCoexist, NORMAL_EXEC, 3); 2658 halbtc8723b2ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 11); 2659 pBtCoexist->fBtcSetRfReg(pBtCoexist, BTC_RF_A, 0x1, 0xfffff, 0x780); 2660 } else { 2661 halbtc8723b2ant_FwDacSwingLvl(pBtCoexist, NORMAL_EXEC, 6); 2662 halbtc8723b2ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 7); 2663 pBtCoexist->fBtcSetRfReg(pBtCoexist, BTC_RF_A, 0x1, 0xfffff, 0x0); 2664 } 2665 halbtc8723b2ant_TdmaDurationAdjust(pBtCoexist, true, false, 2); 2666 } else { 2667 halbtc8723b2ant_FwDacSwingLvl(pBtCoexist, NORMAL_EXEC, 6); 2668 halbtc8723b2ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 11); 2669 pBtCoexist->fBtcSetRfReg(pBtCoexist, BTC_RF_A, 0x1, 0xfffff, 0x0); 2670 halbtc8723b2ant_TdmaDurationAdjust(pBtCoexist, true, true, 2); 2671 } 2672 2673 /* sw mechanism */ 2674 if (BTC_WIFI_BW_HT40 == wifiBw) { 2675 if ( 2676 (wifiRssiState == BTC_RSSI_STATE_HIGH) || 2677 (wifiRssiState == BTC_RSSI_STATE_STAY_HIGH) 2678 ) { 2679 halbtc8723b2ant_SwMechanism1(pBtCoexist, true, true, false, false); 2680 halbtc8723b2ant_SwMechanism2(pBtCoexist, true, false, false, 0x18); 2681 } else { 2682 halbtc8723b2ant_SwMechanism1(pBtCoexist, true, true, false, false); 2683 halbtc8723b2ant_SwMechanism2(pBtCoexist, false, false, false, 0x18); 2684 } 2685 } else { 2686 if ( 2687 (wifiRssiState == BTC_RSSI_STATE_HIGH) || 2688 (wifiRssiState == BTC_RSSI_STATE_STAY_HIGH) 2689 ) { 2690 halbtc8723b2ant_SwMechanism1(pBtCoexist, false, true, false, false); 2691 halbtc8723b2ant_SwMechanism2(pBtCoexist, true, false, false, 0x18); 2692 } else { 2693 halbtc8723b2ant_SwMechanism1(pBtCoexist, false, true, false, false); 2694 halbtc8723b2ant_SwMechanism2(pBtCoexist, false, false, false, 0x18); 2695 } 2696 } 2697 } 2698 2699 /* HID+A2DP+PAN(EDR) */ 2700 static void halbtc8723b2ant_ActionHidA2dpPanEdr(PBTC_COEXIST pBtCoexist) 2701 { 2702 u8 wifiRssiState, btRssiState; 2703 u32 wifiBw; 2704 2705 wifiRssiState = halbtc8723b2ant_WifiRssiState(pBtCoexist, 0, 2, 15, 0); 2706 btRssiState = halbtc8723b2ant_BtRssiState(2, 29, 0); 2707 2708 pBtCoexist->fBtcSetRfReg(pBtCoexist, BTC_RF_A, 0x1, 0xfffff, 0x0); 2709 2710 halbtc8723b2ant_LimitedRx(pBtCoexist, NORMAL_EXEC, false, false, 0x8); 2711 2712 halbtc8723b2ant_FwDacSwingLvl(pBtCoexist, NORMAL_EXEC, 6); 2713 2714 if (BTC_RSSI_HIGH(btRssiState)) 2715 halbtc8723b2ant_DecBtPwr(pBtCoexist, NORMAL_EXEC, 2); 2716 else 2717 halbtc8723b2ant_DecBtPwr(pBtCoexist, NORMAL_EXEC, 0); 2718 2719 pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_U4_WIFI_BW, &wifiBw); 2720 2721 halbtc8723b2ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 7); 2722 2723 if ( 2724 (btRssiState == BTC_RSSI_STATE_HIGH) || 2725 (btRssiState == BTC_RSSI_STATE_STAY_HIGH) 2726 ) { 2727 if (BTC_WIFI_BW_HT40 == wifiBw) 2728 halbtc8723b2ant_TdmaDurationAdjust(pBtCoexist, true, true, 2); 2729 else 2730 halbtc8723b2ant_TdmaDurationAdjust(pBtCoexist, true, false, 3); 2731 } else 2732 halbtc8723b2ant_TdmaDurationAdjust(pBtCoexist, true, true, 3); 2733 2734 /* sw mechanism */ 2735 if (BTC_WIFI_BW_HT40 == wifiBw) { 2736 if ( 2737 (wifiRssiState == BTC_RSSI_STATE_HIGH) || 2738 (wifiRssiState == BTC_RSSI_STATE_STAY_HIGH) 2739 ) { 2740 halbtc8723b2ant_SwMechanism1(pBtCoexist, true, true, false, false); 2741 halbtc8723b2ant_SwMechanism2(pBtCoexist, true, false, false, 0x18); 2742 } else { 2743 halbtc8723b2ant_SwMechanism1(pBtCoexist, true, true, false, false); 2744 halbtc8723b2ant_SwMechanism2(pBtCoexist, false, false, false, 0x18); 2745 } 2746 } else { 2747 if ( 2748 (wifiRssiState == BTC_RSSI_STATE_HIGH) || 2749 (wifiRssiState == BTC_RSSI_STATE_STAY_HIGH) 2750 ) { 2751 halbtc8723b2ant_SwMechanism1(pBtCoexist, false, true, false, false); 2752 halbtc8723b2ant_SwMechanism2(pBtCoexist, true, false, false, 0x18); 2753 } else { 2754 halbtc8723b2ant_SwMechanism1(pBtCoexist, false, true, false, false); 2755 halbtc8723b2ant_SwMechanism2(pBtCoexist, false, false, false, 0x18); 2756 } 2757 } 2758 } 2759 2760 static void halbtc8723b2ant_ActionHidA2dp(PBTC_COEXIST pBtCoexist) 2761 { 2762 u8 wifiRssiState, btRssiState; 2763 u32 wifiBw; 2764 u8 apNum = 0; 2765 2766 wifiRssiState = halbtc8723b2ant_WifiRssiState(pBtCoexist, 0, 2, 15, 0); 2767 /* btRssiState = halbtc8723b2ant_BtRssiState(2, 29, 0); */ 2768 btRssiState = halbtc8723b2ant_BtRssiState(3, 29, 37); 2769 2770 pBtCoexist->fBtcSetRfReg(pBtCoexist, BTC_RF_A, 0x1, 0xfffff, 0x0); 2771 2772 halbtc8723b2ant_LimitedRx(pBtCoexist, NORMAL_EXEC, false, true, 0x5); 2773 2774 halbtc8723b2ant_FwDacSwingLvl(pBtCoexist, NORMAL_EXEC, 6); 2775 2776 pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_U4_WIFI_BW, &wifiBw); 2777 if (BTC_WIFI_BW_LEGACY == wifiBw) { 2778 if (BTC_RSSI_HIGH(btRssiState)) 2779 halbtc8723b2ant_DecBtPwr(pBtCoexist, NORMAL_EXEC, 2); 2780 else if (BTC_RSSI_MEDIUM(btRssiState)) 2781 halbtc8723b2ant_DecBtPwr(pBtCoexist, NORMAL_EXEC, 2); 2782 else 2783 halbtc8723b2ant_DecBtPwr(pBtCoexist, NORMAL_EXEC, 0); 2784 } else { 2785 /* only 802.11N mode we have to dec bt power to 4 degree */ 2786 if (BTC_RSSI_HIGH(btRssiState)) { 2787 pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_U1_AP_NUM, &apNum); 2788 /* need to check ap Number of Not */ 2789 if (apNum < 10) 2790 halbtc8723b2ant_DecBtPwr(pBtCoexist, NORMAL_EXEC, 4); 2791 else 2792 halbtc8723b2ant_DecBtPwr(pBtCoexist, NORMAL_EXEC, 2); 2793 } else if (BTC_RSSI_MEDIUM(btRssiState)) 2794 halbtc8723b2ant_DecBtPwr(pBtCoexist, NORMAL_EXEC, 2); 2795 else 2796 halbtc8723b2ant_DecBtPwr(pBtCoexist, NORMAL_EXEC, 0); 2797 } 2798 2799 halbtc8723b2ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 7); 2800 2801 if ( 2802 (btRssiState == BTC_RSSI_STATE_HIGH) || 2803 (btRssiState == BTC_RSSI_STATE_STAY_HIGH) 2804 ) 2805 halbtc8723b2ant_TdmaDurationAdjust(pBtCoexist, true, false, 2); 2806 else 2807 halbtc8723b2ant_TdmaDurationAdjust(pBtCoexist, true, true, 2); 2808 2809 /* sw mechanism */ 2810 if (BTC_WIFI_BW_HT40 == wifiBw) { 2811 if ( 2812 (wifiRssiState == BTC_RSSI_STATE_HIGH) || 2813 (wifiRssiState == BTC_RSSI_STATE_STAY_HIGH) 2814 ) { 2815 halbtc8723b2ant_SwMechanism1(pBtCoexist, true, true, false, false); 2816 halbtc8723b2ant_SwMechanism2(pBtCoexist, true, false, false, 0x18); 2817 } else { 2818 halbtc8723b2ant_SwMechanism1(pBtCoexist, true, true, false, false); 2819 halbtc8723b2ant_SwMechanism2(pBtCoexist, false, false, false, 0x18); 2820 } 2821 } else { 2822 if ( 2823 (wifiRssiState == BTC_RSSI_STATE_HIGH) || 2824 (wifiRssiState == BTC_RSSI_STATE_STAY_HIGH) 2825 ) { 2826 halbtc8723b2ant_SwMechanism1(pBtCoexist, false, true, false, false); 2827 halbtc8723b2ant_SwMechanism2(pBtCoexist, true, false, false, 0x18); 2828 } else { 2829 halbtc8723b2ant_SwMechanism1(pBtCoexist, false, true, false, false); 2830 halbtc8723b2ant_SwMechanism2(pBtCoexist, false, false, false, 0x18); 2831 } 2832 } 2833 } 2834 2835 static void halbtc8723b2ant_RunCoexistMechanism(PBTC_COEXIST pBtCoexist) 2836 { 2837 u8 algorithm = 0; 2838 2839 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], RunCoexistMechanism() ===>\n")); 2840 2841 if (pBtCoexist->bManualControl) { 2842 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], RunCoexistMechanism(), return for Manual CTRL <===\n")); 2843 return; 2844 } 2845 2846 if (pCoexSta->bUnderIps) { 2847 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], wifi is under IPS !!!\n")); 2848 return; 2849 } 2850 2851 algorithm = halbtc8723b2ant_ActionAlgorithm(pBtCoexist); 2852 if (pCoexSta->bC2hBtInquiryPage && (BT_8723B_2ANT_COEX_ALGO_PANHS != algorithm)) { 2853 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], BT is under inquiry/page scan !!\n")); 2854 halbtc8723b2ant_ActionBtInquiry(pBtCoexist); 2855 return; 2856 } else { 2857 if (pCoexDm->bNeedRecover0x948) { 2858 pCoexDm->bNeedRecover0x948 = false; 2859 pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0x948, pCoexDm->backup0x948); 2860 } 2861 } 2862 2863 pCoexDm->curAlgorithm = algorithm; 2864 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], Algorithm = %d\n", pCoexDm->curAlgorithm)); 2865 2866 if (halbtc8723b2ant_IsCommonAction(pBtCoexist)) { 2867 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], Action 2-Ant common.\n")); 2868 pCoexDm->bAutoTdmaAdjust = false; 2869 } else { 2870 if (pCoexDm->curAlgorithm != pCoexDm->preAlgorithm) { 2871 BTC_PRINT( 2872 BTC_MSG_ALGORITHM, 2873 ALGO_TRACE, 2874 ( 2875 "[BTCoex], preAlgorithm =%d, curAlgorithm =%d\n", 2876 pCoexDm->preAlgorithm, 2877 pCoexDm->curAlgorithm 2878 ) 2879 ); 2880 pCoexDm->bAutoTdmaAdjust = false; 2881 } 2882 2883 2884 switch (pCoexDm->curAlgorithm) { 2885 case BT_8723B_2ANT_COEX_ALGO_SCO: 2886 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], Action 2-Ant, algorithm = SCO.\n")); 2887 halbtc8723b2ant_ActionSco(pBtCoexist); 2888 break; 2889 case BT_8723B_2ANT_COEX_ALGO_HID: 2890 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], Action 2-Ant, algorithm = HID.\n")); 2891 halbtc8723b2ant_ActionHid(pBtCoexist); 2892 break; 2893 case BT_8723B_2ANT_COEX_ALGO_A2DP: 2894 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], Action 2-Ant, algorithm = A2DP.\n")); 2895 halbtc8723b2ant_ActionA2dp(pBtCoexist); 2896 break; 2897 case BT_8723B_2ANT_COEX_ALGO_A2DP_PANHS: 2898 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], Action 2-Ant, algorithm = A2DP+PAN(HS).\n")); 2899 halbtc8723b2ant_ActionA2dpPanHs(pBtCoexist); 2900 break; 2901 case BT_8723B_2ANT_COEX_ALGO_PANEDR: 2902 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], Action 2-Ant, algorithm = PAN(EDR).\n")); 2903 halbtc8723b2ant_ActionPanEdr(pBtCoexist); 2904 break; 2905 case BT_8723B_2ANT_COEX_ALGO_PANHS: 2906 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], Action 2-Ant, algorithm = HS mode.\n")); 2907 halbtc8723b2ant_ActionPanHs(pBtCoexist); 2908 break; 2909 case BT_8723B_2ANT_COEX_ALGO_PANEDR_A2DP: 2910 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], Action 2-Ant, algorithm = PAN+A2DP.\n")); 2911 halbtc8723b2ant_ActionPanEdrA2dp(pBtCoexist); 2912 break; 2913 case BT_8723B_2ANT_COEX_ALGO_PANEDR_HID: 2914 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], Action 2-Ant, algorithm = PAN(EDR)+HID.\n")); 2915 halbtc8723b2ant_ActionPanEdrHid(pBtCoexist); 2916 break; 2917 case BT_8723B_2ANT_COEX_ALGO_HID_A2DP_PANEDR: 2918 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], Action 2-Ant, algorithm = HID+A2DP+PAN.\n")); 2919 halbtc8723b2ant_ActionHidA2dpPanEdr(pBtCoexist); 2920 break; 2921 case BT_8723B_2ANT_COEX_ALGO_HID_A2DP: 2922 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], Action 2-Ant, algorithm = HID+A2DP.\n")); 2923 halbtc8723b2ant_ActionHidA2dp(pBtCoexist); 2924 break; 2925 default: 2926 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], Action 2-Ant, algorithm = coexist All Off!!\n")); 2927 halbtc8723b2ant_CoexAllOff(pBtCoexist); 2928 break; 2929 } 2930 pCoexDm->preAlgorithm = pCoexDm->curAlgorithm; 2931 } 2932 } 2933 2934 static void halbtc8723b2ant_WifiOffHwCfg(PBTC_COEXIST pBtCoexist) 2935 { 2936 bool bIsInMpMode = false; 2937 u8 H2C_Parameter[2] = {0}; 2938 u32 fwVer = 0; 2939 2940 /* set wlan_act to low */ 2941 pBtCoexist->fBtcWrite1Byte(pBtCoexist, 0x76e, 0x4); 2942 2943 pBtCoexist->fBtcSetRfReg(pBtCoexist, BTC_RF_A, 0x1, 0xfffff, 0x780); /* WiFi goto standby while GNT_BT 0-->1 */ 2944 pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_U4_WIFI_FW_VER, &fwVer); 2945 if (fwVer >= 0x180000) { 2946 /* Use H2C to set GNT_BT to HIGH */ 2947 H2C_Parameter[0] = 1; 2948 pBtCoexist->fBtcFillH2c(pBtCoexist, 0x6E, 1, H2C_Parameter); 2949 } else 2950 pBtCoexist->fBtcWrite1Byte(pBtCoexist, 0x765, 0x18); 2951 2952 pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_WIFI_IS_IN_MP_MODE, &bIsInMpMode); 2953 if (!bIsInMpMode) 2954 pBtCoexist->fBtcWrite1ByteBitMask(pBtCoexist, 0x67, 0x20, 0x0); /* BT select s0/s1 is controlled by BT */ 2955 else 2956 pBtCoexist->fBtcWrite1ByteBitMask(pBtCoexist, 0x67, 0x20, 0x1); /* BT select s0/s1 is controlled by WiFi */ 2957 } 2958 2959 static void halbtc8723b2ant_InitHwConfig(PBTC_COEXIST pBtCoexist, bool bBackUp) 2960 { 2961 u8 u1Tmp = 0; 2962 2963 BTC_PRINT(BTC_MSG_INTERFACE, INTF_INIT, ("[BTCoex], 2Ant Init HW Config!!\n")); 2964 2965 /* backup rf 0x1e value */ 2966 pCoexDm->btRf0x1eBackup = 2967 pBtCoexist->fBtcGetRfReg(pBtCoexist, BTC_RF_A, 0x1e, 0xfffff); 2968 2969 /* 0x790[5:0]= 0x5 */ 2970 u1Tmp = pBtCoexist->fBtcRead1Byte(pBtCoexist, 0x790); 2971 u1Tmp &= 0xc0; 2972 u1Tmp |= 0x5; 2973 pBtCoexist->fBtcWrite1Byte(pBtCoexist, 0x790, u1Tmp); 2974 2975 /* Antenna config */ 2976 halbtc8723b2ant_SetAntPath(pBtCoexist, BTC_ANT_WIFI_AT_MAIN, true, false); 2977 2978 /* PTA parameter */ 2979 halbtc8723b2ant_CoexTableWithType(pBtCoexist, FORCE_EXEC, 0); 2980 2981 /* Enable counter statistics */ 2982 pBtCoexist->fBtcWrite1Byte(pBtCoexist, 0x76e, 0xc); /* 0x76e[3] = 1, WLAN_Act control by PTA */ 2983 pBtCoexist->fBtcWrite1Byte(pBtCoexist, 0x778, 0x3); 2984 pBtCoexist->fBtcWrite1ByteBitMask(pBtCoexist, 0x40, 0x20, 0x1); 2985 } 2986 2987 /* */ 2988 /* work around function start with wa_halbtc8723b2ant_ */ 2989 /* */ 2990 /* */ 2991 /* extern function start with EXhalbtc8723b2ant_ */ 2992 /* */ 2993 void EXhalbtc8723b2ant_PowerOnSetting(PBTC_COEXIST pBtCoexist) 2994 { 2995 PBTC_BOARD_INFO pBoardInfo = &pBtCoexist->boardInfo; 2996 u8 u1Tmp = 0x4; /* Set BIT2 by default since it's 2ant case */ 2997 u16 u2Tmp = 0x0; 2998 2999 pBtCoexist->fBtcWrite1Byte(pBtCoexist, 0x67, 0x20); 3000 3001 /* enable BB, REG_SYS_FUNC_EN such that we can write 0x948 correctly. */ 3002 u2Tmp = pBtCoexist->fBtcRead2Byte(pBtCoexist, 0x2); 3003 pBtCoexist->fBtcWrite2Byte(pBtCoexist, 0x2, u2Tmp|BIT0|BIT1); 3004 3005 /* set GRAN_BT = 1 */ 3006 pBtCoexist->fBtcWrite1Byte(pBtCoexist, 0x765, 0x18); 3007 /* set WLAN_ACT = 0 */ 3008 pBtCoexist->fBtcWrite1Byte(pBtCoexist, 0x76e, 0x4); 3009 3010 /* */ 3011 /* S0 or S1 setting and Local register setting(By the setting fw can get ant number, S0/S1, ... info) */ 3012 /* Local setting bit define */ 3013 /* BIT0: "0" for no antenna inverse; "1" for antenna inverse */ 3014 /* BIT1: "0" for internal switch; "1" for external switch */ 3015 /* BIT2: "0" for one antenna; "1" for two antenna */ 3016 /* NOTE: here default all internal switch and 1-antenna ==> BIT1 = 0 and BIT2 = 0 */ 3017 if (pBtCoexist->chipInterface == BTC_INTF_USB) { 3018 /* fixed at S0 for USB interface */ 3019 pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0x948, 0x0); 3020 3021 u1Tmp |= 0x1; /* antenna inverse */ 3022 pBtCoexist->fBtcWriteLocalReg1Byte(pBtCoexist, 0xfe08, u1Tmp); 3023 3024 pBoardInfo->btdmAntPos = BTC_ANTENNA_AT_AUX_PORT; 3025 } else { 3026 /* for PCIE and SDIO interface, we check efuse 0xc3[6] */ 3027 if (pBoardInfo->singleAntPath == 0) { 3028 /* set to S1 */ 3029 pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0x948, 0x280); 3030 pBoardInfo->btdmAntPos = BTC_ANTENNA_AT_MAIN_PORT; 3031 } else if (pBoardInfo->singleAntPath == 1) { 3032 /* set to S0 */ 3033 pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0x948, 0x0); 3034 u1Tmp |= 0x1; /* antenna inverse */ 3035 pBoardInfo->btdmAntPos = BTC_ANTENNA_AT_AUX_PORT; 3036 } 3037 3038 if (pBtCoexist->chipInterface == BTC_INTF_PCI) 3039 pBtCoexist->fBtcWriteLocalReg1Byte(pBtCoexist, 0x384, u1Tmp); 3040 else if (pBtCoexist->chipInterface == BTC_INTF_SDIO) 3041 pBtCoexist->fBtcWriteLocalReg1Byte(pBtCoexist, 0x60, u1Tmp); 3042 } 3043 } 3044 3045 void EXhalbtc8723b2ant_InitHwConfig(PBTC_COEXIST pBtCoexist, bool bWifiOnly) 3046 { 3047 halbtc8723b2ant_InitHwConfig(pBtCoexist, true); 3048 } 3049 3050 void EXhalbtc8723b2ant_InitCoexDm(PBTC_COEXIST pBtCoexist) 3051 { 3052 BTC_PRINT(BTC_MSG_INTERFACE, INTF_INIT, ("[BTCoex], Coex Mechanism Init!!\n")); 3053 3054 halbtc8723b2ant_InitCoexDm(pBtCoexist); 3055 } 3056 3057 void EXhalbtc8723b2ant_DisplayCoexInfo(PBTC_COEXIST pBtCoexist) 3058 { 3059 PBTC_BOARD_INFO pBoardInfo = &pBtCoexist->boardInfo; 3060 PBTC_STACK_INFO pStackInfo = &pBtCoexist->stackInfo; 3061 PBTC_BT_LINK_INFO pBtLinkInfo = &pBtCoexist->btLinkInfo; 3062 u8 *cliBuf = pBtCoexist->cliBuf; 3063 u8 u1Tmp[4], i, btInfoExt, psTdmaCase = 0; 3064 u32 u4Tmp[4]; 3065 bool bRoam = false, bScan = false, bLink = false, bWifiUnder5G = false; 3066 bool bBtHsOn = false, bWifiBusy = false; 3067 s32 wifiRssi = 0, btHsRssi = 0; 3068 u32 wifiBw, wifiTrafficDir, faOfdm, faCck; 3069 u8 wifiDot11Chnl, wifiHsChnl; 3070 u32 fwVer = 0, btPatchVer = 0; 3071 u8 apNum = 0; 3072 3073 CL_SPRINTF(cliBuf, BT_TMP_BUF_SIZE, "\r\n ============[BT Coexist info]============"); 3074 CL_PRINTF(cliBuf); 3075 3076 if (pBtCoexist->bManualControl) { 3077 CL_SPRINTF(cliBuf, BT_TMP_BUF_SIZE, "\r\n ============[Under Manual Control]============"); 3078 CL_PRINTF(cliBuf); 3079 CL_SPRINTF(cliBuf, BT_TMP_BUF_SIZE, "\r\n =========================================="); 3080 CL_PRINTF(cliBuf); 3081 } 3082 3083 CL_SPRINTF( 3084 cliBuf, 3085 BT_TMP_BUF_SIZE, 3086 "\r\n %-35s = %d/ %d ", "Ant PG number/ Ant mechanism:", \ 3087 pBoardInfo->pgAntNum, 3088 pBoardInfo->btdmAntNum 3089 ); 3090 CL_PRINTF(cliBuf); 3091 3092 CL_SPRINTF( 3093 cliBuf, 3094 BT_TMP_BUF_SIZE, 3095 "\r\n %-35s = %s / %d", "BT stack/ hci ext ver", \ 3096 (pStackInfo->bProfileNotified ? "Yes" : "No"), 3097 pStackInfo->hciVersion 3098 ); 3099 CL_PRINTF(cliBuf); 3100 3101 pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_U4_BT_PATCH_VER, &btPatchVer); 3102 pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_U4_WIFI_FW_VER, &fwVer); 3103 CL_SPRINTF(cliBuf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d_%x/ 0x%x/ 0x%x(%d)", "CoexVer/ FwVer/ PatchVer", \ 3104 GLCoexVerDate8723b2Ant, GLCoexVer8723b2Ant, fwVer, btPatchVer, btPatchVer); 3105 CL_PRINTF(cliBuf); 3106 3107 pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_HS_OPERATION, &bBtHsOn); 3108 pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_U1_WIFI_DOT11_CHNL, &wifiDot11Chnl); 3109 pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_U1_WIFI_HS_CHNL, &wifiHsChnl); 3110 CL_SPRINTF( 3111 cliBuf, 3112 BT_TMP_BUF_SIZE, 3113 "\r\n %-35s = %d / %d(%d)", "Dot11 channel / HsChnl(HsMode)", \ 3114 wifiDot11Chnl, 3115 wifiHsChnl, 3116 bBtHsOn 3117 ); 3118 CL_PRINTF(cliBuf); 3119 3120 CL_SPRINTF( 3121 cliBuf, 3122 BT_TMP_BUF_SIZE, 3123 "\r\n %-35s = %02x %02x %02x ", "H2C Wifi inform bt chnl Info", \ 3124 pCoexDm->wifiChnlInfo[0], 3125 pCoexDm->wifiChnlInfo[1], 3126 pCoexDm->wifiChnlInfo[2] 3127 ); 3128 CL_PRINTF(cliBuf); 3129 3130 pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_S4_WIFI_RSSI, &wifiRssi); 3131 pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_S4_HS_RSSI, &btHsRssi); 3132 pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_U1_AP_NUM, &apNum); 3133 CL_SPRINTF( 3134 cliBuf, 3135 BT_TMP_BUF_SIZE, 3136 "\r\n %-35s = %d/ %d/ %d", "Wifi rssi/ HS rssi/ AP#", \ 3137 wifiRssi, 3138 btHsRssi, 3139 apNum 3140 ); 3141 CL_PRINTF(cliBuf); 3142 3143 pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_WIFI_SCAN, &bScan); 3144 pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_WIFI_LINK, &bLink); 3145 pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_WIFI_ROAM, &bRoam); 3146 CL_SPRINTF( 3147 cliBuf, 3148 BT_TMP_BUF_SIZE, 3149 "\r\n %-35s = %d/ %d/ %d ", "Wifi bLink/ bRoam/ bScan", \ 3150 bLink, 3151 bRoam, 3152 bScan 3153 ); 3154 CL_PRINTF(cliBuf); 3155 3156 pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_WIFI_UNDER_5G, &bWifiUnder5G); 3157 pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_U4_WIFI_BW, &wifiBw); 3158 pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_WIFI_BUSY, &bWifiBusy); 3159 pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_U4_WIFI_TRAFFIC_DIRECTION, &wifiTrafficDir); 3160 CL_SPRINTF( 3161 cliBuf, 3162 BT_TMP_BUF_SIZE, 3163 "\r\n %-35s = %s / %s/ %s ", "Wifi status", \ 3164 (bWifiUnder5G ? "5G" : "2.4G"), 3165 ((BTC_WIFI_BW_LEGACY == wifiBw) ? "Legacy" : (((BTC_WIFI_BW_HT40 == wifiBw) ? "HT40" : "HT20"))), 3166 ((!bWifiBusy) ? "idle" : ((BTC_WIFI_TRAFFIC_TX == wifiTrafficDir) ? "uplink" : "downlink")) 3167 ); 3168 CL_PRINTF(cliBuf); 3169 3170 CL_SPRINTF( 3171 cliBuf, 3172 BT_TMP_BUF_SIZE, 3173 "\r\n %-35s = [%s/ %d/ %d] ", "BT [status/ rssi/ retryCnt]", \ 3174 ((pBtCoexist->btInfo.bBtDisabled) ? ("disabled") : ((pCoexSta->bC2hBtInquiryPage) ? ("inquiry/page scan") : ((BT_8723B_2ANT_BT_STATUS_NON_CONNECTED_IDLE == pCoexDm->btStatus) ? "non-connected idle" : 3175 ((BT_8723B_2ANT_BT_STATUS_CONNECTED_IDLE == pCoexDm->btStatus) ? "connected-idle" : "busy")))), 3176 pCoexSta->btRssi, 3177 pCoexSta->btRetryCnt 3178 ); 3179 CL_PRINTF(cliBuf); 3180 3181 CL_SPRINTF( 3182 cliBuf, 3183 BT_TMP_BUF_SIZE, 3184 "\r\n %-35s = %d / %d / %d / %d", "SCO/HID/PAN/A2DP", \ 3185 pBtLinkInfo->bScoExist, 3186 pBtLinkInfo->bHidExist, 3187 pBtLinkInfo->bPanExist, 3188 pBtLinkInfo->bA2dpExist 3189 ); 3190 CL_PRINTF(cliBuf); 3191 pBtCoexist->fBtcDispDbgMsg(pBtCoexist, BTC_DBG_DISP_BT_LINK_INFO); 3192 3193 btInfoExt = pCoexSta->btInfoExt; 3194 CL_SPRINTF( 3195 cliBuf, 3196 BT_TMP_BUF_SIZE, 3197 "\r\n %-35s = %s", "BT Info A2DP rate", \ 3198 (btInfoExt&BIT0) ? "Basic rate" : "EDR rate" 3199 ); 3200 CL_PRINTF(cliBuf); 3201 3202 for (i = 0; i < BT_INFO_SRC_8723B_2ANT_MAX; i++) { 3203 if (pCoexSta->btInfoC2hCnt[i]) { 3204 CL_SPRINTF( 3205 cliBuf, 3206 BT_TMP_BUF_SIZE, 3207 "\r\n %-35s = %02x %02x %02x %02x %02x %02x %02x(%d)", GLBtInfoSrc8723b2Ant[i], \ 3208 pCoexSta->btInfoC2h[i][0], 3209 pCoexSta->btInfoC2h[i][1], 3210 pCoexSta->btInfoC2h[i][2], 3211 pCoexSta->btInfoC2h[i][3], 3212 pCoexSta->btInfoC2h[i][4], 3213 pCoexSta->btInfoC2h[i][5], 3214 pCoexSta->btInfoC2h[i][6], 3215 pCoexSta->btInfoC2hCnt[i] 3216 ); 3217 CL_PRINTF(cliBuf); 3218 } 3219 } 3220 3221 CL_SPRINTF( 3222 cliBuf, 3223 BT_TMP_BUF_SIZE, 3224 "\r\n %-35s = %s/%s", "PS state, IPS/LPS", \ 3225 ((pCoexSta->bUnderIps ? "IPS ON" : "IPS OFF")), 3226 ((pCoexSta->bUnderLps ? "LPS ON" : "LPS OFF")) 3227 ); 3228 CL_PRINTF(cliBuf); 3229 pBtCoexist->fBtcDispDbgMsg(pBtCoexist, BTC_DBG_DISP_FW_PWR_MODE_CMD); 3230 3231 /* Sw mechanism */ 3232 CL_SPRINTF( 3233 cliBuf, 3234 BT_TMP_BUF_SIZE, 3235 "\r\n %-35s", "============[Sw mechanism]============" 3236 ); 3237 CL_PRINTF(cliBuf); 3238 CL_SPRINTF( 3239 cliBuf, 3240 BT_TMP_BUF_SIZE, 3241 "\r\n %-35s = %d/ %d/ %d ", "SM1[ShRf/ LpRA/ LimDig]", \ 3242 pCoexDm->bCurRfRxLpfShrink, 3243 pCoexDm->bCurLowPenaltyRa, 3244 pCoexDm->bLimitedDig 3245 ); 3246 CL_PRINTF(cliBuf); 3247 CL_SPRINTF( 3248 cliBuf, 3249 BT_TMP_BUF_SIZE, 3250 "\r\n %-35s = %d/ %d/ %d(0x%x) ", 3251 "SM2[AgcT/ AdcB/ SwDacSwing(lvl)]", \ 3252 pCoexDm->bCurAgcTableEn, 3253 pCoexDm->bCurAdcBackOff, 3254 pCoexDm->bCurDacSwingOn, 3255 pCoexDm->curDacSwingLvl 3256 ); 3257 CL_PRINTF(cliBuf); 3258 3259 /* Fw mechanism */ 3260 CL_SPRINTF(cliBuf, BT_TMP_BUF_SIZE, "\r\n %-35s", "============[Fw mechanism]============"); 3261 CL_PRINTF(cliBuf); 3262 3263 psTdmaCase = pCoexDm->curPsTdma; 3264 CL_SPRINTF( 3265 cliBuf, 3266 BT_TMP_BUF_SIZE, 3267 "\r\n %-35s = %02x %02x %02x %02x %02x case-%d (auto:%d)", "PS TDMA", \ 3268 pCoexDm->psTdmaPara[0], 3269 pCoexDm->psTdmaPara[1], 3270 pCoexDm->psTdmaPara[2], 3271 pCoexDm->psTdmaPara[3], 3272 pCoexDm->psTdmaPara[4], 3273 psTdmaCase, pCoexDm->bAutoTdmaAdjust 3274 ); 3275 CL_PRINTF(cliBuf); 3276 3277 CL_SPRINTF( 3278 cliBuf, 3279 BT_TMP_BUF_SIZE, 3280 "\r\n %-35s = %d/ %d ", "DecBtPwr/ IgnWlanAct", \ 3281 pCoexDm->curBtDecPwrLvl, 3282 pCoexDm->bCurIgnoreWlanAct 3283 ); 3284 CL_PRINTF(cliBuf); 3285 3286 /* Hw setting */ 3287 CL_SPRINTF(cliBuf, BT_TMP_BUF_SIZE, "\r\n %-35s", "============[Hw setting]============"); 3288 CL_PRINTF(cliBuf); 3289 3290 CL_SPRINTF( 3291 cliBuf, 3292 BT_TMP_BUF_SIZE, 3293 "\r\n %-35s = 0x%x", "RF-A, 0x1e initVal", \ 3294 pCoexDm->btRf0x1eBackup 3295 ); 3296 CL_PRINTF(cliBuf); 3297 3298 u1Tmp[0] = pBtCoexist->fBtcRead1Byte(pBtCoexist, 0x778); 3299 u4Tmp[0] = pBtCoexist->fBtcRead4Byte(pBtCoexist, 0x880); 3300 CL_SPRINTF( 3301 cliBuf, 3302 BT_TMP_BUF_SIZE, 3303 "\r\n %-35s = 0x%x/ 0x%x", "0x778/0x880[29:25]", \ 3304 u1Tmp[0], 3305 (u4Tmp[0]&0x3e000000) >> 25 3306 ); 3307 CL_PRINTF(cliBuf); 3308 3309 3310 u4Tmp[0] = pBtCoexist->fBtcRead4Byte(pBtCoexist, 0x948); 3311 u1Tmp[0] = pBtCoexist->fBtcRead1Byte(pBtCoexist, 0x67); 3312 u1Tmp[1] = pBtCoexist->fBtcRead1Byte(pBtCoexist, 0x765); 3313 CL_SPRINTF( 3314 cliBuf, 3315 BT_TMP_BUF_SIZE, 3316 "\r\n %-35s = 0x%x/ 0x%x/ 0x%x", "0x948/ 0x67[5] / 0x765", \ 3317 u4Tmp[0], 3318 ((u1Tmp[0]&0x20)>>5), 3319 u1Tmp[1] 3320 ); 3321 CL_PRINTF(cliBuf); 3322 3323 u4Tmp[0] = pBtCoexist->fBtcRead4Byte(pBtCoexist, 0x92c); 3324 u4Tmp[1] = pBtCoexist->fBtcRead4Byte(pBtCoexist, 0x930); 3325 u4Tmp[2] = pBtCoexist->fBtcRead4Byte(pBtCoexist, 0x944); 3326 CL_SPRINTF( 3327 cliBuf, 3328 BT_TMP_BUF_SIZE, 3329 "\r\n %-35s = 0x%x/ 0x%x/ 0x%x", "0x92c[1:0]/ 0x930[7:0]/0x944[1:0]", \ 3330 u4Tmp[0]&0x3, 3331 u4Tmp[1]&0xff, 3332 u4Tmp[2]&0x3 3333 ); 3334 CL_PRINTF(cliBuf); 3335 3336 3337 u1Tmp[0] = pBtCoexist->fBtcRead1Byte(pBtCoexist, 0x39); 3338 u1Tmp[1] = pBtCoexist->fBtcRead1Byte(pBtCoexist, 0x40); 3339 u4Tmp[0] = pBtCoexist->fBtcRead4Byte(pBtCoexist, 0x4c); 3340 u1Tmp[2] = pBtCoexist->fBtcRead1Byte(pBtCoexist, 0x64); 3341 CL_SPRINTF( 3342 cliBuf, 3343 BT_TMP_BUF_SIZE, 3344 "\r\n %-35s = 0x%x/ 0x%x/ 0x%x/ 0x%x", "0x38[11]/0x40/0x4c[24:23]/0x64[0]", \ 3345 ((u1Tmp[0] & 0x8)>>3), 3346 u1Tmp[1], 3347 ((u4Tmp[0]&0x01800000)>>23), 3348 u1Tmp[2]&0x1 3349 ); 3350 CL_PRINTF(cliBuf); 3351 3352 u4Tmp[0] = pBtCoexist->fBtcRead4Byte(pBtCoexist, 0x550); 3353 u1Tmp[0] = pBtCoexist->fBtcRead1Byte(pBtCoexist, 0x522); 3354 CL_SPRINTF( 3355 cliBuf, 3356 BT_TMP_BUF_SIZE, 3357 "\r\n %-35s = 0x%x/ 0x%x", "0x550(bcn ctrl)/0x522", \ 3358 u4Tmp[0], 3359 u1Tmp[0] 3360 ); 3361 CL_PRINTF(cliBuf); 3362 3363 u4Tmp[0] = pBtCoexist->fBtcRead4Byte(pBtCoexist, 0xc50); 3364 u1Tmp[0] = pBtCoexist->fBtcRead1Byte(pBtCoexist, 0x49c); 3365 CL_SPRINTF( 3366 cliBuf, 3367 BT_TMP_BUF_SIZE, 3368 "\r\n %-35s = 0x%x/ 0x%x", "0xc50(dig)/0x49c(null-drop)", \ 3369 u4Tmp[0]&0xff, 3370 u1Tmp[0] 3371 ); 3372 CL_PRINTF(cliBuf); 3373 3374 u4Tmp[0] = pBtCoexist->fBtcRead4Byte(pBtCoexist, 0xda0); 3375 u4Tmp[1] = pBtCoexist->fBtcRead4Byte(pBtCoexist, 0xda4); 3376 u4Tmp[2] = pBtCoexist->fBtcRead4Byte(pBtCoexist, 0xda8); 3377 u4Tmp[3] = pBtCoexist->fBtcRead4Byte(pBtCoexist, 0xcf0); 3378 3379 u1Tmp[0] = pBtCoexist->fBtcRead1Byte(pBtCoexist, 0xa5b); 3380 u1Tmp[1] = pBtCoexist->fBtcRead1Byte(pBtCoexist, 0xa5c); 3381 3382 faOfdm = 3383 ((u4Tmp[0]&0xffff0000) >> 16) + 3384 ((u4Tmp[1]&0xffff0000) >> 16) + 3385 (u4Tmp[1] & 0xffff) + (u4Tmp[2] & 0xffff) + \ 3386 ((u4Tmp[3]&0xffff0000) >> 16) + 3387 (u4Tmp[3] & 0xffff); 3388 3389 faCck = (u1Tmp[0] << 8) + u1Tmp[1]; 3390 3391 CL_SPRINTF( 3392 cliBuf, 3393 BT_TMP_BUF_SIZE, 3394 "\r\n %-35s = 0x%x/ 0x%x/ 0x%x", "OFDM-CCA/OFDM-FA/CCK-FA", \ 3395 u4Tmp[0]&0xffff, 3396 faOfdm, 3397 faCck 3398 ); 3399 CL_PRINTF(cliBuf); 3400 3401 u4Tmp[0] = pBtCoexist->fBtcRead4Byte(pBtCoexist, 0x6c0); 3402 u4Tmp[1] = pBtCoexist->fBtcRead4Byte(pBtCoexist, 0x6c4); 3403 u4Tmp[2] = pBtCoexist->fBtcRead4Byte(pBtCoexist, 0x6c8); 3404 u1Tmp[0] = pBtCoexist->fBtcRead1Byte(pBtCoexist, 0x6cc); 3405 CL_SPRINTF( 3406 cliBuf, 3407 BT_TMP_BUF_SIZE, 3408 "\r\n %-35s = 0x%x/ 0x%x/ 0x%x/ 0x%x", "0x6c0/0x6c4/0x6c8/0x6cc(coexTable)", \ 3409 u4Tmp[0], 3410 u4Tmp[1], 3411 u4Tmp[2], 3412 u1Tmp[0] 3413 ); 3414 CL_PRINTF(cliBuf); 3415 3416 CL_SPRINTF( 3417 cliBuf, 3418 BT_TMP_BUF_SIZE, 3419 "\r\n %-35s = %d/ %d", "0x770(high-pri rx/tx)", \ 3420 pCoexSta->highPriorityRx, 3421 pCoexSta->highPriorityTx 3422 ); 3423 CL_PRINTF(cliBuf); 3424 CL_SPRINTF( 3425 cliBuf, 3426 BT_TMP_BUF_SIZE, 3427 "\r\n %-35s = %d/ %d", "0x774(low-pri rx/tx)", \ 3428 pCoexSta->lowPriorityRx, 3429 pCoexSta->lowPriorityTx 3430 ); 3431 CL_PRINTF(cliBuf); 3432 3433 halbtc8723b2ant_MonitorBtCtr(pBtCoexist); 3434 pBtCoexist->fBtcDispDbgMsg(pBtCoexist, BTC_DBG_DISP_COEX_STATISTICS); 3435 } 3436 3437 3438 void EXhalbtc8723b2ant_IpsNotify(PBTC_COEXIST pBtCoexist, u8 type) 3439 { 3440 if (BTC_IPS_ENTER == type) { 3441 BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY, ("[BTCoex], IPS ENTER notify\n")); 3442 pCoexSta->bUnderIps = true; 3443 halbtc8723b2ant_WifiOffHwCfg(pBtCoexist); 3444 halbtc8723b2ant_IgnoreWlanAct(pBtCoexist, FORCE_EXEC, true); 3445 halbtc8723b2ant_CoexAllOff(pBtCoexist); 3446 } else if (BTC_IPS_LEAVE == type) { 3447 BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY, ("[BTCoex], IPS LEAVE notify\n")); 3448 pCoexSta->bUnderIps = false; 3449 halbtc8723b2ant_InitHwConfig(pBtCoexist, false); 3450 halbtc8723b2ant_InitCoexDm(pBtCoexist); 3451 halbtc8723b2ant_QueryBtInfo(pBtCoexist); 3452 } 3453 } 3454 3455 void EXhalbtc8723b2ant_LpsNotify(PBTC_COEXIST pBtCoexist, u8 type) 3456 { 3457 if (BTC_LPS_ENABLE == type) { 3458 BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY, ("[BTCoex], LPS ENABLE notify\n")); 3459 pCoexSta->bUnderLps = true; 3460 } else if (BTC_LPS_DISABLE == type) { 3461 BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY, ("[BTCoex], LPS DISABLE notify\n")); 3462 pCoexSta->bUnderLps = false; 3463 } 3464 } 3465 3466 void EXhalbtc8723b2ant_ScanNotify(PBTC_COEXIST pBtCoexist, u8 type) 3467 { 3468 if (BTC_SCAN_START == type) { 3469 BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY, ("[BTCoex], SCAN START notify\n")); 3470 } else if (BTC_SCAN_FINISH == type) { 3471 BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY, ("[BTCoex], SCAN FINISH notify\n")); 3472 } 3473 } 3474 3475 void EXhalbtc8723b2ant_ConnectNotify(PBTC_COEXIST pBtCoexist, u8 type) 3476 { 3477 if (BTC_ASSOCIATE_START == type) { 3478 BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY, ("[BTCoex], CONNECT START notify\n")); 3479 } else if (BTC_ASSOCIATE_FINISH == type) { 3480 BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY, ("[BTCoex], CONNECT FINISH notify\n")); 3481 } 3482 } 3483 3484 void EXhalbtc8723b2ant_MediaStatusNotify(PBTC_COEXIST pBtCoexist, u8 type) 3485 { 3486 u8 H2C_Parameter[3] = {0}; 3487 u32 wifiBw; 3488 u8 wifiCentralChnl; 3489 u8 apNum = 0; 3490 3491 if (BTC_MEDIA_CONNECT == type) { 3492 BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY, ("[BTCoex], MEDIA connect notify\n")); 3493 } else { 3494 BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY, ("[BTCoex], MEDIA disconnect notify\n")); 3495 } 3496 3497 /* only 2.4G we need to inform bt the chnl mask */ 3498 pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_U1_WIFI_CENTRAL_CHNL, &wifiCentralChnl); 3499 if ((BTC_MEDIA_CONNECT == type) && (wifiCentralChnl <= 14)) { 3500 H2C_Parameter[0] = 0x1; 3501 H2C_Parameter[1] = wifiCentralChnl; 3502 pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_U4_WIFI_BW, &wifiBw); 3503 if (BTC_WIFI_BW_HT40 == wifiBw) 3504 H2C_Parameter[2] = 0x30; 3505 else { 3506 pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_U1_AP_NUM, &apNum); 3507 if (apNum < 10) 3508 H2C_Parameter[2] = 0x30; 3509 else 3510 H2C_Parameter[2] = 0x20; 3511 } 3512 } 3513 3514 pCoexDm->wifiChnlInfo[0] = H2C_Parameter[0]; 3515 pCoexDm->wifiChnlInfo[1] = H2C_Parameter[1]; 3516 pCoexDm->wifiChnlInfo[2] = H2C_Parameter[2]; 3517 3518 BTC_PRINT( 3519 BTC_MSG_ALGORITHM, 3520 ALGO_TRACE_FW_EXEC, 3521 ( 3522 "[BTCoex], FW write 0x66 = 0x%x\n", 3523 H2C_Parameter[0]<<16|H2C_Parameter[1]<<8|H2C_Parameter[2] 3524 ) 3525 ); 3526 3527 pBtCoexist->fBtcFillH2c(pBtCoexist, 0x66, 3, H2C_Parameter); 3528 } 3529 3530 void EXhalbtc8723b2ant_SpecialPacketNotify(PBTC_COEXIST pBtCoexist, u8 type) 3531 { 3532 if (type == BTC_PACKET_DHCP) { 3533 BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY, ("[BTCoex], DHCP Packet notify\n")); 3534 } 3535 } 3536 3537 void EXhalbtc8723b2ant_BtInfoNotify( 3538 PBTC_COEXIST pBtCoexist, u8 *tmpBuf, u8 length 3539 ) 3540 { 3541 u8 btInfo = 0; 3542 u8 i, rspSource = 0; 3543 bool bBtBusy = false, bLimitedDig = false; 3544 bool bWifiConnected = false; 3545 3546 pCoexSta->bC2hBtInfoReqSent = false; 3547 3548 rspSource = tmpBuf[0]&0xf; 3549 if (rspSource >= BT_INFO_SRC_8723B_2ANT_MAX) 3550 rspSource = BT_INFO_SRC_8723B_2ANT_WIFI_FW; 3551 3552 pCoexSta->btInfoC2hCnt[rspSource]++; 3553 3554 BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY, ("[BTCoex], Bt info[%d], length =%d, hex data =[", rspSource, length)); 3555 for (i = 0; i < length; i++) { 3556 pCoexSta->btInfoC2h[rspSource][i] = tmpBuf[i]; 3557 if (i == 1) 3558 btInfo = tmpBuf[i]; 3559 3560 if (i == length-1) { 3561 BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY, ("0x%02x]\n", tmpBuf[i])); 3562 } else { 3563 BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY, ("0x%02x, ", tmpBuf[i])); 3564 } 3565 } 3566 3567 if (pBtCoexist->bManualControl) { 3568 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], BtInfoNotify(), return for Manual CTRL<===\n")); 3569 return; 3570 } 3571 3572 if (BT_INFO_SRC_8723B_2ANT_WIFI_FW != rspSource) { 3573 pCoexSta->btRetryCnt = pCoexSta->btInfoC2h[rspSource][2]&0xf; /* [3:0] */ 3574 3575 pCoexSta->btRssi = pCoexSta->btInfoC2h[rspSource][3]*2+10; 3576 3577 pCoexSta->btInfoExt = pCoexSta->btInfoC2h[rspSource][4]; 3578 3579 pCoexSta->bBtTxRxMask = (pCoexSta->btInfoC2h[rspSource][2]&0x40); 3580 pBtCoexist->fBtcSet(pBtCoexist, BTC_SET_BL_BT_TX_RX_MASK, &pCoexSta->bBtTxRxMask); 3581 if (pCoexSta->bBtTxRxMask) { 3582 /* BT into is responded by BT FW and BT RF REG 0x3C != 0x01 => Need to switch BT TRx Mask */ 3583 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], Switch BT TRx Mask since BT RF REG 0x3C != 0x01\n")); 3584 pBtCoexist->fBtcSetBtReg(pBtCoexist, BTC_BT_REG_RF, 0x3c, 0x01); 3585 } 3586 3587 /* Here we need to resend some wifi info to BT */ 3588 /* because bt is reset and loss of the info. */ 3589 if ((pCoexSta->btInfoExt & BIT1)) { 3590 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], BT ext info bit1 check, send wifi BW&Chnl to BT!!\n")); 3591 pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_WIFI_CONNECTED, &bWifiConnected); 3592 3593 if (bWifiConnected) 3594 EXhalbtc8723b2ant_MediaStatusNotify(pBtCoexist, BTC_MEDIA_CONNECT); 3595 else 3596 EXhalbtc8723b2ant_MediaStatusNotify(pBtCoexist, BTC_MEDIA_DISCONNECT); 3597 } 3598 3599 if ((pCoexSta->btInfoExt & BIT3)) { 3600 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], BT ext info bit3 check, set BT NOT to ignore Wlan active!!\n")); 3601 halbtc8723b2ant_IgnoreWlanAct(pBtCoexist, FORCE_EXEC, false); 3602 } else { 3603 /* BT already NOT ignore Wlan active, do nothing here. */ 3604 } 3605 } 3606 3607 /* check BIT2 first ==> check if bt is under inquiry or page scan */ 3608 if (btInfo & BT_INFO_8723B_2ANT_B_INQ_PAGE) 3609 pCoexSta->bC2hBtInquiryPage = true; 3610 else 3611 pCoexSta->bC2hBtInquiryPage = false; 3612 3613 /* set link exist status */ 3614 if (!(btInfo&BT_INFO_8723B_2ANT_B_CONNECTION)) { 3615 pCoexSta->bBtLinkExist = false; 3616 pCoexSta->bPanExist = false; 3617 pCoexSta->bA2dpExist = false; 3618 pCoexSta->bHidExist = false; 3619 pCoexSta->bScoExist = false; 3620 } else { /* connection exists */ 3621 pCoexSta->bBtLinkExist = true; 3622 if (btInfo & BT_INFO_8723B_2ANT_B_FTP) 3623 pCoexSta->bPanExist = true; 3624 else 3625 pCoexSta->bPanExist = false; 3626 if (btInfo & BT_INFO_8723B_2ANT_B_A2DP) 3627 pCoexSta->bA2dpExist = true; 3628 else 3629 pCoexSta->bA2dpExist = false; 3630 if (btInfo & BT_INFO_8723B_2ANT_B_HID) 3631 pCoexSta->bHidExist = true; 3632 else 3633 pCoexSta->bHidExist = false; 3634 if (btInfo & BT_INFO_8723B_2ANT_B_SCO_ESCO) 3635 pCoexSta->bScoExist = true; 3636 else 3637 pCoexSta->bScoExist = false; 3638 } 3639 3640 halbtc8723b2ant_UpdateBtLinkInfo(pBtCoexist); 3641 3642 if (!(btInfo&BT_INFO_8723B_2ANT_B_CONNECTION)) { 3643 pCoexDm->btStatus = BT_8723B_2ANT_BT_STATUS_NON_CONNECTED_IDLE; 3644 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], BtInfoNotify(), BT Non-Connected idle!!!\n")); 3645 } else if (btInfo == BT_INFO_8723B_2ANT_B_CONNECTION) { /* connection exists but no busy */ 3646 pCoexDm->btStatus = BT_8723B_2ANT_BT_STATUS_CONNECTED_IDLE; 3647 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], BtInfoNotify(), BT Connected-idle!!!\n")); 3648 } else if ( 3649 (btInfo&BT_INFO_8723B_2ANT_B_SCO_ESCO) || 3650 (btInfo&BT_INFO_8723B_2ANT_B_SCO_BUSY) 3651 ) { 3652 pCoexDm->btStatus = BT_8723B_2ANT_BT_STATUS_SCO_BUSY; 3653 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], BtInfoNotify(), BT SCO busy!!!\n")); 3654 } else if (btInfo&BT_INFO_8723B_2ANT_B_ACL_BUSY) { 3655 pCoexDm->btStatus = BT_8723B_2ANT_BT_STATUS_ACL_BUSY; 3656 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], BtInfoNotify(), BT ACL busy!!!\n")); 3657 } else { 3658 pCoexDm->btStatus = BT_8723B_2ANT_BT_STATUS_MAX; 3659 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], BtInfoNotify(), BT Non-Defined state!!!\n")); 3660 } 3661 3662 if ( 3663 (BT_8723B_2ANT_BT_STATUS_ACL_BUSY == pCoexDm->btStatus) || 3664 (BT_8723B_2ANT_BT_STATUS_SCO_BUSY == pCoexDm->btStatus) || 3665 (BT_8723B_2ANT_BT_STATUS_ACL_SCO_BUSY == pCoexDm->btStatus) 3666 ) { 3667 bBtBusy = true; 3668 bLimitedDig = true; 3669 } else { 3670 bBtBusy = false; 3671 bLimitedDig = false; 3672 } 3673 3674 pBtCoexist->fBtcSet(pBtCoexist, BTC_SET_BL_BT_TRAFFIC_BUSY, &bBtBusy); 3675 3676 pCoexDm->bLimitedDig = bLimitedDig; 3677 pBtCoexist->fBtcSet(pBtCoexist, BTC_SET_BL_BT_LIMITED_DIG, &bLimitedDig); 3678 3679 halbtc8723b2ant_RunCoexistMechanism(pBtCoexist); 3680 } 3681 3682 void EXhalbtc8723b2ant_HaltNotify(PBTC_COEXIST pBtCoexist) 3683 { 3684 BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY, ("[BTCoex], Halt notify\n")); 3685 3686 halbtc8723b2ant_WifiOffHwCfg(pBtCoexist); 3687 pBtCoexist->fBtcSetBtReg(pBtCoexist, BTC_BT_REG_RF, 0x3c, 0x15); /* BT goto standby while GNT_BT 1-->0 */ 3688 halbtc8723b2ant_IgnoreWlanAct(pBtCoexist, FORCE_EXEC, true); 3689 3690 EXhalbtc8723b2ant_MediaStatusNotify(pBtCoexist, BTC_MEDIA_DISCONNECT); 3691 } 3692 3693 void EXhalbtc8723b2ant_PnpNotify(PBTC_COEXIST pBtCoexist, u8 pnpState) 3694 { 3695 BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY, ("[BTCoex], Pnp notify\n")); 3696 3697 if (BTC_WIFI_PNP_SLEEP == pnpState) { 3698 BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY, ("[BTCoex], Pnp notify to SLEEP\n")); 3699 } else if (BTC_WIFI_PNP_WAKE_UP == pnpState) { 3700 BTC_PRINT(BTC_MSG_INTERFACE, INTF_NOTIFY, ("[BTCoex], Pnp notify to WAKE UP\n")); 3701 halbtc8723b2ant_InitHwConfig(pBtCoexist, false); 3702 halbtc8723b2ant_InitCoexDm(pBtCoexist); 3703 halbtc8723b2ant_QueryBtInfo(pBtCoexist); 3704 } 3705 } 3706 3707 void EXhalbtc8723b2ant_Periodical(PBTC_COEXIST pBtCoexist) 3708 { 3709 static u8 disVerInfoCnt; 3710 u32 fwVer = 0, btPatchVer = 0; 3711 3712 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], ==========================Periodical ===========================\n")); 3713 3714 if (disVerInfoCnt <= 5) { 3715 disVerInfoCnt += 1; 3716 BTC_PRINT(BTC_MSG_INTERFACE, INTF_INIT, ("[BTCoex], ****************************************************************\n")); 3717 pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_U4_BT_PATCH_VER, &btPatchVer); 3718 pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_U4_WIFI_FW_VER, &fwVer); 3719 BTC_PRINT(BTC_MSG_INTERFACE, INTF_INIT, ("[BTCoex], CoexVer/ FwVer/ PatchVer = %d_%x/ 0x%x/ 0x%x(%d)\n", \ 3720 GLCoexVerDate8723b2Ant, GLCoexVer8723b2Ant, fwVer, btPatchVer, btPatchVer)); 3721 BTC_PRINT(BTC_MSG_INTERFACE, INTF_INIT, ("[BTCoex], ****************************************************************\n")); 3722 } 3723 3724 if ( 3725 halbtc8723b2ant_IsWifiStatusChanged(pBtCoexist) || 3726 pCoexDm->bAutoTdmaAdjust 3727 ) 3728 halbtc8723b2ant_RunCoexistMechanism(pBtCoexist); 3729 } 3730