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