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