1 // SPDX-License-Identifier: GPL-2.0 2 /****************************************************************************** 3 * 4 * Copyright(c) 2013 Realtek Corporation. All rights reserved. 5 * 6 ******************************************************************************/ 7 #define __HAL_BTCOEX_C__ 8 9 #include <hal_data.h> 10 #include <rtw_debug.h> 11 #include <hal_btcoex.h> 12 #include <Mp_Precomp.h> 13 14 /* Global variables */ 15 16 struct BTC_COEXIST GLBtCoexist; 17 static u8 GLBtcWiFiInScanState; 18 static u8 GLBtcWiFiInIQKState; 19 20 u32 GLBtcDbgType[BTC_MSG_MAX]; 21 static u8 GLBtcDbgBuf[BT_TMP_BUF_SIZE]; 22 23 typedef struct _btcoexdbginfo { 24 u8 *info; 25 u32 size; /* buffer total size */ 26 u32 len; /* now used length */ 27 } BTCDBGINFO, *PBTCDBGINFO; 28 29 static BTCDBGINFO GLBtcDbgInfo; 30 31 #define BT_Operation(Adapter) false 32 33 static void DBG_BT_INFO_INIT(PBTCDBGINFO pinfo, u8 *pbuf, u32 size) 34 { 35 if (!pinfo) 36 return; 37 38 memset(pinfo, 0, sizeof(BTCDBGINFO)); 39 40 if (pbuf && size) { 41 pinfo->info = pbuf; 42 pinfo->size = size; 43 } 44 } 45 46 void DBG_BT_INFO(u8 *dbgmsg) 47 { 48 PBTCDBGINFO pinfo; 49 u32 msglen; 50 u8 *pbuf; 51 52 53 pinfo = &GLBtcDbgInfo; 54 55 if (!pinfo->info) 56 return; 57 58 msglen = strlen(dbgmsg); 59 if (pinfo->len + msglen > pinfo->size) 60 return; 61 62 pbuf = pinfo->info + pinfo->len; 63 memcpy(pbuf, dbgmsg, msglen); 64 pinfo->len += msglen; 65 } 66 67 /* */ 68 /* Debug related function */ 69 /* */ 70 static u8 halbtcoutsrc_IsBtCoexistAvailable(struct BTC_COEXIST * pBtCoexist) 71 { 72 if (!pBtCoexist->bBinded || !pBtCoexist->Adapter) 73 return false; 74 75 return true; 76 } 77 78 static void halbtcoutsrc_DbgInit(void) 79 { 80 u8 i; 81 82 for (i = 0; i < BTC_MSG_MAX; i++) 83 GLBtcDbgType[i] = 0; 84 85 GLBtcDbgType[BTC_MSG_INTERFACE] = \ 86 /* INTF_INIT | */ 87 /* INTF_NOTIFY | */ 88 0; 89 90 GLBtcDbgType[BTC_MSG_ALGORITHM] = \ 91 /* ALGO_BT_RSSI_STATE | */ 92 /* ALGO_WIFI_RSSI_STATE | */ 93 /* ALGO_BT_MONITOR | */ 94 /* ALGO_TRACE | */ 95 /* ALGO_TRACE_FW | */ 96 /* ALGO_TRACE_FW_DETAIL | */ 97 /* ALGO_TRACE_FW_EXEC | */ 98 /* ALGO_TRACE_SW | */ 99 /* ALGO_TRACE_SW_DETAIL | */ 100 /* ALGO_TRACE_SW_EXEC | */ 101 0; 102 } 103 104 static void halbtcoutsrc_LeaveLps(struct BTC_COEXIST * pBtCoexist) 105 { 106 struct adapter *padapter; 107 108 109 padapter = pBtCoexist->Adapter; 110 111 pBtCoexist->btInfo.bBtCtrlLps = true; 112 pBtCoexist->btInfo.bBtLpsOn = false; 113 114 rtw_btcoex_LPS_Leave(padapter); 115 } 116 117 static void halbtcoutsrc_EnterLps(struct BTC_COEXIST * pBtCoexist) 118 { 119 struct adapter *padapter; 120 121 122 padapter = pBtCoexist->Adapter; 123 124 pBtCoexist->btInfo.bBtCtrlLps = true; 125 pBtCoexist->btInfo.bBtLpsOn = true; 126 127 rtw_btcoex_LPS_Enter(padapter); 128 } 129 130 static void halbtcoutsrc_NormalLps(struct BTC_COEXIST * pBtCoexist) 131 { 132 struct adapter *padapter; 133 134 135 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE, ("[BTCoex], Normal LPS behavior!!!\n")); 136 137 padapter = pBtCoexist->Adapter; 138 139 if (pBtCoexist->btInfo.bBtCtrlLps) { 140 pBtCoexist->btInfo.bBtLpsOn = false; 141 rtw_btcoex_LPS_Leave(padapter); 142 pBtCoexist->btInfo.bBtCtrlLps = false; 143 144 /* recover the LPS state to the original */ 145 } 146 } 147 148 /* 149 * Constraint: 150 * 1. this function will request pwrctrl->lock 151 */ 152 static void halbtcoutsrc_LeaveLowPower(struct BTC_COEXIST * pBtCoexist) 153 { 154 struct adapter *padapter; 155 s32 ready; 156 unsigned long stime; 157 unsigned long utime; 158 u32 timeout; /* unit: ms */ 159 160 161 padapter = pBtCoexist->Adapter; 162 ready = _FAIL; 163 #ifdef LPS_RPWM_WAIT_MS 164 timeout = LPS_RPWM_WAIT_MS; 165 #else /* !LPS_RPWM_WAIT_MS */ 166 timeout = 30; 167 #endif /* !LPS_RPWM_WAIT_MS */ 168 169 stime = jiffies; 170 do { 171 ready = rtw_register_task_alive(padapter, BTCOEX_ALIVE); 172 if (_SUCCESS == ready) 173 break; 174 175 utime = jiffies_to_msecs(jiffies - stime); 176 if (utime > timeout) 177 break; 178 179 msleep(1); 180 } while (1); 181 } 182 183 /* 184 * Constraint: 185 * 1. this function will request pwrctrl->lock 186 */ 187 static void halbtcoutsrc_NormalLowPower(struct BTC_COEXIST * pBtCoexist) 188 { 189 struct adapter *padapter; 190 191 192 padapter = pBtCoexist->Adapter; 193 rtw_unregister_task_alive(padapter, BTCOEX_ALIVE); 194 } 195 196 static void halbtcoutsrc_DisableLowPower(struct BTC_COEXIST * pBtCoexist, u8 bLowPwrDisable) 197 { 198 pBtCoexist->btInfo.bBtDisableLowPwr = bLowPwrDisable; 199 if (bLowPwrDisable) 200 halbtcoutsrc_LeaveLowPower(pBtCoexist); /* leave 32k low power. */ 201 else 202 halbtcoutsrc_NormalLowPower(pBtCoexist); /* original 32k low power behavior. */ 203 } 204 205 static void halbtcoutsrc_AggregationCheck(struct BTC_COEXIST * pBtCoexist) 206 { 207 struct adapter *padapter; 208 bool bNeedToAct; 209 210 211 padapter = pBtCoexist->Adapter; 212 bNeedToAct = false; 213 214 if (pBtCoexist->btInfo.bRejectAggPkt) { 215 rtw_btcoex_RejectApAggregatedPacket(padapter, true); 216 } else { 217 if (pBtCoexist->btInfo.bPreBtCtrlAggBufSize != 218 pBtCoexist->btInfo.bBtCtrlAggBufSize) { 219 bNeedToAct = true; 220 pBtCoexist->btInfo.bPreBtCtrlAggBufSize = pBtCoexist->btInfo.bBtCtrlAggBufSize; 221 } 222 223 if (pBtCoexist->btInfo.bBtCtrlAggBufSize) { 224 if (pBtCoexist->btInfo.preAggBufSize != 225 pBtCoexist->btInfo.aggBufSize){ 226 bNeedToAct = true; 227 } 228 pBtCoexist->btInfo.preAggBufSize = pBtCoexist->btInfo.aggBufSize; 229 } 230 231 if (bNeedToAct) { 232 rtw_btcoex_RejectApAggregatedPacket(padapter, true); 233 rtw_btcoex_RejectApAggregatedPacket(padapter, false); 234 } 235 } 236 } 237 238 static u8 halbtcoutsrc_IsWifiBusy(struct adapter *padapter) 239 { 240 struct mlme_priv *pmlmepriv; 241 242 243 pmlmepriv = &padapter->mlmepriv; 244 245 if (check_fwstate(pmlmepriv, WIFI_ASOC_STATE) == true) { 246 if (check_fwstate(pmlmepriv, WIFI_AP_STATE) == true) 247 return true; 248 if (pmlmepriv->LinkDetectInfo.bBusyTraffic) 249 return true; 250 } 251 252 return false; 253 } 254 255 static u32 _halbtcoutsrc_GetWifiLinkStatus(struct adapter *padapter) 256 { 257 struct mlme_priv *pmlmepriv; 258 u8 bp2p; 259 u32 portConnectedStatus; 260 261 262 pmlmepriv = &padapter->mlmepriv; 263 bp2p = false; 264 portConnectedStatus = 0; 265 266 if (check_fwstate(pmlmepriv, WIFI_ASOC_STATE) == true) { 267 if (check_fwstate(pmlmepriv, WIFI_AP_STATE) == true) { 268 if (bp2p) 269 portConnectedStatus |= WIFI_P2P_GO_CONNECTED; 270 else 271 portConnectedStatus |= WIFI_AP_CONNECTED; 272 } else { 273 if (bp2p) 274 portConnectedStatus |= WIFI_P2P_GC_CONNECTED; 275 else 276 portConnectedStatus |= WIFI_STA_CONNECTED; 277 } 278 } 279 280 return portConnectedStatus; 281 } 282 283 static u32 halbtcoutsrc_GetWifiLinkStatus(struct BTC_COEXIST * pBtCoexist) 284 { 285 /* */ 286 /* return value: */ 287 /* [31:16]=> connected port number */ 288 /* [15:0]=> port connected bit define */ 289 /* */ 290 291 struct adapter *padapter; 292 u32 retVal; 293 u32 portConnectedStatus, numOfConnectedPort; 294 295 296 padapter = pBtCoexist->Adapter; 297 portConnectedStatus = 0; 298 numOfConnectedPort = 0; 299 300 retVal = _halbtcoutsrc_GetWifiLinkStatus(padapter); 301 if (retVal) { 302 portConnectedStatus |= retVal; 303 numOfConnectedPort++; 304 } 305 306 retVal = (numOfConnectedPort << 16) | portConnectedStatus; 307 308 return retVal; 309 } 310 311 static u32 halbtcoutsrc_GetBtPatchVer(struct BTC_COEXIST * pBtCoexist) 312 { 313 return pBtCoexist->btInfo.btRealFwVer; 314 } 315 316 static s32 halbtcoutsrc_GetWifiRssi(struct adapter *padapter) 317 { 318 struct hal_com_data *pHalData = GET_HAL_DATA(padapter); 319 320 return pHalData->dmpriv.EntryMinUndecoratedSmoothedPWDB; 321 } 322 323 static u8 halbtcoutsrc_GetWifiScanAPNum(struct adapter *padapter) 324 { 325 struct mlme_ext_priv *pmlmeext; 326 static u8 scan_AP_num; 327 328 pmlmeext = &padapter->mlmeextpriv; 329 330 if (!GLBtcWiFiInScanState) { 331 if (pmlmeext->sitesurvey_res.bss_cnt > 0xFF) 332 scan_AP_num = 0xFF; 333 else 334 scan_AP_num = (u8)pmlmeext->sitesurvey_res.bss_cnt; 335 } 336 337 return scan_AP_num; 338 } 339 340 static u8 halbtcoutsrc_Get(void *pBtcContext, u8 getType, void *pOutBuf) 341 { 342 struct BTC_COEXIST * pBtCoexist; 343 struct adapter *padapter; 344 struct hal_com_data *pHalData; 345 struct mlme_ext_priv *mlmeext; 346 u8 *pu8; 347 s32 *pS4Tmp; 348 u32 *pU4Tmp; 349 u8 ret; 350 351 352 pBtCoexist = (struct BTC_COEXIST *)pBtcContext; 353 if (!halbtcoutsrc_IsBtCoexistAvailable(pBtCoexist)) 354 return false; 355 356 padapter = pBtCoexist->Adapter; 357 pHalData = GET_HAL_DATA(padapter); 358 mlmeext = &padapter->mlmeextpriv; 359 pu8 = pOutBuf; 360 pS4Tmp = pOutBuf; 361 pU4Tmp = pOutBuf; 362 ret = true; 363 364 switch (getType) { 365 case BTC_GET_BL_HS_OPERATION: 366 *pu8 = false; 367 ret = false; 368 break; 369 370 case BTC_GET_BL_HS_CONNECTING: 371 *pu8 = false; 372 ret = false; 373 break; 374 375 case BTC_GET_BL_WIFI_CONNECTED: 376 *pu8 = check_fwstate(&padapter->mlmepriv, WIFI_ASOC_STATE); 377 break; 378 379 case BTC_GET_BL_WIFI_BUSY: 380 *pu8 = halbtcoutsrc_IsWifiBusy(padapter); 381 break; 382 383 case BTC_GET_BL_WIFI_SCAN: 384 /* Use the value of the new variable GLBtcWiFiInScanState to judge whether WiFi is in scan state or not, since the originally used flag 385 WIFI_SITE_MONITOR in fwstate may not be cleared in time */ 386 *pu8 = GLBtcWiFiInScanState; 387 break; 388 389 case BTC_GET_BL_WIFI_LINK: 390 *pu8 = check_fwstate(&padapter->mlmepriv, WIFI_UNDER_LINKING); 391 break; 392 393 case BTC_GET_BL_WIFI_ROAM: 394 *pu8 = check_fwstate(&padapter->mlmepriv, WIFI_UNDER_LINKING); 395 break; 396 397 case BTC_GET_BL_WIFI_4_WAY_PROGRESS: 398 *pu8 = false; 399 break; 400 401 case BTC_GET_BL_WIFI_UNDER_5G: 402 *pu8 = pHalData->CurrentBandType == 1; 403 break; 404 405 case BTC_GET_BL_WIFI_AP_MODE_ENABLE: 406 *pu8 = check_fwstate(&padapter->mlmepriv, WIFI_AP_STATE); 407 break; 408 409 case BTC_GET_BL_WIFI_ENABLE_ENCRYPTION: 410 *pu8 = padapter->securitypriv.dot11PrivacyAlgrthm != 0; 411 break; 412 413 case BTC_GET_BL_WIFI_UNDER_B_MODE: 414 if (mlmeext->cur_wireless_mode == WIRELESS_11B) 415 *pu8 = true; 416 else 417 *pu8 = false; 418 break; 419 420 case BTC_GET_BL_WIFI_IS_IN_MP_MODE: 421 *pu8 = false; 422 break; 423 424 case BTC_GET_BL_EXT_SWITCH: 425 *pu8 = false; 426 break; 427 428 case BTC_GET_S4_WIFI_RSSI: 429 *pS4Tmp = halbtcoutsrc_GetWifiRssi(padapter); 430 break; 431 432 case BTC_GET_S4_HS_RSSI: 433 *pS4Tmp = 0; 434 ret = false; 435 break; 436 437 case BTC_GET_U4_WIFI_BW: 438 if (IsLegacyOnly(mlmeext->cur_wireless_mode)) 439 *pU4Tmp = BTC_WIFI_BW_LEGACY; 440 else if (pHalData->CurrentChannelBW == CHANNEL_WIDTH_20) 441 *pU4Tmp = BTC_WIFI_BW_HT20; 442 else 443 *pU4Tmp = BTC_WIFI_BW_HT40; 444 break; 445 446 case BTC_GET_U4_WIFI_TRAFFIC_DIRECTION: 447 { 448 PRT_LINK_DETECT_T plinkinfo; 449 plinkinfo = &padapter->mlmepriv.LinkDetectInfo; 450 451 if (plinkinfo->NumTxOkInPeriod > plinkinfo->NumRxOkInPeriod) 452 *pU4Tmp = BTC_WIFI_TRAFFIC_TX; 453 else 454 *pU4Tmp = BTC_WIFI_TRAFFIC_RX; 455 } 456 break; 457 458 case BTC_GET_U4_WIFI_FW_VER: 459 *pU4Tmp = pHalData->FirmwareVersion << 16; 460 *pU4Tmp |= pHalData->FirmwareSubVersion; 461 break; 462 463 case BTC_GET_U4_WIFI_LINK_STATUS: 464 *pU4Tmp = halbtcoutsrc_GetWifiLinkStatus(pBtCoexist); 465 break; 466 467 case BTC_GET_U4_BT_PATCH_VER: 468 *pU4Tmp = halbtcoutsrc_GetBtPatchVer(pBtCoexist); 469 break; 470 471 case BTC_GET_U1_WIFI_DOT11_CHNL: 472 *pu8 = padapter->mlmeextpriv.cur_channel; 473 break; 474 475 case BTC_GET_U1_WIFI_CENTRAL_CHNL: 476 *pu8 = pHalData->CurrentChannel; 477 break; 478 479 case BTC_GET_U1_WIFI_HS_CHNL: 480 *pu8 = 0; 481 ret = false; 482 break; 483 484 case BTC_GET_U1_MAC_PHY_MODE: 485 *pu8 = BTC_SMSP; 486 /* *pU1Tmp = BTC_DMSP; */ 487 /* *pU1Tmp = BTC_DMDP; */ 488 /* *pU1Tmp = BTC_MP_UNKNOWN; */ 489 break; 490 491 case BTC_GET_U1_AP_NUM: 492 *pu8 = halbtcoutsrc_GetWifiScanAPNum(padapter); 493 break; 494 495 /* 1Ant =========== */ 496 case BTC_GET_U1_LPS_MODE: 497 *pu8 = padapter->dvobj->pwrctl_priv.pwr_mode; 498 break; 499 500 default: 501 ret = false; 502 break; 503 } 504 505 return ret; 506 } 507 508 static u8 halbtcoutsrc_Set(void *pBtcContext, u8 setType, void *pInBuf) 509 { 510 struct BTC_COEXIST * pBtCoexist; 511 struct adapter *padapter; 512 u8 *pu8; 513 u32 *pU4Tmp; 514 u8 ret; 515 516 517 pBtCoexist = (struct BTC_COEXIST *)pBtcContext; 518 padapter = pBtCoexist->Adapter; 519 pu8 = pInBuf; 520 pU4Tmp = pInBuf; 521 ret = true; 522 523 if (!halbtcoutsrc_IsBtCoexistAvailable(pBtCoexist)) 524 return false; 525 526 switch (setType) { 527 /* set some u8 type variables. */ 528 case BTC_SET_BL_BT_DISABLE: 529 pBtCoexist->btInfo.bBtDisabled = *pu8; 530 break; 531 532 case BTC_SET_BL_BT_TRAFFIC_BUSY: 533 pBtCoexist->btInfo.bBtBusy = *pu8; 534 break; 535 536 case BTC_SET_BL_BT_LIMITED_DIG: 537 pBtCoexist->btInfo.bLimitedDig = *pu8; 538 break; 539 540 case BTC_SET_BL_FORCE_TO_ROAM: 541 pBtCoexist->btInfo.bForceToRoam = *pu8; 542 break; 543 544 case BTC_SET_BL_TO_REJ_AP_AGG_PKT: 545 pBtCoexist->btInfo.bRejectAggPkt = *pu8; 546 break; 547 548 case BTC_SET_BL_BT_CTRL_AGG_SIZE: 549 pBtCoexist->btInfo.bBtCtrlAggBufSize = *pu8; 550 break; 551 552 case BTC_SET_BL_INC_SCAN_DEV_NUM: 553 pBtCoexist->btInfo.bIncreaseScanDevNum = *pu8; 554 break; 555 556 case BTC_SET_BL_BT_TX_RX_MASK: 557 pBtCoexist->btInfo.bBtTxRxMask = *pu8; 558 break; 559 560 /* set some u8 type variables. */ 561 case BTC_SET_U1_RSSI_ADJ_VAL_FOR_AGC_TABLE_ON: 562 pBtCoexist->btInfo.rssiAdjustForAgcTableOn = *pu8; 563 break; 564 565 case BTC_SET_U1_AGG_BUF_SIZE: 566 pBtCoexist->btInfo.aggBufSize = *pu8; 567 break; 568 569 /* the following are some action which will be triggered */ 570 case BTC_SET_ACT_GET_BT_RSSI: 571 ret = false; 572 break; 573 574 case BTC_SET_ACT_AGGREGATE_CTRL: 575 halbtcoutsrc_AggregationCheck(pBtCoexist); 576 break; 577 578 /* 1Ant =========== */ 579 /* set some u8 type variables. */ 580 case BTC_SET_U1_RSSI_ADJ_VAL_FOR_1ANT_COEX_TYPE: 581 pBtCoexist->btInfo.rssiAdjustFor1AntCoexType = *pu8; 582 break; 583 584 case BTC_SET_U1_LPS_VAL: 585 pBtCoexist->btInfo.lpsVal = *pu8; 586 break; 587 588 case BTC_SET_U1_RPWM_VAL: 589 pBtCoexist->btInfo.rpwmVal = *pu8; 590 break; 591 592 /* the following are some action which will be triggered */ 593 case BTC_SET_ACT_LEAVE_LPS: 594 halbtcoutsrc_LeaveLps(pBtCoexist); 595 break; 596 597 case BTC_SET_ACT_ENTER_LPS: 598 halbtcoutsrc_EnterLps(pBtCoexist); 599 break; 600 601 case BTC_SET_ACT_NORMAL_LPS: 602 halbtcoutsrc_NormalLps(pBtCoexist); 603 break; 604 605 case BTC_SET_ACT_DISABLE_LOW_POWER: 606 halbtcoutsrc_DisableLowPower(pBtCoexist, *pu8); 607 break; 608 609 case BTC_SET_ACT_UPDATE_RAMASK: 610 pBtCoexist->btInfo.raMask = *pU4Tmp; 611 612 if (check_fwstate(&padapter->mlmepriv, WIFI_ASOC_STATE) == true) { 613 struct sta_info *psta; 614 struct wlan_bssid_ex *cur_network; 615 616 cur_network = &padapter->mlmeextpriv.mlmext_info.network; 617 psta = rtw_get_stainfo(&padapter->stapriv, cur_network->MacAddress); 618 rtw_hal_update_ra_mask(psta, 0); 619 } 620 break; 621 622 case BTC_SET_ACT_SEND_MIMO_PS: 623 ret = false; 624 break; 625 626 case BTC_SET_ACT_CTRL_BT_INFO: 627 ret = false; 628 break; 629 630 case BTC_SET_ACT_CTRL_BT_COEX: 631 ret = false; 632 break; 633 case BTC_SET_ACT_CTRL_8723B_ANT: 634 ret = false; 635 break; 636 /* */ 637 default: 638 ret = false; 639 break; 640 } 641 642 return ret; 643 } 644 645 static void halbtcoutsrc_DisplayFwPwrModeCmd(struct BTC_COEXIST * pBtCoexist) 646 { 647 u8 *cliBuf = pBtCoexist->cliBuf; 648 649 CL_SPRINTF(cliBuf, BT_TMP_BUF_SIZE, "\r\n %-35s = %02x %02x %02x %02x %02x %02x ", "Power mode cmd ", \ 650 pBtCoexist->pwrModeVal[0], pBtCoexist->pwrModeVal[1], 651 pBtCoexist->pwrModeVal[2], pBtCoexist->pwrModeVal[3], 652 pBtCoexist->pwrModeVal[4], pBtCoexist->pwrModeVal[5]); 653 CL_PRINTF(cliBuf); 654 } 655 656 /* */ 657 /* IO related function */ 658 /* */ 659 static u8 halbtcoutsrc_Read1Byte(void *pBtcContext, u32 RegAddr) 660 { 661 struct BTC_COEXIST * pBtCoexist; 662 struct adapter *padapter; 663 664 665 pBtCoexist = (struct BTC_COEXIST *)pBtcContext; 666 padapter = pBtCoexist->Adapter; 667 668 return rtw_read8(padapter, RegAddr); 669 } 670 671 static u16 halbtcoutsrc_Read2Byte(void *pBtcContext, u32 RegAddr) 672 { 673 struct BTC_COEXIST * pBtCoexist; 674 struct adapter *padapter; 675 676 677 pBtCoexist = (struct BTC_COEXIST *)pBtcContext; 678 padapter = pBtCoexist->Adapter; 679 680 return rtw_read16(padapter, RegAddr); 681 } 682 683 static u32 halbtcoutsrc_Read4Byte(void *pBtcContext, u32 RegAddr) 684 { 685 struct BTC_COEXIST * pBtCoexist; 686 struct adapter *padapter; 687 688 689 pBtCoexist = (struct BTC_COEXIST *)pBtcContext; 690 padapter = pBtCoexist->Adapter; 691 692 return rtw_read32(padapter, RegAddr); 693 } 694 695 static void halbtcoutsrc_Write1Byte(void *pBtcContext, u32 RegAddr, u8 Data) 696 { 697 struct BTC_COEXIST * pBtCoexist; 698 struct adapter *padapter; 699 700 701 pBtCoexist = (struct BTC_COEXIST *)pBtcContext; 702 padapter = pBtCoexist->Adapter; 703 704 rtw_write8(padapter, RegAddr, Data); 705 } 706 707 static void halbtcoutsrc_BitMaskWrite1Byte(void *pBtcContext, u32 regAddr, u8 bitMask, u8 data1b) 708 { 709 struct BTC_COEXIST * pBtCoexist; 710 struct adapter *padapter; 711 u8 originalValue, bitShift; 712 u8 i; 713 714 715 pBtCoexist = (struct BTC_COEXIST *)pBtcContext; 716 padapter = pBtCoexist->Adapter; 717 originalValue = 0; 718 bitShift = 0; 719 720 if (bitMask != 0xFF) { 721 originalValue = rtw_read8(padapter, regAddr); 722 723 for (i = 0; i <= 7; i++) { 724 if ((bitMask>>i)&0x1) 725 break; 726 } 727 bitShift = i; 728 729 data1b = (originalValue & ~bitMask) | ((data1b << bitShift) & bitMask); 730 } 731 732 rtw_write8(padapter, regAddr, data1b); 733 } 734 735 static void halbtcoutsrc_Write2Byte(void *pBtcContext, u32 RegAddr, u16 Data) 736 { 737 struct BTC_COEXIST *pBtCoexist; 738 struct adapter *padapter; 739 740 741 pBtCoexist = (struct BTC_COEXIST *)pBtcContext; 742 padapter = pBtCoexist->Adapter; 743 744 rtw_write16(padapter, RegAddr, Data); 745 } 746 747 static void halbtcoutsrc_Write4Byte(void *pBtcContext, u32 RegAddr, u32 Data) 748 { 749 struct BTC_COEXIST * pBtCoexist; 750 struct adapter *padapter; 751 752 753 pBtCoexist = (struct BTC_COEXIST *)pBtcContext; 754 padapter = pBtCoexist->Adapter; 755 756 rtw_write32(padapter, RegAddr, Data); 757 } 758 759 static void halbtcoutsrc_WriteLocalReg1Byte(void *pBtcContext, u32 RegAddr, u8 Data) 760 { 761 struct BTC_COEXIST * pBtCoexist = (struct BTC_COEXIST *)pBtcContext; 762 struct adapter *Adapter = pBtCoexist->Adapter; 763 764 if (BTC_INTF_SDIO == pBtCoexist->chipInterface) 765 rtw_write8(Adapter, SDIO_LOCAL_BASE | RegAddr, Data); 766 else 767 rtw_write8(Adapter, RegAddr, Data); 768 } 769 770 static void halbtcoutsrc_SetBbReg(void *pBtcContext, u32 RegAddr, u32 BitMask, u32 Data) 771 { 772 struct BTC_COEXIST * pBtCoexist; 773 struct adapter *padapter; 774 775 776 pBtCoexist = (struct BTC_COEXIST *)pBtcContext; 777 padapter = pBtCoexist->Adapter; 778 779 PHY_SetBBReg(padapter, RegAddr, BitMask, Data); 780 } 781 782 783 static u32 halbtcoutsrc_GetBbReg(void *pBtcContext, u32 RegAddr, u32 BitMask) 784 { 785 struct BTC_COEXIST * pBtCoexist; 786 struct adapter *padapter; 787 788 789 pBtCoexist = (struct BTC_COEXIST *)pBtcContext; 790 padapter = pBtCoexist->Adapter; 791 792 return PHY_QueryBBReg(padapter, RegAddr, BitMask); 793 } 794 795 static void halbtcoutsrc_SetRfReg(void *pBtcContext, u8 eRFPath, u32 RegAddr, u32 BitMask, u32 Data) 796 { 797 struct BTC_COEXIST * pBtCoexist; 798 struct adapter *padapter; 799 800 801 pBtCoexist = (struct BTC_COEXIST *)pBtcContext; 802 padapter = pBtCoexist->Adapter; 803 804 PHY_SetRFReg(padapter, eRFPath, RegAddr, BitMask, Data); 805 } 806 807 static u32 halbtcoutsrc_GetRfReg(void *pBtcContext, u8 eRFPath, u32 RegAddr, u32 BitMask) 808 { 809 struct BTC_COEXIST * pBtCoexist; 810 struct adapter *padapter; 811 812 813 pBtCoexist = (struct BTC_COEXIST *)pBtcContext; 814 padapter = pBtCoexist->Adapter; 815 816 return PHY_QueryRFReg(padapter, eRFPath, RegAddr, BitMask); 817 } 818 819 static void halbtcoutsrc_SetBtReg(void *pBtcContext, u8 RegType, u32 RegAddr, u32 Data) 820 { 821 struct BTC_COEXIST * pBtCoexist; 822 struct adapter *padapter; 823 u8 CmdBuffer1[4] = {0}; 824 u8 CmdBuffer2[4] = {0}; 825 u8 *AddrToSet = (u8 *)&RegAddr; 826 u8 *ValueToSet = (u8 *)&Data; 827 u8 OperVer = 0; 828 u8 ReqNum = 0; 829 830 pBtCoexist = (struct BTC_COEXIST *)pBtcContext; 831 padapter = pBtCoexist->Adapter; 832 833 CmdBuffer1[0] |= (OperVer & 0x0f); /* Set OperVer */ 834 CmdBuffer1[0] |= ((ReqNum << 4) & 0xf0); /* Set ReqNum */ 835 CmdBuffer1[1] = 0x0d; /* Set OpCode to BT_LO_OP_WRITE_REG_VALUE */ 836 CmdBuffer1[2] = ValueToSet[0]; /* Set WriteRegValue */ 837 rtw_hal_fill_h2c_cmd(padapter, 0x67, 4, &(CmdBuffer1[0])); 838 839 msleep(200); 840 ReqNum++; 841 842 CmdBuffer2[0] |= (OperVer & 0x0f); /* Set OperVer */ 843 CmdBuffer2[0] |= ((ReqNum << 4) & 0xf0); /* Set ReqNum */ 844 CmdBuffer2[1] = 0x0c; /* Set OpCode of BT_LO_OP_WRITE_REG_ADDR */ 845 CmdBuffer2[3] = AddrToSet[0]; /* Set WriteRegAddr */ 846 rtw_hal_fill_h2c_cmd(padapter, 0x67, 4, &(CmdBuffer2[0])); 847 } 848 849 static u32 halbtcoutsrc_GetBtReg(void *pBtcContext, u8 RegType, u32 RegAddr) 850 { 851 /* To be implemented. Always return 0 temporarily */ 852 return 0; 853 } 854 855 static void halbtcoutsrc_FillH2cCmd(void *pBtcContext, u8 elementId, u32 cmdLen, u8 *pCmdBuffer) 856 { 857 struct BTC_COEXIST * pBtCoexist; 858 struct adapter *padapter; 859 860 861 pBtCoexist = (struct BTC_COEXIST *)pBtcContext; 862 padapter = pBtCoexist->Adapter; 863 864 rtw_hal_fill_h2c_cmd(padapter, elementId, cmdLen, pCmdBuffer); 865 } 866 867 static void halbtcoutsrc_DisplayDbgMsg(void *pBtcContext, u8 dispType) 868 { 869 struct BTC_COEXIST * pBtCoexist; 870 871 872 pBtCoexist = (struct BTC_COEXIST *)pBtcContext; 873 switch (dispType) { 874 case BTC_DBG_DISP_COEX_STATISTICS: 875 break; 876 case BTC_DBG_DISP_BT_LINK_INFO: 877 break; 878 case BTC_DBG_DISP_FW_PWR_MODE_CMD: 879 halbtcoutsrc_DisplayFwPwrModeCmd(pBtCoexist); 880 break; 881 default: 882 break; 883 } 884 } 885 886 /* */ 887 /* Extern functions called by other module */ 888 /* */ 889 static u8 EXhalbtcoutsrc_BindBtCoexWithAdapter(void *padapter) 890 { 891 struct BTC_COEXIST * pBtCoexist = &GLBtCoexist; 892 893 if (pBtCoexist->bBinded) 894 return false; 895 else 896 pBtCoexist->bBinded = true; 897 898 pBtCoexist->statistics.cntBind++; 899 900 pBtCoexist->Adapter = padapter; 901 902 pBtCoexist->stackInfo.bProfileNotified = false; 903 904 pBtCoexist->btInfo.bBtCtrlAggBufSize = false; 905 pBtCoexist->btInfo.aggBufSize = 5; 906 907 pBtCoexist->btInfo.bIncreaseScanDevNum = false; 908 909 /* set default antenna position to main port */ 910 pBtCoexist->boardInfo.btdmAntPos = BTC_ANTENNA_AT_MAIN_PORT; 911 912 return true; 913 } 914 915 void hal_btcoex_Initialize(void *padapter) 916 { 917 struct BTC_COEXIST * pBtCoexist; 918 919 memset(&GLBtCoexist, 0, sizeof(GLBtCoexist)); 920 921 pBtCoexist = &GLBtCoexist; 922 923 /* pBtCoexist->statistics.cntBind++; */ 924 925 halbtcoutsrc_DbgInit(); 926 927 pBtCoexist->chipInterface = BTC_INTF_SDIO; 928 929 EXhalbtcoutsrc_BindBtCoexWithAdapter(padapter); 930 931 pBtCoexist->fBtcRead1Byte = halbtcoutsrc_Read1Byte; 932 pBtCoexist->fBtcWrite1Byte = halbtcoutsrc_Write1Byte; 933 pBtCoexist->fBtcWrite1ByteBitMask = halbtcoutsrc_BitMaskWrite1Byte; 934 pBtCoexist->fBtcRead2Byte = halbtcoutsrc_Read2Byte; 935 pBtCoexist->fBtcWrite2Byte = halbtcoutsrc_Write2Byte; 936 pBtCoexist->fBtcRead4Byte = halbtcoutsrc_Read4Byte; 937 pBtCoexist->fBtcWrite4Byte = halbtcoutsrc_Write4Byte; 938 pBtCoexist->fBtcWriteLocalReg1Byte = halbtcoutsrc_WriteLocalReg1Byte; 939 940 pBtCoexist->fBtcSetBbReg = halbtcoutsrc_SetBbReg; 941 pBtCoexist->fBtcGetBbReg = halbtcoutsrc_GetBbReg; 942 943 pBtCoexist->fBtcSetRfReg = halbtcoutsrc_SetRfReg; 944 pBtCoexist->fBtcGetRfReg = halbtcoutsrc_GetRfReg; 945 946 pBtCoexist->fBtcFillH2c = halbtcoutsrc_FillH2cCmd; 947 pBtCoexist->fBtcDispDbgMsg = halbtcoutsrc_DisplayDbgMsg; 948 949 pBtCoexist->fBtcGet = halbtcoutsrc_Get; 950 pBtCoexist->fBtcSet = halbtcoutsrc_Set; 951 pBtCoexist->fBtcGetBtReg = halbtcoutsrc_GetBtReg; 952 pBtCoexist->fBtcSetBtReg = halbtcoutsrc_SetBtReg; 953 954 pBtCoexist->cliBuf = &GLBtcDbgBuf[0]; 955 956 pBtCoexist->boardInfo.singleAntPath = 0; 957 958 GLBtcWiFiInScanState = false; 959 960 GLBtcWiFiInIQKState = false; 961 } 962 963 void EXhalbtcoutsrc_PowerOnSetting(struct BTC_COEXIST * pBtCoexist) 964 { 965 if (!halbtcoutsrc_IsBtCoexistAvailable(pBtCoexist)) 966 return; 967 968 /* Power on setting function is only added in 8723B currently */ 969 if (pBtCoexist->boardInfo.btdmAntNum == 2) 970 EXhalbtc8723b2ant_PowerOnSetting(pBtCoexist); 971 else if (pBtCoexist->boardInfo.btdmAntNum == 1) 972 EXhalbtc8723b1ant_PowerOnSetting(pBtCoexist); 973 } 974 975 void EXhalbtcoutsrc_InitHwConfig(struct BTC_COEXIST * pBtCoexist, u8 bWifiOnly) 976 { 977 if (!halbtcoutsrc_IsBtCoexistAvailable(pBtCoexist)) 978 return; 979 980 pBtCoexist->statistics.cntInitHwConfig++; 981 982 if (pBtCoexist->boardInfo.btdmAntNum == 2) 983 EXhalbtc8723b2ant_InitHwConfig(pBtCoexist, bWifiOnly); 984 else if (pBtCoexist->boardInfo.btdmAntNum == 1) 985 EXhalbtc8723b1ant_InitHwConfig(pBtCoexist, bWifiOnly); 986 } 987 988 void EXhalbtcoutsrc_InitCoexDm(struct BTC_COEXIST * pBtCoexist) 989 { 990 if (!halbtcoutsrc_IsBtCoexistAvailable(pBtCoexist)) 991 return; 992 993 pBtCoexist->statistics.cntInitCoexDm++; 994 995 if (pBtCoexist->boardInfo.btdmAntNum == 2) 996 EXhalbtc8723b2ant_InitCoexDm(pBtCoexist); 997 else if (pBtCoexist->boardInfo.btdmAntNum == 1) 998 EXhalbtc8723b1ant_InitCoexDm(pBtCoexist); 999 1000 pBtCoexist->bInitilized = true; 1001 } 1002 1003 void EXhalbtcoutsrc_IpsNotify(struct BTC_COEXIST * pBtCoexist, u8 type) 1004 { 1005 u8 ipsType; 1006 1007 if (!halbtcoutsrc_IsBtCoexistAvailable(pBtCoexist)) 1008 return; 1009 1010 pBtCoexist->statistics.cntIpsNotify++; 1011 if (pBtCoexist->bManualControl) 1012 return; 1013 1014 if (IPS_NONE == type) 1015 ipsType = BTC_IPS_LEAVE; 1016 else 1017 ipsType = BTC_IPS_ENTER; 1018 1019 /* All notify is called in cmd thread, don't need to leave low power again */ 1020 /* halbtcoutsrc_LeaveLowPower(pBtCoexist); */ 1021 1022 if (pBtCoexist->boardInfo.btdmAntNum == 2) 1023 EXhalbtc8723b2ant_IpsNotify(pBtCoexist, ipsType); 1024 else if (pBtCoexist->boardInfo.btdmAntNum == 1) 1025 EXhalbtc8723b1ant_IpsNotify(pBtCoexist, ipsType); 1026 1027 /* halbtcoutsrc_NormalLowPower(pBtCoexist); */ 1028 } 1029 1030 void EXhalbtcoutsrc_LpsNotify(struct BTC_COEXIST * pBtCoexist, u8 type) 1031 { 1032 u8 lpsType; 1033 1034 1035 if (!halbtcoutsrc_IsBtCoexistAvailable(pBtCoexist)) 1036 return; 1037 1038 pBtCoexist->statistics.cntLpsNotify++; 1039 if (pBtCoexist->bManualControl) 1040 return; 1041 1042 if (PS_MODE_ACTIVE == type) 1043 lpsType = BTC_LPS_DISABLE; 1044 else 1045 lpsType = BTC_LPS_ENABLE; 1046 1047 if (pBtCoexist->boardInfo.btdmAntNum == 2) 1048 EXhalbtc8723b2ant_LpsNotify(pBtCoexist, lpsType); 1049 else if (pBtCoexist->boardInfo.btdmAntNum == 1) 1050 EXhalbtc8723b1ant_LpsNotify(pBtCoexist, lpsType); 1051 } 1052 1053 void EXhalbtcoutsrc_ScanNotify(struct BTC_COEXIST * pBtCoexist, u8 type) 1054 { 1055 u8 scanType; 1056 1057 if (!halbtcoutsrc_IsBtCoexistAvailable(pBtCoexist)) 1058 return; 1059 pBtCoexist->statistics.cntScanNotify++; 1060 if (pBtCoexist->bManualControl) 1061 return; 1062 1063 if (type) { 1064 scanType = BTC_SCAN_START; 1065 GLBtcWiFiInScanState = true; 1066 } else { 1067 scanType = BTC_SCAN_FINISH; 1068 GLBtcWiFiInScanState = false; 1069 } 1070 1071 /* All notify is called in cmd thread, don't need to leave low power again */ 1072 /* halbtcoutsrc_LeaveLowPower(pBtCoexist); */ 1073 1074 if (pBtCoexist->boardInfo.btdmAntNum == 2) 1075 EXhalbtc8723b2ant_ScanNotify(pBtCoexist, scanType); 1076 else if (pBtCoexist->boardInfo.btdmAntNum == 1) 1077 EXhalbtc8723b1ant_ScanNotify(pBtCoexist, scanType); 1078 1079 /* halbtcoutsrc_NormalLowPower(pBtCoexist); */ 1080 } 1081 1082 void EXhalbtcoutsrc_ConnectNotify(struct BTC_COEXIST * pBtCoexist, u8 action) 1083 { 1084 u8 assoType; 1085 1086 if (!halbtcoutsrc_IsBtCoexistAvailable(pBtCoexist)) 1087 return; 1088 pBtCoexist->statistics.cntConnectNotify++; 1089 if (pBtCoexist->bManualControl) 1090 return; 1091 1092 if (action) 1093 assoType = BTC_ASSOCIATE_START; 1094 else 1095 assoType = BTC_ASSOCIATE_FINISH; 1096 1097 /* All notify is called in cmd thread, don't need to leave low power again */ 1098 /* halbtcoutsrc_LeaveLowPower(pBtCoexist); */ 1099 1100 if (pBtCoexist->boardInfo.btdmAntNum == 2) 1101 EXhalbtc8723b2ant_ConnectNotify(pBtCoexist, assoType); 1102 else if (pBtCoexist->boardInfo.btdmAntNum == 1) 1103 EXhalbtc8723b1ant_ConnectNotify(pBtCoexist, assoType); 1104 1105 /* halbtcoutsrc_NormalLowPower(pBtCoexist); */ 1106 } 1107 1108 void EXhalbtcoutsrc_MediaStatusNotify(struct BTC_COEXIST * pBtCoexist, RT_MEDIA_STATUS mediaStatus) 1109 { 1110 u8 mStatus; 1111 1112 if (!halbtcoutsrc_IsBtCoexistAvailable(pBtCoexist)) 1113 return; 1114 1115 pBtCoexist->statistics.cntMediaStatusNotify++; 1116 if (pBtCoexist->bManualControl) 1117 return; 1118 1119 if (RT_MEDIA_CONNECT == mediaStatus) 1120 mStatus = BTC_MEDIA_CONNECT; 1121 else 1122 mStatus = BTC_MEDIA_DISCONNECT; 1123 1124 /* All notify is called in cmd thread, don't need to leave low power again */ 1125 /* halbtcoutsrc_LeaveLowPower(pBtCoexist); */ 1126 1127 if (pBtCoexist->boardInfo.btdmAntNum == 2) 1128 EXhalbtc8723b2ant_MediaStatusNotify(pBtCoexist, mStatus); 1129 else if (pBtCoexist->boardInfo.btdmAntNum == 1) 1130 EXhalbtc8723b1ant_MediaStatusNotify(pBtCoexist, mStatus); 1131 1132 /* halbtcoutsrc_NormalLowPower(pBtCoexist); */ 1133 } 1134 1135 void EXhalbtcoutsrc_SpecialPacketNotify(struct BTC_COEXIST * pBtCoexist, u8 pktType) 1136 { 1137 u8 packetType; 1138 1139 if (!halbtcoutsrc_IsBtCoexistAvailable(pBtCoexist)) 1140 return; 1141 pBtCoexist->statistics.cntSpecialPacketNotify++; 1142 if (pBtCoexist->bManualControl) 1143 return; 1144 1145 if (PACKET_DHCP == pktType) { 1146 packetType = BTC_PACKET_DHCP; 1147 } else if (PACKET_EAPOL == pktType) { 1148 packetType = BTC_PACKET_EAPOL; 1149 } else if (PACKET_ARP == pktType) { 1150 packetType = BTC_PACKET_ARP; 1151 } else { 1152 return; 1153 } 1154 1155 /* All notify is called in cmd thread, don't need to leave low power again */ 1156 /* halbtcoutsrc_LeaveLowPower(pBtCoexist); */ 1157 1158 if (pBtCoexist->boardInfo.btdmAntNum == 2) 1159 EXhalbtc8723b2ant_SpecialPacketNotify(pBtCoexist, packetType); 1160 else if (pBtCoexist->boardInfo.btdmAntNum == 1) 1161 EXhalbtc8723b1ant_SpecialPacketNotify(pBtCoexist, packetType); 1162 1163 /* halbtcoutsrc_NormalLowPower(pBtCoexist); */ 1164 } 1165 1166 void EXhalbtcoutsrc_BtInfoNotify(struct BTC_COEXIST * pBtCoexist, u8 *tmpBuf, u8 length) 1167 { 1168 if (!halbtcoutsrc_IsBtCoexistAvailable(pBtCoexist)) 1169 return; 1170 1171 pBtCoexist->statistics.cntBtInfoNotify++; 1172 1173 /* All notify is called in cmd thread, don't need to leave low power again */ 1174 /* halbtcoutsrc_LeaveLowPower(pBtCoexist); */ 1175 1176 if (pBtCoexist->boardInfo.btdmAntNum == 2) 1177 EXhalbtc8723b2ant_BtInfoNotify(pBtCoexist, tmpBuf, length); 1178 else if (pBtCoexist->boardInfo.btdmAntNum == 1) 1179 EXhalbtc8723b1ant_BtInfoNotify(pBtCoexist, tmpBuf, length); 1180 1181 /* halbtcoutsrc_NormalLowPower(pBtCoexist); */ 1182 } 1183 1184 void EXhalbtcoutsrc_HaltNotify(struct BTC_COEXIST * pBtCoexist) 1185 { 1186 if (!halbtcoutsrc_IsBtCoexistAvailable(pBtCoexist)) 1187 return; 1188 1189 if (pBtCoexist->boardInfo.btdmAntNum == 2) 1190 EXhalbtc8723b2ant_HaltNotify(pBtCoexist); 1191 else if (pBtCoexist->boardInfo.btdmAntNum == 1) 1192 EXhalbtc8723b1ant_HaltNotify(pBtCoexist); 1193 1194 pBtCoexist->bBinded = false; 1195 } 1196 1197 void EXhalbtcoutsrc_PnpNotify(struct BTC_COEXIST * pBtCoexist, u8 pnpState) 1198 { 1199 if (!halbtcoutsrc_IsBtCoexistAvailable(pBtCoexist)) 1200 return; 1201 1202 /* */ 1203 /* currently only 1ant we have to do the notification, */ 1204 /* once pnp is notified to sleep state, we have to leave LPS that we can sleep normally. */ 1205 /* */ 1206 1207 if (pBtCoexist->boardInfo.btdmAntNum == 1) 1208 EXhalbtc8723b1ant_PnpNotify(pBtCoexist, pnpState); 1209 else if (pBtCoexist->boardInfo.btdmAntNum == 2) 1210 EXhalbtc8723b2ant_PnpNotify(pBtCoexist, pnpState); 1211 } 1212 1213 void EXhalbtcoutsrc_Periodical(struct BTC_COEXIST * pBtCoexist) 1214 { 1215 if (!halbtcoutsrc_IsBtCoexistAvailable(pBtCoexist)) 1216 return; 1217 pBtCoexist->statistics.cntPeriodical++; 1218 1219 /* Periodical should be called in cmd thread, */ 1220 /* don't need to leave low power again */ 1221 /* halbtcoutsrc_LeaveLowPower(pBtCoexist); */ 1222 1223 if (pBtCoexist->boardInfo.btdmAntNum == 2) 1224 EXhalbtc8723b2ant_Periodical(pBtCoexist); 1225 else if (pBtCoexist->boardInfo.btdmAntNum == 1) 1226 EXhalbtc8723b1ant_Periodical(pBtCoexist); 1227 1228 /* halbtcoutsrc_NormalLowPower(pBtCoexist); */ 1229 } 1230 1231 void EXhalbtcoutsrc_SetChipType(u8 chipType) 1232 { 1233 GLBtCoexist.boardInfo.btChipType = BTC_CHIP_RTL8723B; 1234 } 1235 1236 void EXhalbtcoutsrc_SetAntNum(u8 type, u8 antNum) 1237 { 1238 if (BT_COEX_ANT_TYPE_PG == type) { 1239 GLBtCoexist.boardInfo.pgAntNum = antNum; 1240 GLBtCoexist.boardInfo.btdmAntNum = antNum; 1241 } else if (BT_COEX_ANT_TYPE_ANTDIV == type) { 1242 GLBtCoexist.boardInfo.btdmAntNum = antNum; 1243 /* GLBtCoexist.boardInfo.btdmAntPos = BTC_ANTENNA_AT_MAIN_PORT; */ 1244 } else if (BT_COEX_ANT_TYPE_DETECTED == type) { 1245 GLBtCoexist.boardInfo.btdmAntNum = antNum; 1246 /* GLBtCoexist.boardInfo.btdmAntPos = BTC_ANTENNA_AT_MAIN_PORT; */ 1247 } 1248 } 1249 1250 /* */ 1251 /* Currently used by 8723b only, S0 or S1 */ 1252 /* */ 1253 void EXhalbtcoutsrc_SetSingleAntPath(u8 singleAntPath) 1254 { 1255 GLBtCoexist.boardInfo.singleAntPath = singleAntPath; 1256 } 1257 1258 void EXhalbtcoutsrc_DisplayBtCoexInfo(struct BTC_COEXIST * pBtCoexist) 1259 { 1260 if (!halbtcoutsrc_IsBtCoexistAvailable(pBtCoexist)) 1261 return; 1262 1263 halbtcoutsrc_LeaveLowPower(pBtCoexist); 1264 1265 if (pBtCoexist->boardInfo.btdmAntNum == 2) 1266 EXhalbtc8723b2ant_DisplayCoexInfo(pBtCoexist); 1267 else if (pBtCoexist->boardInfo.btdmAntNum == 1) 1268 EXhalbtc8723b1ant_DisplayCoexInfo(pBtCoexist); 1269 1270 halbtcoutsrc_NormalLowPower(pBtCoexist); 1271 } 1272 1273 /* 1274 * Description: 1275 *Run BT-Coexist mechanism or not 1276 * 1277 */ 1278 void hal_btcoex_SetBTCoexist(struct adapter *padapter, u8 bBtExist) 1279 { 1280 struct hal_com_data *pHalData; 1281 1282 1283 pHalData = GET_HAL_DATA(padapter); 1284 pHalData->bt_coexist.bBtExist = bBtExist; 1285 } 1286 1287 /* 1288 * Dewcription: 1289 *Check is co-exist mechanism enabled or not 1290 * 1291 * Return: 1292 *true Enable BT co-exist mechanism 1293 *false Disable BT co-exist mechanism 1294 */ 1295 bool hal_btcoex_IsBtExist(struct adapter *padapter) 1296 { 1297 struct hal_com_data *pHalData; 1298 1299 1300 pHalData = GET_HAL_DATA(padapter); 1301 return pHalData->bt_coexist.bBtExist; 1302 } 1303 1304 bool hal_btcoex_IsBtDisabled(struct adapter *padapter) 1305 { 1306 if (!hal_btcoex_IsBtExist(padapter)) 1307 return true; 1308 1309 if (GLBtCoexist.btInfo.bBtDisabled) 1310 return true; 1311 else 1312 return false; 1313 } 1314 1315 void hal_btcoex_SetChipType(struct adapter *padapter, u8 chipType) 1316 { 1317 struct hal_com_data *pHalData; 1318 1319 1320 pHalData = GET_HAL_DATA(padapter); 1321 pHalData->bt_coexist.btChipType = chipType; 1322 1323 EXhalbtcoutsrc_SetChipType(chipType); 1324 } 1325 1326 void hal_btcoex_SetPgAntNum(struct adapter *padapter, u8 antNum) 1327 { 1328 struct hal_com_data *pHalData; 1329 1330 1331 pHalData = GET_HAL_DATA(padapter); 1332 1333 pHalData->bt_coexist.btTotalAntNum = antNum; 1334 EXhalbtcoutsrc_SetAntNum(BT_COEX_ANT_TYPE_PG, antNum); 1335 } 1336 1337 void hal_btcoex_SetSingleAntPath(struct adapter *padapter, u8 singleAntPath) 1338 { 1339 EXhalbtcoutsrc_SetSingleAntPath(singleAntPath); 1340 } 1341 1342 void hal_btcoex_PowerOnSetting(struct adapter *padapter) 1343 { 1344 EXhalbtcoutsrc_PowerOnSetting(&GLBtCoexist); 1345 } 1346 1347 void hal_btcoex_InitHwConfig(struct adapter *padapter, u8 bWifiOnly) 1348 { 1349 if (!hal_btcoex_IsBtExist(padapter)) 1350 return; 1351 1352 EXhalbtcoutsrc_InitHwConfig(&GLBtCoexist, bWifiOnly); 1353 EXhalbtcoutsrc_InitCoexDm(&GLBtCoexist); 1354 } 1355 1356 void hal_btcoex_IpsNotify(struct adapter *padapter, u8 type) 1357 { 1358 EXhalbtcoutsrc_IpsNotify(&GLBtCoexist, type); 1359 } 1360 1361 void hal_btcoex_LpsNotify(struct adapter *padapter, u8 type) 1362 { 1363 EXhalbtcoutsrc_LpsNotify(&GLBtCoexist, type); 1364 } 1365 1366 void hal_btcoex_ScanNotify(struct adapter *padapter, u8 type) 1367 { 1368 EXhalbtcoutsrc_ScanNotify(&GLBtCoexist, type); 1369 } 1370 1371 void hal_btcoex_ConnectNotify(struct adapter *padapter, u8 action) 1372 { 1373 EXhalbtcoutsrc_ConnectNotify(&GLBtCoexist, action); 1374 } 1375 1376 void hal_btcoex_MediaStatusNotify(struct adapter *padapter, u8 mediaStatus) 1377 { 1378 EXhalbtcoutsrc_MediaStatusNotify(&GLBtCoexist, mediaStatus); 1379 } 1380 1381 void hal_btcoex_SpecialPacketNotify(struct adapter *padapter, u8 pktType) 1382 { 1383 EXhalbtcoutsrc_SpecialPacketNotify(&GLBtCoexist, pktType); 1384 } 1385 1386 void hal_btcoex_IQKNotify(struct adapter *padapter, u8 state) 1387 { 1388 GLBtcWiFiInIQKState = state; 1389 } 1390 1391 void hal_btcoex_BtInfoNotify(struct adapter *padapter, u8 length, u8 *tmpBuf) 1392 { 1393 if (GLBtcWiFiInIQKState) 1394 return; 1395 1396 EXhalbtcoutsrc_BtInfoNotify(&GLBtCoexist, tmpBuf, length); 1397 } 1398 1399 void hal_btcoex_SuspendNotify(struct adapter *padapter, u8 state) 1400 { 1401 if (state == 1) 1402 state = BTC_WIFI_PNP_SLEEP; 1403 else 1404 state = BTC_WIFI_PNP_WAKE_UP; 1405 1406 EXhalbtcoutsrc_PnpNotify(&GLBtCoexist, state); 1407 } 1408 1409 void hal_btcoex_HaltNotify(struct adapter *padapter) 1410 { 1411 EXhalbtcoutsrc_HaltNotify(&GLBtCoexist); 1412 } 1413 1414 void hal_btcoex_Handler(struct adapter *padapter) 1415 { 1416 EXhalbtcoutsrc_Periodical(&GLBtCoexist); 1417 } 1418 1419 s32 hal_btcoex_IsBTCoexCtrlAMPDUSize(struct adapter *padapter) 1420 { 1421 return (s32)GLBtCoexist.btInfo.bBtCtrlAggBufSize; 1422 } 1423 1424 void hal_btcoex_SetManualControl(struct adapter *padapter, u8 bmanual) 1425 { 1426 GLBtCoexist.bManualControl = bmanual; 1427 } 1428 1429 bool hal_btcoex_IsBtControlLps(struct adapter *padapter) 1430 { 1431 if (!hal_btcoex_IsBtExist(padapter)) 1432 return false; 1433 1434 if (GLBtCoexist.btInfo.bBtDisabled) 1435 return false; 1436 1437 if (GLBtCoexist.btInfo.bBtCtrlLps) 1438 return true; 1439 1440 return false; 1441 } 1442 1443 bool hal_btcoex_IsLpsOn(struct adapter *padapter) 1444 { 1445 if (!hal_btcoex_IsBtExist(padapter)) 1446 return false; 1447 1448 if (GLBtCoexist.btInfo.bBtDisabled) 1449 return false; 1450 1451 if (GLBtCoexist.btInfo.bBtLpsOn) 1452 return true; 1453 1454 return false; 1455 } 1456 1457 u8 hal_btcoex_RpwmVal(struct adapter *padapter) 1458 { 1459 return GLBtCoexist.btInfo.rpwmVal; 1460 } 1461 1462 u8 hal_btcoex_LpsVal(struct adapter *padapter) 1463 { 1464 return GLBtCoexist.btInfo.lpsVal; 1465 } 1466 1467 u32 hal_btcoex_GetRaMask(struct adapter *padapter) 1468 { 1469 if (!hal_btcoex_IsBtExist(padapter)) 1470 return 0; 1471 1472 if (GLBtCoexist.btInfo.bBtDisabled) 1473 return 0; 1474 1475 if (GLBtCoexist.boardInfo.btdmAntNum != 1) 1476 return 0; 1477 1478 return GLBtCoexist.btInfo.raMask; 1479 } 1480 1481 void hal_btcoex_RecordPwrMode(struct adapter *padapter, u8 *pCmdBuf, u8 cmdLen) 1482 { 1483 BTC_PRINT(BTC_MSG_ALGORITHM, ALGO_TRACE_FW_EXEC, ("[BTCoex], FW write pwrModeCmd = 0x%04x%08x\n", 1484 pCmdBuf[0]<<8|pCmdBuf[1], 1485 pCmdBuf[2]<<24|pCmdBuf[3]<<16|pCmdBuf[4]<<8|pCmdBuf[5])); 1486 1487 memcpy(GLBtCoexist.pwrModeVal, pCmdBuf, cmdLen); 1488 } 1489 1490 void hal_btcoex_DisplayBtCoexInfo(struct adapter *padapter, u8 *pbuf, u32 bufsize) 1491 { 1492 PBTCDBGINFO pinfo; 1493 1494 1495 pinfo = &GLBtcDbgInfo; 1496 DBG_BT_INFO_INIT(pinfo, pbuf, bufsize); 1497 EXhalbtcoutsrc_DisplayBtCoexInfo(&GLBtCoexist); 1498 DBG_BT_INFO_INIT(pinfo, NULL, 0); 1499 } 1500 1501 void hal_btcoex_SetDBG(struct adapter *padapter, u32 *pDbgModule) 1502 { 1503 u32 i; 1504 1505 1506 if (!pDbgModule) 1507 return; 1508 1509 for (i = 0; i < BTC_MSG_MAX; i++) 1510 GLBtcDbgType[i] = pDbgModule[i]; 1511 } 1512 1513 u32 hal_btcoex_GetDBG(struct adapter *padapter, u8 *pStrBuf, u32 bufSize) 1514 { 1515 s32 count; 1516 u8 *pstr; 1517 u32 leftSize; 1518 1519 1520 if (!pStrBuf || bufSize == 0) 1521 return 0; 1522 1523 pstr = pStrBuf; 1524 leftSize = bufSize; 1525 /* DBG_871X(FUNC_ADPT_FMT ": bufsize =%d\n", FUNC_ADPT_ARG(padapter), bufSize); */ 1526 1527 count = rtw_sprintf(pstr, leftSize, "#define DBG\t%d\n", DBG); 1528 if ((count < 0) || (count >= leftSize)) 1529 goto exit; 1530 pstr += count; 1531 leftSize -= count; 1532 1533 count = rtw_sprintf(pstr, leftSize, "BTCOEX Debug Setting:\n"); 1534 if ((count < 0) || (count >= leftSize)) 1535 goto exit; 1536 pstr += count; 1537 leftSize -= count; 1538 1539 count = rtw_sprintf(pstr, leftSize, 1540 "INTERFACE / ALGORITHM: 0x%08X / 0x%08X\n\n", 1541 GLBtcDbgType[BTC_MSG_INTERFACE], 1542 GLBtcDbgType[BTC_MSG_ALGORITHM]); 1543 if ((count < 0) || (count >= leftSize)) 1544 goto exit; 1545 pstr += count; 1546 leftSize -= count; 1547 1548 count = rtw_sprintf(pstr, leftSize, "INTERFACE Debug Setting Definition:\n"); 1549 if ((count < 0) || (count >= leftSize)) 1550 goto exit; 1551 pstr += count; 1552 leftSize -= count; 1553 count = rtw_sprintf(pstr, leftSize, "\tbit[0]=%d for INTF_INIT\n", 1554 (GLBtcDbgType[BTC_MSG_INTERFACE]&INTF_INIT)?1:0); 1555 if ((count < 0) || (count >= leftSize)) 1556 goto exit; 1557 pstr += count; 1558 leftSize -= count; 1559 count = rtw_sprintf(pstr, leftSize, "\tbit[2]=%d for INTF_NOTIFY\n\n", 1560 (GLBtcDbgType[BTC_MSG_INTERFACE]&INTF_NOTIFY)?1:0); 1561 if ((count < 0) || (count >= leftSize)) 1562 goto exit; 1563 pstr += count; 1564 leftSize -= count; 1565 1566 count = rtw_sprintf(pstr, leftSize, "ALGORITHM Debug Setting Definition:\n"); 1567 if ((count < 0) || (count >= leftSize)) 1568 goto exit; 1569 pstr += count; 1570 leftSize -= count; 1571 count = rtw_sprintf(pstr, leftSize, "\tbit[0]=%d for BT_RSSI_STATE\n", 1572 (GLBtcDbgType[BTC_MSG_ALGORITHM]&ALGO_BT_RSSI_STATE)?1:0); 1573 if ((count < 0) || (count >= leftSize)) 1574 goto exit; 1575 pstr += count; 1576 leftSize -= count; 1577 count = rtw_sprintf(pstr, leftSize, "\tbit[1]=%d for WIFI_RSSI_STATE\n", 1578 (GLBtcDbgType[BTC_MSG_ALGORITHM]&ALGO_WIFI_RSSI_STATE)?1:0); 1579 if ((count < 0) || (count >= leftSize)) 1580 goto exit; 1581 pstr += count; 1582 leftSize -= count; 1583 count = rtw_sprintf(pstr, leftSize, "\tbit[2]=%d for BT_MONITOR\n", 1584 (GLBtcDbgType[BTC_MSG_ALGORITHM]&ALGO_BT_MONITOR)?1:0); 1585 if ((count < 0) || (count >= leftSize)) 1586 goto exit; 1587 pstr += count; 1588 leftSize -= count; 1589 count = rtw_sprintf(pstr, leftSize, "\tbit[3]=%d for TRACE\n", 1590 (GLBtcDbgType[BTC_MSG_ALGORITHM]&ALGO_TRACE)?1:0); 1591 if ((count < 0) || (count >= leftSize)) 1592 goto exit; 1593 pstr += count; 1594 leftSize -= count; 1595 count = rtw_sprintf(pstr, leftSize, "\tbit[4]=%d for TRACE_FW\n", 1596 (GLBtcDbgType[BTC_MSG_ALGORITHM]&ALGO_TRACE_FW)?1:0); 1597 if ((count < 0) || (count >= leftSize)) 1598 goto exit; 1599 pstr += count; 1600 leftSize -= count; 1601 count = rtw_sprintf(pstr, leftSize, "\tbit[5]=%d for TRACE_FW_DETAIL\n", 1602 (GLBtcDbgType[BTC_MSG_ALGORITHM]&ALGO_TRACE_FW_DETAIL)?1:0); 1603 if ((count < 0) || (count >= leftSize)) 1604 goto exit; 1605 pstr += count; 1606 leftSize -= count; 1607 count = rtw_sprintf(pstr, leftSize, "\tbit[6]=%d for TRACE_FW_EXEC\n", 1608 (GLBtcDbgType[BTC_MSG_ALGORITHM]&ALGO_TRACE_FW_EXEC)?1:0); 1609 if ((count < 0) || (count >= leftSize)) 1610 goto exit; 1611 pstr += count; 1612 leftSize -= count; 1613 count = rtw_sprintf(pstr, leftSize, "\tbit[7]=%d for TRACE_SW\n", 1614 (GLBtcDbgType[BTC_MSG_ALGORITHM]&ALGO_TRACE_SW)?1:0); 1615 if ((count < 0) || (count >= leftSize)) 1616 goto exit; 1617 pstr += count; 1618 leftSize -= count; 1619 count = rtw_sprintf(pstr, leftSize, "\tbit[8]=%d for TRACE_SW_DETAIL\n", 1620 (GLBtcDbgType[BTC_MSG_ALGORITHM]&ALGO_TRACE_SW_DETAIL)?1:0); 1621 if ((count < 0) || (count >= leftSize)) 1622 goto exit; 1623 pstr += count; 1624 leftSize -= count; 1625 count = rtw_sprintf(pstr, leftSize, "\tbit[9]=%d for TRACE_SW_EXEC\n", 1626 (GLBtcDbgType[BTC_MSG_ALGORITHM]&ALGO_TRACE_SW_EXEC)?1:0); 1627 if ((count < 0) || (count >= leftSize)) 1628 goto exit; 1629 pstr += count; 1630 leftSize -= count; 1631 1632 exit: 1633 count = pstr - pStrBuf; 1634 /* DBG_871X(FUNC_ADPT_FMT ": usedsize =%d\n", FUNC_ADPT_ARG(padapter), count); */ 1635 1636 return count; 1637 } 1638