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_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 
1191 void hal_btcoex_SetSingleAntPath(struct adapter *padapter, u8 singleAntPath)
1192 {
1193 	EXhalbtcoutsrc_SetSingleAntPath(singleAntPath);
1194 }
1195 
1196 void hal_btcoex_PowerOnSetting(struct adapter *padapter)
1197 {
1198 	EXhalbtcoutsrc_PowerOnSetting(&GLBtCoexist);
1199 }
1200 
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 
1210 void hal_btcoex_IpsNotify(struct adapter *padapter, u8 type)
1211 {
1212 	EXhalbtcoutsrc_IpsNotify(&GLBtCoexist, type);
1213 }
1214 
1215 void hal_btcoex_LpsNotify(struct adapter *padapter, u8 type)
1216 {
1217 	EXhalbtcoutsrc_LpsNotify(&GLBtCoexist, type);
1218 }
1219 
1220 void hal_btcoex_ScanNotify(struct adapter *padapter, u8 type)
1221 {
1222 	EXhalbtcoutsrc_ScanNotify(&GLBtCoexist, type);
1223 }
1224 
1225 void hal_btcoex_ConnectNotify(struct adapter *padapter, u8 action)
1226 {
1227 	EXhalbtcoutsrc_ConnectNotify(&GLBtCoexist, action);
1228 }
1229 
1230 void hal_btcoex_MediaStatusNotify(struct adapter *padapter, u8 mediaStatus)
1231 {
1232 	EXhalbtcoutsrc_MediaStatusNotify(&GLBtCoexist, mediaStatus);
1233 }
1234 
1235 void hal_btcoex_SpecialPacketNotify(struct adapter *padapter, u8 pktType)
1236 {
1237 	EXhalbtcoutsrc_SpecialPacketNotify(&GLBtCoexist, pktType);
1238 }
1239 
1240 void hal_btcoex_IQKNotify(struct adapter *padapter, u8 state)
1241 {
1242 	GLBtcWiFiInIQKState = state;
1243 }
1244 
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 
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 
1263 void hal_btcoex_HaltNotify(struct adapter *padapter)
1264 {
1265 	EXhalbtcoutsrc_HaltNotify(&GLBtCoexist);
1266 }
1267 
1268 void hal_btcoex_Handler(struct adapter *padapter)
1269 {
1270 	EXhalbtcoutsrc_Periodical(&GLBtCoexist);
1271 }
1272 
1273 s32 hal_btcoex_IsBTCoexCtrlAMPDUSize(struct adapter *padapter)
1274 {
1275 	return (s32)GLBtCoexist.btInfo.bBtCtrlAggBufSize;
1276 }
1277 
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 
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 
1306 u8 hal_btcoex_RpwmVal(struct adapter *padapter)
1307 {
1308 	return GLBtCoexist.btInfo.rpwmVal;
1309 }
1310 
1311 u8 hal_btcoex_LpsVal(struct adapter *padapter)
1312 {
1313 	return GLBtCoexist.btInfo.lpsVal;
1314 }
1315 
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 
1330 void hal_btcoex_RecordPwrMode(struct adapter *padapter, u8 *pCmdBuf, u8 cmdLen)
1331 {
1332 	memcpy(GLBtCoexist.pwrModeVal, pCmdBuf, cmdLen);
1333 }
1334