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 /* */
halbtcoutsrc_IsBtCoexistAvailable(struct btc_coexist * pBtCoexist)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
halbtcoutsrc_LeaveLps(struct btc_coexist * pBtCoexist)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
halbtcoutsrc_EnterLps(struct btc_coexist * pBtCoexist)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
halbtcoutsrc_NormalLps(struct btc_coexist * pBtCoexist)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 */
halbtcoutsrc_LeaveLowPower(struct btc_coexist * pBtCoexist)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 */
halbtcoutsrc_NormalLowPower(struct btc_coexist * pBtCoexist)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
halbtcoutsrc_DisableLowPower(struct btc_coexist * pBtCoexist,u8 bLowPwrDisable)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
halbtcoutsrc_AggregationCheck(struct btc_coexist * pBtCoexist)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
halbtcoutsrc_IsWifiBusy(struct adapter * padapter)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
_halbtcoutsrc_GetWifiLinkStatus(struct adapter * padapter)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
halbtcoutsrc_GetWifiLinkStatus(struct btc_coexist * pBtCoexist)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
halbtcoutsrc_GetBtPatchVer(struct btc_coexist * pBtCoexist)234 static u32 halbtcoutsrc_GetBtPatchVer(struct btc_coexist *pBtCoexist)
235 {
236 return pBtCoexist->btInfo.btRealFwVer;
237 }
238
halbtcoutsrc_GetWifiRssi(struct adapter * padapter)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
halbtcoutsrc_GetWifiScanAPNum(struct adapter * padapter)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
halbtcoutsrc_Get(void * pBtcContext,u8 getType,void * pOutBuf)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
halbtcoutsrc_Set(void * pBtcContext,u8 setType,void * pInBuf)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 /* */
halbtcoutsrc_Read1Byte(void * pBtcContext,u32 RegAddr)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
halbtcoutsrc_Read2Byte(void * pBtcContext,u32 RegAddr)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
halbtcoutsrc_Read4Byte(void * pBtcContext,u32 RegAddr)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
halbtcoutsrc_Write1Byte(void * pBtcContext,u32 RegAddr,u8 Data)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
halbtcoutsrc_BitMaskWrite1Byte(void * pBtcContext,u32 regAddr,u8 bitMask,u8 data1b)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
halbtcoutsrc_Write2Byte(void * pBtcContext,u32 RegAddr,u16 Data)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
halbtcoutsrc_Write4Byte(void * pBtcContext,u32 RegAddr,u32 Data)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
halbtcoutsrc_WriteLocalReg1Byte(void * pBtcContext,u32 RegAddr,u8 Data)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
halbtcoutsrc_SetBbReg(void * pBtcContext,u32 RegAddr,u32 BitMask,u32 Data)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
halbtcoutsrc_GetBbReg(void * pBtcContext,u32 RegAddr,u32 BitMask)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
halbtcoutsrc_SetRfReg(void * pBtcContext,u8 eRFPath,u32 RegAddr,u32 BitMask,u32 Data)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
halbtcoutsrc_GetRfReg(void * pBtcContext,u8 eRFPath,u32 RegAddr,u32 BitMask)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
halbtcoutsrc_SetBtReg(void * pBtcContext,u8 RegType,u32 RegAddr,u32 Data)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
halbtcoutsrc_GetBtReg(void * pBtcContext,u8 RegType,u32 RegAddr)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
halbtcoutsrc_FillH2cCmd(void * pBtcContext,u8 elementId,u32 cmdLen,u8 * pCmdBuffer)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 /* */
EXhalbtcoutsrc_BindBtCoexWithAdapter(void * padapter)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
hal_btcoex_Initialize(void * padapter)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
EXhalbtcoutsrc_PowerOnSetting(struct btc_coexist * pBtCoexist)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
EXhalbtcoutsrc_InitHwConfig(struct btc_coexist * pBtCoexist,u8 bWifiOnly)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
EXhalbtcoutsrc_InitCoexDm(struct btc_coexist * pBtCoexist)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
EXhalbtcoutsrc_IpsNotify(struct btc_coexist * pBtCoexist,u8 type)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
EXhalbtcoutsrc_LpsNotify(struct btc_coexist * pBtCoexist,u8 type)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
EXhalbtcoutsrc_ScanNotify(struct btc_coexist * pBtCoexist,u8 type)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
EXhalbtcoutsrc_ConnectNotify(struct btc_coexist * pBtCoexist,u8 action)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
EXhalbtcoutsrc_MediaStatusNotify(struct btc_coexist * pBtCoexist,enum rt_media_status mediaStatus)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
EXhalbtcoutsrc_SpecialPacketNotify(struct btc_coexist * pBtCoexist,u8 pktType)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
EXhalbtcoutsrc_BtInfoNotify(struct btc_coexist * pBtCoexist,u8 * tmpBuf,u8 length)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
EXhalbtcoutsrc_HaltNotify(struct btc_coexist * pBtCoexist)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
EXhalbtcoutsrc_PnpNotify(struct btc_coexist * pBtCoexist,u8 pnpState)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
EXhalbtcoutsrc_Periodical(struct btc_coexist * pBtCoexist)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
EXhalbtcoutsrc_SetAntNum(u8 type,u8 antNum)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 /* */
EXhalbtcoutsrc_SetSingleAntPath(u8 singleAntPath)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 */
hal_btcoex_SetBTCoexist(struct adapter * padapter,u8 bBtExist)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 */
hal_btcoex_IsBtExist(struct adapter * padapter)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
hal_btcoex_IsBtDisabled(struct adapter * padapter)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
hal_btcoex_SetPgAntNum(struct adapter * padapter,u8 antNum)1180 void hal_btcoex_SetPgAntNum(struct adapter *padapter, u8 antNum)
1181 {
1182 struct hal_com_data *pHalData;
1183
1184
1185 pHalData = GET_HAL_DATA(padapter);
1186
1187 pHalData->bt_coexist.btTotalAntNum = antNum;
1188 EXhalbtcoutsrc_SetAntNum(BT_COEX_ANT_TYPE_PG, antNum);
1189 }
1190
hal_btcoex_SetSingleAntPath(struct adapter * padapter,u8 singleAntPath)1191 void hal_btcoex_SetSingleAntPath(struct adapter *padapter, u8 singleAntPath)
1192 {
1193 EXhalbtcoutsrc_SetSingleAntPath(singleAntPath);
1194 }
1195
hal_btcoex_PowerOnSetting(struct adapter * padapter)1196 void hal_btcoex_PowerOnSetting(struct adapter *padapter)
1197 {
1198 EXhalbtcoutsrc_PowerOnSetting(&GLBtCoexist);
1199 }
1200
hal_btcoex_InitHwConfig(struct adapter * padapter,u8 bWifiOnly)1201 void hal_btcoex_InitHwConfig(struct adapter *padapter, u8 bWifiOnly)
1202 {
1203 if (!hal_btcoex_IsBtExist(padapter))
1204 return;
1205
1206 EXhalbtcoutsrc_InitHwConfig(&GLBtCoexist, bWifiOnly);
1207 EXhalbtcoutsrc_InitCoexDm(&GLBtCoexist);
1208 }
1209
hal_btcoex_IpsNotify(struct adapter * padapter,u8 type)1210 void hal_btcoex_IpsNotify(struct adapter *padapter, u8 type)
1211 {
1212 EXhalbtcoutsrc_IpsNotify(&GLBtCoexist, type);
1213 }
1214
hal_btcoex_LpsNotify(struct adapter * padapter,u8 type)1215 void hal_btcoex_LpsNotify(struct adapter *padapter, u8 type)
1216 {
1217 EXhalbtcoutsrc_LpsNotify(&GLBtCoexist, type);
1218 }
1219
hal_btcoex_ScanNotify(struct adapter * padapter,u8 type)1220 void hal_btcoex_ScanNotify(struct adapter *padapter, u8 type)
1221 {
1222 EXhalbtcoutsrc_ScanNotify(&GLBtCoexist, type);
1223 }
1224
hal_btcoex_ConnectNotify(struct adapter * padapter,u8 action)1225 void hal_btcoex_ConnectNotify(struct adapter *padapter, u8 action)
1226 {
1227 EXhalbtcoutsrc_ConnectNotify(&GLBtCoexist, action);
1228 }
1229
hal_btcoex_MediaStatusNotify(struct adapter * padapter,u8 mediaStatus)1230 void hal_btcoex_MediaStatusNotify(struct adapter *padapter, u8 mediaStatus)
1231 {
1232 EXhalbtcoutsrc_MediaStatusNotify(&GLBtCoexist, mediaStatus);
1233 }
1234
hal_btcoex_SpecialPacketNotify(struct adapter * padapter,u8 pktType)1235 void hal_btcoex_SpecialPacketNotify(struct adapter *padapter, u8 pktType)
1236 {
1237 EXhalbtcoutsrc_SpecialPacketNotify(&GLBtCoexist, pktType);
1238 }
1239
hal_btcoex_IQKNotify(struct adapter * padapter,u8 state)1240 void hal_btcoex_IQKNotify(struct adapter *padapter, u8 state)
1241 {
1242 GLBtcWiFiInIQKState = state;
1243 }
1244
hal_btcoex_BtInfoNotify(struct adapter * padapter,u8 length,u8 * tmpBuf)1245 void hal_btcoex_BtInfoNotify(struct adapter *padapter, u8 length, u8 *tmpBuf)
1246 {
1247 if (GLBtcWiFiInIQKState)
1248 return;
1249
1250 EXhalbtcoutsrc_BtInfoNotify(&GLBtCoexist, tmpBuf, length);
1251 }
1252
hal_btcoex_SuspendNotify(struct adapter * padapter,u8 state)1253 void hal_btcoex_SuspendNotify(struct adapter *padapter, u8 state)
1254 {
1255 if (state == 1)
1256 state = BTC_WIFI_PNP_SLEEP;
1257 else
1258 state = BTC_WIFI_PNP_WAKE_UP;
1259
1260 EXhalbtcoutsrc_PnpNotify(&GLBtCoexist, state);
1261 }
1262
hal_btcoex_HaltNotify(struct adapter * padapter)1263 void hal_btcoex_HaltNotify(struct adapter *padapter)
1264 {
1265 EXhalbtcoutsrc_HaltNotify(&GLBtCoexist);
1266 }
1267
hal_btcoex_Handler(struct adapter * padapter)1268 void hal_btcoex_Handler(struct adapter *padapter)
1269 {
1270 EXhalbtcoutsrc_Periodical(&GLBtCoexist);
1271 }
1272
hal_btcoex_IsBTCoexCtrlAMPDUSize(struct adapter * padapter)1273 s32 hal_btcoex_IsBTCoexCtrlAMPDUSize(struct adapter *padapter)
1274 {
1275 return (s32)GLBtCoexist.btInfo.bBtCtrlAggBufSize;
1276 }
1277
hal_btcoex_IsBtControlLps(struct adapter * padapter)1278 bool hal_btcoex_IsBtControlLps(struct adapter *padapter)
1279 {
1280 if (!hal_btcoex_IsBtExist(padapter))
1281 return false;
1282
1283 if (GLBtCoexist.btInfo.bBtDisabled)
1284 return false;
1285
1286 if (GLBtCoexist.btInfo.bBtCtrlLps)
1287 return true;
1288
1289 return false;
1290 }
1291
hal_btcoex_IsLpsOn(struct adapter * padapter)1292 bool hal_btcoex_IsLpsOn(struct adapter *padapter)
1293 {
1294 if (!hal_btcoex_IsBtExist(padapter))
1295 return false;
1296
1297 if (GLBtCoexist.btInfo.bBtDisabled)
1298 return false;
1299
1300 if (GLBtCoexist.btInfo.bBtLpsOn)
1301 return true;
1302
1303 return false;
1304 }
1305
hal_btcoex_RpwmVal(struct adapter * padapter)1306 u8 hal_btcoex_RpwmVal(struct adapter *padapter)
1307 {
1308 return GLBtCoexist.btInfo.rpwmVal;
1309 }
1310
hal_btcoex_LpsVal(struct adapter * padapter)1311 u8 hal_btcoex_LpsVal(struct adapter *padapter)
1312 {
1313 return GLBtCoexist.btInfo.lpsVal;
1314 }
1315
hal_btcoex_GetRaMask(struct adapter * padapter)1316 u32 hal_btcoex_GetRaMask(struct adapter *padapter)
1317 {
1318 if (!hal_btcoex_IsBtExist(padapter))
1319 return 0;
1320
1321 if (GLBtCoexist.btInfo.bBtDisabled)
1322 return 0;
1323
1324 if (GLBtCoexist.boardInfo.btdmAntNum != 1)
1325 return 0;
1326
1327 return GLBtCoexist.btInfo.raMask;
1328 }
1329
hal_btcoex_RecordPwrMode(struct adapter * padapter,u8 * pCmdBuf,u8 cmdLen)1330 void hal_btcoex_RecordPwrMode(struct adapter *padapter, u8 *pCmdBuf, u8 cmdLen)
1331 {
1332 memcpy(GLBtCoexist.pwrModeVal, pCmdBuf, cmdLen);
1333 }
1334