1 /******************************************************************************
2  *
3  * Copyright(c) 2007 - 2012 Realtek Corporation. All rights reserved.
4  *
5  * This program is free software; you can redistribute it and/or modify it
6  * under the terms of version 2 of the GNU General Public License as
7  *published by the Free Software Foundation.
8  *
9  * This program is distributed in the hope that it will be useful, but WITHOUT
10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11  * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
12  * more details.
13  *
14  ******************************************************************************/
15 #include <drv_types.h>
16 #include <rtl8723a_hal.h>
17 #include <usb_ops_linux.h>
18 
19 #define DIS_PS_RX_BCN
20 
21 u32 BTCoexDbgLevel = _bt_dbg_off_;
22 
23 #define RTPRINT(_Comp, _Level, Fmt)\
24 do {\
25 	if ((BTCoexDbgLevel == _bt_dbg_on_)) {\
26 		printk Fmt;\
27 	}					\
28 } while (0)
29 
30 #define RTPRINT_ADDR(dbgtype, dbgflag, printstr, _Ptr)\
31 if ((BTCoexDbgLevel == _bt_dbg_on_)) {\
32 	u32 __i;						\
33 	u8 *ptr = (u8 *)_Ptr;	\
34 	printk printstr;				\
35 	printk(" ");					\
36 	for (__i = 0; __i < 6; __i++)		\
37 		printk("%02X%s", ptr[__i], (__i == 5)?"":"-");		\
38 	printk("\n");							\
39 }
40 #define RTPRINT_DATA(dbgtype, dbgflag, _TitleString, _HexData, _HexDataLen)\
41 if ((BTCoexDbgLevel == _bt_dbg_on_)) {\
42 	u32 __i;						\
43 	u8 *ptr = (u8 *)_HexData;				\
44 	printk(_TitleString);					\
45 	for (__i = 0; __i < (u32)_HexDataLen; __i++) {		\
46 		printk("%02X%s", ptr[__i], (((__i + 1) % 4) == 0)?"  ":" ");\
47 		if (((__i + 1) % 16) == 0)			\
48 			printk("\n");				\
49 	}								\
50 	printk("\n");							\
51 }
52 /*  Added by Annie, 2005-11-22. */
53 #define MAX_STR_LEN	64
54 /*  I want to see ASCII 33 to 126 only. Otherwise, I print '?'. */
55 #define PRINTABLE(_ch)	(_ch >= ' ' && _ch <= '~')
56 #define RT_PRINT_STR(_Comp, _Level, _TitleString, _Ptr, _Len)		\
57 	{								\
58 		u32 __i;						\
59 		u8 buffer[MAX_STR_LEN];					\
60 		u32 length = (_Len < MAX_STR_LEN) ? _Len : (MAX_STR_LEN-1);\
61 		memset(buffer, 0, MAX_STR_LEN);				\
62 		memcpy(buffer, (u8 *)_Ptr, length);			\
63 		for (__i = 0; __i < length; __i++) {			\
64 			if (!PRINTABLE(buffer[__i]))			\
65 				buffer[__i] = '?';			\
66 		}							\
67 		buffer[length] = '\0';					\
68 		printk(_TitleString);					\
69 		printk(": %d, <%s>\n", _Len, buffer);			\
70 	}
71 
72 #define DCMD_Printf(...)
73 #define RT_ASSERT(...)
74 
75 #define rsprintf snprintf
76 
77 #define GetDefaultAdapter(padapter)	padapter
78 
79 #define PlatformZeroMemory(ptr, sz)	memset(ptr, 0, sz)
80 
81 #define PlatformProcessHCICommands(...)
82 #define PlatformTxBTQueuedPackets(...)
83 #define PlatformIndicateBTACLData(...)	(RT_STATUS_SUCCESS)
84 #define PlatformAcquireSpinLock(padapter, type)
85 #define PlatformReleaseSpinLock(padapter, type)
86 
87 #define GET_UNDECORATED_AVERAGE_RSSI(padapter)	\
88 			(GET_HAL_DATA(padapter)->dmpriv.EntryMinUndecoratedSmoothedPWDB)
89 #define RT_RF_CHANGE_SOURCE u32
90 
91 enum {
92 	RT_JOIN_INFRA   = 1,
93 	RT_JOIN_IBSS  = 2,
94 	RT_START_IBSS = 3,
95 	RT_NO_ACTION  = 4,
96 };
97 
98 /*  power saving */
99 
100 /*  ===== Below this line is sync from SD7 driver COMMOM/BT.c ===== */
101 
BT_Operation(struct rtw_adapter * padapter)102 static u8 BT_Operation(struct rtw_adapter *padapter)
103 {
104 	struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
105 	struct bt_mgnt *pBtMgnt = &pBTInfo->BtMgnt;
106 
107 	if (pBtMgnt->BtOperationOn)
108 		return true;
109 	else
110 		return false;
111 }
112 
BT_IsLegalChannel(struct rtw_adapter * padapter,u8 channel)113 static u8 BT_IsLegalChannel(struct rtw_adapter *padapter, u8 channel)
114 {
115 	struct rt_channel_info *pChanneList = NULL;
116 	u8 channelLen, i;
117 
118 	pChanneList = padapter->mlmeextpriv.channel_set;
119 	channelLen = padapter->mlmeextpriv.max_chan_nums;
120 
121 	for (i = 0; i < channelLen; i++) {
122 		RTPRINT(FIOCTL, IOCTL_STATE,
123 			("Check if chnl(%d) in channel plan contains bt target chnl(%d) for BT connection\n",
124 			 pChanneList[i].ChannelNum, channel));
125 		if ((channel == pChanneList[i].ChannelNum) ||
126 		    (channel == pChanneList[i].ChannelNum + 2))
127 			return channel;
128 	}
129 	return 0;
130 }
131 
BT_SignalCompensation(struct rtw_adapter * padapter,u8 * rssi_wifi,u8 * rssi_bt)132 void BT_SignalCompensation(struct rtw_adapter *padapter, u8 *rssi_wifi, u8 *rssi_bt)
133 {
134 	BTDM_SignalCompensation(padapter, rssi_wifi, rssi_bt);
135 }
136 
rtl8723a_BT_wifiscan_notify(struct rtw_adapter * padapter,u8 scanType)137 void rtl8723a_BT_wifiscan_notify(struct rtw_adapter *padapter, u8 scanType)
138 {
139 	BTHCI_WifiScanNotify(padapter, scanType);
140 	BTDM_CheckAntSelMode(padapter);
141 	BTDM_WifiScanNotify(padapter, scanType);
142 }
143 
rtl8723a_BT_wifiassociate_notify(struct rtw_adapter * padapter,u8 action)144 void rtl8723a_BT_wifiassociate_notify(struct rtw_adapter *padapter, u8 action)
145 {
146 	/*  action : */
147 	/*  true = associate start */
148 	/*  false = associate finished */
149 	if (action)
150 		BTDM_CheckAntSelMode(padapter);
151 
152 	BTDM_WifiAssociateNotify(padapter, action);
153 }
154 
BT_HaltProcess(struct rtw_adapter * padapter)155 void BT_HaltProcess(struct rtw_adapter *padapter)
156 {
157 	BTDM_ForHalt(padapter);
158 }
159 
160 /*  ===== End of sync from SD7 driver COMMOM/BT.c ===== */
161 
162 #define i64fmt		"ll"
163 #define UINT64_C(v)  (v)
164 
165 #define FillOctetString(_os, _octet, _len)		\
166 	(_os).Octet = (u8 *)(_octet);			\
167 	(_os).Length = (_len);
168 
PlatformIndicateBTEvent(struct rtw_adapter * padapter,void * pEvntData,u32 dataLen)169 static enum rt_status PlatformIndicateBTEvent(
170 	struct rtw_adapter *padapter,
171 	void						*pEvntData,
172 	u32						dataLen
173 	)
174 {
175 	enum rt_status	rt_status = RT_STATUS_FAILURE;
176 
177 	RTPRINT(FIOCTL, IOCTL_BT_EVENT_DETAIL, ("BT event start, %d bytes data to Transferred!!\n", dataLen));
178 	RTPRINT_DATA(FIOCTL, IOCTL_BT_EVENT_DETAIL, "To transfer Hex Data :\n",
179 		pEvntData, dataLen);
180 
181 	BT_EventParse(padapter, pEvntData, dataLen);
182 
183 	printk(KERN_WARNING "%s: Linux has no way to report BT event!!\n", __func__);
184 
185 	RTPRINT(FIOCTL, IOCTL_BT_EVENT_DETAIL, ("BT event end, %s\n",
186 		(rt_status == RT_STATUS_SUCCESS) ? "SUCCESS" : "FAIL"));
187 
188 	return rt_status;
189 }
190 
191 /*  ===== Below this line is sync from SD7 driver COMMOM/bt_hci.c ===== */
192 
bthci_GetLocalChannel(struct rtw_adapter * padapter)193 static u8 bthci_GetLocalChannel(struct rtw_adapter *padapter)
194 {
195 	return padapter->mlmeextpriv.cur_channel;
196 }
197 
bthci_GetCurrentEntryNum(struct rtw_adapter * padapter,u8 PhyHandle)198 static u8 bthci_GetCurrentEntryNum(struct rtw_adapter *padapter, u8 PhyHandle)
199 {
200 	struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
201 	u8 i;
202 
203 	for (i = 0; i < MAX_BT_ASOC_ENTRY_NUM; i++) {
204 		if ((pBTInfo->BtAsocEntry[i].bUsed) &&
205 		    (pBTInfo->BtAsocEntry[i].PhyLinkCmdData.BtPhyLinkhandle == PhyHandle))
206 			return i;
207 	}
208 
209 	return 0xFF;
210 }
211 
bthci_DecideBTChannel(struct rtw_adapter * padapter,u8 EntryNum)212 static void bthci_DecideBTChannel(struct rtw_adapter *padapter, u8 EntryNum)
213 {
214 /*PMGNT_INFO pMgntInfo = &padapter->MgntInfo; */
215 	struct mlme_priv *pmlmepriv;
216 	struct bt_30info *pBTInfo;
217 	struct bt_mgnt *pBtMgnt;
218 	struct bt_hci_info *pBtHciInfo;
219 	struct chnl_txpower_triple *pTriple_subband = NULL;
220 	struct common_triple *pTriple;
221 	u8 i, j, localchnl, firstRemoteLegalChnlInTriplet = 0;
222 	u8 regulatory_skipLen = 0;
223 	u8 subbandTripletCnt = 0;
224 
225 	pmlmepriv = &padapter->mlmepriv;
226 	pBTInfo = GET_BT_INFO(padapter);
227 	pBtMgnt = &pBTInfo->BtMgnt;
228 	pBtHciInfo = &pBTInfo->BtHciInfo;
229 
230 	pBtMgnt->CheckChnlIsSuit = true;
231 	localchnl = bthci_GetLocalChannel(padapter);
232 
233 	pTriple = (struct common_triple *)
234 		&pBtHciInfo->BTPreChnllist[COUNTRY_STR_LEN];
235 
236 	/*  contains country string, len is 3 */
237 	for (i = 0; i < (pBtHciInfo->BtPreChnlListLen-COUNTRY_STR_LEN); i += 3, pTriple++) {
238 		/*  */
239 		/*  check every triplet, an triplet may be */
240 		/*  regulatory extension identifier or sub-band triplet */
241 		/*  */
242 		if (pTriple->byte_1st == 0xc9) {
243 			/*  Regulatory Extension Identifier, skip it */
244 			RTPRINT(FIOCTL, (IOCTL_BT_HCICMD|IOCTL_BT_LOGO),
245 				("Find Regulatory ID, regulatory class = %d\n", pTriple->byte_2nd));
246 			regulatory_skipLen += 3;
247 			pTriple_subband = NULL;
248 			continue;
249 		} else {	/*  Sub-band triplet */
250 			RTPRINT(FIOCTL, (IOCTL_BT_HCICMD|IOCTL_BT_LOGO), ("Find Sub-band triplet \n"));
251 			subbandTripletCnt++;
252 			pTriple_subband = (struct chnl_txpower_triple *)pTriple;
253 			/*  if remote first legal channel not found, then find first remote channel */
254 			/*  and it's legal for our channel plan. */
255 
256 			/*  search the sub-band triplet and find if remote channel is legal to our channel plan. */
257 			for (j = pTriple_subband->FirstChnl; j < (pTriple_subband->FirstChnl+pTriple_subband->NumChnls); j++) {
258 				RTPRINT(FIOCTL, (IOCTL_BT_HCICMD|IOCTL_BT_LOGO), (" Check if chnl(%d) is legal\n", j));
259 				if (BT_IsLegalChannel(padapter, j)) {
260 					/*  remote channel is legal for our channel plan. */
261 					firstRemoteLegalChnlInTriplet = j;
262 					RTPRINT(FIOCTL, (IOCTL_BT_HCICMD|IOCTL_BT_LOGO),
263 						("Find first remote legal channel : %d\n",
264 						firstRemoteLegalChnlInTriplet));
265 
266 					/*  If we find a remote legal channel in the sub-band triplet */
267 					/*  and only BT connection is established(local not connect to any AP or IBSS), */
268 					/*  then we just switch channel to remote channel. */
269 					if (!(check_fwstate(pmlmepriv, WIFI_ASOC_STATE|WIFI_ADHOC_STATE|WIFI_AP_STATE) ||
270 					    BTHCI_HsConnectionEstablished(padapter))) {
271 						pBtMgnt->BTChannel = firstRemoteLegalChnlInTriplet;
272 						RTPRINT(FIOCTL, (IOCTL_BT_HCICMD|IOCTL_BT_LOGO), ("Remote legal channel (%d) is selected, Local not connect to any!!\n", pBtMgnt->BTChannel));
273 						return;
274 					} else {
275 						if ((localchnl >= firstRemoteLegalChnlInTriplet) &&
276 						    (localchnl < (pTriple_subband->FirstChnl+pTriple_subband->NumChnls))) {
277 							pBtMgnt->BTChannel = localchnl;
278 							RTPRINT(FIOCTL, (IOCTL_BT_HCICMD|IOCTL_BT_LOGO), ("Local channel (%d) is selected, wifi or BT connection exists\n", pBtMgnt->BTChannel));
279 							return;
280 						}
281 					}
282 					break;
283 				}
284 			}
285 		}
286 	}
287 
288 	if (subbandTripletCnt) {
289 		/* if any preferred channel triplet exists */
290 		RTPRINT(FIOCTL, (IOCTL_BT_HCICMD|IOCTL_BT_LOGO), ("There are %d sub band triplet exists, ", subbandTripletCnt));
291 		if (firstRemoteLegalChnlInTriplet == 0) {
292 			/* no legal channel is found, reject the connection. */
293 			RTPRINT(FIOCTL, (IOCTL_BT_HCICMD|IOCTL_BT_LOGO), ("no legal channel is found!!\n"));
294 		} else {
295 			/*  Remote Legal channel is found but not match to local */
296 			/* wifi connection exists), so reject the connection. */
297 			RTPRINT(FIOCTL, (IOCTL_BT_HCICMD|IOCTL_BT_LOGO),
298 				("Remote Legal channel is found but not match to local(wifi connection exists)!!\n"));
299 		}
300 		pBtMgnt->CheckChnlIsSuit = false;
301 	} else {
302 		/*  There are not any preferred channel triplet exists */
303 		/*  Use current legal channel as the bt channel. */
304 		RTPRINT(FIOCTL, (IOCTL_BT_HCICMD|IOCTL_BT_LOGO), ("No sub band triplet exists!!\n"));
305 	}
306 	pBtMgnt->BTChannel = localchnl;
307 	RTPRINT(FIOCTL, (IOCTL_BT_HCICMD|IOCTL_BT_LOGO), ("Local channel (%d) is selected!!\n", pBtMgnt->BTChannel));
308 }
309 
310 /* Success:return true */
311 /* Fail:return false */
bthci_GetAssocInfo(struct rtw_adapter * padapter,u8 EntryNum)312 static u8 bthci_GetAssocInfo(struct rtw_adapter *padapter, u8 EntryNum)
313 {
314 	struct bt_30info *pBTInfo;
315 	struct bt_hci_info *pBtHciInfo;
316 	u8 tempBuf[256];
317 	u8 i = 0;
318 	u8 BaseMemoryShift = 0;
319 	u16	TotalLen = 0;
320 	struct amp_assoc_structure *pAmpAsoc;
321 
322 	RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("GetAssocInfo start\n"));
323 	pBTInfo = GET_BT_INFO(padapter);
324 	pBtHciInfo = &pBTInfo->BtHciInfo;
325 
326 	if (pBTInfo->BtAsocEntry[EntryNum].AmpAsocCmdData.LenSoFar == 0) {
327 		if (pBTInfo->BtAsocEntry[EntryNum].AmpAsocCmdData.AMPAssocRemLen < (MAX_AMP_ASSOC_FRAG_LEN))
328 			TotalLen = pBTInfo->BtAsocEntry[EntryNum].AmpAsocCmdData.AMPAssocRemLen;
329 		else if (pBTInfo->BtAsocEntry[EntryNum].AmpAsocCmdData.AMPAssocRemLen == (MAX_AMP_ASSOC_FRAG_LEN))
330 			TotalLen = MAX_AMP_ASSOC_FRAG_LEN;
331 	} else if (pBTInfo->BtAsocEntry[EntryNum].AmpAsocCmdData.LenSoFar > 0)
332 		TotalLen = pBTInfo->BtAsocEntry[EntryNum].AmpAsocCmdData.LenSoFar;
333 
334 	while ((pBTInfo->BtAsocEntry[EntryNum].AmpAsocCmdData.LenSoFar >= BaseMemoryShift) || TotalLen > BaseMemoryShift) {
335 		RTPRINT(FIOCTL, IOCTL_BT_HCICMD_DETAIL, ("GetAssocInfo, TotalLen =%d, BaseMemoryShift =%d\n", TotalLen, BaseMemoryShift));
336 		memcpy(tempBuf,
337 			(u8 *)pBTInfo->BtAsocEntry[EntryNum].AmpAsocCmdData.AMPAssocfragment+BaseMemoryShift,
338 			TotalLen-BaseMemoryShift);
339 		RTPRINT_DATA(FIOCTL, IOCTL_BT_HCICMD_DETAIL, "GetAssocInfo :\n",
340 			tempBuf, TotalLen-BaseMemoryShift);
341 
342 		pAmpAsoc = (struct amp_assoc_structure *)tempBuf;
343 		le16_to_cpus(&pAmpAsoc->Length);
344 		BaseMemoryShift += 3 + pAmpAsoc->Length;
345 
346 		RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("TypeID = 0x%x, ", pAmpAsoc->TypeID));
347 		RTPRINT_DATA(FIOCTL, IOCTL_BT_HCICMD, "Hex Data: \n", pAmpAsoc->Data, pAmpAsoc->Length);
348 		switch (pAmpAsoc->TypeID) {
349 		case AMP_MAC_ADDR:
350 			RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("==> AMP_MAC_ADDR\n"));
351 			if (pAmpAsoc->Length > 6)
352 				return false;
353 			memcpy(pBTInfo->BtAsocEntry[EntryNum].BTRemoteMACAddr, pAmpAsoc->Data, 6);
354 			RTPRINT_ADDR(FIOCTL, IOCTL_BT_HCICMD, ("Remote Mac address \n"), pBTInfo->BtAsocEntry[EntryNum].BTRemoteMACAddr);
355 			break;
356 		case AMP_PREFERRED_CHANNEL_LIST:
357 			RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("==> AMP_PREFERRED_CHANNEL_LIST\n"));
358 			pBtHciInfo->BtPreChnlListLen = pAmpAsoc->Length;
359 			memcpy(pBtHciInfo->BTPreChnllist,
360 				pAmpAsoc->Data,
361 				pBtHciInfo->BtPreChnlListLen);
362 			RTPRINT_DATA(FIOCTL, IOCTL_BT_HCICMD, "Preferred channel list : \n", pBtHciInfo->BTPreChnllist, pBtHciInfo->BtPreChnlListLen);
363 			bthci_DecideBTChannel(padapter, EntryNum);
364 			break;
365 		case AMP_CONNECTED_CHANNEL:
366 			RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("==> AMP_CONNECTED_CHANNEL\n"));
367 			pBtHciInfo->BTConnectChnlListLen = pAmpAsoc->Length;
368 			memcpy(pBtHciInfo->BTConnectChnllist,
369 				pAmpAsoc->Data,
370 				pBtHciInfo->BTConnectChnlListLen);
371 			break;
372 		case AMP_80211_PAL_CAP_LIST:
373 			RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("==> AMP_80211_PAL_CAP_LIST\n"));
374 			pBTInfo->BtAsocEntry[EntryNum].BTCapability = *(u32 *)(pAmpAsoc->Data);
375 			if (pBTInfo->BtAsocEntry[EntryNum].BTCapability & 0x00000001) {
376 				/*  TODO: */
377 
378 				/* Signifies PAL capable of utilizing received activity reports. */
379 			}
380 			if (pBTInfo->BtAsocEntry[EntryNum].BTCapability & 0x00000002) {
381 				/*  TODO: */
382 				/* Signifies PAL is capable of utilizing scheduling information received in an activity reports. */
383 			}
384 			break;
385 		case AMP_80211_PAL_VISION:
386 			pBtHciInfo->BTPalVersion = *(u8 *)(pAmpAsoc->Data);
387 			pBtHciInfo->BTPalCompanyID = *(u16 *)(((u8 *)(pAmpAsoc->Data))+1);
388 			pBtHciInfo->BTPalsubversion = *(u16 *)(((u8 *)(pAmpAsoc->Data))+3);
389 			RTPRINT(FIOCTL, (IOCTL_BT_HCICMD|IOCTL_BT_LOGO), ("==> AMP_80211_PAL_VISION PalVersion  0x%x, PalCompanyID  0x%x, Palsubversion 0x%x\n",
390 				pBtHciInfo->BTPalVersion,
391 				pBtHciInfo->BTPalCompanyID,
392 				pBtHciInfo->BTPalsubversion));
393 			break;
394 		default:
395 			RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("==> Unsupport TypeID !!\n"));
396 			break;
397 		}
398 		i++;
399 	}
400 	RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("GetAssocInfo end\n"));
401 
402 	return true;
403 }
404 
bthci_AddEntry(struct rtw_adapter * padapter)405 static u8 bthci_AddEntry(struct rtw_adapter *padapter)
406 {
407 	struct bt_30info *pBTInfo;
408 	struct bt_mgnt *pBtMgnt;
409 	u8 i;
410 
411 	pBTInfo = GET_BT_INFO(padapter);
412 	pBtMgnt = &pBTInfo->BtMgnt;
413 
414 	for (i = 0; i < MAX_BT_ASOC_ENTRY_NUM; i++) {
415 		if (pBTInfo->BtAsocEntry[i].bUsed == false) {
416 			pBTInfo->BtAsocEntry[i].bUsed = true;
417 			pBtMgnt->CurrentConnectEntryNum = i;
418 			break;
419 		}
420 	}
421 
422 	if (i == MAX_BT_ASOC_ENTRY_NUM) {
423 		RTPRINT(FIOCTL, IOCTL_STATE, ("bthci_AddEntry(), Add entry fail!!\n"));
424 		return false;
425 	}
426 	return true;
427 }
428 
bthci_DiscardTxPackets(struct rtw_adapter * padapter,u16 LLH)429 static u8 bthci_DiscardTxPackets(struct rtw_adapter *padapter, u16 LLH)
430 {
431 	return false;
432 }
433 
434 static u8
bthci_CheckLogLinkBehavior(struct rtw_adapter * padapter,struct hci_flow_spec TxFlowSpec)435 bthci_CheckLogLinkBehavior(
436 	struct rtw_adapter *padapter,
437 	struct hci_flow_spec			TxFlowSpec
438 	)
439 {
440 	u8 ID = TxFlowSpec.Identifier;
441 	u8 ServiceType = TxFlowSpec.ServiceType;
442 	u16	MaxSDUSize = TxFlowSpec.MaximumSDUSize;
443 	u32	SDUInterArrivatime = TxFlowSpec.SDUInterArrivalTime;
444 	u8 match = false;
445 
446 	switch (ID) {
447 	case 1:
448 		if (ServiceType == BT_LL_BE) {
449 			match = true;
450 			RTPRINT(FIOCTL, (IOCTL_BT_EVENT|IOCTL_BT_LOGO), ("Logical Link Type =  TX best effort flowspec\n"));
451 		} else if ((ServiceType == BT_LL_GU) && (MaxSDUSize == 0xffff)) {
452 			match = true;
453 			RTPRINT(FIOCTL, (IOCTL_BT_EVENT|IOCTL_BT_LOGO), ("Logical Link Type =  RX guaranteed latency flowspec\n"));
454 		} else if ((ServiceType == BT_LL_GU) && (MaxSDUSize == 2500)) {
455 			RTPRINT(FIOCTL, (IOCTL_BT_EVENT|IOCTL_BT_LOGO), ("Logical Link Type =  RX guaranteed Large latency flowspec\n"));
456 		}
457 		break;
458 	case 2:
459 		if (ServiceType == BT_LL_BE) {
460 			match = true;
461 			RTPRINT(FIOCTL, (IOCTL_BT_EVENT|IOCTL_BT_LOGO), ("Logical Link Type =  RX best effort flowspec\n"));
462 
463 		}
464 		break;
465 	case 3:
466 		if ((ServiceType == BT_LL_GU) && (MaxSDUSize == 1492)) {
467 			match = true;
468 			RTPRINT(FIOCTL, (IOCTL_BT_EVENT|IOCTL_BT_LOGO), ("Logical Link Type =  TX guaranteed latency flowspec\n"));
469 		} else if ((ServiceType == BT_LL_GU) && (MaxSDUSize == 2500)) {
470 			RTPRINT(FIOCTL, (IOCTL_BT_EVENT|IOCTL_BT_LOGO), ("Logical Link Type =  TX guaranteed Large latency flowspec\n"));
471 		}
472 		break;
473 	case 4:
474 		if (ServiceType == BT_LL_BE) {
475 			if ((SDUInterArrivatime == 0xffffffff) && (ServiceType == BT_LL_BE) && (MaxSDUSize == 1492)) {
476 				match = true;
477 				RTPRINT(FIOCTL, (IOCTL_BT_EVENT|IOCTL_BT_LOGO), ("Logical Link Type =  TX/RX aggregated best effort flowspec\n"));
478 			}
479 		} else if (ServiceType == BT_LL_GU) {
480 			if (SDUInterArrivatime == 100) {
481 				match = true;
482 				RTPRINT(FIOCTL, (IOCTL_BT_EVENT|IOCTL_BT_LOGO), ("Logical Link Type =  TX/RX guaranteed bandwidth flowspec\n"));
483 			}
484 		}
485 		break;
486 	default:
487 		RTPRINT(FIOCTL, (IOCTL_BT_EVENT|IOCTL_BT_LOGO), ("Logical Link Type =  Unknow Type !!!!!!!!\n"));
488 		break;
489 	}
490 
491 	RTPRINT(FIOCTL, (IOCTL_BT_HCICMD|IOCTL_BT_LOGO),
492 		("ID = 0x%x, ServiceType = 0x%x, MaximumSDUSize = 0x%x, SDUInterArrivalTime = 0x%x, AccessLatency = 0x%x, FlushTimeout = 0x%x\n",
493 		TxFlowSpec.Identifier, TxFlowSpec.ServiceType, MaxSDUSize,
494 		SDUInterArrivatime, TxFlowSpec.AccessLatency, TxFlowSpec.FlushTimeout));
495 	return match;
496 }
497 
bthci_AssocMACAddr(struct rtw_adapter * padapter,void * pbuf)498 static u16 bthci_AssocMACAddr(struct rtw_adapter *padapter, void	*pbuf)
499 {
500 	struct amp_assoc_structure *pAssoStrc = (struct amp_assoc_structure *)pbuf;
501 	pAssoStrc->TypeID = AMP_MAC_ADDR;
502 	pAssoStrc->Length = 0x06;
503 	memcpy(&pAssoStrc->Data[0], padapter->eeprompriv.mac_addr, 6);
504 	RTPRINT_DATA(FIOCTL, (IOCTL_BT_HCICMD|IOCTL_BT_HCICMD_DETAIL|IOCTL_BT_LOGO),
505 		     ("AssocMACAddr : \n"), pAssoStrc, pAssoStrc->Length+3);
506 
507 	return pAssoStrc->Length + 3;
508 }
509 
510 static u16
bthci_PALCapabilities(struct rtw_adapter * padapter,void * pbuf)511 bthci_PALCapabilities(
512 	struct rtw_adapter *padapter,
513 	void	*pbuf
514 	)
515 {
516 	struct amp_assoc_structure *pAssoStrc = (struct amp_assoc_structure *)pbuf;
517 
518 	pAssoStrc->TypeID = AMP_80211_PAL_CAP_LIST;
519 	pAssoStrc->Length = 0x04;
520 
521 	pAssoStrc->Data[0] = 0x00;
522 	pAssoStrc->Data[1] = 0x00;
523 
524 	RTPRINT_DATA(FIOCTL, IOCTL_BT_HCICMD_DETAIL, ("PALCapabilities:\n"), pAssoStrc, pAssoStrc->Length+3);
525 	RTPRINT(FIOCTL, IOCTL_BT_LOGO, ("PALCapabilities \n"));
526 
527 	RTPRINT(FIOCTL, IOCTL_BT_LOGO, (" TypeID = 0x%x,\n Length = 0x%x,\n Content = 0x0000\n",
528 		pAssoStrc->TypeID,
529 		pAssoStrc->Length));
530 
531 	return pAssoStrc->Length + 3;
532 }
533 
bthci_AssocPreferredChannelList(struct rtw_adapter * padapter,void * pbuf,u8 EntryNum)534 static u16 bthci_AssocPreferredChannelList(struct rtw_adapter *padapter,
535 					   void *pbuf, u8 EntryNum)
536 {
537 	struct bt_30info *pBTInfo;
538 	struct amp_assoc_structure *pAssoStrc;
539 	struct amp_pref_chnl_regulatory *pReg;
540 	struct chnl_txpower_triple *pTriple;
541 	char ctrString[3] = {'X', 'X', 'X'};
542 	u32 len = 0;
543 	u8 preferredChnl;
544 
545 	pBTInfo = GET_BT_INFO(padapter);
546 	pAssoStrc = (struct amp_assoc_structure *)pbuf;
547 	pReg = (struct amp_pref_chnl_regulatory *)&pAssoStrc->Data[3];
548 
549 	preferredChnl = bthci_GetLocalChannel(padapter);
550 	pAssoStrc->TypeID = AMP_PREFERRED_CHANNEL_LIST;
551 
552 	/*  locale unknown */
553 	memcpy(&pAssoStrc->Data[0], &ctrString[0], 3);
554 	pReg->reXId = 201;
555 	pReg->regulatoryClass = 254;
556 	pReg->coverageClass = 0;
557 	len += 6;
558 	RTPRINT(FIOCTL, (IOCTL_BT_HCICMD | IOCTL_BT_LOGO), ("PREFERRED_CHNL_LIST\n"));
559 	RTPRINT(FIOCTL, (IOCTL_BT_HCICMD | IOCTL_BT_LOGO), ("XXX, 201, 254, 0\n"));
560 	/*  at the following, chnl 1~11 should be contained */
561 	pTriple = (struct chnl_txpower_triple *)&pAssoStrc->Data[len];
562 
563 	/*  (1) if any wifi or bt HS connection exists */
564 	if ((pBTInfo->BtAsocEntry[EntryNum].AMPRole == AMP_BTAP_CREATOR) ||
565 	    (check_fwstate(&padapter->mlmepriv, WIFI_ASOC_STATE |
566 			   WIFI_ADHOC_STATE | WIFI_ADHOC_MASTER_STATE |
567 			   WIFI_AP_STATE)) ||
568 	    BTHCI_HsConnectionEstablished(padapter)) {
569 		pTriple->FirstChnl = preferredChnl;
570 		pTriple->NumChnls = 1;
571 		pTriple->MaxTxPowerInDbm = 20;
572 		len += 3;
573 		RTPRINT(FIOCTL, (IOCTL_BT_HCICMD | IOCTL_BT_LOGO), ("First Channel = %d, Channel Num = %d, MaxDbm = %d\n",
574 			pTriple->FirstChnl,
575 			pTriple->NumChnls,
576 			pTriple->MaxTxPowerInDbm));
577 	}
578 
579 	pAssoStrc->Length = (u16)len;
580 	RTPRINT_DATA(FIOCTL, IOCTL_BT_HCICMD, ("AssocPreferredChannelList : \n"), pAssoStrc, pAssoStrc->Length+3);
581 
582 	return pAssoStrc->Length + 3;
583 }
584 
bthci_AssocPALVer(struct rtw_adapter * padapter,void * pbuf)585 static u16 bthci_AssocPALVer(struct rtw_adapter *padapter, void *pbuf)
586 {
587 	struct amp_assoc_structure *pAssoStrc = (struct amp_assoc_structure *)pbuf;
588 	u8 *pu1Tmp;
589 	u16	*pu2Tmp;
590 
591 	pAssoStrc->TypeID = AMP_80211_PAL_VISION;
592 	pAssoStrc->Length = 0x5;
593 	pu1Tmp = &pAssoStrc->Data[0];
594 	*pu1Tmp = 0x1;	/*  PAL Version */
595 	pu2Tmp = (u16 *)&pAssoStrc->Data[1];
596 	*pu2Tmp = 0x5D;	/*  SIG Company identifier of 802.11 PAL vendor */
597 	pu2Tmp = (u16 *)&pAssoStrc->Data[3];
598 	*pu2Tmp = 0x1;	/*  PAL Sub-version specifier */
599 
600 	RTPRINT_DATA(FIOCTL, IOCTL_BT_HCICMD_DETAIL, ("AssocPALVer : \n"), pAssoStrc, pAssoStrc->Length+3);
601 	RTPRINT(FIOCTL, IOCTL_BT_LOGO, ("AssocPALVer \n"));
602 
603 	RTPRINT(FIOCTL, IOCTL_BT_LOGO, (" TypeID = 0x%x,\n Length = 0x%x,\n PAL Version = 0x01,\n PAL vendor = 0x01,\n PAL Sub-version specifier = 0x01\n",
604 		pAssoStrc->TypeID,
605 		pAssoStrc->Length));
606 	return pAssoStrc->Length + 3;
607 }
608 
bthci_CheckRfStateBeforeConnect(struct rtw_adapter * padapter)609 static u8 bthci_CheckRfStateBeforeConnect(struct rtw_adapter *padapter)
610 {
611 	struct bt_30info *pBTInfo;
612 	enum rt_rf_power_state		RfState;
613 
614 	pBTInfo = GET_BT_INFO(padapter);
615 
616 	RfState = padapter->pwrctrlpriv.rf_pwrstate;
617 
618 	if (RfState != rf_on) {
619 		mod_timer(&pBTInfo->BTPsDisableTimer,
620 			  jiffies + msecs_to_jiffies(50));
621 		return false;
622 	}
623 	return true;
624 }
625 
bthci_ResponderStartToScan(struct rtw_adapter * padapter)626 static void bthci_ResponderStartToScan(struct rtw_adapter *padapter)
627 {
628 }
629 
bthci_PhyLinkConnectionInProgress(struct rtw_adapter * padapter,u8 PhyLinkHandle)630 static u8 bthci_PhyLinkConnectionInProgress(struct rtw_adapter *padapter, u8 PhyLinkHandle)
631 {
632 	struct bt_30info *pBTInfo;
633 	struct bt_mgnt *pBtMgnt;
634 
635 	pBTInfo = GET_BT_INFO(padapter);
636 	pBtMgnt = &pBTInfo->BtMgnt;
637 
638 	if (pBtMgnt->bPhyLinkInProgress &&
639 		(pBtMgnt->BtCurrentPhyLinkhandle == PhyLinkHandle))
640 		return true;
641 	return false;
642 }
643 
bthci_ResetFlowSpec(struct rtw_adapter * padapter,u8 EntryNum,u8 index)644 static void bthci_ResetFlowSpec(struct rtw_adapter *padapter, u8 EntryNum, u8 index)
645 {
646 	struct bt_30info *pBTinfo;
647 
648 	pBTinfo = GET_BT_INFO(padapter);
649 
650 	pBTinfo->BtAsocEntry[EntryNum].LogLinkCmdData[index].BtLogLinkhandle = 0;
651 	pBTinfo->BtAsocEntry[EntryNum].LogLinkCmdData[index].BtPhyLinkhandle = 0;
652 	pBTinfo->BtAsocEntry[EntryNum].LogLinkCmdData[index].bLLCompleteEventIsSet = false;
653 	pBTinfo->BtAsocEntry[EntryNum].LogLinkCmdData[index].bLLCancelCMDIsSetandComplete = false;
654 	pBTinfo->BtAsocEntry[EntryNum].LogLinkCmdData[index].BtTxFlowSpecID = 0;
655 	pBTinfo->BtAsocEntry[EntryNum].LogLinkCmdData[index].TxPacketCount = 0;
656 
657 	pBTinfo->BtAsocEntry[EntryNum].LogLinkCmdData[index].Tx_Flow_Spec.Identifier = 0x01;
658 	pBTinfo->BtAsocEntry[EntryNum].LogLinkCmdData[index].Tx_Flow_Spec.ServiceType = SERVICE_BEST_EFFORT;
659 	pBTinfo->BtAsocEntry[EntryNum].LogLinkCmdData[index].Tx_Flow_Spec.MaximumSDUSize = 0xffff;
660 	pBTinfo->BtAsocEntry[EntryNum].LogLinkCmdData[index].Tx_Flow_Spec.SDUInterArrivalTime = 0xffffffff;
661 	pBTinfo->BtAsocEntry[EntryNum].LogLinkCmdData[index].Tx_Flow_Spec.AccessLatency = 0xffffffff;
662 	pBTinfo->BtAsocEntry[EntryNum].LogLinkCmdData[index].Tx_Flow_Spec.FlushTimeout = 0xffffffff;
663 
664 	pBTinfo->BtAsocEntry[EntryNum].LogLinkCmdData[index].Rx_Flow_Spec.Identifier = 0x01;
665 	pBTinfo->BtAsocEntry[EntryNum].LogLinkCmdData[index].Rx_Flow_Spec.ServiceType = SERVICE_BEST_EFFORT;
666 	pBTinfo->BtAsocEntry[EntryNum].LogLinkCmdData[index].Rx_Flow_Spec.MaximumSDUSize = 0xffff;
667 	pBTinfo->BtAsocEntry[EntryNum].LogLinkCmdData[index].Rx_Flow_Spec.SDUInterArrivalTime = 0xffffffff;
668 	pBTinfo->BtAsocEntry[EntryNum].LogLinkCmdData[index].Rx_Flow_Spec.AccessLatency = 0xffffffff;
669 	pBTinfo->BtAsocEntry[EntryNum].LogLinkCmdData[index].Rx_Flow_Spec.FlushTimeout = 0xffffffff;
670 }
671 
bthci_ResetEntry(struct rtw_adapter * padapter,u8 EntryNum)672 static void bthci_ResetEntry(struct rtw_adapter *padapter, u8 EntryNum)
673 {
674 	struct bt_30info *pBTinfo;
675 	struct bt_mgnt *pBtMgnt;
676 	u8 j;
677 
678 	pBTinfo = GET_BT_INFO(padapter);
679 	pBtMgnt = &pBTinfo->BtMgnt;
680 
681 	pBTinfo->BtAsocEntry[EntryNum].bUsed = false;
682 	pBTinfo->BtAsocEntry[EntryNum].BtCurrentState = HCI_STATE_DISCONNECTED;
683 	pBTinfo->BtAsocEntry[EntryNum].BtNextState = HCI_STATE_DISCONNECTED;
684 
685 	pBTinfo->BtAsocEntry[EntryNum].AmpAsocCmdData.AMPAssocRemLen = 0;
686 	pBTinfo->BtAsocEntry[EntryNum].AmpAsocCmdData.BtPhyLinkhandle = 0;
687 	if (pBTinfo->BtAsocEntry[EntryNum].AmpAsocCmdData.AMPAssocfragment != NULL)
688 		memset(pBTinfo->BtAsocEntry[EntryNum].AmpAsocCmdData.AMPAssocfragment, 0, TOTAL_ALLOCIATE_ASSOC_LEN);
689 	pBTinfo->BtAsocEntry[EntryNum].AmpAsocCmdData.LenSoFar = 0;
690 
691 	pBTinfo->BtAsocEntry[EntryNum].PhyLinkCmdData.BtAMPKeyType = 0;
692 	pBTinfo->BtAsocEntry[EntryNum].PhyLinkCmdData.BtPhyLinkhandle = 0;
693 	memset(pBTinfo->BtAsocEntry[EntryNum].PhyLinkCmdData.BtAMPKey, 0,
694 	       pBTinfo->BtAsocEntry[EntryNum].PhyLinkCmdData.BtAMPKeyLen);
695 	pBTinfo->BtAsocEntry[EntryNum].PhyLinkCmdData.BtAMPKeyLen = 0;
696 
697 	/* 0x640; 0.625ms*1600 = 1000ms, 0.625ms*16000 = 10000ms */
698 	pBTinfo->BtAsocEntry[EntryNum].PhyLinkCmdData.LinkSuperversionTimeout = 0x3e80;
699 
700 	pBTinfo->BtAsocEntry[EntryNum].AMPRole = AMP_BTAP_NONE;
701 
702 	pBTinfo->BtAsocEntry[EntryNum].mAssoc = false;
703 	pBTinfo->BtAsocEntry[EntryNum].b4waySuccess = false;
704 
705 	/*  Reset BT WPA */
706 	pBTinfo->BtAsocEntry[EntryNum].KeyReplayCounter = 0;
707 	pBTinfo->BtAsocEntry[EntryNum].BTWPAAuthState = STATE_WPA_AUTH_UNINITIALIZED;
708 
709 	pBTinfo->BtAsocEntry[EntryNum].bSendSupervisionPacket = false;
710 	pBTinfo->BtAsocEntry[EntryNum].NoRxPktCnt = 0;
711 	pBTinfo->BtAsocEntry[EntryNum].ShortRangeMode = 0;
712 	pBTinfo->BtAsocEntry[EntryNum].rxSuvpPktCnt = 0;
713 
714 	for (j = 0; j < MAX_LOGICAL_LINK_NUM; j++)
715 		bthci_ResetFlowSpec(padapter, EntryNum, j);
716 
717 	pBtMgnt->BTAuthCount = 0;
718 	pBtMgnt->BTAsocCount = 0;
719 	pBtMgnt->BTCurrentConnectType = BT_DISCONNECT;
720 	pBtMgnt->BTReceiveConnectPkt = BT_DISCONNECT;
721 
722 	HALBT_RemoveKey(padapter, EntryNum);
723 }
724 
bthci_RemoveEntryByEntryNum(struct rtw_adapter * padapter,u8 EntryNum)725 static void bthci_RemoveEntryByEntryNum(struct rtw_adapter *padapter, u8 EntryNum)
726 {
727 	struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
728 	struct bt_mgnt *pBtMgnt = &pBTInfo->BtMgnt;
729 
730 	bthci_ResetEntry(padapter, EntryNum);
731 
732 	if (pBtMgnt->CurrentBTConnectionCnt > 0)
733 		pBtMgnt->CurrentBTConnectionCnt--;
734 
735 	RTPRINT(FIOCTL, IOCTL_STATE, ("[BT Flag], CurrentBTConnectionCnt = %d!!\n",
736 		pBtMgnt->CurrentBTConnectionCnt));
737 
738 	if (pBtMgnt->CurrentBTConnectionCnt > 0) {
739 		pBtMgnt->BtOperationOn = true;
740 	} else {
741 		pBtMgnt->BtOperationOn = false;
742 		RTPRINT(FIOCTL, IOCTL_STATE, ("[BT Flag], Bt Operation OFF!!\n"));
743 	}
744 
745 	if (!pBtMgnt->BtOperationOn) {
746 		del_timer_sync(&pBTInfo->BTHCIDiscardAclDataTimer);
747 		del_timer_sync(&pBTInfo->BTBeaconTimer);
748 		pBtMgnt->bStartSendSupervisionPkt = false;
749 	}
750 }
751 
752 static u8
bthci_CommandCompleteHeader(u8 * pbuf,u16 OGF,u16 OCF,enum hci_status status)753 bthci_CommandCompleteHeader(
754 	u8 *pbuf,
755 	u16		OGF,
756 	u16		OCF,
757 	enum hci_status	status
758 	)
759 {
760 	struct packet_irp_hcievent_data *PPacketIrpEvent = (struct packet_irp_hcievent_data *)pbuf;
761 	u8 NumHCI_Comm = 0x1;
762 
763 	PPacketIrpEvent->EventCode = HCI_EVENT_COMMAND_COMPLETE;
764 	PPacketIrpEvent->Data[0] = NumHCI_Comm;	/* packet # */
765 	PPacketIrpEvent->Data[1] = HCIOPCODELOW(OCF, OGF);
766 	PPacketIrpEvent->Data[2] = HCIOPCODEHIGHT(OCF, OGF);
767 
768 	if (OGF == OGF_EXTENSION) {
769 		if (OCF == HCI_SET_RSSI_VALUE) {
770 			RTPRINT(FIOCTL, (IOCTL_BT_EVENT_PERIODICAL),
771 				("[BT event], CommandComplete, Num_HCI_Comm = 0x%x, Opcode = 0x%02x%02x, status = 0x%x, OGF = 0x%x, OCF = 0x%x\n",
772 				NumHCI_Comm, (HCIOPCODEHIGHT(OCF, OGF)), (HCIOPCODELOW(OCF, OGF)), status, OGF, OCF));
773 		} else {
774 			RTPRINT(FIOCTL, (IOCTL_BT_HCICMD_EXT),
775 				("[BT event], CommandComplete, Num_HCI_Comm = 0x%x, Opcode = 0x%02x%02x, status = 0x%x, OGF = 0x%x, OCF = 0x%x\n",
776 				NumHCI_Comm, (HCIOPCODEHIGHT(OCF, OGF)), (HCIOPCODELOW(OCF, OGF)), status, OGF, OCF));
777 		}
778 	} else {
779 		RTPRINT(FIOCTL, (IOCTL_BT_EVENT|IOCTL_BT_LOGO),
780 			("[BT event], CommandComplete, Num_HCI_Comm = 0x%x, Opcode = 0x%02x%02x, status = 0x%x, OGF = 0x%x, OCF = 0x%x\n",
781 			NumHCI_Comm, (HCIOPCODEHIGHT(OCF, OGF)), (HCIOPCODELOW(OCF, OGF)), status, OGF, OCF));
782 	}
783 	return 3;
784 }
785 
bthci_ExtensionEventHeaderRtk(u8 * pbuf,u8 extensionEvent)786 static u8 bthci_ExtensionEventHeaderRtk(u8 *pbuf, u8 extensionEvent)
787 {
788 	struct packet_irp_hcievent_data *PPacketIrpEvent = (struct packet_irp_hcievent_data *)pbuf;
789 	PPacketIrpEvent->EventCode = HCI_EVENT_EXTENSION_RTK;
790 	PPacketIrpEvent->Data[0] = extensionEvent;	/* extension event code */
791 
792 	return 1;
793 }
794 
795 static enum rt_status
bthci_IndicateEvent(struct rtw_adapter * padapter,void * pEvntData,u32 dataLen)796 bthci_IndicateEvent(
797 	struct rtw_adapter *padapter,
798 	void		*pEvntData,
799 	u32		dataLen
800 	)
801 {
802 	enum rt_status	rt_status;
803 
804 	rt_status = PlatformIndicateBTEvent(padapter, pEvntData, dataLen);
805 
806 	return rt_status;
807 }
808 
809 static void
bthci_EventWriteRemoteAmpAssoc(struct rtw_adapter * padapter,enum hci_status status,u8 PLHandle)810 bthci_EventWriteRemoteAmpAssoc(
811 	struct rtw_adapter *padapter,
812 	enum hci_status	status,
813 	u8 PLHandle
814 	)
815 {
816 	u8 localBuf[TmpLocalBufSize] = "";
817 	u8 *pRetPar;
818 	u8 len = 0;
819 	struct packet_irp_hcievent_data *PPacketIrpEvent;
820 
821 	PlatformZeroMemory(&localBuf[0], TmpLocalBufSize);
822 	PPacketIrpEvent = (struct packet_irp_hcievent_data *)(&localBuf[0]);
823 
824 	len += bthci_CommandCompleteHeader(&localBuf[0],
825 		OGF_STATUS_PARAMETERS,
826 		HCI_WRITE_REMOTE_AMP_ASSOC,
827 		status);
828 	RTPRINT(FIOCTL, (IOCTL_BT_HCICMD|IOCTL_BT_LOGO), ("PhyLinkHandle = 0x%x, status = %d\n", PLHandle, status));
829 	/*  Return parameters starts from here */
830 	pRetPar = &PPacketIrpEvent->Data[len];
831 	pRetPar[0] = status;		/* status */
832 	pRetPar[1] = PLHandle;
833 	len += 2;
834 	PPacketIrpEvent->Length = len;
835 
836 	bthci_IndicateEvent(padapter, PPacketIrpEvent, len+2);
837 }
838 
839 static void
bthci_EventEnhancedFlushComplete(struct rtw_adapter * padapter,u16 LLH)840 bthci_EventEnhancedFlushComplete(
841 	struct rtw_adapter *padapter,
842 	u16					LLH
843 	)
844 {
845 	u8 localBuf[4] = "";
846 	struct packet_irp_hcievent_data *PPacketIrpEvent;
847 
848 	RTPRINT(FIOCTL, IOCTL_BT_EVENT, ("EventEnhancedFlushComplete, LLH = 0x%x\n", LLH));
849 
850 	PPacketIrpEvent = (struct packet_irp_hcievent_data *)(&localBuf[0]);
851 	PPacketIrpEvent->EventCode = HCI_EVENT_ENHANCED_FLUSH_COMPLETE;
852 	PPacketIrpEvent->Length = 2;
853 	/* Logical link handle */
854 	PPacketIrpEvent->Data[0] = TWOBYTE_LOWBYTE(LLH);
855 	PPacketIrpEvent->Data[1] = TWOBYTE_HIGHTBYTE(LLH);
856 
857 	bthci_IndicateEvent(padapter, PPacketIrpEvent, 4);
858 }
859 
860 static void
bthci_EventShortRangeModeChangeComplete(struct rtw_adapter * padapter,enum hci_status HciStatus,u8 ShortRangeState,u8 EntryNum)861 bthci_EventShortRangeModeChangeComplete(
862 	struct rtw_adapter *padapter,
863 	enum hci_status				HciStatus,
864 	u8 		ShortRangeState,
865 	u8 		EntryNum
866 	)
867 {
868 	struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
869 	struct bt_hci_info *pBtHciInfo = &pBTInfo->BtHciInfo;
870 	u8 localBuf[5] = "";
871 	struct packet_irp_hcievent_data *PPacketIrpEvent;
872 
873 	if (!(pBtHciInfo->BTEventMaskPage2 & EMP2_HCI_EVENT_SHORT_RANGE_MODE_CHANGE_COMPLETE)) {
874 		RTPRINT(FIOCTL, IOCTL_BT_EVENT,
875 			("[BT event], Short Range Mode Change Complete, Ignore to send this event due to event mask page 2\n"));
876 		return;
877 	}
878 	RTPRINT(FIOCTL, IOCTL_BT_EVENT, ("[BT event], Short Range Mode Change Complete, Status = %d\n , PLH = 0x%x\n, Short_Range_Mode_State = 0x%x\n",
879 		HciStatus, pBTInfo->BtAsocEntry[EntryNum].PhyLinkCmdData.BtPhyLinkhandle, ShortRangeState));
880 
881 	PPacketIrpEvent = (struct packet_irp_hcievent_data *)(&localBuf[0]);
882 	PPacketIrpEvent->EventCode = HCI_EVENT_SHORT_RANGE_MODE_CHANGE_COMPLETE;
883 	PPacketIrpEvent->Length = 3;
884 	PPacketIrpEvent->Data[0] = HciStatus;
885 	PPacketIrpEvent->Data[1] = pBTInfo->BtAsocEntry[EntryNum].PhyLinkCmdData.BtPhyLinkhandle;
886 	PPacketIrpEvent->Data[2] = ShortRangeState;
887 	bthci_IndicateEvent(padapter, PPacketIrpEvent, 5);
888 }
889 
bthci_EventSendFlowSpecModifyComplete(struct rtw_adapter * padapter,enum hci_status HciStatus,u16 logicHandle)890 static void bthci_EventSendFlowSpecModifyComplete(struct rtw_adapter *padapter,
891 						  enum hci_status HciStatus,
892 						  u16 logicHandle)
893 {
894 	u8 localBuf[5] = "";
895 	struct packet_irp_hcievent_data *PPacketIrpEvent;
896 	struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
897 	struct bt_hci_info *pBtHciInfo = &pBTInfo->BtHciInfo;
898 
899 	if (!(pBtHciInfo->BTEventMaskPage2 & EMP2_HCI_EVENT_FLOW_SPEC_MODIFY_COMPLETE)) {
900 		RTPRINT(FIOCTL, (IOCTL_BT_EVENT|IOCTL_BT_LOGO),
901 			("[BT event], Flow Spec Modify Complete, Ignore to send this event due to event mask page 2\n"));
902 		return;
903 	}
904 	RTPRINT(FIOCTL, (IOCTL_BT_EVENT|IOCTL_BT_LOGO),
905 		("[BT event], Flow Spec Modify Complete, status = 0x%x, LLH = 0x%x\n", HciStatus, logicHandle));
906 	PPacketIrpEvent = (struct packet_irp_hcievent_data *)(&localBuf[0]);
907 	PPacketIrpEvent->EventCode = HCI_EVENT_FLOW_SPEC_MODIFY_COMPLETE;
908 	PPacketIrpEvent->Length = 3;
909 
910 	PPacketIrpEvent->Data[0] = HciStatus;
911 	/* Logical link handle */
912 	PPacketIrpEvent->Data[1] = TWOBYTE_LOWBYTE(logicHandle);
913 	PPacketIrpEvent->Data[2] = TWOBYTE_HIGHTBYTE(logicHandle);
914 
915 	bthci_IndicateEvent(padapter, PPacketIrpEvent, 5);
916 }
917 
918 static void
bthci_EventExtWifiScanNotify(struct rtw_adapter * padapter,u8 scanType)919 bthci_EventExtWifiScanNotify(
920 	struct rtw_adapter *padapter,
921 	u8 			scanType
922 	)
923 {
924 	struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
925 	struct bt_mgnt *pBtMgnt = &pBTInfo->BtMgnt;
926 	u8 len = 0;
927 	u8 localBuf[7] = "";
928 	u8 *pRetPar;
929 	u8 *pu1Temp;
930 	struct packet_irp_hcievent_data *PPacketIrpEvent;
931 
932 	if (!pBtMgnt->BtOperationOn)
933 		return;
934 
935 	PPacketIrpEvent = (struct packet_irp_hcievent_data *)(&localBuf[0]);
936 
937 	len += bthci_ExtensionEventHeaderRtk(&localBuf[0], HCI_EVENT_EXT_WIFI_SCAN_NOTIFY);
938 
939 	/*  Return parameters starts from here */
940 	pRetPar = &PPacketIrpEvent->Data[len];
941 	pu1Temp = (u8 *)&pRetPar[0];
942 	*pu1Temp = scanType;
943 	len += 1;
944 
945 	PPacketIrpEvent->Length = len;
946 
947 	if (bthci_IndicateEvent(padapter, PPacketIrpEvent, len+2) == RT_STATUS_SUCCESS) {
948 		RTPRINT(FIOCTL, IOCTL_BT_EVENT, ("[BT event], Wifi scan notify, scan type = %d\n",
949 			scanType));
950 	}
951 }
952 
953 static void
bthci_EventAMPReceiverReport(struct rtw_adapter * padapter,u8 Reason)954 bthci_EventAMPReceiverReport(
955 	struct rtw_adapter *padapter,
956 	u8 Reason
957 	)
958 {
959 	struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
960 	struct bt_hci_info *pBtHciInfo = &pBTInfo->BtHciInfo;
961 
962 	if (pBtHciInfo->bTestNeedReport) {
963 		u8 localBuf[20] = "";
964 		u32	*pu4Temp;
965 		u16	*pu2Temp;
966 		struct packet_irp_hcievent_data *PPacketIrpEvent;
967 
968 		RTPRINT(FIOCTL, (IOCTL_BT_EVENT|IOCTL_BT_LOGO), (" HCI_EVENT_AMP_RECEIVER_REPORT\n"));
969 		PPacketIrpEvent = (struct packet_irp_hcievent_data *)(&localBuf[0]);
970 		PPacketIrpEvent->EventCode = HCI_EVENT_AMP_RECEIVER_REPORT;
971 		PPacketIrpEvent->Length = 2;
972 
973 		PPacketIrpEvent->Data[0] = pBtHciInfo->TestCtrType;
974 
975 		PPacketIrpEvent->Data[1] = Reason;
976 
977 		pu4Temp = (u32 *)&PPacketIrpEvent->Data[2];
978 		*pu4Temp = pBtHciInfo->TestEventType;
979 
980 		pu2Temp = (u16 *)&PPacketIrpEvent->Data[6];
981 		*pu2Temp = pBtHciInfo->TestNumOfFrame;
982 
983 		pu2Temp = (u16 *)&PPacketIrpEvent->Data[8];
984 		*pu2Temp = pBtHciInfo->TestNumOfErrFrame;
985 
986 		pu4Temp = (u32 *)&PPacketIrpEvent->Data[10];
987 		*pu4Temp = pBtHciInfo->TestNumOfBits;
988 
989 		pu4Temp = (u32 *)&PPacketIrpEvent->Data[14];
990 		*pu4Temp = pBtHciInfo->TestNumOfErrBits;
991 
992 		bthci_IndicateEvent(padapter, PPacketIrpEvent, 20);
993 
994 		/* Return to Idel state with RX and TX off. */
995 
996 	}
997 
998 	pBtHciInfo->TestNumOfFrame = 0x00;
999 }
1000 
1001 static void
bthci_EventChannelSelected(struct rtw_adapter * padapter,u8 EntryNum)1002 bthci_EventChannelSelected(
1003 	struct rtw_adapter *padapter,
1004 	u8 	EntryNum
1005 	)
1006 {
1007 	struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
1008 	struct bt_hci_info *pBtHciInfo = &pBTInfo->BtHciInfo;
1009 	u8 localBuf[3] = "";
1010 	struct packet_irp_hcievent_data *PPacketIrpEvent;
1011 
1012 	if (!(pBtHciInfo->BTEventMaskPage2 & EMP2_HCI_EVENT_CHANNEL_SELECT)) {
1013 		RTPRINT(FIOCTL, IOCTL_BT_EVENT,
1014 			("[BT event], Channel Selected, Ignore to send this event due to event mask page 2\n"));
1015 		return;
1016 	}
1017 
1018 	RTPRINT(FIOCTL, IOCTL_BT_EVENT|IOCTL_STATE,
1019 		("[BT event], Channel Selected, PhyLinkHandle %d\n",
1020 		pBTInfo->BtAsocEntry[EntryNum].PhyLinkCmdData.BtPhyLinkhandle));
1021 
1022 	PPacketIrpEvent = (struct packet_irp_hcievent_data *)(&localBuf[0]);
1023 	PPacketIrpEvent->EventCode = HCI_EVENT_CHANNEL_SELECT;
1024 	PPacketIrpEvent->Length = 1;
1025 	PPacketIrpEvent->Data[0] = pBTInfo->BtAsocEntry[EntryNum].PhyLinkCmdData.BtPhyLinkhandle;
1026 	bthci_IndicateEvent(padapter, PPacketIrpEvent, 3);
1027 }
1028 
1029 static void
bthci_EventDisconnectPhyLinkComplete(struct rtw_adapter * padapter,enum hci_status HciStatus,enum hci_status Reason,u8 EntryNum)1030 bthci_EventDisconnectPhyLinkComplete(
1031 	struct rtw_adapter *padapter,
1032 	enum hci_status				HciStatus,
1033 	enum hci_status				Reason,
1034 	u8 		EntryNum
1035 	)
1036 {
1037 	struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
1038 	struct bt_hci_info *pBtHciInfo = &pBTInfo->BtHciInfo;
1039 	u8 localBuf[5] = "";
1040 	struct packet_irp_hcievent_data *PPacketIrpEvent;
1041 
1042 	if (!(pBtHciInfo->BTEventMaskPage2 & EMP2_HCI_EVENT_DISCONNECT_PHY_LINK_COMPLETE)) {
1043 		RTPRINT(FIOCTL, IOCTL_BT_EVENT,
1044 			("[BT event], Disconnect Physical Link Complete, Ignore to send this event due to event mask page 2\n"));
1045 		return;
1046 	}
1047 	RTPRINT(FIOCTL, IOCTL_BT_EVENT,
1048 		("[BT event], Disconnect Physical Link Complete, Status = 0x%x, PLH = 0x%x Reason = 0x%x\n",
1049 		HciStatus, pBTInfo->BtAsocEntry[EntryNum].PhyLinkCmdData.BtPhyLinkhandle, Reason));
1050 	PPacketIrpEvent = (struct packet_irp_hcievent_data *)(&localBuf[0]);
1051 	PPacketIrpEvent->EventCode = HCI_EVENT_DISCONNECT_PHY_LINK_COMPLETE;
1052 	PPacketIrpEvent->Length = 3;
1053 	PPacketIrpEvent->Data[0] = HciStatus;
1054 	PPacketIrpEvent->Data[1] = pBTInfo->BtAsocEntry[EntryNum].PhyLinkCmdData.BtPhyLinkhandle;
1055 	PPacketIrpEvent->Data[2] = Reason;
1056 	bthci_IndicateEvent(padapter, PPacketIrpEvent, 5);
1057 }
1058 
1059 static void
bthci_EventPhysicalLinkComplete(struct rtw_adapter * padapter,enum hci_status HciStatus,u8 EntryNum,u8 PLHandle)1060 bthci_EventPhysicalLinkComplete(
1061 	struct rtw_adapter *padapter,
1062 	enum hci_status				HciStatus,
1063 	u8 		EntryNum,
1064 	u8 		PLHandle
1065 	)
1066 {
1067 	struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
1068 	struct bt_mgnt *pBtMgnt = &pBTInfo->BtMgnt;
1069 	struct bt_hci_info *pBtHciInfo = &pBTInfo->BtHciInfo;
1070 	struct bt_dgb *pBtDbg = &pBTInfo->BtDbg;
1071 	u8 localBuf[4] = "";
1072 	struct packet_irp_hcievent_data *PPacketIrpEvent;
1073 	u8 PL_handle;
1074 
1075 	pBtMgnt->bPhyLinkInProgress = false;
1076 	pBtDbg->dbgHciInfo.hciCmdPhyLinkStatus = HciStatus;
1077 	if (!(pBtHciInfo->BTEventMaskPage2 & EMP2_HCI_EVENT_PHY_LINK_COMPLETE)) {
1078 		RTPRINT(FIOCTL, IOCTL_BT_EVENT,
1079 			("[BT event], Physical Link Complete, Ignore to send this event due to event mask page 2\n"));
1080 		return;
1081 	}
1082 
1083 	if (EntryNum == 0xff) {
1084 		/*  connection not started yet, just use the input physical link handle to response. */
1085 		PL_handle = PLHandle;
1086 	} else {
1087 		/*  connection is under progress, use the phy link handle we recorded. */
1088 		PL_handle  = pBTInfo->BtAsocEntry[EntryNum].PhyLinkCmdData.BtPhyLinkhandle;
1089 		pBTInfo->BtAsocEntry[EntryNum].bNeedPhysLinkCompleteEvent = false;
1090 	}
1091 
1092 	RTPRINT(FIOCTL, IOCTL_BT_EVENT, ("[BT event], Physical Link Complete, Status = 0x%x PhyLinkHandle = 0x%x\n", HciStatus,
1093 		PL_handle));
1094 
1095 	PPacketIrpEvent = (struct packet_irp_hcievent_data *)(&localBuf[0]);
1096 	PPacketIrpEvent->EventCode = HCI_EVENT_PHY_LINK_COMPLETE;
1097 	PPacketIrpEvent->Length = 2;
1098 
1099 	PPacketIrpEvent->Data[0] = HciStatus;
1100 	PPacketIrpEvent->Data[1] = PL_handle;
1101 	bthci_IndicateEvent(padapter, PPacketIrpEvent, 4);
1102 
1103 }
1104 
1105 static void
bthci_EventCommandStatus(struct rtw_adapter * padapter,u8 OGF,u16 OCF,enum hci_status HciStatus)1106 bthci_EventCommandStatus(
1107 	struct rtw_adapter *padapter,
1108 	u8 		OGF,
1109 	u16					OCF,
1110 	enum hci_status				HciStatus
1111 	)
1112 {
1113 
1114 	u8 localBuf[6] = "";
1115 	struct packet_irp_hcievent_data *PPacketIrpEvent;
1116 	u8 Num_Hci_Comm = 0x1;
1117 	RTPRINT(FIOCTL, IOCTL_BT_EVENT,
1118 		("[BT event], CommandStatus, Opcode = 0x%02x%02x, OGF = 0x%x,  OCF = 0x%x, Status = 0x%x, Num_HCI_COMM = 0x%x\n",
1119 		(HCIOPCODEHIGHT(OCF, OGF)), (HCIOPCODELOW(OCF, OGF)), OGF, OCF, HciStatus, Num_Hci_Comm));
1120 
1121 	PPacketIrpEvent = (struct packet_irp_hcievent_data *)(&localBuf[0]);
1122 	PPacketIrpEvent->EventCode = HCI_EVENT_COMMAND_STATUS;
1123 	PPacketIrpEvent->Length = 4;
1124 	PPacketIrpEvent->Data[0] = HciStatus;	/* current pending */
1125 	PPacketIrpEvent->Data[1] = Num_Hci_Comm;	/* packet # */
1126 	PPacketIrpEvent->Data[2] = HCIOPCODELOW(OCF, OGF);
1127 	PPacketIrpEvent->Data[3] = HCIOPCODEHIGHT(OCF, OGF);
1128 
1129 	bthci_IndicateEvent(padapter, PPacketIrpEvent, 6);
1130 
1131 }
1132 
1133 static void
bthci_EventLogicalLinkComplete(struct rtw_adapter * padapter,enum hci_status HciStatus,u8 PhyLinkHandle,u16 LogLinkHandle,u8 LogLinkIndex,u8 EntryNum)1134 bthci_EventLogicalLinkComplete(
1135 	struct rtw_adapter *padapter,
1136 	enum hci_status				HciStatus,
1137 	u8 		PhyLinkHandle,
1138 	u16					LogLinkHandle,
1139 	u8 		LogLinkIndex,
1140 	u8 		EntryNum
1141 	)
1142 {
1143 /*PMGNT_INFO pMgntInfo = &padapter->MgntInfo; */
1144 	struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
1145 	struct bt_hci_info *pBtHciInfo = &pBTInfo->BtHciInfo;
1146 	u8 localBuf[7] = "";
1147 	struct packet_irp_hcievent_data *PPacketIrpEvent;
1148 
1149 	if (!(pBtHciInfo->BTEventMaskPage2 & EMP2_HCI_EVENT_LOGICAL_LINK_COMPLETE)) {
1150 		RTPRINT(FIOCTL, IOCTL_BT_EVENT,
1151 			("[BT event], Logical Link Complete, Ignore to send this event due to event mask page 2\n"));
1152 		return;
1153 	}
1154 	RTPRINT(FIOCTL, IOCTL_BT_EVENT, ("[BT event], Logical Link Complete, PhyLinkHandle = 0x%x,  LogLinkHandle = 0x%x, Status = 0x%x\n",
1155 		PhyLinkHandle, LogLinkHandle, HciStatus));
1156 
1157 	PPacketIrpEvent = (struct packet_irp_hcievent_data *)(&localBuf[0]);
1158 	PPacketIrpEvent->EventCode = HCI_EVENT_LOGICAL_LINK_COMPLETE;
1159 	PPacketIrpEvent->Length = 5;
1160 
1161 	PPacketIrpEvent->Data[0] = HciStatus;/* status code */
1162 	/* Logical link handle */
1163 	PPacketIrpEvent->Data[1] = TWOBYTE_LOWBYTE(LogLinkHandle);
1164 	PPacketIrpEvent->Data[2] = TWOBYTE_HIGHTBYTE(LogLinkHandle);
1165 	/* Physical link handle */
1166 	PPacketIrpEvent->Data[3] = TWOBYTE_LOWBYTE(PhyLinkHandle);
1167 	/* corresponding Tx flow spec ID */
1168 	if (HciStatus == HCI_STATUS_SUCCESS) {
1169 		PPacketIrpEvent->Data[4] =
1170 			pBTInfo->BtAsocEntry[EntryNum].LogLinkCmdData[LogLinkIndex].Tx_Flow_Spec.Identifier;
1171 	} else {
1172 		PPacketIrpEvent->Data[4] = 0x0;
1173 	}
1174 
1175 	bthci_IndicateEvent(padapter, PPacketIrpEvent, 7);
1176 }
1177 
1178 static void
bthci_EventDisconnectLogicalLinkComplete(struct rtw_adapter * padapter,enum hci_status HciStatus,u16 LogLinkHandle,enum hci_status Reason)1179 bthci_EventDisconnectLogicalLinkComplete(
1180 	struct rtw_adapter *padapter,
1181 	enum hci_status				HciStatus,
1182 	u16					LogLinkHandle,
1183 	enum hci_status				Reason
1184 	)
1185 {
1186 	u8 localBuf[6] = "";
1187 	struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
1188 	struct bt_hci_info *pBtHciInfo = &pBTInfo->BtHciInfo;
1189 	struct packet_irp_hcievent_data *PPacketIrpEvent;
1190 
1191 	if (!(pBtHciInfo->BTEventMaskPage2 & EMP2_HCI_EVENT_DISCONNECT_LOGICAL_LINK_COMPLETE)) {
1192 		RTPRINT(FIOCTL, IOCTL_BT_EVENT, ("[BT event], Disconnect Logical Link Complete, Ignore to send this event due to event mask page 2\n"));
1193 		return;
1194 	}
1195 	RTPRINT(FIOCTL, IOCTL_BT_EVENT, ("[BT event], Disconnect Logical Link Complete, Status = 0x%x, LLH = 0x%x Reason = 0x%x\n", HciStatus, LogLinkHandle, Reason));
1196 
1197 	PPacketIrpEvent = (struct packet_irp_hcievent_data *)(&localBuf[0]);
1198 	PPacketIrpEvent->EventCode = HCI_EVENT_DISCONNECT_LOGICAL_LINK_COMPLETE;
1199 	PPacketIrpEvent->Length = 4;
1200 
1201 	PPacketIrpEvent->Data[0] = HciStatus;
1202 	/* Logical link handle */
1203 	PPacketIrpEvent->Data[1] = TWOBYTE_LOWBYTE(LogLinkHandle);
1204 	PPacketIrpEvent->Data[2] = TWOBYTE_HIGHTBYTE(LogLinkHandle);
1205 	/* Disconnect reason */
1206 	PPacketIrpEvent->Data[3] = Reason;
1207 
1208 	bthci_IndicateEvent(padapter, PPacketIrpEvent, 6);
1209 }
1210 
1211 static void
bthci_EventFlushOccurred(struct rtw_adapter * padapter,u16 LogLinkHandle)1212 bthci_EventFlushOccurred(
1213 	struct rtw_adapter *padapter,
1214 	u16					LogLinkHandle
1215 	)
1216 {
1217 	u8 localBuf[4] = "";
1218 	struct packet_irp_hcievent_data *PPacketIrpEvent;
1219 	RTPRINT(FIOCTL, IOCTL_BT_EVENT, ("bthci_EventFlushOccurred(), LLH = 0x%x\n", LogLinkHandle));
1220 
1221 	PPacketIrpEvent = (struct packet_irp_hcievent_data *)(&localBuf[0]);
1222 	PPacketIrpEvent->EventCode = HCI_EVENT_FLUSH_OCCRUED;
1223 	PPacketIrpEvent->Length = 2;
1224 	/* Logical link handle */
1225 	PPacketIrpEvent->Data[0] = TWOBYTE_LOWBYTE(LogLinkHandle);
1226 	PPacketIrpEvent->Data[1] = TWOBYTE_HIGHTBYTE(LogLinkHandle);
1227 
1228 	bthci_IndicateEvent(padapter, PPacketIrpEvent, 4);
1229 }
1230 
1231 static enum hci_status
bthci_BuildPhysicalLink(struct rtw_adapter * padapter,struct packet_irp_hcicmd_data * pHciCmd,u16 OCF)1232 bthci_BuildPhysicalLink(
1233 	struct rtw_adapter *padapter,
1234 	struct packet_irp_hcicmd_data *pHciCmd,
1235 	u16	OCF
1236 )
1237 {
1238 	enum hci_status		status = HCI_STATUS_SUCCESS;
1239 	struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
1240 	struct bt_mgnt *pBtMgnt = &pBTInfo->BtMgnt;
1241 	u8 EntryNum, PLH;
1242 
1243 	/* Send HCI Command status event to AMP. */
1244 	bthci_EventCommandStatus(padapter,
1245 			LINK_CONTROL_COMMANDS,
1246 			OCF,
1247 			HCI_STATUS_SUCCESS);
1248 
1249 	PLH = *((u8 *)pHciCmd->Data);
1250 
1251 	/*  Check if resource or bt connection is under progress, if yes, reject the link creation. */
1252 	if (!bthci_AddEntry(padapter)) {
1253 		status = HCI_STATUS_CONNECT_RJT_LIMIT_RESOURCE;
1254 		bthci_EventPhysicalLinkComplete(padapter, status, INVALID_ENTRY_NUM, PLH);
1255 		return status;
1256 	}
1257 
1258 	EntryNum = pBtMgnt->CurrentConnectEntryNum;
1259 	pBTInfo->BtAsocEntry[EntryNum].PhyLinkCmdData.BtPhyLinkhandle = PLH;
1260 	pBtMgnt->BtCurrentPhyLinkhandle = PLH;
1261 
1262 	if (pBTInfo->BtAsocEntry[EntryNum].AmpAsocCmdData.AMPAssocfragment == NULL) {
1263 		RTPRINT(FIOCTL, (IOCTL_BT_HCICMD|IOCTL_BT_LOGO), ("Create/Accept PhysicalLink, AMP controller is busy\n"));
1264 		status = HCI_STATUS_CONTROLLER_BUSY;
1265 		bthci_EventPhysicalLinkComplete(padapter, status, INVALID_ENTRY_NUM, PLH);
1266 		return status;
1267 	}
1268 
1269 	/*  Record Key and the info */
1270 	pBTInfo->BtAsocEntry[EntryNum].PhyLinkCmdData.BtAMPKeyLen = (*((u8 *)pHciCmd->Data+1));
1271 	pBTInfo->BtAsocEntry[EntryNum].PhyLinkCmdData.BtAMPKeyType = (*((u8 *)pHciCmd->Data+2));
1272 	memcpy(pBTInfo->BtAsocEntry[EntryNum].PhyLinkCmdData.BtAMPKey,
1273 		(((u8 *)pHciCmd->Data+3)), pBTInfo->BtAsocEntry[EntryNum].PhyLinkCmdData.BtAMPKeyLen);
1274 	memcpy(pBTInfo->BtAsocEntry[EntryNum].PMK, pBTInfo->BtAsocEntry[EntryNum].PhyLinkCmdData.BtAMPKey, PMK_LEN);
1275 	RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("BuildPhysicalLink, EntryNum = %d, PLH = 0x%x  KeyLen = 0x%x, KeyType = 0x%x\n",
1276 		EntryNum, pBTInfo->BtAsocEntry[EntryNum].PhyLinkCmdData.BtPhyLinkhandle,
1277 		pBTInfo->BtAsocEntry[EntryNum].PhyLinkCmdData.BtAMPKeyLen,
1278 		pBTInfo->BtAsocEntry[EntryNum].PhyLinkCmdData.BtAMPKeyType));
1279 	RTPRINT_DATA(FIOCTL, (IOCTL_BT_LOGO|IOCTL_BT_HCICMD), ("BtAMPKey\n"), pBTInfo->BtAsocEntry[EntryNum].PhyLinkCmdData.BtAMPKey,
1280 		pBTInfo->BtAsocEntry[EntryNum].PhyLinkCmdData.BtAMPKeyLen);
1281 	RTPRINT_DATA(FIOCTL, (IOCTL_BT_LOGO|IOCTL_BT_HCICMD), ("PMK\n"), pBTInfo->BtAsocEntry[EntryNum].PMK,
1282 		PMK_LEN);
1283 
1284 	if (OCF == HCI_CREATE_PHYSICAL_LINK) {
1285 		/* These macros require braces */
1286 		BTHCI_SM_WITH_INFO(padapter, HCI_STATE_DISCONNECTED, STATE_CMD_CREATE_PHY_LINK, EntryNum);
1287 	} else if (OCF == HCI_ACCEPT_PHYSICAL_LINK) {
1288 		BTHCI_SM_WITH_INFO(padapter, HCI_STATE_DISCONNECTED, STATE_CMD_ACCEPT_PHY_LINK, EntryNum);
1289 	}
1290 
1291 	return status;
1292 }
1293 
1294 static void
bthci_BuildLogicalLink(struct rtw_adapter * padapter,struct packet_irp_hcicmd_data * pHciCmd,u16 OCF)1295 bthci_BuildLogicalLink(
1296 	struct rtw_adapter *padapter,
1297 	struct packet_irp_hcicmd_data *pHciCmd,
1298 	u16 OCF
1299 	)
1300 {
1301 	enum hci_status status = HCI_STATUS_SUCCESS;
1302 	struct bt_30info *pBTinfo = GET_BT_INFO(padapter);
1303 	struct bt_mgnt *pBtMgnt = &pBTinfo->BtMgnt;
1304 	u8 PhyLinkHandle, EntryNum;
1305 	static u16 AssignLogHandle = 1;
1306 
1307 	struct hci_flow_spec	TxFlowSpec;
1308 	struct hci_flow_spec	RxFlowSpec;
1309 	u32	MaxSDUSize, ArriveTime, Bandwidth;
1310 
1311 	PhyLinkHandle = *((u8 *)pHciCmd->Data);
1312 
1313 	EntryNum = bthci_GetCurrentEntryNum(padapter, PhyLinkHandle);
1314 
1315 	memcpy(&TxFlowSpec,
1316 		&pHciCmd->Data[1], sizeof(struct hci_flow_spec));
1317 	memcpy(&RxFlowSpec,
1318 		&pHciCmd->Data[17], sizeof(struct hci_flow_spec));
1319 
1320 	MaxSDUSize = TxFlowSpec.MaximumSDUSize;
1321 	ArriveTime = TxFlowSpec.SDUInterArrivalTime;
1322 
1323 	if (bthci_CheckLogLinkBehavior(padapter, TxFlowSpec) && bthci_CheckLogLinkBehavior(padapter, RxFlowSpec))
1324 		Bandwidth = BTTOTALBANDWIDTH;
1325 	else if (MaxSDUSize == 0xffff && ArriveTime == 0xffffffff)
1326 		Bandwidth = BTTOTALBANDWIDTH;
1327 	else
1328 		Bandwidth = MaxSDUSize*8*1000/(ArriveTime+244);
1329 
1330 	RTPRINT(FIOCTL, IOCTL_BT_HCICMD,
1331 		("BuildLogicalLink, PhyLinkHandle = 0x%x, MaximumSDUSize = 0x%x, SDUInterArrivalTime = 0x%x, Bandwidth = 0x%x\n",
1332 		PhyLinkHandle, MaxSDUSize, ArriveTime, Bandwidth));
1333 
1334 	if (EntryNum == 0xff) {
1335 		RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("Invalid Physical Link handle = 0x%x, status = HCI_STATUS_UNKNOW_CONNECT_ID, return\n", PhyLinkHandle));
1336 		status = HCI_STATUS_UNKNOW_CONNECT_ID;
1337 
1338 		/* When we receive Create/Accept logical link command, we should send command status event first. */
1339 		bthci_EventCommandStatus(padapter,
1340 			LINK_CONTROL_COMMANDS,
1341 			OCF,
1342 			status);
1343 		return;
1344 	}
1345 
1346 	if (!pBtMgnt->bLogLinkInProgress) {
1347 		if (bthci_PhyLinkConnectionInProgress(padapter, PhyLinkHandle)) {
1348 			RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("Physical link connection in progress, status = HCI_STATUS_CMD_DISALLOW, return\n"));
1349 			status = HCI_STATUS_CMD_DISALLOW;
1350 
1351 			pBtMgnt->bPhyLinkInProgressStartLL = true;
1352 			/* When we receive Create/Accept logical link command, we should send command status event first. */
1353 			bthci_EventCommandStatus(padapter,
1354 				LINK_CONTROL_COMMANDS,
1355 				OCF,
1356 				status);
1357 
1358 			return;
1359 		}
1360 
1361 		if (Bandwidth > BTTOTALBANDWIDTH) {
1362 			RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("status = HCI_STATUS_QOS_REJECT, Bandwidth = 0x%x, return\n", Bandwidth));
1363 			status = HCI_STATUS_QOS_REJECT;
1364 
1365 			/* When we receive Create/Accept logical link command, we should send command status event first. */
1366 			bthci_EventCommandStatus(padapter,
1367 				LINK_CONTROL_COMMANDS,
1368 				OCF,
1369 				status);
1370 		} else {
1371 			RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("status = HCI_STATUS_SUCCESS\n"));
1372 			status = HCI_STATUS_SUCCESS;
1373 
1374 			/* When we receive Create/Accept logical link command, we should send command status event first. */
1375 			bthci_EventCommandStatus(padapter,
1376 				LINK_CONTROL_COMMANDS,
1377 				OCF,
1378 				status);
1379 
1380 		}
1381 
1382 		if (pBTinfo->BtAsocEntry[EntryNum].BtCurrentState != HCI_STATE_CONNECTED) {
1383 			bthci_EventLogicalLinkComplete(padapter,
1384 				HCI_STATUS_CMD_DISALLOW, 0, 0, 0, EntryNum);
1385 		} else {
1386 			u8 i, find = 0;
1387 
1388 			pBtMgnt->bLogLinkInProgress = true;
1389 
1390 			/*  find an unused logical link index and copy the data */
1391 			for (i = 0; i < MAX_LOGICAL_LINK_NUM; i++) {
1392 				if (pBTinfo->BtAsocEntry[EntryNum].LogLinkCmdData[i].BtLogLinkhandle == 0) {
1393 					enum hci_status LogCompEventstatus = HCI_STATUS_SUCCESS;
1394 
1395 					pBTinfo->BtAsocEntry[EntryNum].LogLinkCmdData[i].BtPhyLinkhandle = *((u8 *)pHciCmd->Data);
1396 					pBTinfo->BtAsocEntry[EntryNum].LogLinkCmdData[i].BtLogLinkhandle = AssignLogHandle;
1397 					RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("BuildLogicalLink, EntryNum = %d, physical link handle = 0x%x, logical link handle = 0x%x\n",
1398 						EntryNum, pBTinfo->BtAsocEntry[EntryNum].PhyLinkCmdData.BtPhyLinkhandle,
1399 								  pBTinfo->BtAsocEntry[EntryNum].LogLinkCmdData[i].BtLogLinkhandle));
1400 					memcpy(&pBTinfo->BtAsocEntry[EntryNum].LogLinkCmdData[i].Tx_Flow_Spec,
1401 						&TxFlowSpec, sizeof(struct hci_flow_spec));
1402 					memcpy(&pBTinfo->BtAsocEntry[EntryNum].LogLinkCmdData[i].Rx_Flow_Spec,
1403 						&RxFlowSpec, sizeof(struct hci_flow_spec));
1404 
1405 					pBTinfo->BtAsocEntry[EntryNum].LogLinkCmdData[i].bLLCompleteEventIsSet = false;
1406 
1407 					if (pBTinfo->BtAsocEntry[EntryNum].LogLinkCmdData[i].bLLCancelCMDIsSetandComplete)
1408 						LogCompEventstatus = HCI_STATUS_UNKNOW_CONNECT_ID;
1409 					bthci_EventLogicalLinkComplete(padapter,
1410 						LogCompEventstatus,
1411 						pBTinfo->BtAsocEntry[EntryNum].LogLinkCmdData[i].BtPhyLinkhandle,
1412 						pBTinfo->BtAsocEntry[EntryNum].LogLinkCmdData[i].BtLogLinkhandle, i, EntryNum);
1413 
1414 					pBTinfo->BtAsocEntry[EntryNum].LogLinkCmdData[i].bLLCompleteEventIsSet = true;
1415 
1416 					find = 1;
1417 					pBtMgnt->BtCurrentLogLinkhandle = AssignLogHandle;
1418 					AssignLogHandle++;
1419 					break;
1420 				}
1421 			}
1422 
1423 			if (!find) {
1424 				bthci_EventLogicalLinkComplete(padapter,
1425 					HCI_STATUS_CONNECT_RJT_LIMIT_RESOURCE, 0, 0, 0, EntryNum);
1426 			}
1427 			pBtMgnt->bLogLinkInProgress = false;
1428 		}
1429 	} else {
1430 		bthci_EventLogicalLinkComplete(padapter,
1431 			HCI_STATUS_CONTROLLER_BUSY, 0, 0, 0, EntryNum);
1432 	}
1433 
1434 }
1435 
1436 static void
bthci_StartBeaconAndConnect(struct rtw_adapter * padapter,struct packet_irp_hcicmd_data * pHciCmd,u8 CurrentAssocNum)1437 bthci_StartBeaconAndConnect(
1438 	struct rtw_adapter *padapter,
1439 	struct packet_irp_hcicmd_data *pHciCmd,
1440 	u8 CurrentAssocNum
1441 	)
1442 {
1443 /*PMGNT_INFO pMgntInfo = &padapter->MgntInfo; */
1444 	struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
1445 	struct bt_mgnt *pBtMgnt = &pBTInfo->BtMgnt;
1446 
1447 	RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("StartBeaconAndConnect, CurrentAssocNum =%d, AMPRole =%d\n",
1448 		CurrentAssocNum,
1449 		pBTInfo->BtAsocEntry[CurrentAssocNum].AMPRole));
1450 
1451 	if (!pBtMgnt->CheckChnlIsSuit) {
1452 		bthci_EventPhysicalLinkComplete(padapter, HCI_STATUS_CONNECT_REJ_NOT_SUIT_CHNL_FOUND, CurrentAssocNum, INVALID_PL_HANDLE);
1453 		bthci_RemoveEntryByEntryNum(padapter, CurrentAssocNum);
1454 		return;
1455 	}
1456 
1457 	if (pBTInfo->BtAsocEntry[CurrentAssocNum].AMPRole == AMP_BTAP_CREATOR) {
1458 		rsprintf((char *)pBTInfo->BtAsocEntry[CurrentAssocNum].BTSsidBuf, 32, "AMP-%02x-%02x-%02x-%02x-%02x-%02x",
1459 		padapter->eeprompriv.mac_addr[0],
1460 		padapter->eeprompriv.mac_addr[1],
1461 		padapter->eeprompriv.mac_addr[2],
1462 		padapter->eeprompriv.mac_addr[3],
1463 		padapter->eeprompriv.mac_addr[4],
1464 		padapter->eeprompriv.mac_addr[5]);
1465 	} else if (pBTInfo->BtAsocEntry[CurrentAssocNum].AMPRole == AMP_BTAP_JOINER) {
1466 		rsprintf((char *)pBTInfo->BtAsocEntry[CurrentAssocNum].BTSsidBuf, 32, "AMP-%02x-%02x-%02x-%02x-%02x-%02x",
1467 		pBTInfo->BtAsocEntry[CurrentAssocNum].BTRemoteMACAddr[0],
1468 		pBTInfo->BtAsocEntry[CurrentAssocNum].BTRemoteMACAddr[1],
1469 		pBTInfo->BtAsocEntry[CurrentAssocNum].BTRemoteMACAddr[2],
1470 		pBTInfo->BtAsocEntry[CurrentAssocNum].BTRemoteMACAddr[3],
1471 		pBTInfo->BtAsocEntry[CurrentAssocNum].BTRemoteMACAddr[4],
1472 		pBTInfo->BtAsocEntry[CurrentAssocNum].BTRemoteMACAddr[5]);
1473 	}
1474 
1475 	FillOctetString(pBTInfo->BtAsocEntry[CurrentAssocNum].BTSsid, pBTInfo->BtAsocEntry[CurrentAssocNum].BTSsidBuf, 21);
1476 	pBTInfo->BtAsocEntry[CurrentAssocNum].BTSsid.Length = 21;
1477 
1478 	/* To avoid set the start ap or connect twice, or the original connection will be disconnected. */
1479 	if (!pBtMgnt->bBTConnectInProgress) {
1480 		pBtMgnt->bBTConnectInProgress = true;
1481 		RTPRINT(FIOCTL, IOCTL_STATE, ("[BT Flag], BT Connect in progress ON!!\n"));
1482 		BTHCI_SM_WITH_INFO(padapter, HCI_STATE_STARTING, STATE_CMD_MAC_START_COMPLETE, CurrentAssocNum);
1483 
1484 		/*  20100325 Joseph: Check RF ON/OFF. */
1485 		/*  If RF OFF, it reschedule connecting operation after 50ms. */
1486 		if (!bthci_CheckRfStateBeforeConnect(padapter))
1487 			return;
1488 
1489 		if (pBTInfo->BtAsocEntry[CurrentAssocNum].AMPRole == AMP_BTAP_CREATOR) {
1490 			/* These macros need braces */
1491 			BTHCI_SM_WITH_INFO(padapter, HCI_STATE_CONNECTING, STATE_CMD_MAC_CONNECT_COMPLETE, CurrentAssocNum);
1492 		} else if (pBTInfo->BtAsocEntry[CurrentAssocNum].AMPRole == AMP_BTAP_JOINER) {
1493 			bthci_ResponderStartToScan(padapter);
1494 		}
1495 	}
1496 	RT_PRINT_STR(_module_rtl871x_mlme_c_, _drv_notice_,
1497 		     "StartBeaconAndConnect, SSID:\n",
1498 		     pBTInfo->BtAsocEntry[pBtMgnt->CurrentConnectEntryNum].BTSsid.Octet,
1499 		     pBTInfo->BtAsocEntry[pBtMgnt->CurrentConnectEntryNum].BTSsid.Length);
1500 }
1501 
bthci_ResetBtMgnt(struct bt_mgnt * pBtMgnt)1502 static void bthci_ResetBtMgnt(struct bt_mgnt *pBtMgnt)
1503 {
1504 	pBtMgnt->BtOperationOn = false;
1505 	pBtMgnt->bBTConnectInProgress = false;
1506 	pBtMgnt->bLogLinkInProgress = false;
1507 	pBtMgnt->bPhyLinkInProgress = false;
1508 	pBtMgnt->bPhyLinkInProgressStartLL = false;
1509 	pBtMgnt->DisconnectEntryNum = 0xff;
1510 	pBtMgnt->bStartSendSupervisionPkt = false;
1511 	pBtMgnt->JoinerNeedSendAuth = false;
1512 	pBtMgnt->CurrentBTConnectionCnt = 0;
1513 	pBtMgnt->BTCurrentConnectType = BT_DISCONNECT;
1514 	pBtMgnt->BTReceiveConnectPkt = BT_DISCONNECT;
1515 	pBtMgnt->BTAuthCount = 0;
1516 	pBtMgnt->btLogoTest = 0;
1517 }
1518 
bthci_ResetBtHciInfo(struct bt_hci_info * pBtHciInfo)1519 static void bthci_ResetBtHciInfo(struct bt_hci_info *pBtHciInfo)
1520 {
1521 	pBtHciInfo->BTEventMask = 0;
1522 	pBtHciInfo->BTEventMaskPage2 = 0;
1523 	pBtHciInfo->ConnAcceptTimeout =  10000;
1524 	pBtHciInfo->PageTimeout  =  0x30;
1525 	pBtHciInfo->LocationDomainAware = 0x0;
1526 	pBtHciInfo->LocationDomain = 0x5858;
1527 	pBtHciInfo->LocationDomainOptions = 0x58;
1528 	pBtHciInfo->LocationOptions = 0x0;
1529 	pBtHciInfo->FlowControlMode = 0x1;	/*  0:Packet based data flow control mode(BR/EDR), 1: Data block based data flow control mode(AMP). */
1530 
1531 	pBtHciInfo->enFlush_LLH = 0;
1532 	pBtHciInfo->FLTO_LLH = 0;
1533 
1534 	/* Test command only */
1535 	pBtHciInfo->bTestIsEnd = true;
1536 	pBtHciInfo->bInTestMode = false;
1537 	pBtHciInfo->bTestNeedReport = false;
1538 	pBtHciInfo->TestScenario = 0xff;
1539 	pBtHciInfo->TestReportInterval = 0x01;
1540 	pBtHciInfo->TestCtrType = 0x5d;
1541 	pBtHciInfo->TestEventType = 0x00;
1542 	pBtHciInfo->TestNumOfFrame = 0;
1543 	pBtHciInfo->TestNumOfErrFrame = 0;
1544 	pBtHciInfo->TestNumOfBits = 0;
1545 	pBtHciInfo->TestNumOfErrBits = 0;
1546 }
1547 
bthci_ResetBtSec(struct rtw_adapter * padapter,struct bt_security * pBtSec)1548 static void bthci_ResetBtSec(struct rtw_adapter *padapter, struct bt_security *pBtSec)
1549 {
1550 /*PMGNT_INFO	pMgntInfo = &padapter->MgntInfo; */
1551 
1552 	/*  Set BT used HW or SW encrypt !! */
1553 	if (GET_HAL_DATA(padapter)->bBTMode)
1554 		pBtSec->bUsedHwEncrypt = true;
1555 	else
1556 		pBtSec->bUsedHwEncrypt = false;
1557 	RT_TRACE(_module_rtl871x_security_c_, _drv_info_,
1558 		 "%s: bUsedHwEncrypt =%d\n", __func__, pBtSec->bUsedHwEncrypt);
1559 
1560 	pBtSec->RSNIE.Octet = pBtSec->RSNIEBuf;
1561 }
1562 
bthci_ResetBtExtInfo(struct bt_mgnt * pBtMgnt)1563 static void bthci_ResetBtExtInfo(struct bt_mgnt *pBtMgnt)
1564 {
1565 	u8 i;
1566 
1567 	for (i = 0; i < MAX_BT_ASOC_ENTRY_NUM; i++) {
1568 		pBtMgnt->ExtConfig.linkInfo[i].ConnectHandle = 0;
1569 		pBtMgnt->ExtConfig.linkInfo[i].IncomingTrafficMode = 0;
1570 		pBtMgnt->ExtConfig.linkInfo[i].OutgoingTrafficMode = 0;
1571 		pBtMgnt->ExtConfig.linkInfo[i].BTProfile = BT_PROFILE_NONE;
1572 		pBtMgnt->ExtConfig.linkInfo[i].BTCoreSpec = BT_SPEC_2_1_EDR;
1573 		pBtMgnt->ExtConfig.linkInfo[i].BT_RSSI = 0;
1574 		pBtMgnt->ExtConfig.linkInfo[i].TrafficProfile = BT_PROFILE_NONE;
1575 		pBtMgnt->ExtConfig.linkInfo[i].linkRole = BT_LINK_MASTER;
1576 	}
1577 
1578 	pBtMgnt->ExtConfig.CurrentConnectHandle = 0;
1579 	pBtMgnt->ExtConfig.CurrentIncomingTrafficMode = 0;
1580 	pBtMgnt->ExtConfig.CurrentOutgoingTrafficMode = 0;
1581 	pBtMgnt->ExtConfig.MIN_BT_RSSI = 0;
1582 	pBtMgnt->ExtConfig.NumberOfHandle = 0;
1583 	pBtMgnt->ExtConfig.NumberOfSCO = 0;
1584 	pBtMgnt->ExtConfig.CurrentBTStatus = 0;
1585 	pBtMgnt->ExtConfig.HCIExtensionVer = 0;
1586 
1587 	pBtMgnt->ExtConfig.bManualControl = false;
1588 	pBtMgnt->ExtConfig.bBTBusy = false;
1589 	pBtMgnt->ExtConfig.bBTA2DPBusy = false;
1590 }
1591 
bthci_CmdReset(struct rtw_adapter * _padapter,u8 bNeedSendEvent)1592 static enum hci_status bthci_CmdReset(struct rtw_adapter *_padapter, u8 bNeedSendEvent)
1593 {
1594 	enum hci_status status = HCI_STATUS_SUCCESS;
1595 	struct rtw_adapter *padapter;
1596 /*PMGNT_INFO pMgntInfo = &padapter->MgntInfo; */
1597 	struct bt_30info *pBTInfo;
1598 	struct bt_mgnt *pBtMgnt;
1599 	struct bt_hci_info *pBtHciInfo;
1600 	struct bt_security *pBtSec;
1601 	struct bt_dgb *pBtDbg;
1602 	u8 i;
1603 
1604 	RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("bthci_CmdReset()\n"));
1605 
1606 	padapter = GetDefaultAdapter(_padapter);
1607 	pBTInfo = GET_BT_INFO(padapter);
1608 	pBtMgnt = &pBTInfo->BtMgnt;
1609 	pBtHciInfo = &pBTInfo->BtHciInfo;
1610 	pBtSec = &pBTInfo->BtSec;
1611 	pBtDbg = &pBTInfo->BtDbg;
1612 
1613 	pBTInfo->padapter = padapter;
1614 
1615 	for (i = 0; i < MAX_BT_ASOC_ENTRY_NUM; i++)
1616 		bthci_ResetEntry(padapter, i);
1617 
1618 	bthci_ResetBtMgnt(pBtMgnt);
1619 	bthci_ResetBtHciInfo(pBtHciInfo);
1620 	bthci_ResetBtSec(padapter, pBtSec);
1621 
1622 	pBtMgnt->BTChannel = BT_Default_Chnl;
1623 	pBtMgnt->CheckChnlIsSuit = true;
1624 
1625 	pBTInfo->BTBeaconTmrOn = false;
1626 
1627 	pBtMgnt->bCreateSpportQos = true;
1628 
1629 	del_timer_sync(&pBTInfo->BTHCIDiscardAclDataTimer);
1630 	del_timer_sync(&pBTInfo->BTBeaconTimer);
1631 
1632 	HALBT_SetRtsCtsNoLenLimit(padapter);
1633 	/*  */
1634 	/*  Maybe we need to take care Group != AES case !! */
1635 	/*  now we Pairwise and Group all used AES !! */
1636 
1637 	bthci_ResetBtExtInfo(pBtMgnt);
1638 
1639 	/* send command complete event here when all data are received. */
1640 	if (bNeedSendEvent) {
1641 		u8 localBuf[6] = "";
1642 		u8 *pRetPar;
1643 		u8 len = 0;
1644 		struct packet_irp_hcievent_data *PPacketIrpEvent;
1645 
1646 		PPacketIrpEvent = (struct packet_irp_hcievent_data *)(&localBuf[0]);
1647 
1648 		len += bthci_CommandCompleteHeader(&localBuf[0],
1649 			OGF_SET_EVENT_MASK_COMMAND,
1650 			HCI_RESET,
1651 			status);
1652 
1653 		/*  Return parameters starts from here */
1654 		pRetPar = &PPacketIrpEvent->Data[len];
1655 		pRetPar[0] = status;		/* status */
1656 		len += 1;
1657 		PPacketIrpEvent->Length = len;
1658 
1659 		bthci_IndicateEvent(padapter, PPacketIrpEvent, len+2);
1660 	}
1661 
1662 	return status;
1663 }
1664 
1665 static enum hci_status
bthci_CmdWriteRemoteAMPAssoc(struct rtw_adapter * padapter,struct packet_irp_hcicmd_data * pHciCmd)1666 bthci_CmdWriteRemoteAMPAssoc(
1667 	struct rtw_adapter *padapter,
1668 	struct packet_irp_hcicmd_data *pHciCmd
1669 	)
1670 {
1671 	enum hci_status status = HCI_STATUS_SUCCESS;
1672 	struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
1673 	struct bt_dgb *pBtDbg = &pBTInfo->BtDbg;
1674 	u8 CurrentAssocNum;
1675 	u8 PhyLinkHandle;
1676 
1677 	pBtDbg->dbgHciInfo.hciCmdCntWriteRemoteAmpAssoc++;
1678 	PhyLinkHandle = *((u8 *)pHciCmd->Data);
1679 	CurrentAssocNum = bthci_GetCurrentEntryNum(padapter, PhyLinkHandle);
1680 
1681 	if (CurrentAssocNum == 0xff) {
1682 		RTPRINT(FIOCTL, (IOCTL_BT_HCICMD|IOCTL_BT_LOGO), ("WriteRemoteAMPAssoc, No such Handle in the Entry\n"));
1683 		status = HCI_STATUS_UNKNOW_CONNECT_ID;
1684 		bthci_EventWriteRemoteAmpAssoc(padapter, status, PhyLinkHandle);
1685 		return status;
1686 	}
1687 
1688 	if (pBTInfo->BtAsocEntry[CurrentAssocNum].AmpAsocCmdData.AMPAssocfragment == NULL) {
1689 		RTPRINT(FIOCTL, (IOCTL_BT_HCICMD|IOCTL_BT_LOGO), ("WriteRemoteAMPAssoc, AMP controller is busy\n"));
1690 		status = HCI_STATUS_CONTROLLER_BUSY;
1691 		bthci_EventWriteRemoteAmpAssoc(padapter, status, PhyLinkHandle);
1692 		return status;
1693 	}
1694 
1695 	pBTInfo->BtAsocEntry[CurrentAssocNum].AmpAsocCmdData.BtPhyLinkhandle = PhyLinkHandle;/* u8 *)pHciCmd->Data); */
1696 	pBTInfo->BtAsocEntry[CurrentAssocNum].AmpAsocCmdData.LenSoFar = *((u16 *)((u8 *)pHciCmd->Data+1));
1697 	pBTInfo->BtAsocEntry[CurrentAssocNum].AmpAsocCmdData.AMPAssocRemLen = *((u16 *)((u8 *)pHciCmd->Data+3));
1698 
1699 	RTPRINT(FIOCTL, (IOCTL_BT_HCICMD_DETAIL|IOCTL_BT_LOGO), ("WriteRemoteAMPAssoc, LenSoFar = 0x%x, AssocRemLen = 0x%x\n",
1700 		pBTInfo->BtAsocEntry[CurrentAssocNum].AmpAsocCmdData.LenSoFar,
1701 		pBTInfo->BtAsocEntry[CurrentAssocNum].AmpAsocCmdData.AMPAssocRemLen));
1702 
1703 	RTPRINT_DATA(FIOCTL, (IOCTL_BT_HCICMD_DETAIL|IOCTL_BT_LOGO),
1704 		     ("WriteRemoteAMPAssoc fragment \n"),
1705 		     pHciCmd->Data,
1706 		     pBTInfo->BtAsocEntry[CurrentAssocNum].AmpAsocCmdData.AMPAssocRemLen+5);
1707 	if ((pBTInfo->BtAsocEntry[CurrentAssocNum].AmpAsocCmdData.AMPAssocRemLen) > MAX_AMP_ASSOC_FRAG_LEN) {
1708 		memcpy(((u8 *)pBTInfo->BtAsocEntry[CurrentAssocNum].AmpAsocCmdData.AMPAssocfragment+(pBTInfo->BtAsocEntry[CurrentAssocNum].AmpAsocCmdData.LenSoFar*(sizeof(u8)))),
1709 			(u8 *)pHciCmd->Data+5,
1710 			MAX_AMP_ASSOC_FRAG_LEN);
1711 	} else {
1712 		memcpy((u8 *)(pBTInfo->BtAsocEntry[CurrentAssocNum].AmpAsocCmdData.AMPAssocfragment)+(pBTInfo->BtAsocEntry[CurrentAssocNum].AmpAsocCmdData.LenSoFar*(sizeof(u8))),
1713 			((u8 *)pHciCmd->Data+5),
1714 			(pBTInfo->BtAsocEntry[CurrentAssocNum].AmpAsocCmdData.AMPAssocRemLen));
1715 
1716 		RTPRINT_DATA(FIOCTL, (IOCTL_BT_HCICMD_DETAIL|IOCTL_BT_LOGO), "WriteRemoteAMPAssoc :\n",
1717 			pHciCmd->Data+5, pBTInfo->BtAsocEntry[CurrentAssocNum].AmpAsocCmdData.AMPAssocRemLen);
1718 
1719 		if (!bthci_GetAssocInfo(padapter, CurrentAssocNum))
1720 			status = HCI_STATUS_INVALID_HCI_CMD_PARA_VALUE;
1721 
1722 		bthci_EventWriteRemoteAmpAssoc(padapter, status, PhyLinkHandle);
1723 
1724 		bthci_StartBeaconAndConnect(padapter, pHciCmd, CurrentAssocNum);
1725 	}
1726 
1727 	return status;
1728 }
1729 
1730 /* 7.3.13 */
bthci_CmdReadConnectionAcceptTimeout(struct rtw_adapter * padapter)1731 static enum hci_status bthci_CmdReadConnectionAcceptTimeout(struct rtw_adapter *padapter)
1732 {
1733 	enum hci_status		status = HCI_STATUS_SUCCESS;
1734 /*PMGNT_INFO		pMgntInfo = &padapter->MgntInfo; */
1735 	struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
1736 	struct bt_hci_info *pBtHciInfo = &pBTInfo->BtHciInfo;
1737 	u8 localBuf[8] = "";
1738 	u8 *pRetPar;
1739 	u8 len = 0;
1740 	struct packet_irp_hcievent_data *PPacketIrpEvent;
1741 	u16 *pu2Temp;
1742 
1743 	PPacketIrpEvent = (struct packet_irp_hcievent_data *)(&localBuf[0]);
1744 
1745 	len += bthci_CommandCompleteHeader(&localBuf[0],
1746 		OGF_SET_EVENT_MASK_COMMAND,
1747 		HCI_READ_CONNECTION_ACCEPT_TIMEOUT,
1748 		status);
1749 
1750 	/*  Return parameters starts from here */
1751 	pRetPar = &PPacketIrpEvent->Data[len];
1752 	pRetPar[0] = status;		/* status */
1753 	pu2Temp = (u16 *)&pRetPar[1];		/*  Conn_Accept_Timeout */
1754 	*pu2Temp = pBtHciInfo->ConnAcceptTimeout;
1755 	len += 3;
1756 	PPacketIrpEvent->Length = len;
1757 
1758 	bthci_IndicateEvent(padapter, PPacketIrpEvent, len+2);
1759 
1760 	return status;
1761 }
1762 
1763 /* 7.3.14 */
1764 static enum hci_status
bthci_CmdWriteConnectionAcceptTimeout(struct rtw_adapter * padapter,struct packet_irp_hcicmd_data * pHciCmd)1765 bthci_CmdWriteConnectionAcceptTimeout(
1766 	struct rtw_adapter *padapter,
1767 	struct packet_irp_hcicmd_data *pHciCmd
1768 	)
1769 {
1770 	enum hci_status		status = HCI_STATUS_SUCCESS;
1771 	struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
1772 	struct bt_hci_info *pBtHciInfo = &pBTInfo->BtHciInfo;
1773 	u16	*pu2Temp;
1774 	u8 localBuf[6] = "";
1775 	u8 *pRetPar;
1776 	u8 len = 0;
1777 	struct packet_irp_hcievent_data *PPacketIrpEvent;
1778 
1779 	pu2Temp = (u16 *)&pHciCmd->Data[0];
1780 	pBtHciInfo->ConnAcceptTimeout = *pu2Temp;
1781 	RTPRINT(FIOCTL, IOCTL_BT_HCICMD_DETAIL, ("ConnAcceptTimeout = 0x%x",
1782 		pBtHciInfo->ConnAcceptTimeout));
1783 
1784 	/* send command complete event here when all data are received. */
1785 	PPacketIrpEvent = (struct packet_irp_hcievent_data *)(&localBuf[0]);
1786 
1787 	len += bthci_CommandCompleteHeader(&localBuf[0],
1788 		OGF_SET_EVENT_MASK_COMMAND,
1789 		HCI_WRITE_CONNECTION_ACCEPT_TIMEOUT,
1790 		status);
1791 
1792 	/*  Return parameters starts from here */
1793 	pRetPar = &PPacketIrpEvent->Data[len];
1794 	pRetPar[0] = status;		/* status */
1795 	len += 1;
1796 	PPacketIrpEvent->Length = len;
1797 
1798 	bthci_IndicateEvent(padapter, PPacketIrpEvent, len+2);
1799 
1800 	return status;
1801 }
1802 
1803 static enum hci_status
bthci_CmdReadPageTimeout(struct rtw_adapter * padapter,struct packet_irp_hcicmd_data * pHciCmd)1804 bthci_CmdReadPageTimeout(
1805 	struct rtw_adapter *padapter,
1806 	struct packet_irp_hcicmd_data *pHciCmd
1807 	)
1808 {
1809 	enum hci_status		status = HCI_STATUS_SUCCESS;
1810 	struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
1811 	struct bt_hci_info *pBtHciInfo = &pBTInfo->BtHciInfo;
1812 	u8 localBuf[8] = "";
1813 	u8 *pRetPar;
1814 	u8 len = 0;
1815 	struct packet_irp_hcievent_data *PPacketIrpEvent;
1816 	u16 *pu2Temp;
1817 
1818 	PPacketIrpEvent = (struct packet_irp_hcievent_data *)(&localBuf[0]);
1819 
1820 	len += bthci_CommandCompleteHeader(&localBuf[0],
1821 		OGF_SET_EVENT_MASK_COMMAND,
1822 		HCI_READ_PAGE_TIMEOUT,
1823 		status);
1824 
1825 	RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("Read PageTimeout = 0x%x\n", pBtHciInfo->PageTimeout));
1826 	/*  Return parameters starts from here */
1827 	pRetPar = &PPacketIrpEvent->Data[len];
1828 	pRetPar[0] = status;		/* status */
1829 	pu2Temp = (u16 *)&pRetPar[1];		/*  Page_Timeout */
1830 	*pu2Temp = pBtHciInfo->PageTimeout;
1831 	len += 3;
1832 	PPacketIrpEvent->Length = len;
1833 
1834 	bthci_IndicateEvent(padapter, PPacketIrpEvent, len+2);
1835 
1836 	return status;
1837 }
1838 
1839 static enum hci_status
bthci_CmdWritePageTimeout(struct rtw_adapter * padapter,struct packet_irp_hcicmd_data * pHciCmd)1840 bthci_CmdWritePageTimeout(
1841 	struct rtw_adapter *padapter,
1842 	struct packet_irp_hcicmd_data *pHciCmd
1843 	)
1844 {
1845 	enum hci_status		status = HCI_STATUS_SUCCESS;
1846 	struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
1847 	struct bt_hci_info *pBtHciInfo = &pBTInfo->BtHciInfo;
1848 	u16	*pu2Temp;
1849 
1850 	pu2Temp = (u16 *)&pHciCmd->Data[0];
1851 	pBtHciInfo->PageTimeout = *pu2Temp;
1852 	RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("Write PageTimeout = 0x%x\n",
1853 		pBtHciInfo->PageTimeout));
1854 
1855 	/* send command complete event here when all data are received. */
1856 	{
1857 		u8 localBuf[6] = "";
1858 		u8 *pRetPar;
1859 		u8 len = 0;
1860 		struct packet_irp_hcievent_data *PPacketIrpEvent;
1861 
1862 		PPacketIrpEvent = (struct packet_irp_hcievent_data *)(&localBuf[0]);
1863 
1864 		len += bthci_CommandCompleteHeader(&localBuf[0],
1865 			OGF_SET_EVENT_MASK_COMMAND,
1866 			HCI_WRITE_PAGE_TIMEOUT,
1867 			status);
1868 
1869 		/*  Return parameters starts from here */
1870 		pRetPar = &PPacketIrpEvent->Data[len];
1871 		pRetPar[0] = status;		/* status */
1872 		len += 1;
1873 		PPacketIrpEvent->Length = len;
1874 
1875 		bthci_IndicateEvent(padapter, PPacketIrpEvent, len+2);
1876 	}
1877 
1878 	return status;
1879 }
1880 
1881 static enum hci_status
bthci_CmdReadLinkSupervisionTimeout(struct rtw_adapter * padapter,struct packet_irp_hcicmd_data * pHciCmd)1882 bthci_CmdReadLinkSupervisionTimeout(
1883 	struct rtw_adapter *padapter,
1884 	struct packet_irp_hcicmd_data *pHciCmd
1885 	)
1886 {
1887 	enum hci_status	status = HCI_STATUS_SUCCESS;
1888 	struct bt_30info *pBTinfo = GET_BT_INFO(padapter);
1889 	u8 physicalLinkHandle, EntryNum;
1890 
1891 	physicalLinkHandle = *((u8 *)pHciCmd->Data);
1892 
1893 	EntryNum = bthci_GetCurrentEntryNum(padapter, physicalLinkHandle);
1894 
1895 	if (EntryNum == 0xff) {
1896 		RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("ReadLinkSupervisionTimeout, No such Handle in the Entry\n"));
1897 		status = HCI_STATUS_UNKNOW_CONNECT_ID;
1898 		return status;
1899 	}
1900 
1901 	if (pBTinfo->BtAsocEntry[EntryNum].PhyLinkCmdData.BtPhyLinkhandle != physicalLinkHandle)
1902 		status = HCI_STATUS_UNKNOW_CONNECT_ID;
1903 
1904 	{
1905 		u8 localBuf[10] = "";
1906 		u8 *pRetPar;
1907 		u8 len = 0;
1908 		struct packet_irp_hcievent_data *PPacketIrpEvent;
1909 		u16 *pu2Temp;
1910 
1911 		PPacketIrpEvent = (struct packet_irp_hcievent_data *)(&localBuf[0]);
1912 
1913 		len += bthci_CommandCompleteHeader(&localBuf[0],
1914 			OGF_SET_EVENT_MASK_COMMAND,
1915 			HCI_READ_LINK_SUPERVISION_TIMEOUT,
1916 			status);
1917 
1918 		/*  Return parameters starts from here */
1919 		pRetPar = &PPacketIrpEvent->Data[len];
1920 		pRetPar[0] = status;
1921 		pRetPar[1] = pBTinfo->BtAsocEntry[EntryNum].PhyLinkCmdData.BtPhyLinkhandle;
1922 		pRetPar[2] = 0;
1923 		pu2Temp = (u16 *)&pRetPar[3];		/*  Conn_Accept_Timeout */
1924 		*pu2Temp = pBTinfo->BtAsocEntry[EntryNum].PhyLinkCmdData.LinkSuperversionTimeout;
1925 		len += 5;
1926 		PPacketIrpEvent->Length = len;
1927 
1928 		bthci_IndicateEvent(padapter, PPacketIrpEvent, len+2);
1929 	}
1930 
1931 	return status;
1932 }
1933 
1934 static enum hci_status
bthci_CmdWriteLinkSupervisionTimeout(struct rtw_adapter * padapter,struct packet_irp_hcicmd_data * pHciCmd)1935 bthci_CmdWriteLinkSupervisionTimeout(
1936 	struct rtw_adapter *padapter,
1937 	struct packet_irp_hcicmd_data *pHciCmd
1938 	)
1939 {
1940 	enum hci_status	status = HCI_STATUS_SUCCESS;
1941 	struct bt_30info *pBTinfo = GET_BT_INFO(padapter);
1942 	u8 physicalLinkHandle, EntryNum;
1943 
1944 	physicalLinkHandle = *((u8 *)pHciCmd->Data);
1945 
1946 	EntryNum = bthci_GetCurrentEntryNum(padapter, physicalLinkHandle);
1947 
1948 	if (EntryNum == 0xff) {
1949 		RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("WriteLinkSupervisionTimeout, No such Handle in the Entry\n"));
1950 		status = HCI_STATUS_UNKNOW_CONNECT_ID;
1951 	} else {
1952 		if (pBTinfo->BtAsocEntry[EntryNum].PhyLinkCmdData.BtPhyLinkhandle != physicalLinkHandle) {
1953 			status = HCI_STATUS_UNKNOW_CONNECT_ID;
1954 		} else {
1955 			pBTinfo->BtAsocEntry[EntryNum].PhyLinkCmdData.LinkSuperversionTimeout = *((u16 *)(((u8 *)pHciCmd->Data)+2));
1956 			RTPRINT(FIOCTL, IOCTL_STATE, ("BT Write LinkSuperversionTimeout[%d] = 0x%x\n",
1957 				EntryNum, pBTinfo->BtAsocEntry[EntryNum].PhyLinkCmdData.LinkSuperversionTimeout));
1958 		}
1959 	}
1960 
1961 	{
1962 		u8 localBuf[8] = "";
1963 		u8 *pRetPar;
1964 		u8 len = 0;
1965 		struct packet_irp_hcievent_data *PPacketIrpEvent;
1966 
1967 		PPacketIrpEvent = (struct packet_irp_hcievent_data *)(&localBuf[0]);
1968 
1969 		len += bthci_CommandCompleteHeader(&localBuf[0],
1970 			OGF_SET_EVENT_MASK_COMMAND,
1971 			HCI_WRITE_LINK_SUPERVISION_TIMEOUT,
1972 			status);
1973 
1974 		/*  Return parameters starts from here */
1975 		pRetPar = &PPacketIrpEvent->Data[len];
1976 		pRetPar[0] = status;
1977 		pRetPar[1] = pBTinfo->BtAsocEntry[EntryNum].PhyLinkCmdData.BtPhyLinkhandle;
1978 		pRetPar[2] = 0;
1979 		len += 3;
1980 		PPacketIrpEvent->Length = len;
1981 
1982 		bthci_IndicateEvent(padapter, PPacketIrpEvent, len+2);
1983 	}
1984 
1985 	return status;
1986 }
1987 
1988 static enum hci_status
bthci_CmdEnhancedFlush(struct rtw_adapter * padapter,struct packet_irp_hcicmd_data * pHciCmd)1989 bthci_CmdEnhancedFlush(
1990 	struct rtw_adapter *padapter,
1991 	struct packet_irp_hcicmd_data *pHciCmd
1992 	)
1993 {
1994 	enum hci_status		status = HCI_STATUS_SUCCESS;
1995 	struct bt_30info *pBTinfo = GET_BT_INFO(padapter);
1996 	struct bt_hci_info *pBtHciInfo = &pBTinfo->BtHciInfo;
1997 	u16		logicHandle;
1998 	u8 Packet_Type;
1999 
2000 	logicHandle = *((u16 *)&pHciCmd->Data[0]);
2001 	Packet_Type = pHciCmd->Data[2];
2002 
2003 	if (Packet_Type != 0)
2004 		status = HCI_STATUS_INVALID_HCI_CMD_PARA_VALUE;
2005 	else
2006 		pBtHciInfo->enFlush_LLH = logicHandle;
2007 
2008 	if (bthci_DiscardTxPackets(padapter, pBtHciInfo->enFlush_LLH))
2009 		bthci_EventFlushOccurred(padapter, pBtHciInfo->enFlush_LLH);
2010 
2011 	/*  should send command status event */
2012 	bthci_EventCommandStatus(padapter,
2013 			OGF_SET_EVENT_MASK_COMMAND,
2014 			HCI_ENHANCED_FLUSH,
2015 			status);
2016 
2017 	if (pBtHciInfo->enFlush_LLH) {
2018 		bthci_EventEnhancedFlushComplete(padapter, pBtHciInfo->enFlush_LLH);
2019 		pBtHciInfo->enFlush_LLH = 0;
2020 	}
2021 
2022 	return status;
2023 }
2024 
2025 static enum hci_status
bthci_CmdReadLogicalLinkAcceptTimeout(struct rtw_adapter * padapter,struct packet_irp_hcicmd_data * pHciCmd)2026 bthci_CmdReadLogicalLinkAcceptTimeout(
2027 	struct rtw_adapter *padapter,
2028 	struct packet_irp_hcicmd_data *pHciCmd
2029 	)
2030 {
2031 	enum hci_status		status = HCI_STATUS_SUCCESS;
2032 /*PMGNT_INFO		pMgntInfo = &padapter->MgntInfo; */
2033 	struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
2034 	struct bt_hci_info *pBtHciInfo = &pBTInfo->BtHciInfo;
2035 	u8 localBuf[8] = "";
2036 	u8 *pRetPar;
2037 	u8 len = 0;
2038 	struct packet_irp_hcievent_data *PPacketIrpEvent;
2039 	u16 *pu2Temp;
2040 
2041 	PPacketIrpEvent = (struct packet_irp_hcievent_data *)(&localBuf[0]);
2042 
2043 	len += bthci_CommandCompleteHeader(&localBuf[0],
2044 		OGF_SET_EVENT_MASK_COMMAND,
2045 		HCI_READ_LOGICAL_LINK_ACCEPT_TIMEOUT,
2046 		status);
2047 
2048 	/*  Return parameters starts from here */
2049 	pRetPar = &PPacketIrpEvent->Data[len];
2050 	pRetPar[0] = status;
2051 
2052 	pu2Temp = (u16 *)&pRetPar[1];		/*  Conn_Accept_Timeout */
2053 	*pu2Temp = pBtHciInfo->LogicalAcceptTimeout;
2054 	len += 3;
2055 	PPacketIrpEvent->Length = len;
2056 
2057 	bthci_IndicateEvent(padapter, PPacketIrpEvent, len+2);
2058 
2059 	return status;
2060 }
2061 
2062 static enum hci_status
bthci_CmdWriteLogicalLinkAcceptTimeout(struct rtw_adapter * padapter,struct packet_irp_hcicmd_data * pHciCmd)2063 bthci_CmdWriteLogicalLinkAcceptTimeout(
2064 	struct rtw_adapter *padapter,
2065 	struct packet_irp_hcicmd_data *pHciCmd
2066 	)
2067 {
2068 	enum hci_status		status = HCI_STATUS_SUCCESS;
2069 /*PMGNT_INFO		pMgntInfo = &padapter->MgntInfo; */
2070 	struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
2071 	struct bt_hci_info *pBtHciInfo = &pBTInfo->BtHciInfo;
2072 	u8 localBuf[6] = "";
2073 	u8 *pRetPar;
2074 	u8 len = 0;
2075 	struct packet_irp_hcievent_data *PPacketIrpEvent;
2076 
2077 	pBtHciInfo->LogicalAcceptTimeout = *((u16 *)pHciCmd->Data);
2078 
2079 	PPacketIrpEvent = (struct packet_irp_hcievent_data *)(&localBuf[0]);
2080 
2081 	len += bthci_CommandCompleteHeader(&localBuf[0],
2082 		OGF_SET_EVENT_MASK_COMMAND,
2083 		HCI_WRITE_LOGICAL_LINK_ACCEPT_TIMEOUT,
2084 		status);
2085 
2086 	/*  Return parameters starts from here */
2087 	pRetPar = &PPacketIrpEvent->Data[len];
2088 	pRetPar[0] = status;
2089 
2090 	len += 1;
2091 	PPacketIrpEvent->Length = len;
2092 
2093 	bthci_IndicateEvent(padapter, PPacketIrpEvent, len+2);
2094 	return status;
2095 }
2096 
2097 static enum hci_status
bthci_CmdSetEventMask(struct rtw_adapter * padapter,struct packet_irp_hcicmd_data * pHciCmd)2098 bthci_CmdSetEventMask(
2099 	struct rtw_adapter *padapter,
2100 	struct packet_irp_hcicmd_data *pHciCmd
2101 	)
2102 {
2103 	enum hci_status		status = HCI_STATUS_SUCCESS;
2104 /*PMGNT_INFO		pMgntInfo = &padapter->MgntInfo; */
2105 	struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
2106 	struct bt_hci_info *pBtHciInfo = &pBTInfo->BtHciInfo;
2107 	u8 *pu8Temp;
2108 	u8 localBuf[6] = "";
2109 	u8 *pRetPar;
2110 	u8 len = 0;
2111 	struct packet_irp_hcievent_data *PPacketIrpEvent;
2112 
2113 	pu8Temp = (u8 *)&pHciCmd->Data[0];
2114 	pBtHciInfo->BTEventMask = *pu8Temp;
2115 	RTPRINT(FIOCTL, IOCTL_BT_HCICMD_DETAIL, ("BTEventMask = 0x%"i64fmt"x\n",
2116 		pBtHciInfo->BTEventMask));
2117 
2118 	/* send command complete event here when all data are received. */
2119 	PPacketIrpEvent = (struct packet_irp_hcievent_data *)(&localBuf[0]);
2120 
2121 	len += bthci_CommandCompleteHeader(&localBuf[0],
2122 		OGF_SET_EVENT_MASK_COMMAND,
2123 		HCI_SET_EVENT_MASK,
2124 		status);
2125 
2126 	/*  Return parameters starts from here */
2127 	pRetPar = &PPacketIrpEvent->Data[len];
2128 	pRetPar[0] = status;		/* status */
2129 	len += 1;
2130 	PPacketIrpEvent->Length = len;
2131 
2132 	bthci_IndicateEvent(padapter, PPacketIrpEvent, len+2);
2133 
2134 	return status;
2135 }
2136 
2137 /*  7.3.69 */
2138 static enum hci_status
bthci_CmdSetEventMaskPage2(struct rtw_adapter * padapter,struct packet_irp_hcicmd_data * pHciCmd)2139 bthci_CmdSetEventMaskPage2(
2140 	struct rtw_adapter *padapter,
2141 	struct packet_irp_hcicmd_data *pHciCmd
2142 	)
2143 {
2144 	enum hci_status		status = HCI_STATUS_SUCCESS;
2145 	struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
2146 	struct bt_hci_info *pBtHciInfo = &pBTInfo->BtHciInfo;
2147 	u8 *pu8Temp;
2148 	u8 localBuf[6] = "";
2149 	u8 *pRetPar;
2150 	u8 len = 0;
2151 	struct packet_irp_hcievent_data *PPacketIrpEvent;
2152 
2153 	pu8Temp = (u8 *)&pHciCmd->Data[0];
2154 	pBtHciInfo->BTEventMaskPage2 = *pu8Temp;
2155 	RTPRINT(FIOCTL, (IOCTL_BT_HCICMD_DETAIL|IOCTL_BT_LOGO), ("BTEventMaskPage2 = 0x%"i64fmt"x\n",
2156 		pBtHciInfo->BTEventMaskPage2));
2157 
2158 	/* send command complete event here when all data are received. */
2159 	PPacketIrpEvent = (struct packet_irp_hcievent_data *)(&localBuf[0]);
2160 
2161 	len += bthci_CommandCompleteHeader(&localBuf[0],
2162 		OGF_SET_EVENT_MASK_COMMAND,
2163 		HCI_SET_EVENT_MASK_PAGE_2,
2164 		status);
2165 
2166 	/*  Return parameters starts from here */
2167 	pRetPar = &PPacketIrpEvent->Data[len];
2168 	pRetPar[0] = status;		/* status */
2169 	len += 1;
2170 	PPacketIrpEvent->Length = len;
2171 
2172 	bthci_IndicateEvent(padapter, PPacketIrpEvent, len+2);
2173 
2174 	return status;
2175 }
2176 
2177 static enum hci_status
bthci_CmdReadLocationData(struct rtw_adapter * padapter,struct packet_irp_hcicmd_data * pHciCmd)2178 bthci_CmdReadLocationData(
2179 	struct rtw_adapter *padapter,
2180 	struct packet_irp_hcicmd_data *pHciCmd
2181 	)
2182 {
2183 	enum hci_status		status = HCI_STATUS_SUCCESS;
2184 	struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
2185 	struct bt_hci_info *pBtHciInfo = &pBTInfo->BtHciInfo;
2186 	u8 localBuf[12] = "";
2187 	u8 *pRetPar;
2188 	u8 len = 0;
2189 	struct packet_irp_hcievent_data *PPacketIrpEvent;
2190 	u16 *pu2Temp;
2191 
2192 	PPacketIrpEvent = (struct packet_irp_hcievent_data *)(&localBuf[0]);
2193 
2194 	len += bthci_CommandCompleteHeader(&localBuf[0],
2195 		OGF_SET_EVENT_MASK_COMMAND,
2196 		HCI_READ_LOCATION_DATA,
2197 		status);
2198 	RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("DomainAware = 0x%x\n", pBtHciInfo->LocationDomainAware));
2199 	RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("Domain = 0x%x\n", pBtHciInfo->LocationDomain));
2200 	RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("DomainOptions = 0x%x\n", pBtHciInfo->LocationDomainOptions));
2201 	RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("Options = 0x%x\n", pBtHciInfo->LocationOptions));
2202 
2203 	/*  Return parameters starts from here */
2204 	pRetPar = &PPacketIrpEvent->Data[len];
2205 	pRetPar[0] = status;
2206 
2207 	pRetPar[1] = pBtHciInfo->LocationDomainAware;	/* 0x0;	 Location_Domain_Aware */
2208 	pu2Temp = (u16 *)&pRetPar[2];					/*  Location_Domain */
2209 	*pu2Temp = pBtHciInfo->LocationDomain;		/* 0x5858; */
2210 	pRetPar[4] = pBtHciInfo->LocationDomainOptions;	/* 0x58;	Location_Domain_Options */
2211 	pRetPar[5] = pBtHciInfo->LocationOptions;		/* 0x0;	Location_Options */
2212 	len += 6;
2213 	PPacketIrpEvent->Length = len;
2214 
2215 	bthci_IndicateEvent(padapter, PPacketIrpEvent, len+2);
2216 	return status;
2217 }
2218 
2219 static enum hci_status
bthci_CmdWriteLocationData(struct rtw_adapter * padapter,struct packet_irp_hcicmd_data * pHciCmd)2220 bthci_CmdWriteLocationData(
2221 	struct rtw_adapter *padapter,
2222 	struct packet_irp_hcicmd_data *pHciCmd
2223 	)
2224 {
2225 	enum hci_status status = HCI_STATUS_SUCCESS;
2226 	struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
2227 	struct bt_hci_info *pBtHciInfo = &pBTInfo->BtHciInfo;
2228 	u16	*pu2Temp;
2229 	u8 localBuf[6] = "";
2230 	u8 *pRetPar;
2231 	u8 len = 0;
2232 	struct packet_irp_hcievent_data *PPacketIrpEvent;
2233 
2234 	pBtHciInfo->LocationDomainAware = pHciCmd->Data[0];
2235 	pu2Temp = (u16 *)&pHciCmd->Data[1];
2236 	pBtHciInfo->LocationDomain = *pu2Temp;
2237 	pBtHciInfo->LocationDomainOptions = pHciCmd->Data[3];
2238 	pBtHciInfo->LocationOptions = pHciCmd->Data[4];
2239 	RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("DomainAware = 0x%x\n", pBtHciInfo->LocationDomainAware));
2240 	RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("Domain = 0x%x\n", pBtHciInfo->LocationDomain));
2241 	RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("DomainOptions = 0x%x\n", pBtHciInfo->LocationDomainOptions));
2242 	RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("Options = 0x%x\n", pBtHciInfo->LocationOptions));
2243 
2244 	/* send command complete event here when all data are received. */
2245 	PPacketIrpEvent = (struct packet_irp_hcievent_data *)(&localBuf[0]);
2246 
2247 	len += bthci_CommandCompleteHeader(&localBuf[0],
2248 		OGF_SET_EVENT_MASK_COMMAND,
2249 		HCI_WRITE_LOCATION_DATA,
2250 		status);
2251 
2252 	/*  Return parameters starts from here */
2253 	pRetPar = &PPacketIrpEvent->Data[len];
2254 	pRetPar[0] = status;		/* status */
2255 	len += 1;
2256 	PPacketIrpEvent->Length = len;
2257 
2258 	bthci_IndicateEvent(padapter, PPacketIrpEvent, len+2);
2259 
2260 	return status;
2261 }
2262 
2263 static enum hci_status
bthci_CmdReadFlowControlMode(struct rtw_adapter * padapter,struct packet_irp_hcicmd_data * pHciCmd)2264 bthci_CmdReadFlowControlMode(
2265 	struct rtw_adapter *padapter,
2266 	struct packet_irp_hcicmd_data *pHciCmd
2267 	)
2268 {
2269 	enum hci_status status = HCI_STATUS_SUCCESS;
2270 	struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
2271 	struct bt_hci_info *pBtHciInfo = &pBTInfo->BtHciInfo;
2272 	u8 localBuf[7] = "";
2273 	u8 *pRetPar;
2274 	u8 len = 0;
2275 	struct packet_irp_hcievent_data *PPacketIrpEvent;
2276 
2277 	PPacketIrpEvent = (struct packet_irp_hcievent_data *)(&localBuf[0]);
2278 
2279 	len += bthci_CommandCompleteHeader(&localBuf[0],
2280 		OGF_SET_EVENT_MASK_COMMAND,
2281 		HCI_READ_FLOW_CONTROL_MODE,
2282 		status);
2283 
2284 	/*  Return parameters starts from here */
2285 	pRetPar = &PPacketIrpEvent->Data[len];
2286 	pRetPar[0] = status;
2287 	pRetPar[1] = pBtHciInfo->FlowControlMode;	/*  Flow Control Mode */
2288 	len += 2;
2289 	PPacketIrpEvent->Length = len;
2290 
2291 	bthci_IndicateEvent(padapter, PPacketIrpEvent, len+2);
2292 	return status;
2293 }
2294 
2295 static enum hci_status
bthci_CmdWriteFlowControlMode(struct rtw_adapter * padapter,struct packet_irp_hcicmd_data * pHciCmd)2296 bthci_CmdWriteFlowControlMode(
2297 	struct rtw_adapter *padapter,
2298 	struct packet_irp_hcicmd_data *pHciCmd
2299 	)
2300 {
2301 	enum hci_status status = HCI_STATUS_SUCCESS;
2302 	struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
2303 	struct bt_hci_info *pBtHciInfo = &pBTInfo->BtHciInfo;
2304 	u8 localBuf[6] = "";
2305 	u8 *pRetPar;
2306 	u8 len = 0;
2307 	struct packet_irp_hcievent_data *PPacketIrpEvent;
2308 
2309 	pBtHciInfo->FlowControlMode = pHciCmd->Data[0];
2310 
2311 	/* send command complete event here when all data are received. */
2312 	PPacketIrpEvent = (struct packet_irp_hcievent_data *)(&localBuf[0]);
2313 
2314 	len += bthci_CommandCompleteHeader(&localBuf[0],
2315 		OGF_SET_EVENT_MASK_COMMAND,
2316 		HCI_WRITE_FLOW_CONTROL_MODE,
2317 		status);
2318 
2319 	/*  Return parameters starts from here */
2320 	pRetPar = &PPacketIrpEvent->Data[len];
2321 	pRetPar[0] = status;		/* status */
2322 	len += 1;
2323 	PPacketIrpEvent->Length = len;
2324 
2325 	bthci_IndicateEvent(padapter, PPacketIrpEvent, len+2);
2326 
2327 	return status;
2328 }
2329 
2330 static enum hci_status
bthci_CmdReadBestEffortFlushTimeout(struct rtw_adapter * padapter,struct packet_irp_hcicmd_data * pHciCmd)2331 bthci_CmdReadBestEffortFlushTimeout(
2332 	struct rtw_adapter *padapter,
2333 	struct packet_irp_hcicmd_data *pHciCmd
2334 	)
2335 {
2336 	enum hci_status status = HCI_STATUS_SUCCESS;
2337 	struct bt_30info *pBTinfo = GET_BT_INFO(padapter);
2338 	u16 i, j, logicHandle;
2339 	u32 BestEffortFlushTimeout = 0xffffffff;
2340 	u8 find = 0;
2341 
2342 	logicHandle = *((u16 *)pHciCmd->Data);
2343 	/*  find an matched logical link index and copy the data */
2344 	for (j = 0; j < MAX_BT_ASOC_ENTRY_NUM; j++) {
2345 		for (i = 0; i < MAX_LOGICAL_LINK_NUM; i++) {
2346 			if (pBTinfo->BtAsocEntry[j].LogLinkCmdData[i].BtLogLinkhandle == logicHandle) {
2347 				BestEffortFlushTimeout = pBTinfo->BtAsocEntry[j].LogLinkCmdData[i].BestEffortFlushTimeout;
2348 				find = 1;
2349 				break;
2350 			}
2351 		}
2352 	}
2353 
2354 	if (!find)
2355 		status = HCI_STATUS_UNKNOW_CONNECT_ID;
2356 
2357 	{
2358 		u8 localBuf[10] = "";
2359 		u8 *pRetPar;
2360 		u8 len = 0;
2361 		struct packet_irp_hcievent_data *PPacketIrpEvent;
2362 		u32 *pu4Temp;
2363 
2364 		PPacketIrpEvent = (struct packet_irp_hcievent_data *)(&localBuf[0]);
2365 
2366 		len += bthci_CommandCompleteHeader(&localBuf[0],
2367 			OGF_SET_EVENT_MASK_COMMAND,
2368 			HCI_READ_BEST_EFFORT_FLUSH_TIMEOUT,
2369 			status);
2370 
2371 		/*  Return parameters starts from here */
2372 		pRetPar = &PPacketIrpEvent->Data[len];
2373 		pRetPar[0] = status;
2374 		pu4Temp = (u32 *)&pRetPar[1];	/*  Best_Effort_Flush_Timeout */
2375 		*pu4Temp = BestEffortFlushTimeout;
2376 		len += 5;
2377 		PPacketIrpEvent->Length = len;
2378 
2379 		bthci_IndicateEvent(padapter, PPacketIrpEvent, len+2);
2380 	}
2381 	return status;
2382 }
2383 
2384 static enum hci_status
bthci_CmdWriteBestEffortFlushTimeout(struct rtw_adapter * padapter,struct packet_irp_hcicmd_data * pHciCmd)2385 bthci_CmdWriteBestEffortFlushTimeout(
2386 	struct rtw_adapter *padapter,
2387 	struct packet_irp_hcicmd_data *pHciCmd
2388 	)
2389 {
2390 	enum hci_status status = HCI_STATUS_SUCCESS;
2391 	struct bt_30info *pBTinfo = GET_BT_INFO(padapter);
2392 	u16 i, j, logicHandle;
2393 	u32 BestEffortFlushTimeout = 0xffffffff;
2394 	u8 find = 0;
2395 
2396 	logicHandle = *((u16 *)pHciCmd->Data);
2397 	BestEffortFlushTimeout = *((u32 *)(pHciCmd->Data+1));
2398 
2399 	/*  find an matched logical link index and copy the data */
2400 	for (j = 0; j < MAX_BT_ASOC_ENTRY_NUM; j++) {
2401 		for (i = 0; i < MAX_LOGICAL_LINK_NUM; i++) {
2402 			if (pBTinfo->BtAsocEntry[j].LogLinkCmdData[i].BtLogLinkhandle == logicHandle) {
2403 				pBTinfo->BtAsocEntry[j].LogLinkCmdData[i].BestEffortFlushTimeout = BestEffortFlushTimeout;
2404 				find = 1;
2405 				break;
2406 			}
2407 		}
2408 	}
2409 
2410 	if (!find)
2411 		status = HCI_STATUS_UNKNOW_CONNECT_ID;
2412 
2413 	{
2414 		u8 localBuf[6] = "";
2415 		u8 *pRetPar;
2416 		u8 len = 0;
2417 		struct packet_irp_hcievent_data *PPacketIrpEvent;
2418 
2419 		PPacketIrpEvent = (struct packet_irp_hcievent_data *)(&localBuf[0]);
2420 
2421 		len += bthci_CommandCompleteHeader(&localBuf[0],
2422 			OGF_SET_EVENT_MASK_COMMAND,
2423 			HCI_WRITE_BEST_EFFORT_FLUSH_TIMEOUT,
2424 			status);
2425 
2426 		/*  Return parameters starts from here */
2427 		pRetPar = &PPacketIrpEvent->Data[len];
2428 		pRetPar[0] = status;
2429 		len += 1;
2430 		PPacketIrpEvent->Length = len;
2431 
2432 		bthci_IndicateEvent(padapter, PPacketIrpEvent, len+2);
2433 	}
2434 	return status;
2435 }
2436 
2437 static enum hci_status
bthci_CmdShortRangeMode(struct rtw_adapter * padapter,struct packet_irp_hcicmd_data * pHciCmd)2438 bthci_CmdShortRangeMode(
2439 	struct rtw_adapter *padapter,
2440 	struct packet_irp_hcicmd_data *pHciCmd
2441 	)
2442 {
2443 	enum hci_status status = HCI_STATUS_SUCCESS;
2444 	struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
2445 	u8 PhyLinkHandle, EntryNum, ShortRangeMode;
2446 
2447 	PhyLinkHandle = pHciCmd->Data[0];
2448 	ShortRangeMode = pHciCmd->Data[1];
2449 	RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("PLH = 0x%x, Short_Range_Mode = 0x%x\n", PhyLinkHandle, ShortRangeMode));
2450 
2451 	EntryNum = bthci_GetCurrentEntryNum(padapter, PhyLinkHandle);
2452 	if (EntryNum != 0xff) {
2453 		pBTInfo->BtAsocEntry[EntryNum].ShortRangeMode = ShortRangeMode;
2454 	} else {
2455 		RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("No such PLH(0x%x)\n", PhyLinkHandle));
2456 		status = HCI_STATUS_UNKNOW_CONNECT_ID;
2457 	}
2458 
2459 	bthci_EventCommandStatus(padapter,
2460 			OGF_SET_EVENT_MASK_COMMAND,
2461 			HCI_SHORT_RANGE_MODE,
2462 			status);
2463 
2464 	bthci_EventShortRangeModeChangeComplete(padapter, status, ShortRangeMode, EntryNum);
2465 
2466 	return status;
2467 }
2468 
bthci_CmdReadLocalSupportedCommands(struct rtw_adapter * padapter)2469 static enum hci_status bthci_CmdReadLocalSupportedCommands(struct rtw_adapter *padapter)
2470 {
2471 	enum hci_status status = HCI_STATUS_SUCCESS;
2472 	u8 localBuf[TmpLocalBufSize] = "";
2473 	u8 *pRetPar, *pSupportedCmds;
2474 	u8 len = 0;
2475 	struct packet_irp_hcievent_data *PPacketIrpEvent;
2476 
2477 	/*  send command complete event here when all data are received. */
2478 	PlatformZeroMemory(&localBuf[0], TmpLocalBufSize);
2479 	PPacketIrpEvent = (struct packet_irp_hcievent_data *)(&localBuf[0]);
2480 
2481 	len += bthci_CommandCompleteHeader(&localBuf[0],
2482 		OGF_INFORMATIONAL_PARAMETERS,
2483 		HCI_READ_LOCAL_SUPPORTED_COMMANDS,
2484 		status);
2485 
2486 	/*  Return parameters starts from here */
2487 	pRetPar = &PPacketIrpEvent->Data[len];
2488 	pRetPar[0] = status;		/* status */
2489 	len += 1;
2490 	pSupportedCmds = &pRetPar[1];
2491 	RTPRINT(FIOCTL, (IOCTL_BT_HCICMD|IOCTL_BT_LOGO), ("Octet[5]= 0xc0\nBit [6]= Set Event Mask, [7]= Reset\n"));
2492 	pSupportedCmds[5] = 0xc0;
2493 	RTPRINT(FIOCTL, (IOCTL_BT_HCICMD|IOCTL_BT_LOGO), ("Octet[6]= 0x01\nBit [0]= Set Event Filter\n"));
2494 	pSupportedCmds[6] = 0x01;
2495 	RTPRINT(FIOCTL, (IOCTL_BT_HCICMD|IOCTL_BT_LOGO), ("Octet[7]= 0x0c\nBit [2]= Read Connection Accept Timeout, [3]= Write Connection Accept Timeout\n"));
2496 	pSupportedCmds[7] = 0x0c;
2497 	RTPRINT(FIOCTL, (IOCTL_BT_HCICMD|IOCTL_BT_LOGO), ("Octet[10]= 0x80\nBit [7]= Host Number Of Completed Packets\n"));
2498 	pSupportedCmds[10] = 0x80;
2499 	RTPRINT(FIOCTL, (IOCTL_BT_HCICMD|IOCTL_BT_LOGO), ("Octet[11]= 0x03\nBit [0]= Read Link Supervision Timeout, [1]= Write Link Supervision Timeout\n"));
2500 	pSupportedCmds[11] = 0x03;
2501 	RTPRINT(FIOCTL, (IOCTL_BT_HCICMD|IOCTL_BT_LOGO), ("Octet[14]= 0xa8\nBit [3]= Read Local Version Information, [5]= Read Local Supported Features, [7]= Read Buffer Size\n"));
2502 	pSupportedCmds[14] = 0xa8;
2503 	RTPRINT(FIOCTL, (IOCTL_BT_HCICMD|IOCTL_BT_LOGO), ("Octet[15]= 0x1c\nBit [2]= Read Failed Contact Count, [3]= Reset Failed Contact Count, [4]= Get Link Quality\n"));
2504 	pSupportedCmds[15] = 0x1c;
2505 	/* pSupportedCmds[16] = 0x04; */
2506 	RTPRINT(FIOCTL, (IOCTL_BT_HCICMD|IOCTL_BT_LOGO), ("Octet[19]= 0x40\nBit [6]= Enhanced Flush\n"));
2507 	pSupportedCmds[19] = 0x40;
2508 	RTPRINT(FIOCTL, (IOCTL_BT_HCICMD|IOCTL_BT_LOGO), ("Octet[21]= 0xff\nBit [0]= Create Physical Link, [1]= Accept Physical Link, [2]= Disconnect Physical Link, [3]= Create Logical Link\n"));
2509 	RTPRINT(FIOCTL, (IOCTL_BT_HCICMD|IOCTL_BT_LOGO), ("	[4]= Accept Logical Link, [5]= Disconnect Logical Link, [6]= Logical Link Cancel, [7]= Flow Spec Modify\n"));
2510 	pSupportedCmds[21] = 0xff;
2511 	RTPRINT(FIOCTL, (IOCTL_BT_HCICMD|IOCTL_BT_LOGO), ("Octet[22]= 0xff\nBit [0]= Read Logical Link Accept Timeout, [1]= Write Logical Link Accept Timeout, [2]= Set Event Mask Page 2, [3]= Read Location Data\n"));
2512 	RTPRINT(FIOCTL, (IOCTL_BT_HCICMD|IOCTL_BT_LOGO), ("	[4]= Write Location Data, [5]= Read Local AMP Info, [6]= Read Local AMP_ASSOC, [7]= Write Remote AMP_ASSOC\n"));
2513 	pSupportedCmds[22] = 0xff;
2514 	RTPRINT(FIOCTL, (IOCTL_BT_HCICMD|IOCTL_BT_LOGO), ("Octet[23]= 0x07\nBit [0]= Read Flow Control Mode, [1]= Write Flow Control Mode, [2]= Read Data Block Size\n"));
2515 	pSupportedCmds[23] = 0x07;
2516 	RTPRINT(FIOCTL, (IOCTL_BT_HCICMD|IOCTL_BT_LOGO), ("Octet[24]= 0x1c\nBit [2]= Read Best Effort Flush Timeout, [3]= Write Best Effort Flush Timeout, [4]= Short Range Mode\n"));
2517 	pSupportedCmds[24] = 0x1c;
2518 	len += 64;
2519 	PPacketIrpEvent->Length = len;
2520 
2521 	bthci_IndicateEvent(padapter, PPacketIrpEvent, len+2);
2522 
2523 	return status;
2524 }
2525 
bthci_CmdReadLocalSupportedFeatures(struct rtw_adapter * padapter)2526 static enum hci_status bthci_CmdReadLocalSupportedFeatures(struct rtw_adapter *padapter)
2527 {
2528 	enum hci_status status = HCI_STATUS_SUCCESS;
2529 	u8 localBuf[TmpLocalBufSize] = "";
2530 	u8 *pRetPar;
2531 	u8 len = 0;
2532 	struct packet_irp_hcievent_data *PPacketIrpEvent;
2533 
2534 	/* send command complete event here when all data are received. */
2535 	PlatformZeroMemory(&localBuf[0], TmpLocalBufSize);
2536 	PPacketIrpEvent = (struct packet_irp_hcievent_data *)(&localBuf[0]);
2537 
2538 	len += bthci_CommandCompleteHeader(&localBuf[0],
2539 		OGF_INFORMATIONAL_PARAMETERS,
2540 		HCI_READ_LOCAL_SUPPORTED_FEATURES,
2541 		status);
2542 
2543 	/*  Return parameters starts from here */
2544 	pRetPar = &PPacketIrpEvent->Data[len];
2545 	pRetPar[0] = status;		/* status */
2546 	len += 9;
2547 	PPacketIrpEvent->Length = len;
2548 
2549 	bthci_IndicateEvent(padapter, PPacketIrpEvent, len+2);
2550 	return status;
2551 }
2552 
bthci_CmdReadLocalAMPAssoc(struct rtw_adapter * padapter,struct packet_irp_hcicmd_data * pHciCmd)2553 static enum hci_status bthci_CmdReadLocalAMPAssoc(struct rtw_adapter *padapter,
2554 	struct packet_irp_hcicmd_data *pHciCmd)
2555 {
2556 	enum hci_status status = HCI_STATUS_SUCCESS;
2557 	struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
2558 	struct bt_mgnt *pBtMgnt = &pBTInfo->BtMgnt;
2559 	struct bt_dgb *pBtDbg = &pBTInfo->BtDbg;
2560 	u8 PhyLinkHandle, EntryNum;
2561 
2562 	pBtDbg->dbgHciInfo.hciCmdCntReadLocalAmpAssoc++;
2563 	PhyLinkHandle = *((u8 *)pHciCmd->Data);
2564 	EntryNum = bthci_GetCurrentEntryNum(padapter, PhyLinkHandle);
2565 
2566 	if ((EntryNum == 0xff) && PhyLinkHandle != 0) {
2567 		RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("ReadLocalAMPAssoc, EntryNum = %d  !!!!!, physical link handle = 0x%x\n",
2568 		EntryNum, PhyLinkHandle));
2569 		status = HCI_STATUS_UNKNOW_CONNECT_ID;
2570 	} else if (pBtMgnt->bPhyLinkInProgressStartLL) {
2571 		status = HCI_STATUS_UNKNOW_CONNECT_ID;
2572 		pBtMgnt->bPhyLinkInProgressStartLL = false;
2573 	} else {
2574 		pBTInfo->BtAsocEntry[EntryNum].AmpAsocCmdData.BtPhyLinkhandle = *((u8 *)pHciCmd->Data);
2575 		pBTInfo->BtAsocEntry[EntryNum].AmpAsocCmdData.LenSoFar = *((u16 *)((u8 *)pHciCmd->Data+1));
2576 		pBTInfo->BtAsocEntry[EntryNum].AmpAsocCmdData.MaxRemoteASSOCLen = *((u16 *)((u8 *)pHciCmd->Data+3));
2577 		RTPRINT(FIOCTL, IOCTL_BT_HCICMD_DETAIL, ("ReadLocalAMPAssoc, LenSoFar =%d, MaxRemoteASSOCLen =%d\n",
2578 			pBTInfo->BtAsocEntry[EntryNum].AmpAsocCmdData.LenSoFar,
2579 			pBTInfo->BtAsocEntry[EntryNum].AmpAsocCmdData.MaxRemoteASSOCLen));
2580 	}
2581 
2582 	RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("ReadLocalAMPAssoc, EntryNum = %d  !!!!!, physical link handle = 0x%x, LengthSoFar = %x  \n",
2583 		EntryNum, PhyLinkHandle, pBTInfo->BtAsocEntry[EntryNum].AmpAsocCmdData.LenSoFar));
2584 
2585 	/* send command complete event here when all data are received. */
2586 	{
2587 		struct packet_irp_hcievent_data *PPacketIrpEvent;
2588 
2589 		/* PVOID buffer = padapter->IrpHCILocalbuf.Ptr; */
2590 		u8 localBuf[TmpLocalBufSize] = "";
2591 		u16	*pRemainLen;
2592 		u32	totalLen = 0;
2593 		u16	typeLen = 0, remainLen = 0, ret_index = 0;
2594 		u8 *pRetPar;
2595 
2596 		PlatformZeroMemory(&localBuf[0], TmpLocalBufSize);
2597 		/* PPacketIrpEvent = (struct packet_irp_hcievent_data *)(buffer); */
2598 		PPacketIrpEvent = (struct packet_irp_hcievent_data *)(&localBuf[0]);
2599 
2600 		totalLen += bthci_CommandCompleteHeader(&localBuf[0],
2601 			OGF_STATUS_PARAMETERS,
2602 			HCI_READ_LOCAL_AMP_ASSOC,
2603 			status);
2604 		RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("ReadLocalAMPAssoc, Remaining_Len =%d  \n", remainLen));
2605 		/*  Return parameters starts from here */
2606 		pRetPar = &PPacketIrpEvent->Data[totalLen];
2607 		pRetPar[0] = status;		/* status */
2608 		pRetPar[1] = *((u8 *)pHciCmd->Data);
2609 		pRemainLen = (u16 *)&pRetPar[2];	/* AMP_ASSOC_Remaining_Length */
2610 		totalLen += 4;	/* 0]~[3] */
2611 		ret_index = 4;
2612 
2613 		typeLen = bthci_AssocMACAddr(padapter, &pRetPar[ret_index]);
2614 		totalLen += typeLen;
2615 		remainLen += typeLen;
2616 		ret_index += typeLen;
2617 		typeLen = bthci_AssocPreferredChannelList(padapter, &pRetPar[ret_index], EntryNum);
2618 		totalLen += typeLen;
2619 		remainLen += typeLen;
2620 		ret_index += typeLen;
2621 		typeLen = bthci_PALCapabilities(padapter, &pRetPar[ret_index]);
2622 		totalLen += typeLen;
2623 		remainLen += typeLen;
2624 		ret_index += typeLen;
2625 		typeLen = bthci_AssocPALVer(padapter, &pRetPar[ret_index]);
2626 		totalLen += typeLen;
2627 		remainLen += typeLen;
2628 		PPacketIrpEvent->Length = (u8)totalLen;
2629 		*pRemainLen = remainLen;	/*  AMP_ASSOC_Remaining_Length */
2630 		RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("ReadLocalAMPAssoc, Remaining_Len =%d  \n", remainLen));
2631 		RTPRINT_DATA(FIOCTL, (IOCTL_BT_HCICMD_DETAIL|IOCTL_BT_LOGO), ("AMP_ASSOC_fragment : \n"), PPacketIrpEvent->Data, totalLen);
2632 
2633 		bthci_IndicateEvent(padapter, PPacketIrpEvent, totalLen+2);
2634 	}
2635 
2636 	return status;
2637 }
2638 
bthci_CmdReadFailedContactCounter(struct rtw_adapter * padapter,struct packet_irp_hcicmd_data * pHciCmd)2639 static enum hci_status bthci_CmdReadFailedContactCounter(struct rtw_adapter *padapter,
2640 		       struct packet_irp_hcicmd_data *pHciCmd)
2641 {
2642 
2643 	enum hci_status		status = HCI_STATUS_SUCCESS;
2644 	struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
2645 	struct bt_hci_info *pBtHciInfo = &pBTInfo->BtHciInfo;
2646 	u8 localBuf[TmpLocalBufSize] = "";
2647 	u8 *pRetPar;
2648 	u8 len = 0;
2649 	struct packet_irp_hcievent_data *PPacketIrpEvent;
2650 	u16 handle;
2651 
2652 	handle = *((u16 *)pHciCmd->Data);
2653 	/* send command complete event here when all data are received. */
2654 	PlatformZeroMemory(&localBuf[0], TmpLocalBufSize);
2655 	PPacketIrpEvent = (struct packet_irp_hcievent_data *)(&localBuf[0]);
2656 
2657 	len += bthci_CommandCompleteHeader(&localBuf[0],
2658 		OGF_STATUS_PARAMETERS,
2659 		HCI_READ_FAILED_CONTACT_COUNTER,
2660 		status);
2661 
2662 	/*  Return parameters starts from here */
2663 	pRetPar = &PPacketIrpEvent->Data[len];
2664 	pRetPar[0] = status;		/* status */
2665 	pRetPar[1] = TWOBYTE_LOWBYTE(handle);
2666 	pRetPar[2] = TWOBYTE_HIGHTBYTE(handle);
2667 	pRetPar[3] = TWOBYTE_LOWBYTE(pBtHciInfo->FailContactCount);
2668 	pRetPar[4] = TWOBYTE_HIGHTBYTE(pBtHciInfo->FailContactCount);
2669 	len += 5;
2670 	PPacketIrpEvent->Length = len;
2671 
2672 	bthci_IndicateEvent(padapter, PPacketIrpEvent, len+2);
2673 
2674 	return status;
2675 }
2676 
2677 static enum hci_status
bthci_CmdResetFailedContactCounter(struct rtw_adapter * padapter,struct packet_irp_hcicmd_data * pHciCmd)2678 bthci_CmdResetFailedContactCounter(
2679 	struct rtw_adapter *padapter,
2680 	struct packet_irp_hcicmd_data *pHciCmd
2681 	)
2682 {
2683 	enum hci_status		status = HCI_STATUS_SUCCESS;
2684 /*PMGNT_INFO		pMgntInfo = &padapter->MgntInfo; */
2685 	struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
2686 	struct bt_hci_info *pBtHciInfo = &pBTInfo->BtHciInfo;
2687 	u16		handle;
2688 	u8 localBuf[TmpLocalBufSize] = "";
2689 	u8 *pRetPar;
2690 	u8 len = 0;
2691 	struct packet_irp_hcievent_data *PPacketIrpEvent;
2692 
2693 	handle = *((u16 *)pHciCmd->Data);
2694 	pBtHciInfo->FailContactCount = 0;
2695 
2696 	/* send command complete event here when all data are received. */
2697 	PlatformZeroMemory(&localBuf[0], TmpLocalBufSize);
2698 	/* PPacketIrpEvent = (struct packet_irp_hcievent_data *)(buffer); */
2699 	PPacketIrpEvent = (struct packet_irp_hcievent_data *)(&localBuf[0]);
2700 
2701 	len += bthci_CommandCompleteHeader(&localBuf[0],
2702 		OGF_STATUS_PARAMETERS,
2703 		HCI_RESET_FAILED_CONTACT_COUNTER,
2704 		status);
2705 
2706 	/*  Return parameters starts from here */
2707 	pRetPar = &PPacketIrpEvent->Data[len];
2708 	pRetPar[0] = status;		/* status */
2709 	pRetPar[1] = TWOBYTE_LOWBYTE(handle);
2710 	pRetPar[2] = TWOBYTE_HIGHTBYTE(handle);
2711 	len += 3;
2712 	PPacketIrpEvent->Length = len;
2713 
2714 	bthci_IndicateEvent(padapter, PPacketIrpEvent, len+2);
2715 	return status;
2716 }
2717 
2718 /*  */
2719 /*  BT 3.0+HS [Vol 2] 7.4.1 */
2720 /*  */
2721 static enum hci_status
bthci_CmdReadLocalVersionInformation(struct rtw_adapter * padapter)2722 bthci_CmdReadLocalVersionInformation(
2723 	struct rtw_adapter *padapter
2724 	)
2725 {
2726 	enum hci_status status = HCI_STATUS_SUCCESS;
2727 	/* send command complete event here when all data are received. */
2728 	u8 localBuf[TmpLocalBufSize] = "";
2729 	u8 *pRetPar;
2730 	u8 len = 0;
2731 	struct packet_irp_hcievent_data *PPacketIrpEvent;
2732 	u16 *pu2Temp;
2733 
2734 	PlatformZeroMemory(&localBuf[0], TmpLocalBufSize);
2735 	PPacketIrpEvent = (struct packet_irp_hcievent_data *)(&localBuf[0]);
2736 
2737 	len += bthci_CommandCompleteHeader(&localBuf[0],
2738 		OGF_INFORMATIONAL_PARAMETERS,
2739 		HCI_READ_LOCAL_VERSION_INFORMATION,
2740 		status);
2741 
2742 	/*  Return parameters starts from here */
2743 	pRetPar = &PPacketIrpEvent->Data[len];
2744 	pRetPar[0] = status;		/* status */
2745 	pRetPar[1] = 0x05;			/*  HCI_Version */
2746 	pu2Temp = (u16 *)&pRetPar[2];		/*  HCI_Revision */
2747 	*pu2Temp = 0x0001;
2748 	pRetPar[4] = 0x05;			/*  LMP/PAL_Version */
2749 	pu2Temp = (u16 *)&pRetPar[5];		/*  Manufacturer_Name */
2750 	*pu2Temp = 0x005d;
2751 	pu2Temp = (u16 *)&pRetPar[7];		/*  LMP/PAL_Subversion */
2752 	*pu2Temp = 0x0001;
2753 	len += 9;
2754 	PPacketIrpEvent->Length = len;
2755 
2756 	RTPRINT(FIOCTL, (IOCTL_BT_HCICMD_DETAIL|IOCTL_BT_LOGO), ("LOCAL_VERSION_INFORMATION\n"));
2757 	RTPRINT(FIOCTL, (IOCTL_BT_HCICMD_DETAIL|IOCTL_BT_LOGO), ("Status  %x\n", status));
2758 	RTPRINT(FIOCTL, (IOCTL_BT_HCICMD_DETAIL|IOCTL_BT_LOGO), ("HCI_Version = 0x05\n"));
2759 	RTPRINT(FIOCTL, (IOCTL_BT_HCICMD_DETAIL|IOCTL_BT_LOGO), ("HCI_Revision = 0x0001\n"));
2760 	RTPRINT(FIOCTL, (IOCTL_BT_HCICMD_DETAIL|IOCTL_BT_LOGO), ("LMP/PAL_Version = 0x05\n"));
2761 	RTPRINT(FIOCTL, (IOCTL_BT_HCICMD_DETAIL|IOCTL_BT_LOGO), ("Manufacturer_Name = 0x0001\n"));
2762 	RTPRINT(FIOCTL, (IOCTL_BT_HCICMD_DETAIL|IOCTL_BT_LOGO), ("LMP/PAL_Subversion = 0x0001\n"));
2763 
2764 	bthci_IndicateEvent(padapter, PPacketIrpEvent, len+2);
2765 
2766 	return status;
2767 }
2768 
2769 /* 7.4.7 */
bthci_CmdReadDataBlockSize(struct rtw_adapter * padapter)2770 static enum hci_status bthci_CmdReadDataBlockSize(struct rtw_adapter *padapter)
2771 {
2772 	enum hci_status			status = HCI_STATUS_SUCCESS;
2773 	u8 localBuf[TmpLocalBufSize] = "";
2774 	u8 *pRetPar;
2775 	u8 len = 0;
2776 	struct packet_irp_hcievent_data *PPacketIrpEvent;
2777 	u16 *pu2Temp;
2778 
2779 	PlatformZeroMemory(&localBuf[0], TmpLocalBufSize);
2780 	PPacketIrpEvent = (struct packet_irp_hcievent_data *)(&localBuf[0]);
2781 
2782 	len += bthci_CommandCompleteHeader(&localBuf[0],
2783 		OGF_INFORMATIONAL_PARAMETERS,
2784 		HCI_READ_DATA_BLOCK_SIZE,
2785 		status);
2786 
2787 	/*  Return parameters starts from here */
2788 	pRetPar = &PPacketIrpEvent->Data[len];
2789 	pRetPar[0] = HCI_STATUS_SUCCESS;	/* status */
2790 	pu2Temp = (u16 *)&pRetPar[1];		/*  Max_ACL_Data_Packet_Length */
2791 	*pu2Temp = Max80211PALPDUSize;
2792 
2793 	pu2Temp = (u16 *)&pRetPar[3];		/*  Data_Block_Length */
2794 	*pu2Temp = Max80211PALPDUSize;
2795 	pu2Temp = (u16 *)&pRetPar[5];		/*  Total_Num_Data_Blocks */
2796 	*pu2Temp = BTTotalDataBlockNum;
2797 	len += 7;
2798 	PPacketIrpEvent->Length = len;
2799 
2800 	bthci_IndicateEvent(padapter, PPacketIrpEvent, len+2);
2801 
2802 	return status;
2803 }
2804 
2805 /*  7.4.5 */
bthci_CmdReadBufferSize(struct rtw_adapter * padapter)2806 static enum hci_status bthci_CmdReadBufferSize(struct rtw_adapter *padapter)
2807 {
2808 	enum hci_status status = HCI_STATUS_SUCCESS;
2809 	u8 localBuf[TmpLocalBufSize] = "";
2810 	u8 *pRetPar;
2811 	u8 len = 0;
2812 	struct packet_irp_hcievent_data *PPacketIrpEvent;
2813 	u16 *pu2Temp;
2814 
2815 	PlatformZeroMemory(&localBuf[0], TmpLocalBufSize);
2816 	/* PPacketIrpEvent = (struct packet_irp_hcievent_data *)(buffer); */
2817 	PPacketIrpEvent = (struct packet_irp_hcievent_data *)(&localBuf[0]);
2818 
2819 	len += bthci_CommandCompleteHeader(&localBuf[0],
2820 		OGF_INFORMATIONAL_PARAMETERS,
2821 		HCI_READ_BUFFER_SIZE,
2822 		status);
2823 	RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("Synchronous_Data_Packet_Length = 0x%x\n", BTSynDataPacketLength));
2824 	RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("Total_Num_ACL_Data_Packets = 0x%x\n", BTTotalDataBlockNum));
2825 	RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("Total_Num_Synchronous_Data_Packets = 0x%x\n", BTTotalDataBlockNum));
2826 	/*  Return parameters starts from here */
2827 	pRetPar = &PPacketIrpEvent->Data[len];
2828 	pRetPar[0] = status;		/* status */
2829 	pu2Temp = (u16 *)&pRetPar[1];		/*  HC_ACL_Data_Packet_Length */
2830 	*pu2Temp = Max80211PALPDUSize;
2831 
2832 	pRetPar[3] = BTSynDataPacketLength;	/*  HC_Synchronous_Data_Packet_Length */
2833 	pu2Temp = (u16 *)&pRetPar[4];		/*  HC_Total_Num_ACL_Data_Packets */
2834 	*pu2Temp = BTTotalDataBlockNum;
2835 	pu2Temp = (u16 *)&pRetPar[6];		/*  HC_Total_Num_Synchronous_Data_Packets */
2836 	*pu2Temp = BTTotalDataBlockNum;
2837 	len += 8;
2838 	PPacketIrpEvent->Length = len;
2839 
2840 	bthci_IndicateEvent(padapter, PPacketIrpEvent, len+2);
2841 
2842 	return status;
2843 }
2844 
bthci_CmdReadLocalAMPInfo(struct rtw_adapter * padapter)2845 static enum hci_status bthci_CmdReadLocalAMPInfo(struct rtw_adapter *padapter)
2846 {
2847 	enum hci_status	status = HCI_STATUS_SUCCESS;
2848 	struct pwrctrl_priv *ppwrctrl = &padapter->pwrctrlpriv;
2849 	u8 localBuf[TmpLocalBufSize] = "";
2850 	u8 *pRetPar;
2851 	u8 len = 0;
2852 	struct packet_irp_hcievent_data *PPacketIrpEvent;
2853 	u16 *pu2Temp;
2854 	u32 *pu4Temp;
2855 	u32	TotalBandwidth = BTTOTALBANDWIDTH, MaxBandGUBandwidth = BTMAXBANDGUBANDWIDTH;
2856 	u8 ControlType = 0x01, AmpStatus = 0x01;
2857 	u32	MaxFlushTimeout = 10000, BestEffortFlushTimeout = 5000;
2858 	u16 MaxPDUSize = Max80211PALPDUSize, PalCap = 0x1, AmpAssocLen = Max80211AMPASSOCLen, MinLatency = 20;
2859 
2860 	if ((ppwrctrl->rfoff_reason & RF_CHANGE_BY_HW) ||
2861 	    (ppwrctrl->rfoff_reason & RF_CHANGE_BY_SW)) {
2862 		AmpStatus = AMP_STATUS_NO_CAPACITY_FOR_BT;
2863 	}
2864 
2865 	PlatformZeroMemory(&localBuf[0], TmpLocalBufSize);
2866 	/* PPacketIrpEvent = (struct packet_irp_hcievent_data *)(buffer); */
2867 	PPacketIrpEvent = (struct packet_irp_hcievent_data *)(&localBuf[0]);
2868 
2869 	len += bthci_CommandCompleteHeader(&localBuf[0],
2870 		OGF_STATUS_PARAMETERS,
2871 		HCI_READ_LOCAL_AMP_INFO,
2872 		status);
2873 
2874 	/*  Return parameters starts from here */
2875 	pRetPar = &PPacketIrpEvent->Data[len];
2876 	pRetPar[0] = status;			/* status */
2877 	pRetPar[1] = AmpStatus;			/*  AMP_Status */
2878 	pu4Temp = (u32 *)&pRetPar[2];		/*  Total_Bandwidth */
2879 	*pu4Temp = TotalBandwidth;		/* 0x19bfcc00;0x7530; */
2880 	pu4Temp = (u32 *)&pRetPar[6];		/*  Max_Guaranteed_Bandwidth */
2881 	*pu4Temp = MaxBandGUBandwidth;		/* 0x19bfcc00;0x4e20; */
2882 	pu4Temp = (u32 *)&pRetPar[10];		/*  Min_Latency */
2883 	*pu4Temp = MinLatency;			/* 150; */
2884 	pu4Temp = (u32 *)&pRetPar[14];		/*  Max_PDU_Size */
2885 	*pu4Temp = MaxPDUSize;
2886 	pRetPar[18] = ControlType;		/*  Controller_Type */
2887 	pu2Temp = (u16 *)&pRetPar[19];		/*  PAL_Capabilities */
2888 	*pu2Temp = PalCap;
2889 	pu2Temp = (u16 *)&pRetPar[21];		/*  AMP_ASSOC_Length */
2890 	*pu2Temp = AmpAssocLen;
2891 	pu4Temp = (u32 *)&pRetPar[23];		/*  Max_Flush_Timeout */
2892 	*pu4Temp = MaxFlushTimeout;
2893 	pu4Temp = (u32 *)&pRetPar[27];		/*  Best_Effort_Flush_Timeout */
2894 	*pu4Temp = BestEffortFlushTimeout;
2895 	len += 31;
2896 	PPacketIrpEvent->Length = len;
2897 	RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("AmpStatus = 0x%x\n",
2898 		AmpStatus));
2899 	RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("TotalBandwidth = 0x%x, MaxBandGUBandwidth = 0x%x, MinLatency = 0x%x, \n MaxPDUSize = 0x%x, ControlType = 0x%x\n",
2900 		TotalBandwidth, MaxBandGUBandwidth, MinLatency, MaxPDUSize, ControlType));
2901 	RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("PalCap = 0x%x, AmpAssocLen = 0x%x, MaxFlushTimeout = 0x%x, BestEffortFlushTimeout = 0x%x\n",
2902 		PalCap, AmpAssocLen, MaxFlushTimeout, BestEffortFlushTimeout));
2903 	bthci_IndicateEvent(padapter, PPacketIrpEvent, len+2);
2904 	return status;
2905 }
2906 
2907 static enum hci_status
bthci_CmdCreatePhysicalLink(struct rtw_adapter * padapter,struct packet_irp_hcicmd_data * pHciCmd)2908 bthci_CmdCreatePhysicalLink(
2909 	struct rtw_adapter *padapter,
2910 	struct packet_irp_hcicmd_data *pHciCmd
2911 	)
2912 {
2913 	enum hci_status	status;
2914 	struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
2915 	struct bt_dgb *pBtDbg = &pBTInfo->BtDbg;
2916 
2917 	pBtDbg->dbgHciInfo.hciCmdCntCreatePhyLink++;
2918 
2919 	status = bthci_BuildPhysicalLink(padapter,
2920 		pHciCmd, HCI_CREATE_PHYSICAL_LINK);
2921 
2922 	return status;
2923 }
2924 
2925 static enum hci_status
bthci_CmdReadLinkQuality(struct rtw_adapter * padapter,struct packet_irp_hcicmd_data * pHciCmd)2926 bthci_CmdReadLinkQuality(
2927 	struct rtw_adapter *padapter,
2928 	struct packet_irp_hcicmd_data *pHciCmd
2929 	)
2930 {
2931 	enum hci_status			status = HCI_STATUS_SUCCESS;
2932 	struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
2933 	u16				PLH;
2934 	u8 	EntryNum, LinkQuality = 0x55;
2935 
2936 	PLH = *((u16 *)&pHciCmd->Data[0]);
2937 	RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("PLH = 0x%x\n", PLH));
2938 
2939 	EntryNum = bthci_GetCurrentEntryNum(padapter, (u8)PLH);
2940 	if (EntryNum == 0xff) {
2941 		RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("No such PLH(0x%x)\n", PLH));
2942 		status = HCI_STATUS_UNKNOW_CONNECT_ID;
2943 	}
2944 
2945 	{
2946 		u8 localBuf[11] = "";
2947 		u8 *pRetPar;
2948 		u8 len = 0;
2949 		struct packet_irp_hcievent_data *PPacketIrpEvent;
2950 
2951 		PPacketIrpEvent = (struct packet_irp_hcievent_data *)(&localBuf[0]);
2952 
2953 		len += bthci_CommandCompleteHeader(&localBuf[0],
2954 			OGF_STATUS_PARAMETERS,
2955 			HCI_READ_LINK_QUALITY,
2956 			status);
2957 
2958 		RTPRINT(FIOCTL, IOCTL_BT_HCICMD, (" PLH = 0x%x\n Link Quality = 0x%x\n", PLH, LinkQuality));
2959 
2960 		/*  Return parameters starts from here */
2961 		pRetPar = &PPacketIrpEvent->Data[len];
2962 		pRetPar[0] = status;			/* status */
2963 		*((u16 *)&pRetPar[1]) = pBTInfo->BtAsocEntry[EntryNum].PhyLinkCmdData.BtPhyLinkhandle;	/*  Handle */
2964 		pRetPar[3] = 0x55;	/* Link Quailty */
2965 		len += 4;
2966 		PPacketIrpEvent->Length = len;
2967 
2968 		bthci_IndicateEvent(padapter, PPacketIrpEvent, len+2);
2969 	}
2970 
2971 	return status;
2972 }
2973 
2974 static enum hci_status
bthci_CmdCreateLogicalLink(struct rtw_adapter * padapter,struct packet_irp_hcicmd_data * pHciCmd)2975 bthci_CmdCreateLogicalLink(
2976 	struct rtw_adapter *padapter,
2977 	struct packet_irp_hcicmd_data *pHciCmd
2978 	)
2979 {
2980 	struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
2981 	struct bt_dgb *pBtDbg = &pBTInfo->BtDbg;
2982 
2983 	pBtDbg->dbgHciInfo.hciCmdCntCreateLogLink++;
2984 
2985 	bthci_BuildLogicalLink(padapter, pHciCmd,
2986 		HCI_CREATE_LOGICAL_LINK);
2987 
2988 	return HCI_STATUS_SUCCESS;
2989 }
2990 
2991 static enum hci_status
bthci_CmdAcceptLogicalLink(struct rtw_adapter * padapter,struct packet_irp_hcicmd_data * pHciCmd)2992 bthci_CmdAcceptLogicalLink(
2993 	struct rtw_adapter *padapter,
2994 	struct packet_irp_hcicmd_data *pHciCmd
2995 	)
2996 {
2997 	struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
2998 	struct bt_dgb *pBtDbg = &pBTInfo->BtDbg;
2999 
3000 	pBtDbg->dbgHciInfo.hciCmdCntAcceptLogLink++;
3001 
3002 	bthci_BuildLogicalLink(padapter, pHciCmd,
3003 		HCI_ACCEPT_LOGICAL_LINK);
3004 
3005 	return HCI_STATUS_SUCCESS;
3006 }
3007 
3008 static enum hci_status
bthci_CmdDisconnectLogicalLink(struct rtw_adapter * padapter,struct packet_irp_hcicmd_data * pHciCmd)3009 bthci_CmdDisconnectLogicalLink(
3010 	struct rtw_adapter *padapter,
3011 	struct packet_irp_hcicmd_data *pHciCmd
3012 	)
3013 {
3014 	enum hci_status status = HCI_STATUS_SUCCESS;
3015 /*PMGNT_INFO pMgntInfo = &padapter->MgntInfo; */
3016 	struct bt_30info *pBTinfo = GET_BT_INFO(padapter);
3017 	struct bt_mgnt *pBtMgnt = &pBTinfo->BtMgnt;
3018 	struct bt_dgb *pBtDbg = &pBTinfo->BtDbg;
3019 	u16	logicHandle;
3020 	u8 i, j, find = 0, LogLinkCount = 0;
3021 
3022 	pBtDbg->dbgHciInfo.hciCmdCntDisconnectLogLink++;
3023 
3024 	logicHandle = *((u16 *)pHciCmd->Data);
3025 	RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("DisconnectLogicalLink, logicHandle = 0x%x\n", logicHandle));
3026 
3027 	/*  find an created logical link index and clear the data */
3028 	for (j = 0; j < MAX_BT_ASOC_ENTRY_NUM; j++) {
3029 		for (i = 0; i < MAX_LOGICAL_LINK_NUM; i++) {
3030 			if (pBTinfo->BtAsocEntry[j].LogLinkCmdData[i].BtLogLinkhandle == logicHandle) {
3031 				RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("DisconnectLogicalLink, logicHandle is matched  0x%x\n", logicHandle));
3032 				bthci_ResetFlowSpec(padapter, j, i);
3033 				find = 1;
3034 				pBtMgnt->DisconnectEntryNum = j;
3035 				break;
3036 			}
3037 		}
3038 	}
3039 
3040 	if (!find)
3041 		status = HCI_STATUS_UNKNOW_CONNECT_ID;
3042 
3043 	/*  To check each */
3044 	for (i = 0; i < MAX_LOGICAL_LINK_NUM; i++) {
3045 		if (pBTinfo->BtAsocEntry[pBtMgnt->DisconnectEntryNum].LogLinkCmdData[i].BtLogLinkhandle != 0)
3046 			LogLinkCount++;
3047 	}
3048 
3049 	/* When we receive Create logical link command, we should send command status event first. */
3050 	bthci_EventCommandStatus(padapter,
3051 			LINK_CONTROL_COMMANDS,
3052 			HCI_DISCONNECT_LOGICAL_LINK,
3053 			status);
3054 	/*  */
3055 	/* When we determines the logical link is established, we should send command complete event. */
3056 	/*  */
3057 	if (status == HCI_STATUS_SUCCESS) {
3058 		bthci_EventDisconnectLogicalLinkComplete(padapter, status,
3059 			logicHandle, HCI_STATUS_CONNECT_TERMINATE_LOCAL_HOST);
3060 	}
3061 
3062 	if (LogLinkCount == 0)
3063 		mod_timer(&pBTinfo->BTDisconnectPhyLinkTimer,
3064 			  jiffies + msecs_to_jiffies(100));
3065 
3066 	return status;
3067 }
3068 
3069 static enum hci_status
bthci_CmdLogicalLinkCancel(struct rtw_adapter * padapter,struct packet_irp_hcicmd_data * pHciCmd)3070 bthci_CmdLogicalLinkCancel(struct rtw_adapter *padapter,
3071 			   struct packet_irp_hcicmd_data *pHciCmd)
3072 {
3073 	enum hci_status status = HCI_STATUS_SUCCESS;
3074 	struct bt_30info *pBTinfo = GET_BT_INFO(padapter);
3075 	struct bt_mgnt *pBtMgnt = &pBTinfo->BtMgnt;
3076 	u8 CurrentEntryNum, CurrentLogEntryNum;
3077 
3078 	u8 physicalLinkHandle, TxFlowSpecID, i;
3079 	u16	CurrentLogicalHandle;
3080 
3081 	physicalLinkHandle = *((u8 *)pHciCmd->Data);
3082 	TxFlowSpecID = *(((u8 *)pHciCmd->Data)+1);
3083 
3084 	RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("LogicalLinkCancel, physicalLinkHandle = 0x%x, TxFlowSpecID = 0x%x\n",
3085 		physicalLinkHandle, TxFlowSpecID));
3086 
3087 	CurrentEntryNum = pBtMgnt->CurrentConnectEntryNum;
3088 	CurrentLogicalHandle = pBtMgnt->BtCurrentLogLinkhandle;
3089 
3090 	RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("CurrentEntryNum = 0x%x, CurrentLogicalHandle = 0x%x\n",
3091 		CurrentEntryNum, CurrentLogicalHandle));
3092 
3093 	CurrentLogEntryNum = 0xff;
3094 	for (i = 0; i < MAX_LOGICAL_LINK_NUM; i++) {
3095 		if ((CurrentLogicalHandle == pBTinfo->BtAsocEntry[CurrentEntryNum].LogLinkCmdData[i].BtLogLinkhandle) &&
3096 			(physicalLinkHandle == pBTinfo->BtAsocEntry[CurrentEntryNum].LogLinkCmdData[i].BtPhyLinkhandle)) {
3097 			CurrentLogEntryNum = i;
3098 			break;
3099 		}
3100 	}
3101 
3102 	if (CurrentLogEntryNum == 0xff) {
3103 		RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("LogicalLinkCancel, CurrentLogEntryNum == 0xff !!!!\n"));
3104 		status = HCI_STATUS_UNKNOW_CONNECT_ID;
3105 		return status;
3106 	} else {
3107 		if (pBTinfo->BtAsocEntry[CurrentEntryNum].LogLinkCmdData[CurrentLogEntryNum].bLLCompleteEventIsSet) {
3108 			RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("LogicalLinkCancel, LLCompleteEventIsSet!!!!\n"));
3109 			status = HCI_STATUS_ACL_CONNECT_EXISTS;
3110 		}
3111 	}
3112 
3113 	{
3114 		u8 localBuf[8] = "";
3115 		u8 *pRetPar;
3116 		u8 len = 0;
3117 		struct packet_irp_hcievent_data *PPacketIrpEvent;
3118 
3119 		PPacketIrpEvent = (struct packet_irp_hcievent_data *)(&localBuf[0]);
3120 
3121 		len += bthci_CommandCompleteHeader(&localBuf[0],
3122 			LINK_CONTROL_COMMANDS,
3123 			HCI_LOGICAL_LINK_CANCEL,
3124 			status);
3125 
3126 		/*  Return parameters starts from here */
3127 		pRetPar = &PPacketIrpEvent->Data[len];
3128 		pRetPar[0] = status;		/* status */
3129 		pRetPar[1] = pBTinfo->BtAsocEntry[CurrentEntryNum].LogLinkCmdData[CurrentLogEntryNum].BtPhyLinkhandle;
3130 		pRetPar[2] = pBTinfo->BtAsocEntry[CurrentEntryNum].LogLinkCmdData[CurrentLogEntryNum].BtTxFlowSpecID;
3131 		len += 3;
3132 		PPacketIrpEvent->Length = len;
3133 
3134 		bthci_IndicateEvent(padapter, PPacketIrpEvent, len+2);
3135 	}
3136 
3137 	pBTinfo->BtAsocEntry[CurrentEntryNum].LogLinkCmdData[CurrentLogEntryNum].bLLCancelCMDIsSetandComplete = true;
3138 
3139 	return status;
3140 }
3141 
3142 static enum hci_status
bthci_CmdFlowSpecModify(struct rtw_adapter * padapter,struct packet_irp_hcicmd_data * pHciCmd)3143 bthci_CmdFlowSpecModify(struct rtw_adapter *padapter,
3144 			struct packet_irp_hcicmd_data *pHciCmd)
3145 {
3146 	enum hci_status status = HCI_STATUS_SUCCESS;
3147 /*PMGNT_INFO pMgntInfo = &padapter->MgntInfo; */
3148 	struct bt_30info *pBTinfo = GET_BT_INFO(padapter);
3149 	u8 i, j, find = 0;
3150 	u16 logicHandle;
3151 
3152 	logicHandle = *((u16 *)pHciCmd->Data);
3153 	/*  find an matched logical link index and copy the data */
3154 	for (j = 0; j < MAX_BT_ASOC_ENTRY_NUM; j++) {
3155 		for (i = 0; i < MAX_LOGICAL_LINK_NUM; i++) {
3156 			if (pBTinfo->BtAsocEntry[j].LogLinkCmdData[i].BtLogLinkhandle == logicHandle) {
3157 				memcpy(&pBTinfo->BtAsocEntry[j].LogLinkCmdData[i].Tx_Flow_Spec,
3158 					&pHciCmd->Data[2], sizeof(struct hci_flow_spec));
3159 				memcpy(&pBTinfo->BtAsocEntry[j].LogLinkCmdData[i].Rx_Flow_Spec,
3160 					&pHciCmd->Data[18], sizeof(struct hci_flow_spec));
3161 
3162 				bthci_CheckLogLinkBehavior(padapter, pBTinfo->BtAsocEntry[j].LogLinkCmdData[i].Tx_Flow_Spec);
3163 				find = 1;
3164 				break;
3165 			}
3166 		}
3167 	}
3168 	RTPRINT(FIOCTL, IOCTL_BT_LOGO, ("FlowSpecModify, LLH = 0x%x, \n", logicHandle));
3169 
3170 	/* When we receive Flow Spec Modify command, we should send command status event first. */
3171 	bthci_EventCommandStatus(padapter,
3172 		LINK_CONTROL_COMMANDS,
3173 		HCI_FLOW_SPEC_MODIFY,
3174 		HCI_STATUS_SUCCESS);
3175 
3176 	if (!find)
3177 		status = HCI_STATUS_UNKNOW_CONNECT_ID;
3178 
3179 	bthci_EventSendFlowSpecModifyComplete(padapter, status, logicHandle);
3180 
3181 	return status;
3182 }
3183 
3184 static enum hci_status
bthci_CmdAcceptPhysicalLink(struct rtw_adapter * padapter,struct packet_irp_hcicmd_data * pHciCmd)3185 bthci_CmdAcceptPhysicalLink(struct rtw_adapter *padapter,
3186 			    struct packet_irp_hcicmd_data *pHciCmd)
3187 {
3188 	enum hci_status	status;
3189 	struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
3190 	struct bt_dgb *pBtDbg = &pBTInfo->BtDbg;
3191 
3192 	pBtDbg->dbgHciInfo.hciCmdCntAcceptPhyLink++;
3193 
3194 	status = bthci_BuildPhysicalLink(padapter,
3195 		pHciCmd, HCI_ACCEPT_PHYSICAL_LINK);
3196 
3197 	return status;
3198 }
3199 
3200 static enum hci_status
bthci_CmdDisconnectPhysicalLink(struct rtw_adapter * padapter,struct packet_irp_hcicmd_data * pHciCmd)3201 bthci_CmdDisconnectPhysicalLink(struct rtw_adapter *padapter,
3202 				struct packet_irp_hcicmd_data *pHciCmd)
3203 {
3204 	enum hci_status	status = HCI_STATUS_SUCCESS;
3205 	struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
3206 	struct bt_dgb *pBtDbg = &pBTInfo->BtDbg;
3207 	u8 PLH, CurrentEntryNum, PhysLinkDisconnectReason;
3208 
3209 	pBtDbg->dbgHciInfo.hciCmdCntDisconnectPhyLink++;
3210 
3211 	PLH = *((u8 *)pHciCmd->Data);
3212 	PhysLinkDisconnectReason = *((u8 *)pHciCmd->Data+1);
3213 	RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_DISCONNECT_PHYSICAL_LINK  PhyHandle = 0x%x, Reason = 0x%x\n",
3214 		PLH, PhysLinkDisconnectReason));
3215 
3216 	CurrentEntryNum = bthci_GetCurrentEntryNum(padapter, PLH);
3217 
3218 	if (CurrentEntryNum == 0xff) {
3219 		RTPRINT(FIOCTL, IOCTL_BT_HCICMD,
3220 			("DisconnectPhysicalLink, No such Handle in the Entry\n"));
3221 		status = HCI_STATUS_UNKNOW_CONNECT_ID;
3222 	} else {
3223 		pBTInfo->BtAsocEntry[CurrentEntryNum].PhyLinkDisconnectReason =
3224 			(enum hci_status)PhysLinkDisconnectReason;
3225 	}
3226 	/* Send HCI Command status event to AMP. */
3227 	bthci_EventCommandStatus(padapter, LINK_CONTROL_COMMANDS,
3228 				 HCI_DISCONNECT_PHYSICAL_LINK, status);
3229 
3230 	if (status != HCI_STATUS_SUCCESS)
3231 		return status;
3232 
3233 	/* The macros below require { and } in the if statement */
3234 	if (pBTInfo->BtAsocEntry[CurrentEntryNum].BtCurrentState == HCI_STATE_DISCONNECTED) {
3235 		BTHCI_SM_WITH_INFO(padapter, HCI_STATE_DISCONNECTED, STATE_CMD_DISCONNECT_PHY_LINK, CurrentEntryNum);
3236 	} else {
3237 		BTHCI_SM_WITH_INFO(padapter, HCI_STATE_DISCONNECTING, STATE_CMD_DISCONNECT_PHY_LINK, CurrentEntryNum);
3238 	}
3239 	return status;
3240 }
3241 
3242 static enum hci_status
bthci_CmdSetACLLinkDataFlowMode(struct rtw_adapter * padapter,struct packet_irp_hcicmd_data * pHciCmd)3243 bthci_CmdSetACLLinkDataFlowMode(struct rtw_adapter *padapter,
3244 				struct packet_irp_hcicmd_data *pHciCmd)
3245 {
3246 	enum hci_status status = HCI_STATUS_SUCCESS;
3247 	struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
3248 	struct bt_mgnt *pBtMgnt = &pBTInfo->BtMgnt;
3249 	u8 localBuf[8] = "";
3250 	u8 *pRetPar;
3251 	u8 len = 0;
3252 	struct packet_irp_hcievent_data *PPacketIrpEvent;
3253 	u16 *pu2Temp;
3254 
3255 	pBtMgnt->ExtConfig.CurrentConnectHandle = *((u16 *)pHciCmd->Data);
3256 	pBtMgnt->ExtConfig.CurrentIncomingTrafficMode = *((u8 *)pHciCmd->Data)+2;
3257 	pBtMgnt->ExtConfig.CurrentOutgoingTrafficMode = *((u8 *)pHciCmd->Data)+3;
3258 	RTPRINT(FIOCTL, IOCTL_BT_HCICMD_EXT, ("Connection Handle = 0x%x, Incoming Traffic mode = 0x%x, Outgoing Traffic mode = 0x%x",
3259 		pBtMgnt->ExtConfig.CurrentConnectHandle,
3260 		pBtMgnt->ExtConfig.CurrentIncomingTrafficMode,
3261 		pBtMgnt->ExtConfig.CurrentOutgoingTrafficMode));
3262 
3263 
3264 	PPacketIrpEvent = (struct packet_irp_hcievent_data *)(&localBuf[0]);
3265 
3266 	len += bthci_CommandCompleteHeader(&localBuf[0],
3267 		OGF_EXTENSION,
3268 		HCI_SET_ACL_LINK_DATA_FLOW_MODE,
3269 		status);
3270 
3271 	/*  Return parameters starts from here */
3272 	pRetPar = &PPacketIrpEvent->Data[len];
3273 	pRetPar[0] = status;		/* status */
3274 
3275 	pu2Temp = (u16 *)&pRetPar[1];
3276 	*pu2Temp = pBtMgnt->ExtConfig.CurrentConnectHandle;
3277 	len += 3;
3278 	PPacketIrpEvent->Length = len;
3279 
3280 	bthci_IndicateEvent(padapter, PPacketIrpEvent, len+2);
3281 	return status;
3282 }
3283 
3284 static enum hci_status
bthci_CmdSetACLLinkStatus(struct rtw_adapter * padapter,struct packet_irp_hcicmd_data * pHciCmd)3285 bthci_CmdSetACLLinkStatus(struct rtw_adapter *padapter,
3286 			  struct packet_irp_hcicmd_data *pHciCmd)
3287 {
3288 	enum hci_status status = HCI_STATUS_SUCCESS;
3289 	struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
3290 	struct bt_mgnt *pBtMgnt = &pBTInfo->BtMgnt;
3291 	struct bt_dgb *pBtDbg = &pBTInfo->BtDbg;
3292 	u8 i;
3293 	u8 *pTriple;
3294 
3295 	pBtDbg->dbgHciInfo.hciCmdCntSetAclLinkStatus++;
3296 	RTPRINT_DATA(FIOCTL, IOCTL_BT_HCICMD_EXT, "SetACLLinkStatus, Hex Data :\n",
3297 			&pHciCmd->Data[0], pHciCmd->Length);
3298 
3299 	/*  Only Core Stack v251 and later version support this command. */
3300 	pBtMgnt->bSupportProfile = true;
3301 
3302 	pBtMgnt->ExtConfig.NumberOfHandle = *((u8 *)pHciCmd->Data);
3303 	RTPRINT(FIOCTL, IOCTL_BT_HCICMD_EXT, ("NumberOfHandle = 0x%x\n", pBtMgnt->ExtConfig.NumberOfHandle));
3304 
3305 	pTriple = &pHciCmd->Data[1];
3306 	for (i = 0; i < pBtMgnt->ExtConfig.NumberOfHandle; i++) {
3307 		pBtMgnt->ExtConfig.linkInfo[i].ConnectHandle = *((u16 *)&pTriple[0]);
3308 		pBtMgnt->ExtConfig.linkInfo[i].IncomingTrafficMode = pTriple[2];
3309 		pBtMgnt->ExtConfig.linkInfo[i].OutgoingTrafficMode = pTriple[3];
3310 		RTPRINT(FIOCTL, IOCTL_BT_HCICMD_EXT,
3311 			("Connection_Handle = 0x%x, Incoming Traffic mode = 0x%x, Outgoing Traffic Mode = 0x%x\n",
3312 			pBtMgnt->ExtConfig.linkInfo[i].ConnectHandle,
3313 			pBtMgnt->ExtConfig.linkInfo[i].IncomingTrafficMode,
3314 			pBtMgnt->ExtConfig.linkInfo[i].OutgoingTrafficMode));
3315 		pTriple += 4;
3316 	}
3317 
3318 	{
3319 		u8 localBuf[6] = "";
3320 		u8 *pRetPar;
3321 		u8 len = 0;
3322 		struct packet_irp_hcievent_data *PPacketIrpEvent;
3323 
3324 		PPacketIrpEvent = (struct packet_irp_hcievent_data *)(&localBuf[0]);
3325 
3326 		len += bthci_CommandCompleteHeader(&localBuf[0],
3327 			OGF_EXTENSION,
3328 			HCI_SET_ACL_LINK_STATUS,
3329 			status);
3330 
3331 		/*  Return parameters starts from here */
3332 		pRetPar = &PPacketIrpEvent->Data[len];
3333 		pRetPar[0] = status;		/* status */
3334 
3335 		len += 1;
3336 		PPacketIrpEvent->Length = len;
3337 
3338 		bthci_IndicateEvent(padapter, PPacketIrpEvent, len+2);
3339 	}
3340 
3341 	return status;
3342 }
3343 
3344 static enum hci_status
bthci_CmdSetSCOLinkStatus(struct rtw_adapter * padapter,struct packet_irp_hcicmd_data * pHciCmd)3345 bthci_CmdSetSCOLinkStatus(
3346 	struct rtw_adapter *padapter,
3347 	struct packet_irp_hcicmd_data *pHciCmd
3348 	)
3349 {
3350 	enum hci_status status = HCI_STATUS_SUCCESS;
3351 	struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
3352 	struct bt_mgnt *pBtMgnt = &pBTInfo->BtMgnt;
3353 	struct bt_dgb *pBtDbg = &pBTInfo->BtDbg;
3354 
3355 	pBtDbg->dbgHciInfo.hciCmdCntSetScoLinkStatus++;
3356 	pBtMgnt->ExtConfig.NumberOfSCO = *((u8 *)pHciCmd->Data);
3357 	RTPRINT(FIOCTL, IOCTL_BT_HCICMD_EXT, ("NumberOfSCO = 0x%x\n",
3358 		pBtMgnt->ExtConfig.NumberOfSCO));
3359 
3360 	{
3361 		u8 localBuf[6] = "";
3362 		u8 *pRetPar;
3363 		u8 len = 0;
3364 		struct packet_irp_hcievent_data *PPacketIrpEvent;
3365 
3366 		PPacketIrpEvent = (struct packet_irp_hcievent_data *)(&localBuf[0]);
3367 
3368 		len += bthci_CommandCompleteHeader(&localBuf[0],
3369 			OGF_EXTENSION,
3370 			HCI_SET_SCO_LINK_STATUS,
3371 			status);
3372 
3373 		/*  Return parameters starts from here */
3374 		pRetPar = &PPacketIrpEvent->Data[len];
3375 		pRetPar[0] = status;		/* status */
3376 
3377 		len += 1;
3378 		PPacketIrpEvent->Length = len;
3379 
3380 		bthci_IndicateEvent(padapter, PPacketIrpEvent, len+2);
3381 	}
3382 
3383 	return status;
3384 }
3385 
3386 static enum hci_status
bthci_CmdSetRSSIValue(struct rtw_adapter * padapter,struct packet_irp_hcicmd_data * pHciCmd)3387 bthci_CmdSetRSSIValue(
3388 	struct rtw_adapter *padapter,
3389 	struct packet_irp_hcicmd_data *pHciCmd
3390 	)
3391 {
3392 	enum hci_status status = HCI_STATUS_SUCCESS;
3393 	struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
3394 	struct bt_mgnt *pBtMgnt = &pBTInfo->BtMgnt;
3395 	s8		min_bt_rssi = 0;
3396 	u8 i;
3397 	for (i = 0; i < pBtMgnt->ExtConfig.NumberOfHandle; i++) {
3398 		if (pBtMgnt->ExtConfig.linkInfo[i].ConnectHandle == *((u16 *)&pHciCmd->Data[0])) {
3399 			pBtMgnt->ExtConfig.linkInfo[i].BT_RSSI = (s8)(pHciCmd->Data[2]);
3400 			RTPRINT(FIOCTL, IOCTL_BT_EVENT_PERIODICAL,
3401 			("Connection_Handle = 0x%x, RSSI = %d \n",
3402 			pBtMgnt->ExtConfig.linkInfo[i].ConnectHandle,
3403 			pBtMgnt->ExtConfig.linkInfo[i].BT_RSSI));
3404 		}
3405 		/*  get the minimum bt rssi value */
3406 		if (pBtMgnt->ExtConfig.linkInfo[i].BT_RSSI <= min_bt_rssi)
3407 			min_bt_rssi = pBtMgnt->ExtConfig.linkInfo[i].BT_RSSI;
3408 	}
3409 
3410 	pBtMgnt->ExtConfig.MIN_BT_RSSI = min_bt_rssi;
3411 	RTPRINT(FBT, BT_TRACE, ("[bt rssi], the min rssi is %d\n", min_bt_rssi));
3412 
3413 	{
3414 		u8 localBuf[6] = "";
3415 		u8 *pRetPar;
3416 		u8 len = 0;
3417 		struct packet_irp_hcievent_data *PPacketIrpEvent;
3418 
3419 		PPacketIrpEvent = (struct packet_irp_hcievent_data *)(&localBuf[0]);
3420 
3421 		len += bthci_CommandCompleteHeader(&localBuf[0],
3422 			OGF_EXTENSION,
3423 			HCI_SET_RSSI_VALUE,
3424 			status);
3425 
3426 		/*  Return parameters starts from here */
3427 		pRetPar = &PPacketIrpEvent->Data[len];
3428 		pRetPar[0] = status;		/* status */
3429 
3430 		len += 1;
3431 		PPacketIrpEvent->Length = len;
3432 
3433 		bthci_IndicateEvent(padapter, PPacketIrpEvent, len+2);
3434 	}
3435 
3436 	return status;
3437 }
3438 
3439 static enum hci_status
bthci_CmdSetCurrentBluetoothStatus(struct rtw_adapter * padapter,struct packet_irp_hcicmd_data * pHciCmd)3440 bthci_CmdSetCurrentBluetoothStatus(
3441 	struct rtw_adapter *padapter,
3442 	struct packet_irp_hcicmd_data *pHciCmd
3443 	)
3444 {
3445 	enum hci_status	status = HCI_STATUS_SUCCESS;
3446 /*PMGNT_INFO	pMgntInfo = &padapter->MgntInfo; */
3447 	struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
3448 	struct bt_mgnt *pBtMgnt = &pBTInfo->BtMgnt;
3449 
3450 	pBtMgnt->ExtConfig.CurrentBTStatus = *((u8 *)&pHciCmd->Data[0]);
3451 	RTPRINT(FIOCTL, IOCTL_BT_HCICMD_EXT, ("SetCurrentBluetoothStatus, CurrentBTStatus = 0x%x\n",
3452 		pBtMgnt->ExtConfig.CurrentBTStatus));
3453 
3454 	{
3455 		u8 localBuf[6] = "";
3456 		u8 *pRetPar;
3457 		u8 len = 0;
3458 		struct packet_irp_hcievent_data *PPacketIrpEvent;
3459 
3460 		PPacketIrpEvent = (struct packet_irp_hcievent_data *)(&localBuf[0]);
3461 
3462 		len += bthci_CommandCompleteHeader(&localBuf[0],
3463 			OGF_EXTENSION,
3464 			HCI_SET_CURRENT_BLUETOOTH_STATUS,
3465 			status);
3466 
3467 		/*  Return parameters starts from here */
3468 		pRetPar = &PPacketIrpEvent->Data[len];
3469 		pRetPar[0] = status;		/* status */
3470 		len += 1;
3471 
3472 		PPacketIrpEvent->Length = len;
3473 
3474 		bthci_IndicateEvent(padapter, PPacketIrpEvent, len+2);
3475 	}
3476 
3477 	return status;
3478 }
3479 
3480 static enum hci_status
bthci_CmdExtensionVersionNotify(struct rtw_adapter * padapter,struct packet_irp_hcicmd_data * pHciCmd)3481 bthci_CmdExtensionVersionNotify(
3482 	struct rtw_adapter *padapter,
3483 	struct packet_irp_hcicmd_data *pHciCmd
3484 	)
3485 {
3486 	enum hci_status	status = HCI_STATUS_SUCCESS;
3487 	struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
3488 	struct bt_mgnt *pBtMgnt = &pBTInfo->BtMgnt;
3489 	struct bt_dgb *pBtDbg = &pBTInfo->BtDbg;
3490 
3491 	pBtDbg->dbgHciInfo.hciCmdCntExtensionVersionNotify++;
3492 	RTPRINT_DATA(FIOCTL, IOCTL_BT_HCICMD_EXT, "ExtensionVersionNotify, Hex Data :\n",
3493 			&pHciCmd->Data[0], pHciCmd->Length);
3494 
3495 	pBtMgnt->ExtConfig.HCIExtensionVer = *((u16 *)&pHciCmd->Data[0]);
3496 	RTPRINT(FIOCTL, IOCTL_BT_HCICMD_EXT, ("HCIExtensionVer = 0x%x\n", pBtMgnt->ExtConfig.HCIExtensionVer));
3497 
3498 	{
3499 		u8 localBuf[6] = "";
3500 		u8 *pRetPar;
3501 		u8 len = 0;
3502 		struct packet_irp_hcievent_data *PPacketIrpEvent;
3503 
3504 		PPacketIrpEvent = (struct packet_irp_hcievent_data *)(&localBuf[0]);
3505 
3506 		len += bthci_CommandCompleteHeader(&localBuf[0],
3507 			OGF_EXTENSION,
3508 			HCI_EXTENSION_VERSION_NOTIFY,
3509 			status);
3510 
3511 		/*  Return parameters starts from here */
3512 		pRetPar = &PPacketIrpEvent->Data[len];
3513 		pRetPar[0] = status;		/* status */
3514 
3515 		len += 1;
3516 		PPacketIrpEvent->Length = len;
3517 
3518 		bthci_IndicateEvent(padapter, PPacketIrpEvent, len+2);
3519 	}
3520 
3521 	return status;
3522 }
3523 
3524 static enum hci_status
bthci_CmdLinkStatusNotify(struct rtw_adapter * padapter,struct packet_irp_hcicmd_data * pHciCmd)3525 bthci_CmdLinkStatusNotify(
3526 	struct rtw_adapter *padapter,
3527 	struct packet_irp_hcicmd_data *pHciCmd
3528 	)
3529 {
3530 	enum hci_status	status = HCI_STATUS_SUCCESS;
3531 	struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
3532 	struct bt_mgnt *pBtMgnt = &pBTInfo->BtMgnt;
3533 	struct bt_dgb *pBtDbg = &pBTInfo->BtDbg;
3534 	u8 i;
3535 	u8 *pTriple;
3536 
3537 	pBtDbg->dbgHciInfo.hciCmdCntLinkStatusNotify++;
3538 	RTPRINT_DATA(FIOCTL, IOCTL_BT_HCICMD_EXT, "LinkStatusNotify, Hex Data :\n",
3539 			&pHciCmd->Data[0], pHciCmd->Length);
3540 
3541 	/*  Current only RTL8723 support this command. */
3542 	pBtMgnt->bSupportProfile = true;
3543 
3544 	pBtMgnt->ExtConfig.NumberOfHandle = *((u8 *)pHciCmd->Data);
3545 	RTPRINT(FIOCTL, IOCTL_BT_HCICMD_EXT, ("NumberOfHandle = 0x%x\n", pBtMgnt->ExtConfig.NumberOfHandle));
3546 	RTPRINT(FIOCTL, IOCTL_BT_HCICMD_EXT, ("HCIExtensionVer = %d\n", pBtMgnt->ExtConfig.HCIExtensionVer));
3547 
3548 	pTriple = &pHciCmd->Data[1];
3549 	for (i = 0; i < pBtMgnt->ExtConfig.NumberOfHandle; i++) {
3550 		if (pBtMgnt->ExtConfig.HCIExtensionVer < 1) {
3551 			pBtMgnt->ExtConfig.linkInfo[i].ConnectHandle = *((u16 *)&pTriple[0]);
3552 			pBtMgnt->ExtConfig.linkInfo[i].BTProfile = pTriple[2];
3553 			pBtMgnt->ExtConfig.linkInfo[i].BTCoreSpec = pTriple[3];
3554 			RTPRINT(FIOCTL, IOCTL_BT_HCICMD_EXT,
3555 				("Connection_Handle = 0x%x, BTProfile =%d, BTSpec =%d\n",
3556 				pBtMgnt->ExtConfig.linkInfo[i].ConnectHandle,
3557 				pBtMgnt->ExtConfig.linkInfo[i].BTProfile,
3558 				pBtMgnt->ExtConfig.linkInfo[i].BTCoreSpec));
3559 			pTriple += 4;
3560 		} else if (pBtMgnt->ExtConfig.HCIExtensionVer >= 1) {
3561 			pBtMgnt->ExtConfig.linkInfo[i].ConnectHandle = *((u16 *)&pTriple[0]);
3562 			pBtMgnt->ExtConfig.linkInfo[i].BTProfile = pTriple[2];
3563 			pBtMgnt->ExtConfig.linkInfo[i].BTCoreSpec = pTriple[3];
3564 			pBtMgnt->ExtConfig.linkInfo[i].linkRole = pTriple[4];
3565 			RTPRINT(FIOCTL, IOCTL_BT_HCICMD_EXT,
3566 				("Connection_Handle = 0x%x, BTProfile =%d, BTSpec =%d, LinkRole =%d\n",
3567 				pBtMgnt->ExtConfig.linkInfo[i].ConnectHandle,
3568 				pBtMgnt->ExtConfig.linkInfo[i].BTProfile,
3569 				pBtMgnt->ExtConfig.linkInfo[i].BTCoreSpec,
3570 				pBtMgnt->ExtConfig.linkInfo[i].linkRole));
3571 			pTriple += 5;
3572 		}
3573 
3574 	}
3575 	BTHCI_UpdateBTProfileRTKToMoto(padapter);
3576 	{
3577 		u8 localBuf[6] = "";
3578 		u8 *pRetPar;
3579 		u8 len = 0;
3580 		struct packet_irp_hcievent_data *PPacketIrpEvent;
3581 
3582 		PPacketIrpEvent = (struct packet_irp_hcievent_data *)(&localBuf[0]);
3583 
3584 		len += bthci_CommandCompleteHeader(&localBuf[0],
3585 			OGF_EXTENSION,
3586 			HCI_LINK_STATUS_NOTIFY,
3587 			status);
3588 
3589 		/*  Return parameters starts from here */
3590 		pRetPar = &PPacketIrpEvent->Data[len];
3591 		pRetPar[0] = status;		/* status */
3592 
3593 		len += 1;
3594 		PPacketIrpEvent->Length = len;
3595 
3596 		bthci_IndicateEvent(padapter, PPacketIrpEvent, len+2);
3597 	}
3598 
3599 	return status;
3600 }
3601 
3602 static enum hci_status
bthci_CmdBtOperationNotify(struct rtw_adapter * padapter,struct packet_irp_hcicmd_data * pHciCmd)3603 bthci_CmdBtOperationNotify(
3604 	struct rtw_adapter *padapter,
3605 	struct packet_irp_hcicmd_data *pHciCmd
3606 	)
3607 {
3608 	enum hci_status	status = HCI_STATUS_SUCCESS;
3609 	struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
3610 	struct bt_mgnt *pBtMgnt = &pBTInfo->BtMgnt;
3611 
3612 	RTPRINT_DATA(FIOCTL, IOCTL_BT_HCICMD_EXT, "Bt Operation notify, Hex Data :\n",
3613 			&pHciCmd->Data[0], pHciCmd->Length);
3614 
3615 	pBtMgnt->ExtConfig.btOperationCode = *((u8 *)pHciCmd->Data);
3616 	RTPRINT(FIOCTL, IOCTL_BT_HCICMD_EXT, ("btOperationCode = 0x%x\n", pBtMgnt->ExtConfig.btOperationCode));
3617 	switch (pBtMgnt->ExtConfig.btOperationCode) {
3618 	case HCI_BT_OP_NONE:
3619 		RTPRINT(FIOCTL, IOCTL_BT_HCICMD_EXT, ("[bt operation] : Operation None!!\n"));
3620 		break;
3621 	case HCI_BT_OP_INQUIRY_START:
3622 		RTPRINT(FIOCTL, IOCTL_BT_HCICMD_EXT, ("[bt operation] : Inquire start!!\n"));
3623 		break;
3624 	case HCI_BT_OP_INQUIRY_FINISH:
3625 		RTPRINT(FIOCTL, IOCTL_BT_HCICMD_EXT, ("[bt operation] : Inquire finished!!\n"));
3626 		break;
3627 	case HCI_BT_OP_PAGING_START:
3628 		RTPRINT(FIOCTL, IOCTL_BT_HCICMD_EXT, ("[bt operation] : Paging is started!!\n"));
3629 		break;
3630 	case HCI_BT_OP_PAGING_SUCCESS:
3631 		RTPRINT(FIOCTL, IOCTL_BT_HCICMD_EXT, ("[bt operation] : Paging complete successfully!!\n"));
3632 		break;
3633 	case HCI_BT_OP_PAGING_UNSUCCESS:
3634 		RTPRINT(FIOCTL, IOCTL_BT_HCICMD_EXT, ("[bt operation] : Paging complete unsuccessfully!!\n"));
3635 		break;
3636 	case HCI_BT_OP_PAIRING_START:
3637 		RTPRINT(FIOCTL, IOCTL_BT_HCICMD_EXT, ("[bt operation] : Pairing start!!\n"));
3638 		break;
3639 	case HCI_BT_OP_PAIRING_FINISH:
3640 		RTPRINT(FIOCTL, IOCTL_BT_HCICMD_EXT, ("[bt operation] : Pairing finished!!\n"));
3641 		break;
3642 	case HCI_BT_OP_BT_DEV_ENABLE:
3643 		RTPRINT(FIOCTL, IOCTL_BT_HCICMD_EXT, ("[bt operation] : BT Device is enabled!!\n"));
3644 		break;
3645 	case HCI_BT_OP_BT_DEV_DISABLE:
3646 		RTPRINT(FIOCTL, IOCTL_BT_HCICMD_EXT, ("[bt operation] : BT Device is disabled!!\n"));
3647 		break;
3648 	default:
3649 		RTPRINT(FIOCTL, IOCTL_BT_HCICMD_EXT, ("[bt operation] : Unknown, error!!\n"));
3650 		break;
3651 	}
3652 	BTDM_AdjustForBtOperation(padapter);
3653 	{
3654 		u8 localBuf[6] = "";
3655 		u8 *pRetPar;
3656 		u8 len = 0;
3657 		struct packet_irp_hcievent_data *PPacketIrpEvent;
3658 
3659 		PPacketIrpEvent = (struct packet_irp_hcievent_data *)(&localBuf[0]);
3660 
3661 		len += bthci_CommandCompleteHeader(&localBuf[0],
3662 			OGF_EXTENSION,
3663 			HCI_BT_OPERATION_NOTIFY,
3664 			status);
3665 
3666 		/*  Return parameters starts from here */
3667 		pRetPar = &PPacketIrpEvent->Data[len];
3668 		pRetPar[0] = status;		/* status */
3669 
3670 		len += 1;
3671 		PPacketIrpEvent->Length = len;
3672 
3673 		bthci_IndicateEvent(padapter, PPacketIrpEvent, len+2);
3674 	}
3675 
3676 	return status;
3677 }
3678 
3679 static enum hci_status
bthci_CmdEnableWifiScanNotify(struct rtw_adapter * padapter,struct packet_irp_hcicmd_data * pHciCmd)3680 bthci_CmdEnableWifiScanNotify(struct rtw_adapter *padapter,
3681 			      struct packet_irp_hcicmd_data *pHciCmd)
3682 {
3683 	enum hci_status	status = HCI_STATUS_SUCCESS;
3684 	struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
3685 	struct bt_mgnt *pBtMgnt = &pBTInfo->BtMgnt;
3686 
3687 	RTPRINT_DATA(FIOCTL, IOCTL_BT_HCICMD_EXT, "Enable Wifi scan notify, Hex Data :\n",
3688 			&pHciCmd->Data[0], pHciCmd->Length);
3689 
3690 	pBtMgnt->ExtConfig.bEnableWifiScanNotify = *((u8 *)pHciCmd->Data);
3691 	RTPRINT(FIOCTL, IOCTL_BT_HCICMD_EXT, ("bEnableWifiScanNotify = %d\n", pBtMgnt->ExtConfig.bEnableWifiScanNotify));
3692 
3693 	{
3694 		u8 localBuf[6] = "";
3695 		u8 *pRetPar;
3696 		u8 len = 0;
3697 		struct packet_irp_hcievent_data *PPacketIrpEvent;
3698 
3699 		PPacketIrpEvent = (struct packet_irp_hcievent_data *)(&localBuf[0]);
3700 
3701 		len += bthci_CommandCompleteHeader(&localBuf[0],
3702 			OGF_EXTENSION,
3703 			HCI_ENABLE_WIFI_SCAN_NOTIFY,
3704 			status);
3705 
3706 		/*  Return parameters starts from here */
3707 		pRetPar = &PPacketIrpEvent->Data[len];
3708 		pRetPar[0] = status;		/* status */
3709 
3710 		len += 1;
3711 		PPacketIrpEvent->Length = len;
3712 
3713 		bthci_IndicateEvent(padapter, PPacketIrpEvent, len+2);
3714 	}
3715 
3716 	return status;
3717 }
3718 
3719 static enum hci_status
bthci_CmdWIFICurrentChannel(struct rtw_adapter * padapter,struct packet_irp_hcicmd_data * pHciCmd)3720 bthci_CmdWIFICurrentChannel(struct rtw_adapter *padapter,
3721 			    struct packet_irp_hcicmd_data *pHciCmd)
3722 {
3723 	enum hci_status status = HCI_STATUS_SUCCESS;
3724 	struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
3725 	u8 chnl = pmlmeext->cur_channel;
3726 
3727 	if (pmlmeext->cur_bwmode == HT_CHANNEL_WIDTH_40) {
3728 		if (pmlmeext->cur_ch_offset == HAL_PRIME_CHNL_OFFSET_UPPER)
3729 			chnl += 2;
3730 		else if (pmlmeext->cur_ch_offset == HAL_PRIME_CHNL_OFFSET_LOWER)
3731 			chnl -= 2;
3732 	}
3733 
3734 	RTPRINT(FIOCTL, IOCTL_BT_HCICMD_EXT, ("Current Channel  = 0x%x\n", chnl));
3735 
3736 	{
3737 		u8 localBuf[8] = "";
3738 		u8 *pRetPar;
3739 		u8 len = 0;
3740 		struct packet_irp_hcievent_data *PPacketIrpEvent;
3741 
3742 		PPacketIrpEvent = (struct packet_irp_hcievent_data *)(&localBuf[0]);
3743 
3744 		len += bthci_CommandCompleteHeader(&localBuf[0],
3745 			OGF_EXTENSION,
3746 			HCI_WIFI_CURRENT_CHANNEL,
3747 			status);
3748 
3749 		/*  Return parameters starts from here */
3750 		pRetPar = &PPacketIrpEvent->Data[len];
3751 		pRetPar[0] = status;		/* status */
3752 		pRetPar[1] = chnl;			/* current channel */
3753 		len += 2;
3754 		PPacketIrpEvent->Length = len;
3755 
3756 		bthci_IndicateEvent(padapter, PPacketIrpEvent, len+2);
3757 	}
3758 
3759 	return status;
3760 }
3761 
3762 static enum hci_status
bthci_CmdWIFICurrentBandwidth(struct rtw_adapter * padapter,struct packet_irp_hcicmd_data * pHciCmd)3763 bthci_CmdWIFICurrentBandwidth(struct rtw_adapter *padapter,
3764 			      struct packet_irp_hcicmd_data *pHciCmd)
3765 {
3766 	enum hci_status status = HCI_STATUS_SUCCESS;
3767 	enum ht_channel_width bw;
3768 	u8 CurrentBW = 0;
3769 
3770 	bw = padapter->mlmeextpriv.cur_bwmode;
3771 
3772 	if (bw == HT_CHANNEL_WIDTH_20)
3773 		CurrentBW = 0;
3774 	else if (bw == HT_CHANNEL_WIDTH_40)
3775 		CurrentBW = 1;
3776 
3777 	RTPRINT(FIOCTL, IOCTL_BT_HCICMD_EXT, ("Current BW = 0x%x\n",
3778 		CurrentBW));
3779 
3780 	{
3781 		u8 localBuf[8] = "";
3782 		u8 *pRetPar;
3783 		u8 len = 0;
3784 		struct packet_irp_hcievent_data *PPacketIrpEvent;
3785 
3786 		PPacketIrpEvent = (struct packet_irp_hcievent_data *)(&localBuf[0]);
3787 
3788 		len += bthci_CommandCompleteHeader(&localBuf[0],
3789 			OGF_EXTENSION,
3790 			HCI_WIFI_CURRENT_BANDWIDTH,
3791 			status);
3792 
3793 		/*  Return parameters starts from here */
3794 		pRetPar = &PPacketIrpEvent->Data[len];
3795 		pRetPar[0] = status;		/* status */
3796 		pRetPar[1] = CurrentBW;		/* current BW */
3797 		len += 2;
3798 		PPacketIrpEvent->Length = len;
3799 
3800 		bthci_IndicateEvent(padapter, PPacketIrpEvent, len+2);
3801 	}
3802 
3803 	return status;
3804 }
3805 
3806 static enum hci_status
bthci_CmdWIFIConnectionStatus(struct rtw_adapter * padapter,struct packet_irp_hcicmd_data * pHciCmd)3807 bthci_CmdWIFIConnectionStatus(
3808 	struct rtw_adapter *padapter,
3809 	struct packet_irp_hcicmd_data *pHciCmd
3810 	)
3811 {
3812 	enum hci_status status = HCI_STATUS_SUCCESS;
3813 	u8 connectStatus = HCI_WIFI_NOT_CONNECTED;
3814 
3815 	if (check_fwstate(&padapter->mlmepriv, WIFI_AP_STATE)) {
3816 		if (padapter->stapriv.asoc_sta_count >= 3)
3817 			connectStatus = HCI_WIFI_CONNECTED;
3818 		else
3819 			connectStatus = HCI_WIFI_NOT_CONNECTED;
3820 	} else if (check_fwstate(&padapter->mlmepriv, WIFI_ADHOC_STATE|WIFI_ADHOC_MASTER_STATE|WIFI_ASOC_STATE)) {
3821 		connectStatus = HCI_WIFI_CONNECTED;
3822 	} else if (check_fwstate(&padapter->mlmepriv, WIFI_UNDER_LINKING)) {
3823 		connectStatus = HCI_WIFI_CONNECT_IN_PROGRESS;
3824 	} else {
3825 		connectStatus = HCI_WIFI_NOT_CONNECTED;
3826 	}
3827 
3828 	{
3829 		u8 localBuf[8] = "";
3830 		u8 *pRetPar;
3831 		u8 len = 0;
3832 		struct packet_irp_hcievent_data *PPacketIrpEvent;
3833 
3834 		PPacketIrpEvent = (struct packet_irp_hcievent_data *)(&localBuf[0]);
3835 
3836 		len += bthci_CommandCompleteHeader(&localBuf[0],
3837 			OGF_EXTENSION,
3838 			HCI_WIFI_CONNECTION_STATUS,
3839 			status);
3840 
3841 		/*  Return parameters starts from here */
3842 		pRetPar = &PPacketIrpEvent->Data[len];
3843 		pRetPar[0] = status;			/* status */
3844 		pRetPar[1] = connectStatus;	/* connect status */
3845 		len += 2;
3846 		PPacketIrpEvent->Length = len;
3847 
3848 		bthci_IndicateEvent(padapter, PPacketIrpEvent, len+2);
3849 	}
3850 
3851 	return status;
3852 }
3853 
3854 static enum hci_status
bthci_CmdEnableDeviceUnderTestMode(struct rtw_adapter * padapter,struct packet_irp_hcicmd_data * pHciCmd)3855 bthci_CmdEnableDeviceUnderTestMode(
3856 	struct rtw_adapter *padapter,
3857 	struct packet_irp_hcicmd_data *pHciCmd
3858 	)
3859 {
3860 	enum hci_status status = HCI_STATUS_SUCCESS;
3861 	struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
3862 	struct bt_hci_info *pBtHciInfo = &pBTInfo->BtHciInfo;
3863 
3864 	pBtHciInfo->bInTestMode = true;
3865 	pBtHciInfo->bTestIsEnd = false;
3866 
3867 	/* send command complete event here when all data are received. */
3868 	{
3869 		u8 localBuf[6] = "";
3870 		u8 *pRetPar;
3871 		u8 len = 0;
3872 		struct packet_irp_hcievent_data *PPacketIrpEvent;
3873 
3874 		PPacketIrpEvent = (struct packet_irp_hcievent_data *)(&localBuf[0]);
3875 
3876 		len += bthci_CommandCompleteHeader(&localBuf[0],
3877 			OGF_TESTING_COMMANDS,
3878 			HCI_ENABLE_DEVICE_UNDER_TEST_MODE,
3879 			status);
3880 
3881 		/*  Return parameters starts from here */
3882 		pRetPar = &PPacketIrpEvent->Data[len];
3883 		pRetPar[0] = status;		/* status */
3884 		len += 1;
3885 		PPacketIrpEvent->Length = len;
3886 
3887 		bthci_IndicateEvent(padapter, PPacketIrpEvent, len+2);
3888 	}
3889 
3890 	return status;
3891 }
3892 
3893 static enum hci_status
bthci_CmdAMPTestEnd(struct rtw_adapter * padapter,struct packet_irp_hcicmd_data * pHciCmd)3894 bthci_CmdAMPTestEnd(struct rtw_adapter *padapter,
3895 		    struct packet_irp_hcicmd_data *pHciCmd)
3896 {
3897 	enum hci_status status = HCI_STATUS_SUCCESS;
3898 	struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
3899 	struct bt_hci_info *pBtHciInfo = &pBTInfo->BtHciInfo;
3900 
3901 	if (!pBtHciInfo->bInTestMode) {
3902 		RTPRINT(FIOCTL, (IOCTL_BT_EVENT|IOCTL_BT_LOGO), ("Not in Test mode, return status = HCI_STATUS_CMD_DISALLOW\n"));
3903 		status = HCI_STATUS_CMD_DISALLOW;
3904 		return status;
3905 	}
3906 
3907 	pBtHciInfo->bTestIsEnd = true;
3908 
3909 	del_timer_sync(&pBTInfo->BTTestSendPacketTimer);
3910 
3911 	rtl8723a_check_bssid(padapter, true);
3912 
3913 	/* send command complete event here when all data are received. */
3914 	{
3915 		u8 localBuf[4] = "";
3916 		struct packet_irp_hcievent_data *PPacketIrpEvent;
3917 
3918 		RTPRINT(FIOCTL, (IOCTL_BT_EVENT|IOCTL_BT_LOGO), ("AMP Test End Event \n"));
3919 		PPacketIrpEvent = (struct packet_irp_hcievent_data *)(&localBuf[0]);
3920 		PPacketIrpEvent->EventCode = HCI_EVENT_AMP_TEST_END;
3921 		PPacketIrpEvent->Length = 2;
3922 
3923 		PPacketIrpEvent->Data[0] = status;
3924 		PPacketIrpEvent->Data[1] = pBtHciInfo->TestScenario;
3925 
3926 		bthci_IndicateEvent(padapter, PPacketIrpEvent, 4);
3927 	}
3928 
3929 	bthci_EventAMPReceiverReport(padapter, 0x01);
3930 
3931 	return status;
3932 }
3933 
3934 static enum hci_status
bthci_CmdAMPTestCommand(struct rtw_adapter * padapter,struct packet_irp_hcicmd_data * pHciCmd)3935 bthci_CmdAMPTestCommand(struct rtw_adapter *padapter,
3936 			struct packet_irp_hcicmd_data *pHciCmd)
3937 {
3938 	enum hci_status status = HCI_STATUS_SUCCESS;
3939 	struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
3940 	struct bt_hci_info *pBtHciInfo = &pBTInfo->BtHciInfo;
3941 
3942 	if (!pBtHciInfo->bInTestMode) {
3943 		RTPRINT(FIOCTL, (IOCTL_BT_EVENT|IOCTL_BT_LOGO), ("Not in Test mode, return status = HCI_STATUS_CMD_DISALLOW\n"));
3944 		status = HCI_STATUS_CMD_DISALLOW;
3945 		return status;
3946 	}
3947 
3948 	pBtHciInfo->TestScenario = *((u8 *)pHciCmd->Data);
3949 
3950 	if (pBtHciInfo->TestScenario == 0x01)
3951 		RTPRINT(FIOCTL, (IOCTL_BT_EVENT|IOCTL_BT_LOGO), ("TX Single Test \n"));
3952 	else if (pBtHciInfo->TestScenario == 0x02)
3953 		RTPRINT(FIOCTL, (IOCTL_BT_EVENT|IOCTL_BT_LOGO), ("Receive Frame Test \n"));
3954 	else
3955 		RTPRINT(FIOCTL, (IOCTL_BT_EVENT|IOCTL_BT_LOGO), ("No Such Test !!!!!!!!!!!!!!!!!! \n"));
3956 
3957 	if (pBtHciInfo->bTestIsEnd) {
3958 		u8 localBuf[5] = "";
3959 		struct packet_irp_hcievent_data *PPacketIrpEvent;
3960 
3961 		RTPRINT(FIOCTL, (IOCTL_BT_EVENT|IOCTL_BT_LOGO), ("AMP Test End Event \n"));
3962 		PPacketIrpEvent = (struct packet_irp_hcievent_data *)(&localBuf[0]);
3963 		PPacketIrpEvent->EventCode = HCI_EVENT_AMP_TEST_END;
3964 		PPacketIrpEvent->Length = 2;
3965 
3966 		PPacketIrpEvent->Data[0] = status;
3967 		PPacketIrpEvent->Data[1] = pBtHciInfo->TestScenario ;
3968 
3969 		bthci_IndicateEvent(padapter, PPacketIrpEvent, 4);
3970 
3971 		/* Return to Idel state with RX and TX off. */
3972 
3973 		return status;
3974 	}
3975 
3976 	/*  should send command status event */
3977 	bthci_EventCommandStatus(padapter,
3978 			OGF_TESTING_COMMANDS,
3979 			HCI_AMP_TEST_COMMAND,
3980 			status);
3981 
3982 	/* The HCI_AMP_Start Test Event shall be generated when the */
3983 	/* HCI_AMP_Test_Command has completed and the first data is ready to be sent */
3984 	/* or received. */
3985 
3986 	{
3987 		u8 localBuf[5] = "";
3988 		struct packet_irp_hcievent_data *PPacketIrpEvent;
3989 
3990 		RTPRINT(FIOCTL, (IOCTL_BT_EVENT|IOCTL_BT_LOGO), (" HCI_AMP_Start Test Event \n"));
3991 		PPacketIrpEvent = (struct packet_irp_hcievent_data *)(&localBuf[0]);
3992 		PPacketIrpEvent->EventCode = HCI_EVENT_AMP_START_TEST;
3993 		PPacketIrpEvent->Length = 2;
3994 
3995 		PPacketIrpEvent->Data[0] = status;
3996 		PPacketIrpEvent->Data[1] = pBtHciInfo->TestScenario ;
3997 
3998 		bthci_IndicateEvent(padapter, PPacketIrpEvent, 4);
3999 
4000 		/* Return to Idel state with RX and TX off. */
4001 	}
4002 
4003 	if (pBtHciInfo->TestScenario == 0x01) {
4004 		/*
4005 			When in a transmitter test scenario and the frames/bursts count have been
4006 			transmitted the HCI_AMP_Test_End event shall be sent.
4007 		*/
4008 		mod_timer(&pBTInfo->BTTestSendPacketTimer,
4009 			  jiffies + msecs_to_jiffies(50));
4010 		RTPRINT(FIOCTL, (IOCTL_BT_EVENT|IOCTL_BT_LOGO), ("TX Single Test \n"));
4011 	} else if (pBtHciInfo->TestScenario == 0x02) {
4012 		rtl8723a_check_bssid(padapter, false);
4013 		RTPRINT(FIOCTL, (IOCTL_BT_EVENT|IOCTL_BT_LOGO), ("Receive Frame Test \n"));
4014 	}
4015 
4016 	return status;
4017 }
4018 
4019 static enum hci_status
bthci_CmdEnableAMPReceiverReports(struct rtw_adapter * padapter,struct packet_irp_hcicmd_data * pHciCmd)4020 bthci_CmdEnableAMPReceiverReports(struct rtw_adapter *padapter,
4021 				  struct packet_irp_hcicmd_data *pHciCmd)
4022 {
4023 	enum hci_status status = HCI_STATUS_SUCCESS;
4024 	struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
4025 	struct bt_hci_info *pBtHciInfo = &pBTInfo->BtHciInfo;
4026 
4027 	if (!pBtHciInfo->bInTestMode) {
4028 		status = HCI_STATUS_CMD_DISALLOW;
4029 		/* send command complete event here when all data are received. */
4030 		{
4031 			u8 localBuf[6] = "";
4032 			u8 *pRetPar;
4033 			u8 len = 0;
4034 			struct packet_irp_hcievent_data *PPacketIrpEvent;
4035 
4036 			PPacketIrpEvent = (struct packet_irp_hcievent_data *)(&localBuf[0]);
4037 
4038 			len += bthci_CommandCompleteHeader(&localBuf[0],
4039 				OGF_TESTING_COMMANDS,
4040 				HCI_ENABLE_AMP_RECEIVER_REPORTS,
4041 				status);
4042 
4043 			/*  Return parameters starts from here */
4044 			pRetPar = &PPacketIrpEvent->Data[len];
4045 			pRetPar[0] = status;		/* status */
4046 			len += 1;
4047 			PPacketIrpEvent->Length = len;
4048 
4049 			bthci_IndicateEvent(padapter, PPacketIrpEvent, len+2);
4050 		}
4051 		return status;
4052 	}
4053 
4054 	pBtHciInfo->bTestNeedReport = *((u8 *)pHciCmd->Data);
4055 	pBtHciInfo->TestReportInterval = (*((u8 *)pHciCmd->Data+2));
4056 
4057 	bthci_EventAMPReceiverReport(padapter, 0x00);
4058 
4059 	/* send command complete event here when all data are received. */
4060 	{
4061 		u8 localBuf[6] = "";
4062 		u8 *pRetPar;
4063 		u8 len = 0;
4064 		struct packet_irp_hcievent_data *PPacketIrpEvent;
4065 
4066 		PPacketIrpEvent = (struct packet_irp_hcievent_data *)(&localBuf[0]);
4067 
4068 		len += bthci_CommandCompleteHeader(&localBuf[0],
4069 			OGF_TESTING_COMMANDS,
4070 			HCI_ENABLE_AMP_RECEIVER_REPORTS,
4071 			status);
4072 
4073 		/*  Return parameters starts from here */
4074 		pRetPar = &PPacketIrpEvent->Data[len];
4075 		pRetPar[0] = status;		/* status */
4076 		len += 1;
4077 		PPacketIrpEvent->Length = len;
4078 
4079 		bthci_IndicateEvent(padapter, PPacketIrpEvent, len+2);
4080 	}
4081 
4082 	return status;
4083 }
4084 
4085 static enum hci_status
bthci_CmdHostBufferSize(struct rtw_adapter * padapter,struct packet_irp_hcicmd_data * pHciCmd)4086 bthci_CmdHostBufferSize(struct rtw_adapter *padapter,
4087 			struct packet_irp_hcicmd_data *pHciCmd)
4088 {
4089 	struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
4090 	struct bt_mgnt *pBtMgnt = &pBTInfo->BtMgnt;
4091 	struct packet_irp_hcievent_data *PPacketIrpEvent;
4092 	enum hci_status status = HCI_STATUS_SUCCESS;
4093 	u8 localBuf[6] = "";
4094 	u8 *pRetPar;
4095 	u8 len = 0;
4096 
4097 	pBTInfo->BtAsocEntry[pBtMgnt->CurrentConnectEntryNum].ACLPacketsData.ACLDataPacketLen = *((u16 *)pHciCmd->Data);
4098 	pBTInfo->BtAsocEntry[pBtMgnt->CurrentConnectEntryNum].SyncDataPacketLen = *((u8 *)(pHciCmd->Data+2));
4099 	pBTInfo->BtAsocEntry[pBtMgnt->CurrentConnectEntryNum].TotalNumACLDataPackets = *((u16 *)(pHciCmd->Data+3));
4100 	pBTInfo->BtAsocEntry[pBtMgnt->CurrentConnectEntryNum].TotalSyncNumDataPackets = *((u16 *)(pHciCmd->Data+5));
4101 
4102 	/* send command complete event here when all data are received. */
4103 	PPacketIrpEvent = (struct packet_irp_hcievent_data *)(&localBuf[0]);
4104 
4105 	len += bthci_CommandCompleteHeader(&localBuf[0],
4106 		OGF_SET_EVENT_MASK_COMMAND,
4107 		HCI_HOST_BUFFER_SIZE,
4108 		status);
4109 
4110 	/*  Return parameters starts from here */
4111 	pRetPar = &PPacketIrpEvent->Data[len];
4112 	pRetPar[0] = status;		/* status */
4113 	len += 1;
4114 	PPacketIrpEvent->Length = len;
4115 
4116 	bthci_IndicateEvent(padapter, PPacketIrpEvent, len+2);
4117 
4118 	return status;
4119 }
4120 
4121 static enum hci_status
bthci_UnknownCMD(struct rtw_adapter * padapter,struct packet_irp_hcicmd_data * pHciCmd)4122 bthci_UnknownCMD(struct rtw_adapter *padapter, struct packet_irp_hcicmd_data *pHciCmd)
4123 {
4124 	enum hci_status status = HCI_STATUS_UNKNOW_HCI_CMD;
4125 	struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
4126 	struct bt_dgb *pBtDbg = &pBTInfo->BtDbg;
4127 
4128 	pBtDbg->dbgHciInfo.hciCmdCntUnknown++;
4129 	bthci_EventCommandStatus(padapter,
4130 			(u8)pHciCmd->OGF,
4131 			pHciCmd->OCF,
4132 			status);
4133 
4134 	return status;
4135 }
4136 
4137 static enum hci_status
bthci_HandleOGFInformationalParameters(struct rtw_adapter * padapter,struct packet_irp_hcicmd_data * pHciCmd)4138 bthci_HandleOGFInformationalParameters(struct rtw_adapter *padapter,
4139 				       struct packet_irp_hcicmd_data *pHciCmd)
4140 {
4141 	enum hci_status status = HCI_STATUS_SUCCESS;
4142 
4143 	switch (pHciCmd->OCF) {
4144 	case HCI_READ_LOCAL_VERSION_INFORMATION:
4145 		RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_READ_LOCAL_VERSION_INFORMATION\n"));
4146 		status = bthci_CmdReadLocalVersionInformation(padapter);
4147 		break;
4148 	case HCI_READ_LOCAL_SUPPORTED_COMMANDS:
4149 		RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_READ_LOCAL_SUPPORTED_COMMANDS\n"));
4150 		status = bthci_CmdReadLocalSupportedCommands(padapter);
4151 		break;
4152 	case HCI_READ_LOCAL_SUPPORTED_FEATURES:
4153 		RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_READ_LOCAL_SUPPORTED_FEATURES\n"));
4154 		status = bthci_CmdReadLocalSupportedFeatures(padapter);
4155 		break;
4156 	case HCI_READ_BUFFER_SIZE:
4157 		RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_READ_BUFFER_SIZE\n"));
4158 		status = bthci_CmdReadBufferSize(padapter);
4159 		break;
4160 	case HCI_READ_DATA_BLOCK_SIZE:
4161 		RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_READ_DATA_BLOCK_SIZE\n"));
4162 		status = bthci_CmdReadDataBlockSize(padapter);
4163 		break;
4164 	default:
4165 		RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("bthci_HandleOGFInformationalParameters(), Unknown case = 0x%x\n", pHciCmd->OCF));
4166 		RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_UNKNOWN_COMMAND\n"));
4167 		status = bthci_UnknownCMD(padapter, pHciCmd);
4168 		break;
4169 	}
4170 	return status;
4171 }
4172 
4173 static enum hci_status
bthci_HandleOGFSetEventMaskCMD(struct rtw_adapter * padapter,struct packet_irp_hcicmd_data * pHciCmd)4174 bthci_HandleOGFSetEventMaskCMD(struct rtw_adapter *padapter,
4175 			       struct packet_irp_hcicmd_data *pHciCmd)
4176 {
4177 	enum hci_status status = HCI_STATUS_SUCCESS;
4178 
4179 	switch (pHciCmd->OCF) {
4180 	case HCI_SET_EVENT_MASK:
4181 		RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_SET_EVENT_MASK\n"));
4182 		status = bthci_CmdSetEventMask(padapter, pHciCmd);
4183 		break;
4184 	case HCI_RESET:
4185 		RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_RESET\n"));
4186 		status = bthci_CmdReset(padapter, true);
4187 		break;
4188 	case HCI_READ_CONNECTION_ACCEPT_TIMEOUT:
4189 		RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_READ_CONNECTION_ACCEPT_TIMEOUT\n"));
4190 		status = bthci_CmdReadConnectionAcceptTimeout(padapter);
4191 		break;
4192 	case HCI_SET_EVENT_FILTER:
4193 		RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_SET_EVENT_FILTER\n"));
4194 		break;
4195 	case HCI_WRITE_CONNECTION_ACCEPT_TIMEOUT:
4196 		RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_WRITE_CONNECTION_ACCEPT_TIMEOUT\n"));
4197 		status = bthci_CmdWriteConnectionAcceptTimeout(padapter, pHciCmd);
4198 		break;
4199 	case HCI_READ_PAGE_TIMEOUT:
4200 		RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_READ_PAGE_TIMEOUT\n"));
4201 		status = bthci_CmdReadPageTimeout(padapter, pHciCmd);
4202 		break;
4203 	case HCI_WRITE_PAGE_TIMEOUT:
4204 		RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_WRITE_PAGE_TIMEOUT\n"));
4205 		status = bthci_CmdWritePageTimeout(padapter, pHciCmd);
4206 		break;
4207 	case HCI_HOST_NUMBER_OF_COMPLETED_PACKETS:
4208 		RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_HOST_NUMBER_OF_COMPLETED_PACKETS\n"));
4209 		break;
4210 	case HCI_READ_LINK_SUPERVISION_TIMEOUT:
4211 		RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_READ_LINK_SUPERVISION_TIMEOUT\n"));
4212 		status = bthci_CmdReadLinkSupervisionTimeout(padapter, pHciCmd);
4213 		break;
4214 	case HCI_WRITE_LINK_SUPERVISION_TIMEOUT:
4215 		RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_WRITE_LINK_SUPERVISION_TIMEOUT\n"));
4216 		status = bthci_CmdWriteLinkSupervisionTimeout(padapter, pHciCmd);
4217 		break;
4218 	case HCI_ENHANCED_FLUSH:
4219 		RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_ENHANCED_FLUSH\n"));
4220 		status = bthci_CmdEnhancedFlush(padapter, pHciCmd);
4221 		break;
4222 	case HCI_READ_LOGICAL_LINK_ACCEPT_TIMEOUT:
4223 		RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_READ_LOGICAL_LINK_ACCEPT_TIMEOUT\n"));
4224 		status = bthci_CmdReadLogicalLinkAcceptTimeout(padapter, pHciCmd);
4225 		break;
4226 	case HCI_WRITE_LOGICAL_LINK_ACCEPT_TIMEOUT:
4227 		RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_WRITE_LOGICAL_LINK_ACCEPT_TIMEOUT\n"));
4228 		status = bthci_CmdWriteLogicalLinkAcceptTimeout(padapter, pHciCmd);
4229 		break;
4230 	case HCI_SET_EVENT_MASK_PAGE_2:
4231 		RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_SET_EVENT_MASK_PAGE_2\n"));
4232 		status = bthci_CmdSetEventMaskPage2(padapter, pHciCmd);
4233 		break;
4234 	case HCI_READ_LOCATION_DATA:
4235 		RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_READ_LOCATION_DATA\n"));
4236 		status = bthci_CmdReadLocationData(padapter, pHciCmd);
4237 		break;
4238 	case HCI_WRITE_LOCATION_DATA:
4239 		RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_WRITE_LOCATION_DATA\n"));
4240 		status = bthci_CmdWriteLocationData(padapter, pHciCmd);
4241 		break;
4242 	case HCI_READ_FLOW_CONTROL_MODE:
4243 		RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_READ_FLOW_CONTROL_MODE\n"));
4244 		status = bthci_CmdReadFlowControlMode(padapter, pHciCmd);
4245 		break;
4246 	case HCI_WRITE_FLOW_CONTROL_MODE:
4247 		RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_WRITE_FLOW_CONTROL_MODE\n"));
4248 		status = bthci_CmdWriteFlowControlMode(padapter, pHciCmd);
4249 		break;
4250 	case HCI_READ_BEST_EFFORT_FLUSH_TIMEOUT:
4251 		RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_READ_BEST_EFFORT_FLUSH_TIMEOUT\n"));
4252 		status = bthci_CmdReadBestEffortFlushTimeout(padapter, pHciCmd);
4253 		break;
4254 	case HCI_WRITE_BEST_EFFORT_FLUSH_TIMEOUT:
4255 		RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_WRITE_BEST_EFFORT_FLUSH_TIMEOUT\n"));
4256 		status = bthci_CmdWriteBestEffortFlushTimeout(padapter, pHciCmd);
4257 		break;
4258 	case HCI_SHORT_RANGE_MODE:
4259 		RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_SHORT_RANGE_MODE\n"));
4260 		status = bthci_CmdShortRangeMode(padapter, pHciCmd);
4261 		break;
4262 	case HCI_HOST_BUFFER_SIZE:
4263 		RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_HOST_BUFFER_SIZE\n"));
4264 		status = bthci_CmdHostBufferSize(padapter, pHciCmd);
4265 		break;
4266 	default:
4267 		RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("bthci_HandleOGFSetEventMaskCMD(), Unknown case = 0x%x\n", pHciCmd->OCF));
4268 		RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_UNKNOWN_COMMAND\n"));
4269 		status = bthci_UnknownCMD(padapter, pHciCmd);
4270 		break;
4271 	}
4272 	return status;
4273 }
4274 
4275 static enum hci_status
bthci_HandleOGFStatusParameters(struct rtw_adapter * padapter,struct packet_irp_hcicmd_data * pHciCmd)4276 bthci_HandleOGFStatusParameters(struct rtw_adapter *padapter,
4277 				struct packet_irp_hcicmd_data *pHciCmd)
4278 {
4279 	enum hci_status status = HCI_STATUS_SUCCESS;
4280 
4281 	switch (pHciCmd->OCF) {
4282 	case HCI_READ_FAILED_CONTACT_COUNTER:
4283 		RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_READ_FAILED_CONTACT_COUNTER\n"));
4284 		status = bthci_CmdReadFailedContactCounter(padapter, pHciCmd);
4285 		break;
4286 	case HCI_RESET_FAILED_CONTACT_COUNTER:
4287 		RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_RESET_FAILED_CONTACT_COUNTER\n"));
4288 		status = bthci_CmdResetFailedContactCounter(padapter, pHciCmd);
4289 		break;
4290 	case HCI_READ_LINK_QUALITY:
4291 		RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_READ_LINK_QUALITY\n"));
4292 		status = bthci_CmdReadLinkQuality(padapter, pHciCmd);
4293 		break;
4294 	case HCI_READ_RSSI:
4295 		RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_READ_RSSI\n"));
4296 		break;
4297 	case HCI_READ_LOCAL_AMP_INFO:
4298 		RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_READ_LOCAL_AMP_INFO\n"));
4299 		status = bthci_CmdReadLocalAMPInfo(padapter);
4300 		break;
4301 	case HCI_READ_LOCAL_AMP_ASSOC:
4302 		RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_READ_LOCAL_AMP_ASSOC\n"));
4303 		status = bthci_CmdReadLocalAMPAssoc(padapter, pHciCmd);
4304 		break;
4305 	case HCI_WRITE_REMOTE_AMP_ASSOC:
4306 		RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_WRITE_REMOTE_AMP_ASSOC\n"));
4307 		status = bthci_CmdWriteRemoteAMPAssoc(padapter, pHciCmd);
4308 		break;
4309 	default:
4310 		RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("bthci_HandleOGFStatusParameters(), Unknown case = 0x%x\n", pHciCmd->OCF));
4311 		RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_UNKNOWN_COMMAND\n"));
4312 		status = bthci_UnknownCMD(padapter, pHciCmd);
4313 		break;
4314 	}
4315 	return status;
4316 }
4317 
4318 static enum hci_status
bthci_HandleOGFLinkControlCMD(struct rtw_adapter * padapter,struct packet_irp_hcicmd_data * pHciCmd)4319 bthci_HandleOGFLinkControlCMD(struct rtw_adapter *padapter,
4320 			      struct packet_irp_hcicmd_data *pHciCmd)
4321 {
4322 	enum hci_status status = HCI_STATUS_SUCCESS;
4323 
4324 	switch (pHciCmd->OCF) {
4325 	case HCI_CREATE_PHYSICAL_LINK:
4326 		RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_CREATE_PHYSICAL_LINK\n"));
4327 		status = bthci_CmdCreatePhysicalLink(padapter, pHciCmd);
4328 		break;
4329 	case HCI_ACCEPT_PHYSICAL_LINK:
4330 		RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_ACCEPT_PHYSICAL_LINK\n"));
4331 		status = bthci_CmdAcceptPhysicalLink(padapter, pHciCmd);
4332 		break;
4333 	case HCI_DISCONNECT_PHYSICAL_LINK:
4334 		RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_DISCONNECT_PHYSICAL_LINK\n"));
4335 		status = bthci_CmdDisconnectPhysicalLink(padapter, pHciCmd);
4336 		break;
4337 	case HCI_CREATE_LOGICAL_LINK:
4338 		RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_CREATE_LOGICAL_LINK\n"));
4339 		status = bthci_CmdCreateLogicalLink(padapter, pHciCmd);
4340 		break;
4341 	case HCI_ACCEPT_LOGICAL_LINK:
4342 		RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_ACCEPT_LOGICAL_LINK\n"));
4343 		status = bthci_CmdAcceptLogicalLink(padapter, pHciCmd);
4344 		break;
4345 	case HCI_DISCONNECT_LOGICAL_LINK:
4346 		RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_DISCONNECT_LOGICAL_LINK\n"));
4347 		status = bthci_CmdDisconnectLogicalLink(padapter, pHciCmd);
4348 		break;
4349 	case HCI_LOGICAL_LINK_CANCEL:
4350 		RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_LOGICAL_LINK_CANCEL\n"));
4351 		status = bthci_CmdLogicalLinkCancel(padapter, pHciCmd);
4352 		break;
4353 	case HCI_FLOW_SPEC_MODIFY:
4354 		RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_FLOW_SPEC_MODIFY\n"));
4355 		status = bthci_CmdFlowSpecModify(padapter, pHciCmd);
4356 		break;
4357 	default:
4358 		RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("bthci_HandleOGFLinkControlCMD(), Unknown case = 0x%x\n", pHciCmd->OCF));
4359 		RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_UNKNOWN_COMMAND\n"));
4360 		status = bthci_UnknownCMD(padapter, pHciCmd);
4361 		break;
4362 	}
4363 	return status;
4364 }
4365 
4366 static enum hci_status
bthci_HandleOGFTestingCMD(struct rtw_adapter * padapter,struct packet_irp_hcicmd_data * pHciCmd)4367 bthci_HandleOGFTestingCMD(struct rtw_adapter *padapter,
4368 			  struct packet_irp_hcicmd_data *pHciCmd)
4369 {
4370 	enum hci_status status = HCI_STATUS_SUCCESS;
4371 	switch (pHciCmd->OCF) {
4372 	case HCI_ENABLE_DEVICE_UNDER_TEST_MODE:
4373 		RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_ENABLE_DEVICE_UNDER_TEST_MODE\n"));
4374 		bthci_CmdEnableDeviceUnderTestMode(padapter, pHciCmd);
4375 		break;
4376 	case HCI_AMP_TEST_END:
4377 		RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_AMP_TEST_END\n"));
4378 		bthci_CmdAMPTestEnd(padapter, pHciCmd);
4379 		break;
4380 	case HCI_AMP_TEST_COMMAND:
4381 		RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_AMP_TEST_COMMAND\n"));
4382 		bthci_CmdAMPTestCommand(padapter, pHciCmd);
4383 		break;
4384 	case HCI_ENABLE_AMP_RECEIVER_REPORTS:
4385 		RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_ENABLE_AMP_RECEIVER_REPORTS\n"));
4386 		bthci_CmdEnableAMPReceiverReports(padapter, pHciCmd);
4387 		break;
4388 	default:
4389 		RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_UNKNOWN_COMMAND\n"));
4390 		status = bthci_UnknownCMD(padapter, pHciCmd);
4391 		break;
4392 	}
4393 	return status;
4394 }
4395 
4396 static enum hci_status
bthci_HandleOGFExtension(struct rtw_adapter * padapter,struct packet_irp_hcicmd_data * pHciCmd)4397 bthci_HandleOGFExtension(struct rtw_adapter *padapter,
4398 			 struct packet_irp_hcicmd_data *pHciCmd)
4399 {
4400 	enum hci_status status = HCI_STATUS_SUCCESS;
4401 	switch (pHciCmd->OCF) {
4402 	case HCI_SET_ACL_LINK_DATA_FLOW_MODE:
4403 		RTPRINT(FIOCTL, IOCTL_BT_HCICMD_EXT, ("HCI_SET_ACL_LINK_DATA_FLOW_MODE\n"));
4404 		status = bthci_CmdSetACLLinkDataFlowMode(padapter, pHciCmd);
4405 		break;
4406 	case HCI_SET_ACL_LINK_STATUS:
4407 		RTPRINT(FIOCTL, IOCTL_BT_HCICMD_EXT, ("HCI_SET_ACL_LINK_STATUS\n"));
4408 		status = bthci_CmdSetACLLinkStatus(padapter, pHciCmd);
4409 		break;
4410 	case HCI_SET_SCO_LINK_STATUS:
4411 		RTPRINT(FIOCTL, IOCTL_BT_HCICMD_EXT, ("HCI_SET_SCO_LINK_STATUS\n"));
4412 		status = bthci_CmdSetSCOLinkStatus(padapter, pHciCmd);
4413 		break;
4414 	case HCI_SET_RSSI_VALUE:
4415 		RTPRINT(FIOCTL, IOCTL_BT_EVENT_PERIODICAL, ("HCI_SET_RSSI_VALUE\n"));
4416 		status = bthci_CmdSetRSSIValue(padapter, pHciCmd);
4417 		break;
4418 	case HCI_SET_CURRENT_BLUETOOTH_STATUS:
4419 		RTPRINT(FIOCTL, IOCTL_BT_HCICMD_EXT, ("HCI_SET_CURRENT_BLUETOOTH_STATUS\n"));
4420 		status = bthci_CmdSetCurrentBluetoothStatus(padapter, pHciCmd);
4421 		break;
4422 	/* The following is for RTK8723 */
4423 
4424 	case HCI_EXTENSION_VERSION_NOTIFY:
4425 		RTPRINT(FIOCTL, IOCTL_BT_HCICMD_EXT, ("HCI_EXTENSION_VERSION_NOTIFY\n"));
4426 		status = bthci_CmdExtensionVersionNotify(padapter, pHciCmd);
4427 		break;
4428 	case HCI_LINK_STATUS_NOTIFY:
4429 		RTPRINT(FIOCTL, IOCTL_BT_HCICMD_EXT, ("HCI_LINK_STATUS_NOTIFY\n"));
4430 		status = bthci_CmdLinkStatusNotify(padapter, pHciCmd);
4431 		break;
4432 	case HCI_BT_OPERATION_NOTIFY:
4433 		RTPRINT(FIOCTL, IOCTL_BT_HCICMD_EXT, ("HCI_BT_OPERATION_NOTIFY\n"));
4434 		status = bthci_CmdBtOperationNotify(padapter, pHciCmd);
4435 		break;
4436 	case HCI_ENABLE_WIFI_SCAN_NOTIFY:
4437 		RTPRINT(FIOCTL, IOCTL_BT_HCICMD_EXT, ("HCI_ENABLE_WIFI_SCAN_NOTIFY\n"));
4438 		status = bthci_CmdEnableWifiScanNotify(padapter, pHciCmd);
4439 		break;
4440 
4441 	/* The following is for IVT */
4442 	case HCI_WIFI_CURRENT_CHANNEL:
4443 		RTPRINT(FIOCTL, IOCTL_BT_HCICMD_EXT, ("HCI_WIFI_CURRENT_CHANNEL\n"));
4444 		status = bthci_CmdWIFICurrentChannel(padapter, pHciCmd);
4445 		break;
4446 	case HCI_WIFI_CURRENT_BANDWIDTH:
4447 		RTPRINT(FIOCTL, IOCTL_BT_HCICMD_EXT, ("HCI_WIFI_CURRENT_BANDWIDTH\n"));
4448 		status = bthci_CmdWIFICurrentBandwidth(padapter, pHciCmd);
4449 		break;
4450 	case HCI_WIFI_CONNECTION_STATUS:
4451 		RTPRINT(FIOCTL, IOCTL_BT_HCICMD_EXT, ("HCI_WIFI_CONNECTION_STATUS\n"));
4452 		status = bthci_CmdWIFIConnectionStatus(padapter, pHciCmd);
4453 		break;
4454 
4455 	default:
4456 		RTPRINT(FIOCTL, IOCTL_BT_HCICMD_EXT, ("HCI_UNKNOWN_COMMAND\n"));
4457 		status = bthci_UnknownCMD(padapter, pHciCmd);
4458 		break;
4459 	}
4460 	return status;
4461 }
4462 
4463 static void
bthci_StateStarting(struct rtw_adapter * padapter,enum hci_state_with_cmd StateCmd,u8 EntryNum)4464 bthci_StateStarting(struct rtw_adapter *padapter,
4465 		    enum hci_state_with_cmd StateCmd, u8 EntryNum)
4466 {
4467 	struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
4468 	struct bt_mgnt *pBtMgnt = &pBTInfo->BtMgnt;
4469 
4470 	RTPRINT(FIOCTL, IOCTL_STATE, ("[BT state], [Starting], "));
4471 	switch (StateCmd) {
4472 	case STATE_CMD_CONNECT_ACCEPT_TIMEOUT:
4473 		RTPRINT(FIOCTL, IOCTL_STATE, ("STATE_CMD_CONNECT_ACCEPT_TIMEOUT\n"));
4474 		pBTInfo->BtAsocEntry[EntryNum].PhysLinkCompleteStatus = HCI_STATUS_CONNECT_ACCEPT_TIMEOUT;
4475 		pBtMgnt->bNeedNotifyAMPNoCap = true;
4476 		BTHCI_DisconnectPeer(padapter, EntryNum);
4477 		break;
4478 	case STATE_CMD_DISCONNECT_PHY_LINK:
4479 		RTPRINT(FIOCTL, IOCTL_STATE, ("STATE_CMD_DISCONNECT_PHY_LINK\n"));
4480 
4481 		bthci_EventDisconnectPhyLinkComplete(padapter,
4482 		HCI_STATUS_SUCCESS,
4483 		pBTInfo->BtAsocEntry[EntryNum].PhyLinkDisconnectReason,
4484 		EntryNum);
4485 
4486 		del_timer_sync(&pBTInfo->BTHCIJoinTimeoutTimer);
4487 
4488 		pBTInfo->BtAsocEntry[EntryNum].PhysLinkCompleteStatus = HCI_STATUS_UNKNOW_CONNECT_ID;
4489 
4490 		BTHCI_DisconnectPeer(padapter, EntryNum);
4491 		break;
4492 	case STATE_CMD_MAC_START_COMPLETE:
4493 		RTPRINT(FIOCTL, IOCTL_STATE, ("STATE_CMD_MAC_START_COMPLETE\n"));
4494 		if (pBTInfo->BtAsocEntry[EntryNum].AMPRole == AMP_BTAP_CREATOR)
4495 			bthci_EventChannelSelected(padapter, EntryNum);
4496 		break;
4497 	default:
4498 		RTPRINT(FIOCTL, IOCTL_STATE, ("State command(%d) is Wrong !!!\n", StateCmd));
4499 		break;
4500 	}
4501 }
4502 
4503 static void
bthci_StateConnecting(struct rtw_adapter * padapter,enum hci_state_with_cmd StateCmd,u8 EntryNum)4504 bthci_StateConnecting(struct rtw_adapter *padapter,
4505 		      enum hci_state_with_cmd StateCmd, u8 EntryNum)
4506 {
4507 	struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
4508 	struct bt_mgnt *pBtMgnt = &pBTInfo->BtMgnt;
4509 
4510 	RTPRINT(FIOCTL, IOCTL_STATE, ("[BT state], [Connecting], "));
4511 	switch (StateCmd) {
4512 	case STATE_CMD_CONNECT_ACCEPT_TIMEOUT:
4513 		RTPRINT(FIOCTL, IOCTL_STATE, ("STATE_CMD_CONNECT_ACCEPT_TIMEOUT\n"));
4514 		pBTInfo->BtAsocEntry[EntryNum].PhysLinkCompleteStatus = HCI_STATUS_CONNECT_ACCEPT_TIMEOUT;
4515 		pBtMgnt->bNeedNotifyAMPNoCap = true;
4516 		BTHCI_DisconnectPeer(padapter, EntryNum);
4517 		break;
4518 	case STATE_CMD_MAC_CONNECT_COMPLETE:
4519 		RTPRINT(FIOCTL, IOCTL_STATE, ("STATE_CMD_MAC_CONNECT_COMPLETE\n"));
4520 
4521 		if (pBTInfo->BtAsocEntry[EntryNum].AMPRole == AMP_BTAP_JOINER) {
4522 			RT_TRACE(_module_rtl871x_security_c_, _drv_info_,
4523 				 "StateConnecting\n");
4524 		}
4525 		break;
4526 	case STATE_CMD_DISCONNECT_PHY_LINK:
4527 		RTPRINT(FIOCTL, IOCTL_STATE, ("STATE_CMD_DISCONNECT_PHY_LINK\n"));
4528 
4529 		bthci_EventDisconnectPhyLinkComplete(padapter,
4530 		HCI_STATUS_SUCCESS,
4531 		pBTInfo->BtAsocEntry[EntryNum].PhyLinkDisconnectReason,
4532 		EntryNum);
4533 
4534 		pBTInfo->BtAsocEntry[EntryNum].PhysLinkCompleteStatus = HCI_STATUS_UNKNOW_CONNECT_ID;
4535 
4536 		del_timer_sync(&pBTInfo->BTHCIJoinTimeoutTimer);
4537 
4538 		BTHCI_DisconnectPeer(padapter, EntryNum);
4539 
4540 		break;
4541 	case STATE_CMD_MAC_CONNECT_CANCEL_INDICATE:
4542 		RTPRINT(FIOCTL, IOCTL_STATE, ("STATE_CMD_MAC_CONNECT_CANCEL_INDICATE\n"));
4543 		pBTInfo->BtAsocEntry[EntryNum].PhysLinkCompleteStatus = HCI_STATUS_CONTROLLER_BUSY;
4544 		/*  Because this state cmd is caused by the BTHCI_EventAMPStatusChange(), */
4545 		/*  we don't need to send event in the following BTHCI_DisconnectPeer() again. */
4546 		pBtMgnt->bNeedNotifyAMPNoCap = false;
4547 		BTHCI_DisconnectPeer(padapter, EntryNum);
4548 		break;
4549 	default:
4550 		RTPRINT(FIOCTL, IOCTL_STATE, ("State command(%d) is Wrong !!!\n", StateCmd));
4551 		break;
4552 	}
4553 }
4554 
4555 static void
bthci_StateConnected(struct rtw_adapter * padapter,enum hci_state_with_cmd StateCmd,u8 EntryNum)4556 bthci_StateConnected(struct rtw_adapter *padapter,
4557 		     enum hci_state_with_cmd StateCmd, u8 EntryNum)
4558 {
4559 /*PMGNT_INFO pMgntInfo = &padapter->MgntInfo; */
4560 	struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
4561 	struct bt_mgnt *pBtMgnt = &pBTInfo->BtMgnt;
4562 	u8 i;
4563 	u16 logicHandle = 0;
4564 
4565 	RTPRINT(FIOCTL, IOCTL_STATE, ("[BT state], [Connected], "));
4566 	switch (StateCmd) {
4567 	case STATE_CMD_DISCONNECT_PHY_LINK:
4568 		RTPRINT(FIOCTL, IOCTL_STATE, ("STATE_CMD_DISCONNECT_PHY_LINK\n"));
4569 
4570 		/* When we are trying to disconnect the phy link, we should disconnect log link first, */
4571 		for (i = 0; i < MAX_LOGICAL_LINK_NUM; i++) {
4572 			if (pBTInfo->BtAsocEntry[EntryNum].LogLinkCmdData->BtLogLinkhandle != 0) {
4573 				logicHandle = pBTInfo->BtAsocEntry[EntryNum].LogLinkCmdData->BtLogLinkhandle;
4574 
4575 				bthci_EventDisconnectLogicalLinkComplete(padapter, HCI_STATUS_SUCCESS,
4576 					logicHandle, pBTInfo->BtAsocEntry[EntryNum].PhyLinkDisconnectReason);
4577 
4578 				pBTInfo->BtAsocEntry[EntryNum].LogLinkCmdData->BtLogLinkhandle = 0;
4579 			}
4580 		}
4581 
4582 		bthci_EventDisconnectPhyLinkComplete(padapter,
4583 		HCI_STATUS_SUCCESS,
4584 		pBTInfo->BtAsocEntry[EntryNum].PhyLinkDisconnectReason,
4585 		EntryNum);
4586 
4587 		del_timer_sync(&pBTInfo->BTHCIJoinTimeoutTimer);
4588 
4589 		BTHCI_DisconnectPeer(padapter, EntryNum);
4590 		break;
4591 
4592 	case STATE_CMD_MAC_DISCONNECT_INDICATE:
4593 		RTPRINT(FIOCTL, IOCTL_STATE, ("STATE_CMD_MAC_DISCONNECT_INDICATE\n"));
4594 
4595 		bthci_EventDisconnectPhyLinkComplete(padapter,
4596 		HCI_STATUS_SUCCESS,
4597 		/*  TODO: Remote Host not local host */
4598 		HCI_STATUS_CONNECT_TERMINATE_LOCAL_HOST,
4599 		EntryNum);
4600 		BTHCI_DisconnectPeer(padapter, EntryNum);
4601 
4602 		break;
4603 	case STATE_CMD_ENTER_STATE:
4604 		RTPRINT(FIOCTL, IOCTL_STATE, ("STATE_CMD_ENTER_STATE\n"));
4605 
4606 		if (pBtMgnt->bBTConnectInProgress) {
4607 			pBtMgnt->bBTConnectInProgress = false;
4608 			RTPRINT(FIOCTL, IOCTL_STATE, ("[BT Flag], BT Connect in progress OFF!!\n"));
4609 		}
4610 		pBTInfo->BtAsocEntry[EntryNum].BtCurrentState = HCI_STATE_CONNECTED;
4611 		pBTInfo->BtAsocEntry[EntryNum].b4waySuccess = true;
4612 		pBtMgnt->bStartSendSupervisionPkt = true;
4613 
4614 		/*  for rate adaptive */
4615 
4616 		rtl8723a_update_ramask(padapter,
4617 				       MAX_FW_SUPPORT_MACID_NUM-1-EntryNum, 0);
4618 
4619 		HalSetBrateCfg23a(padapter, padapter->mlmepriv.cur_network.network.SupportedRates);
4620 		BTDM_SetFwChnlInfo(padapter, RT_MEDIA_CONNECT);
4621 		break;
4622 	default:
4623 		RTPRINT(FIOCTL, IOCTL_STATE, ("State command(%d) is Wrong !!!\n", StateCmd));
4624 		break;
4625 	}
4626 }
4627 
4628 static void
bthci_StateAuth(struct rtw_adapter * padapter,enum hci_state_with_cmd StateCmd,u8 EntryNum)4629 bthci_StateAuth(struct rtw_adapter *padapter, enum hci_state_with_cmd StateCmd,
4630 		u8 EntryNum)
4631 {
4632 	struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
4633 	struct bt_mgnt *pBtMgnt = &pBTInfo->BtMgnt;
4634 
4635 	RTPRINT(FIOCTL, IOCTL_STATE, ("[BT state], [Authenticating], "));
4636 	switch (StateCmd) {
4637 	case STATE_CMD_CONNECT_ACCEPT_TIMEOUT:
4638 		RTPRINT(FIOCTL, IOCTL_STATE, ("STATE_CMD_CONNECT_ACCEPT_TIMEOUT\n"));
4639 		pBTInfo->BtAsocEntry[EntryNum].PhysLinkCompleteStatus = HCI_STATUS_CONNECT_ACCEPT_TIMEOUT;
4640 		pBtMgnt->bNeedNotifyAMPNoCap = true;
4641 		BTHCI_DisconnectPeer(padapter, EntryNum);
4642 		break;
4643 	case STATE_CMD_DISCONNECT_PHY_LINK:
4644 		RTPRINT(FIOCTL, IOCTL_STATE, ("STATE_CMD_DISCONNECT_PHY_LINK\n"));
4645 		bthci_EventDisconnectPhyLinkComplete(padapter,
4646 		HCI_STATUS_SUCCESS,
4647 		pBTInfo->BtAsocEntry[EntryNum].PhyLinkDisconnectReason,
4648 		EntryNum);
4649 
4650 		pBTInfo->BtAsocEntry[EntryNum].PhysLinkCompleteStatus = HCI_STATUS_UNKNOW_CONNECT_ID;
4651 
4652 		del_timer_sync(&pBTInfo->BTHCIJoinTimeoutTimer);
4653 
4654 		BTHCI_DisconnectPeer(padapter, EntryNum);
4655 		break;
4656 	case STATE_CMD_4WAY_FAILED:
4657 		RTPRINT(FIOCTL, IOCTL_STATE, ("STATE_CMD_4WAY_FAILED\n"));
4658 
4659 		pBTInfo->BtAsocEntry[EntryNum].PhysLinkCompleteStatus = HCI_STATUS_AUTH_FAIL;
4660 		pBtMgnt->bNeedNotifyAMPNoCap = true;
4661 
4662 		BTHCI_DisconnectPeer(padapter, EntryNum);
4663 
4664 		del_timer_sync(&pBTInfo->BTHCIJoinTimeoutTimer);
4665 		break;
4666 	case STATE_CMD_4WAY_SUCCESSED:
4667 		RTPRINT(FIOCTL, IOCTL_STATE, ("STATE_CMD_4WAY_SUCCESSED\n"));
4668 
4669 		bthci_EventPhysicalLinkComplete(padapter, HCI_STATUS_SUCCESS, EntryNum, INVALID_PL_HANDLE);
4670 
4671 		del_timer_sync(&pBTInfo->BTHCIJoinTimeoutTimer);
4672 
4673 		BTHCI_SM_WITH_INFO(padapter, HCI_STATE_CONNECTED, STATE_CMD_ENTER_STATE, EntryNum);
4674 		break;
4675 	default:
4676 		RTPRINT(FIOCTL, IOCTL_STATE, ("State command(%d) is Wrong !!!\n", StateCmd));
4677 		break;
4678 	}
4679 }
4680 
4681 static void
bthci_StateDisconnecting(struct rtw_adapter * padapter,enum hci_state_with_cmd StateCmd,u8 EntryNum)4682 bthci_StateDisconnecting(struct rtw_adapter *padapter,
4683 			 enum hci_state_with_cmd StateCmd, u8 EntryNum)
4684 {
4685 	struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
4686 	struct bt_mgnt *pBtMgnt = &pBTInfo->BtMgnt;
4687 
4688 	RTPRINT(FIOCTL, IOCTL_STATE, ("[BT state], [Disconnecting], "));
4689 	switch (StateCmd) {
4690 	case STATE_CMD_MAC_CONNECT_CANCEL_INDICATE:
4691 		RTPRINT(FIOCTL, IOCTL_STATE, ("STATE_CMD_MAC_CONNECT_CANCEL_INDICATE\n"));
4692 		if (pBTInfo->BtAsocEntry[EntryNum].bNeedPhysLinkCompleteEvent) {
4693 			bthci_EventPhysicalLinkComplete(padapter,
4694 				pBTInfo->BtAsocEntry[EntryNum].PhysLinkCompleteStatus,
4695 				EntryNum, INVALID_PL_HANDLE);
4696 		}
4697 
4698 		if (pBtMgnt->bBTConnectInProgress) {
4699 			pBtMgnt->bBTConnectInProgress = false;
4700 			RTPRINT(FIOCTL, IOCTL_STATE, ("[BT Flag], BT Connect in progress OFF!!\n"));
4701 		}
4702 
4703 		BTHCI_SM_WITH_INFO(padapter, HCI_STATE_DISCONNECTED, STATE_CMD_ENTER_STATE, EntryNum);
4704 		break;
4705 	case STATE_CMD_DISCONNECT_PHY_LINK:
4706 		RTPRINT(FIOCTL, IOCTL_STATE, ("STATE_CMD_DISCONNECT_PHY_LINK\n"));
4707 
4708 		bthci_EventDisconnectPhyLinkComplete(padapter,
4709 		HCI_STATUS_SUCCESS,
4710 		pBTInfo->BtAsocEntry[EntryNum].PhyLinkDisconnectReason,
4711 		EntryNum);
4712 
4713 		del_timer_sync(&pBTInfo->BTHCIJoinTimeoutTimer);
4714 
4715 		BTHCI_DisconnectPeer(padapter, EntryNum);
4716 		break;
4717 	default:
4718 		RTPRINT(FIOCTL, IOCTL_STATE, ("State command(%d) is Wrong !!!\n", StateCmd));
4719 		break;
4720 	}
4721 }
4722 
4723 static void
bthci_StateDisconnected(struct rtw_adapter * padapter,enum hci_state_with_cmd StateCmd,u8 EntryNum)4724 bthci_StateDisconnected(struct rtw_adapter *padapter,
4725 			enum hci_state_with_cmd StateCmd, u8 EntryNum)
4726 {
4727 /*PMGNT_INFO pMgntInfo = &padapter->MgntInfo; */
4728 	struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
4729 	struct bt_hci_info *pBtHciInfo = &pBTInfo->BtHciInfo;
4730 	struct bt_mgnt *pBtMgnt = &pBTInfo->BtMgnt;
4731 
4732 	RTPRINT(FIOCTL, IOCTL_STATE, ("[BT state], [Disconnected], "));
4733 	switch (StateCmd) {
4734 	case STATE_CMD_CREATE_PHY_LINK:
4735 	case STATE_CMD_ACCEPT_PHY_LINK:
4736 		if (StateCmd == STATE_CMD_CREATE_PHY_LINK)
4737 			RTPRINT(FIOCTL, IOCTL_STATE, ("STATE_CMD_CREATE_PHY_LINK\n"));
4738 		else
4739 			RTPRINT(FIOCTL, IOCTL_STATE, ("STATE_CMD_ACCEPT_PHY_LINK\n"));
4740 
4741 		RTPRINT(FIOCTL, IOCTL_STATE, ("[BT PS], Disable IPS and LPS\n"));
4742 		ips_leave23a(padapter);
4743 		LPS_Leave23a(padapter);
4744 
4745 		pBtMgnt->bPhyLinkInProgress = true;
4746 		pBtMgnt->BTCurrentConnectType = BT_DISCONNECT;
4747 		pBtMgnt->CurrentBTConnectionCnt++;
4748 		RTPRINT(FIOCTL, IOCTL_STATE, ("[BT Flag], CurrentBTConnectionCnt = %d\n",
4749 			pBtMgnt->CurrentBTConnectionCnt));
4750 		pBtMgnt->BtOperationOn = true;
4751 		RTPRINT(FIOCTL, IOCTL_STATE, ("[BT Flag], Bt Operation ON!! CurrentConnectEntryNum = %d\n",
4752 			pBtMgnt->CurrentConnectEntryNum));
4753 
4754 		if (pBtMgnt->bBTConnectInProgress) {
4755 			bthci_EventPhysicalLinkComplete(padapter, HCI_STATUS_CONTROLLER_BUSY, INVALID_ENTRY_NUM, pBtMgnt->BtCurrentPhyLinkhandle);
4756 			bthci_RemoveEntryByEntryNum(padapter, EntryNum);
4757 			return;
4758 		}
4759 
4760 		if (StateCmd == STATE_CMD_CREATE_PHY_LINK)
4761 			pBTInfo->BtAsocEntry[EntryNum].AMPRole = AMP_BTAP_CREATOR;
4762 		else
4763 			pBTInfo->BtAsocEntry[EntryNum].AMPRole = AMP_BTAP_JOINER;
4764 
4765 		/*  1. MAC not yet in selected channel */
4766 		while (check_fwstate(&padapter->mlmepriv, WIFI_ASOC_STATE|WIFI_SITE_MONITOR)) {
4767 			RTPRINT(FIOCTL, IOCTL_STATE, ("Scan/Roaming/Wifi Link is in Progress, wait 200 ms\n"));
4768 			mdelay(200);
4769 		}
4770 		/*  2. MAC already in selected channel */
4771 		RTPRINT(FIOCTL, IOCTL_STATE, ("Channel is Ready\n"));
4772 		mod_timer(&pBTInfo->BTHCIJoinTimeoutTimer,
4773 			  jiffies + msecs_to_jiffies(pBtHciInfo->ConnAcceptTimeout));
4774 
4775 		pBTInfo->BtAsocEntry[EntryNum].bNeedPhysLinkCompleteEvent = true;
4776 		break;
4777 	case STATE_CMD_DISCONNECT_PHY_LINK:
4778 		RTPRINT(FIOCTL, IOCTL_STATE, ("STATE_CMD_DISCONNECT_PHY_LINK\n"));
4779 
4780 		del_timer_sync(&pBTInfo->BTHCIJoinTimeoutTimer);
4781 
4782 		bthci_EventDisconnectPhyLinkComplete(padapter,
4783 		HCI_STATUS_SUCCESS,
4784 		pBTInfo->BtAsocEntry[EntryNum].PhyLinkDisconnectReason,
4785 		EntryNum);
4786 
4787 		if (pBTInfo->BtAsocEntry[EntryNum].bNeedPhysLinkCompleteEvent) {
4788 			bthci_EventPhysicalLinkComplete(padapter,
4789 				HCI_STATUS_UNKNOW_CONNECT_ID,
4790 				EntryNum, INVALID_PL_HANDLE);
4791 		}
4792 
4793 		if (pBtMgnt->bBTConnectInProgress) {
4794 			pBtMgnt->bBTConnectInProgress = false;
4795 			RTPRINT(FIOCTL, IOCTL_STATE, ("[BT Flag], BT Connect in progress OFF!!\n"));
4796 		}
4797 		BTHCI_SM_WITH_INFO(padapter, HCI_STATE_DISCONNECTED, STATE_CMD_ENTER_STATE, EntryNum);
4798 		bthci_RemoveEntryByEntryNum(padapter, EntryNum);
4799 		break;
4800 	case STATE_CMD_ENTER_STATE:
4801 		RTPRINT(FIOCTL, IOCTL_STATE, ("STATE_CMD_ENTER_STATE\n"));
4802 		break;
4803 	default:
4804 		RTPRINT(FIOCTL, IOCTL_STATE, ("State command(%d) is Wrong !!!\n", StateCmd));
4805 		break;
4806 	}
4807 }
4808 
BTHCI_EventParse(struct rtw_adapter * padapter,void * pEvntData,u32 dataLen)4809 void BTHCI_EventParse(struct rtw_adapter *padapter, void *pEvntData, u32 dataLen)
4810 {
4811 }
4812 
BTHCI_HsConnectionEstablished(struct rtw_adapter * padapter)4813 u8 BTHCI_HsConnectionEstablished(struct rtw_adapter *padapter)
4814 {
4815 	u8 bBtConnectionExist = false;
4816 	struct bt_30info *pBtinfo = GET_BT_INFO(padapter);
4817 	u8 i;
4818 
4819 	for (i = 0; i < MAX_BT_ASOC_ENTRY_NUM; i++) {
4820 		if (pBtinfo->BtAsocEntry[i].b4waySuccess) {
4821 			bBtConnectionExist = true;
4822 			break;
4823 		}
4824 	}
4825 
4826 /*RTPRINT(FIOCTL, IOCTL_STATE, (" BTHCI_HsConnectionEstablished(), connection exist = %d\n", bBtConnectionExist)); */
4827 
4828 	return bBtConnectionExist;
4829 }
4830 
4831 static u8
BTHCI_CheckProfileExist(struct rtw_adapter * padapter,enum bt_traffic_mode_profile Profile)4832 BTHCI_CheckProfileExist(struct rtw_adapter *padapter,
4833 			enum bt_traffic_mode_profile Profile)
4834 {
4835 	struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
4836 	struct bt_mgnt *pBtMgnt = &pBTInfo->BtMgnt;
4837 	u8 IsPRofile = false;
4838 	u8 i = 0;
4839 
4840 	for (i = 0; i < pBtMgnt->ExtConfig.NumberOfHandle; i++) {
4841 		if (pBtMgnt->ExtConfig.linkInfo[i].TrafficProfile == Profile) {
4842 			IsPRofile = true;
4843 			break;
4844 		}
4845 	}
4846 
4847 	return IsPRofile;
4848 }
4849 
BTHCI_UpdateBTProfileRTKToMoto(struct rtw_adapter * padapter)4850 void BTHCI_UpdateBTProfileRTKToMoto(struct rtw_adapter *padapter)
4851 {
4852 	struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
4853 	struct bt_mgnt *pBtMgnt = &pBTInfo->BtMgnt;
4854 	u8 i = 0;
4855 
4856 	pBtMgnt->ExtConfig.NumberOfSCO = 0;
4857 
4858 	for (i = 0; i < pBtMgnt->ExtConfig.NumberOfHandle; i++) {
4859 		pBtMgnt->ExtConfig.linkInfo[i].TrafficProfile = BT_PROFILE_NONE;
4860 
4861 		if (pBtMgnt->ExtConfig.linkInfo[i].BTProfile == BT_PROFILE_SCO)
4862 			pBtMgnt->ExtConfig.NumberOfSCO++;
4863 
4864 		pBtMgnt->ExtConfig.linkInfo[i].TrafficProfile = pBtMgnt->ExtConfig.linkInfo[i].BTProfile;
4865 		switch (pBtMgnt->ExtConfig.linkInfo[i].TrafficProfile) {
4866 		case BT_PROFILE_SCO:
4867 			break;
4868 		case BT_PROFILE_PAN:
4869 			pBtMgnt->ExtConfig.linkInfo[i].IncomingTrafficMode = BT_MOTOR_EXT_BE;
4870 			pBtMgnt->ExtConfig.linkInfo[i].OutgoingTrafficMode = BT_MOTOR_EXT_BE;
4871 			break;
4872 		case BT_PROFILE_A2DP:
4873 			pBtMgnt->ExtConfig.linkInfo[i].IncomingTrafficMode = BT_MOTOR_EXT_GULB;
4874 			pBtMgnt->ExtConfig.linkInfo[i].OutgoingTrafficMode = BT_MOTOR_EXT_GULB;
4875 			break;
4876 		case BT_PROFILE_HID:
4877 			pBtMgnt->ExtConfig.linkInfo[i].IncomingTrafficMode = BT_MOTOR_EXT_GUL;
4878 			pBtMgnt->ExtConfig.linkInfo[i].OutgoingTrafficMode = BT_MOTOR_EXT_BE;
4879 			break;
4880 		default:
4881 			break;
4882 		}
4883 	}
4884 
4885 	RTPRINT(FBT, BT_TRACE, ("[DM][BT], RTK, NumberOfHandle = %d, NumberOfSCO = %d\n",
4886 		pBtMgnt->ExtConfig.NumberOfHandle, pBtMgnt->ExtConfig.NumberOfSCO));
4887 }
4888 
BTHCI_WifiScanNotify(struct rtw_adapter * padapter,u8 scanType)4889 void BTHCI_WifiScanNotify(struct rtw_adapter *padapter, u8 scanType)
4890 {
4891 	struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
4892 	struct bt_mgnt *pBtMgnt = &pBTInfo->BtMgnt;
4893 
4894 	if (pBtMgnt->ExtConfig.bEnableWifiScanNotify)
4895 		bthci_EventExtWifiScanNotify(padapter, scanType);
4896 }
4897 
4898 void
BTHCI_StateMachine(struct rtw_adapter * padapter,u8 StateToEnter,enum hci_state_with_cmd StateCmd,u8 EntryNum)4899 BTHCI_StateMachine(
4900 	struct rtw_adapter *padapter,
4901 	u8 		StateToEnter,
4902 	enum hci_state_with_cmd		StateCmd,
4903 	u8 		EntryNum
4904 	)
4905 {
4906 	struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
4907 	struct bt_mgnt *pBtMgnt = &pBTInfo->BtMgnt;
4908 
4909 	if (EntryNum == 0xff) {
4910 		RTPRINT(FIOCTL, IOCTL_STATE, (" StateMachine, error EntryNum = 0x%x \n", EntryNum));
4911 		return;
4912 	}
4913 	RTPRINT(FIOCTL, IOCTL_STATE, (" StateMachine, EntryNum = 0x%x, CurrentState = 0x%x, BtNextState = 0x%x,  StateCmd = 0x%x , StateToEnter = 0x%x\n",
4914 		EntryNum, pBTInfo->BtAsocEntry[EntryNum].BtCurrentState, pBTInfo->BtAsocEntry[EntryNum].BtNextState, StateCmd, StateToEnter));
4915 
4916 	if (pBTInfo->BtAsocEntry[EntryNum].BtNextState & StateToEnter) {
4917 		pBTInfo->BtAsocEntry[EntryNum].BtCurrentState = StateToEnter;
4918 
4919 		switch (StateToEnter) {
4920 		case HCI_STATE_STARTING:
4921 			pBTInfo->BtAsocEntry[EntryNum].BtNextState = HCI_STATE_DISCONNECTING | HCI_STATE_CONNECTING;
4922 			bthci_StateStarting(padapter, StateCmd, EntryNum);
4923 			break;
4924 		case HCI_STATE_CONNECTING:
4925 			pBTInfo->BtAsocEntry[EntryNum].BtNextState = HCI_STATE_CONNECTING | HCI_STATE_DISCONNECTING | HCI_STATE_AUTHENTICATING;
4926 			bthci_StateConnecting(padapter, StateCmd, EntryNum);
4927 			break;
4928 		case HCI_STATE_AUTHENTICATING:
4929 			pBTInfo->BtAsocEntry[EntryNum].BtNextState = HCI_STATE_DISCONNECTING | HCI_STATE_CONNECTED;
4930 			bthci_StateAuth(padapter, StateCmd, EntryNum);
4931 			break;
4932 		case HCI_STATE_CONNECTED:
4933 			pBTInfo->BtAsocEntry[EntryNum].BtNextState = HCI_STATE_CONNECTED | HCI_STATE_DISCONNECTING;
4934 			bthci_StateConnected(padapter, StateCmd, EntryNum);
4935 			break;
4936 		case HCI_STATE_DISCONNECTING:
4937 			pBTInfo->BtAsocEntry[EntryNum].BtNextState = HCI_STATE_DISCONNECTED | HCI_STATE_DISCONNECTING;
4938 			bthci_StateDisconnecting(padapter, StateCmd, EntryNum);
4939 			break;
4940 		case HCI_STATE_DISCONNECTED:
4941 			pBTInfo->BtAsocEntry[EntryNum].BtNextState = HCI_STATE_DISCONNECTED | HCI_STATE_STARTING | HCI_STATE_CONNECTING;
4942 			bthci_StateDisconnected(padapter, StateCmd, EntryNum);
4943 			break;
4944 		default:
4945 			RTPRINT(FIOCTL, IOCTL_STATE, (" StateMachine, Unknown state to enter!!!\n"));
4946 			break;
4947 		}
4948 	} else {
4949 		RTPRINT(FIOCTL, IOCTL_STATE, (" StateMachine, Wrong state to enter\n"));
4950 	}
4951 
4952 	/*  20100325 Joseph: Disable/Enable IPS/LPS according to BT status. */
4953 	if (!pBtMgnt->bBTConnectInProgress && !pBtMgnt->BtOperationOn) {
4954 		RTPRINT(FIOCTL, IOCTL_STATE, ("[BT PS], ips_enter23a()\n"));
4955 		ips_enter23a(padapter);
4956 	}
4957 }
4958 
BTHCI_DisconnectPeer(struct rtw_adapter * padapter,u8 EntryNum)4959 void BTHCI_DisconnectPeer(struct rtw_adapter *padapter, u8 EntryNum)
4960 {
4961 	struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
4962 	struct bt_mgnt *pBtMgnt = &pBTInfo->BtMgnt;
4963 
4964 	RTPRINT(FIOCTL, IOCTL_BT_HCICMD, (" BTHCI_DisconnectPeer()\n"));
4965 
4966 	BTHCI_SM_WITH_INFO(padapter, HCI_STATE_DISCONNECTING, STATE_CMD_MAC_CONNECT_CANCEL_INDICATE, EntryNum);
4967 
4968 	if (pBTInfo->BtAsocEntry[EntryNum].bUsed) {
4969 /*BTPKT_SendDeauthentication(padapter, pBTInfo->BtAsocEntry[EntryNum].BTRemoteMACAddr, unspec_reason); not porting yet */
4970 	}
4971 
4972 	if (pBtMgnt->bBTConnectInProgress) {
4973 		pBtMgnt->bBTConnectInProgress = false;
4974 		RTPRINT(FIOCTL, IOCTL_STATE, ("[BT Flag], BT Connect in progress OFF!!\n"));
4975 	}
4976 
4977 	bthci_RemoveEntryByEntryNum(padapter, EntryNum);
4978 
4979 	if (pBtMgnt->bNeedNotifyAMPNoCap) {
4980 		RTPRINT(FIOCTL, IOCTL_STATE, ("[BT AMPStatus], set to invalid in BTHCI_DisconnectPeer()\n"));
4981 		BTHCI_EventAMPStatusChange(padapter, AMP_STATUS_NO_CAPACITY_FOR_BT);
4982 	}
4983 }
4984 
BTHCI_EventNumOfCompletedDataBlocks(struct rtw_adapter * padapter)4985 void BTHCI_EventNumOfCompletedDataBlocks(struct rtw_adapter *padapter)
4986 {
4987 /*PMGNT_INFO pMgntInfo = &padapter->MgntInfo; */
4988 	struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
4989 	struct bt_hci_info *pBtHciInfo = &pBTInfo->BtHciInfo;
4990 	u8 localBuf[TmpLocalBufSize] = "";
4991 	u8 *pRetPar, *pTriple;
4992 	u8 len = 0, i, j, handleNum = 0;
4993 	struct packet_irp_hcievent_data *PPacketIrpEvent;
4994 	u16 *pu2Temp, *pPackets, *pHandle, *pDblocks;
4995 	u8 sent = 0;
4996 
4997 	PPacketIrpEvent = (struct packet_irp_hcievent_data *)(&localBuf[0]);
4998 
4999 	if (!(pBtHciInfo->BTEventMaskPage2 & EMP2_HCI_EVENT_NUM_OF_COMPLETE_DATA_BLOCKS)) {
5000 		RTPRINT(FIOCTL, IOCTL_BT_EVENT, ("[BT event], Num Of Completed DataBlocks, Ignore to send NumOfCompletedDataBlocksEvent due to event mask page 2\n"));
5001 		return;
5002 	}
5003 
5004 	/*  Return parameters starts from here */
5005 	pRetPar = &PPacketIrpEvent->Data[0];
5006 	pTriple = &pRetPar[3];
5007 	for (j = 0; j < MAX_BT_ASOC_ENTRY_NUM; j++) {
5008 
5009 		for (i = 0; i < MAX_LOGICAL_LINK_NUM; i++) {
5010 			if (pBTInfo->BtAsocEntry[j].LogLinkCmdData[i].BtLogLinkhandle) {
5011 				handleNum++;
5012 				pHandle = (u16 *)&pTriple[0];	/*  Handle[i] */
5013 				pPackets = (u16 *)&pTriple[2];	/*  Num_Of_Completed_Packets[i] */
5014 				pDblocks = (u16 *)&pTriple[4];	/*  Num_Of_Completed_Blocks[i] */
5015 				*pHandle = pBTInfo->BtAsocEntry[j].LogLinkCmdData[i].BtLogLinkhandle;
5016 				*pPackets = (u16)pBTInfo->BtAsocEntry[j].LogLinkCmdData[i].TxPacketCount;
5017 				*pDblocks = (u16)pBTInfo->BtAsocEntry[j].LogLinkCmdData[i].TxPacketCount;
5018 				if (pBTInfo->BtAsocEntry[j].LogLinkCmdData[i].TxPacketCount) {
5019 					sent = 1;
5020 					RTPRINT(FIOCTL, IOCTL_BT_EVENT_DETAIL,
5021 						("[BT event], Num Of Completed DataBlocks, Handle = 0x%x, Num_Of_Completed_Packets = 0x%x, Num_Of_Completed_Blocks = 0x%x\n",
5022 					*pHandle, *pPackets, *pDblocks));
5023 				}
5024 				pBTInfo->BtAsocEntry[j].LogLinkCmdData[i].TxPacketCount = 0;
5025 				len += 6;
5026 				pTriple += len;
5027 			}
5028 		}
5029 	}
5030 
5031 	pRetPar[2] = handleNum;				/*  Number_of_Handles */
5032 	len += 1;
5033 	pu2Temp = (u16 *)&pRetPar[0];
5034 	*pu2Temp = BTTotalDataBlockNum;
5035 	len += 2;
5036 
5037 	PPacketIrpEvent->EventCode = HCI_EVENT_NUM_OF_COMPLETE_DATA_BLOCKS;
5038 	PPacketIrpEvent->Length = len;
5039 	if (handleNum && sent)
5040 		bthci_IndicateEvent(padapter, PPacketIrpEvent, len+2);
5041 }
5042 
BTHCI_EventAMPStatusChange(struct rtw_adapter * padapter,u8 AMP_Status)5043 void BTHCI_EventAMPStatusChange(struct rtw_adapter *padapter, u8 AMP_Status)
5044 {
5045 	struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
5046 	struct bt_mgnt *pBtMgnt = &pBTInfo->BtMgnt;
5047 	struct packet_irp_hcievent_data *PPacketIrpEvent;
5048 	u8 len = 0;
5049 	u8 localBuf[7] = "";
5050 	u8 *pRetPar;
5051 
5052 	if (AMP_Status == AMP_STATUS_NO_CAPACITY_FOR_BT) {
5053 		pBtMgnt->BTNeedAMPStatusChg = true;
5054 		pBtMgnt->bNeedNotifyAMPNoCap = false;
5055 
5056 		BTHCI_DisconnectAll(padapter);
5057 	} else if (AMP_Status == AMP_STATUS_FULL_CAPACITY_FOR_BT) {
5058 		pBtMgnt->BTNeedAMPStatusChg = false;
5059 	}
5060 
5061 	PPacketIrpEvent = (struct packet_irp_hcievent_data *)(&localBuf[0]);
5062 	/*  Return parameters starts from here */
5063 	pRetPar = &PPacketIrpEvent->Data[0];
5064 
5065 	pRetPar[0] = 0;	/*  Status */
5066 	len += 1;
5067 	pRetPar[1] = AMP_Status;	/*  AMP_Status */
5068 	len += 1;
5069 
5070 	PPacketIrpEvent->EventCode = HCI_EVENT_AMP_STATUS_CHANGE;
5071 	PPacketIrpEvent->Length = len;
5072 	if (bthci_IndicateEvent(padapter, PPacketIrpEvent, len+2) == RT_STATUS_SUCCESS)
5073 		RTPRINT(FIOCTL, (IOCTL_BT_EVENT|IOCTL_STATE), ("[BT event], AMP Status Change, AMP_Status = %d\n", AMP_Status));
5074 }
5075 
BTHCI_DisconnectAll(struct rtw_adapter * padapter)5076 void BTHCI_DisconnectAll(struct rtw_adapter *padapter)
5077 {
5078 	struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
5079 	u8 i;
5080 
5081 	RTPRINT(FIOCTL, IOCTL_STATE, (" DisconnectALL()\n"));
5082 
5083 	for (i = 0; i < MAX_BT_ASOC_ENTRY_NUM; i++) {
5084 		if (pBTInfo->BtAsocEntry[i].b4waySuccess) {
5085 			BTHCI_SM_WITH_INFO(padapter, HCI_STATE_CONNECTED, STATE_CMD_DISCONNECT_PHY_LINK, i);
5086 		} else if (pBTInfo->BtAsocEntry[i].bUsed) {
5087 			if (pBTInfo->BtAsocEntry[i].BtCurrentState == HCI_STATE_CONNECTING) {
5088 				BTHCI_SM_WITH_INFO(padapter, HCI_STATE_CONNECTING, STATE_CMD_MAC_CONNECT_CANCEL_INDICATE, i);
5089 			} else if (pBTInfo->BtAsocEntry[i].BtCurrentState == HCI_STATE_DISCONNECTING) {
5090 				BTHCI_SM_WITH_INFO(padapter, HCI_STATE_DISCONNECTING, STATE_CMD_MAC_CONNECT_CANCEL_INDICATE, i);
5091 			}
5092 		}
5093 	}
5094 }
5095 
5096 enum hci_status
BTHCI_HandleHCICMD(struct rtw_adapter * padapter,struct packet_irp_hcicmd_data * pHciCmd)5097 BTHCI_HandleHCICMD(
5098 	struct rtw_adapter *padapter,
5099 	struct packet_irp_hcicmd_data *pHciCmd
5100 	)
5101 {
5102 	enum hci_status	status = HCI_STATUS_SUCCESS;
5103 	struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
5104 	struct bt_dgb *pBtDbg = &pBTInfo->BtDbg;
5105 
5106 	RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("\n"));
5107 	RTPRINT(FIOCTL, (IOCTL_BT_HCICMD_DETAIL|IOCTL_BT_LOGO), ("HCI Command start, OGF = 0x%x, OCF = 0x%x, Length = 0x%x\n",
5108 		pHciCmd->OGF, pHciCmd->OCF, pHciCmd->Length));
5109 	if (pHciCmd->Length) {
5110 		RTPRINT_DATA(FIOCTL, (IOCTL_BT_HCICMD_DETAIL|IOCTL_BT_LOGO), "HCI Command, Hex Data :\n",
5111 			&pHciCmd->Data[0], pHciCmd->Length);
5112 	}
5113 	if (pHciCmd->OGF == OGF_EXTENSION) {
5114 		if (pHciCmd->OCF == HCI_SET_RSSI_VALUE)
5115 			RTPRINT(FIOCTL, IOCTL_BT_EVENT_PERIODICAL, ("[BT cmd], "));
5116 		else
5117 			RTPRINT(FIOCTL, IOCTL_BT_HCICMD_EXT, ("[BT cmd], "));
5118 	} else {
5119 		RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("[BT cmd], "));
5120 	}
5121 
5122 	pBtDbg->dbgHciInfo.hciCmdCnt++;
5123 
5124 	switch (pHciCmd->OGF) {
5125 	case LINK_CONTROL_COMMANDS:
5126 		status = bthci_HandleOGFLinkControlCMD(padapter, pHciCmd);
5127 		break;
5128 	case HOLD_MODE_COMMAND:
5129 		break;
5130 	case OGF_SET_EVENT_MASK_COMMAND:
5131 		status = bthci_HandleOGFSetEventMaskCMD(padapter, pHciCmd);
5132 		break;
5133 	case OGF_INFORMATIONAL_PARAMETERS:
5134 		status = bthci_HandleOGFInformationalParameters(padapter, pHciCmd);
5135 		break;
5136 	case OGF_STATUS_PARAMETERS:
5137 		status = bthci_HandleOGFStatusParameters(padapter, pHciCmd);
5138 		break;
5139 	case OGF_TESTING_COMMANDS:
5140 		status = bthci_HandleOGFTestingCMD(padapter, pHciCmd);
5141 		break;
5142 	case OGF_EXTENSION:
5143 		status = bthci_HandleOGFExtension(padapter, pHciCmd);
5144 		break;
5145 	default:
5146 		RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI Command(), Unknown OGF = 0x%x\n", pHciCmd->OGF));
5147 		RTPRINT(FIOCTL, IOCTL_BT_HCICMD, ("HCI_UNKNOWN_COMMAND\n"));
5148 		status = bthci_UnknownCMD(padapter, pHciCmd);
5149 		break;
5150 	}
5151 	RTPRINT(FIOCTL, IOCTL_BT_HCICMD_DETAIL, ("HCI Command execution end!!\n"));
5152 
5153 	return status;
5154 }
5155 
5156 /*  ===== End of sync from SD7 driver COMMOM/bt_hci.c ===== */
5157 
5158 static const char *const BtStateString[] = {
5159 	"BT_DISABLED",
5160 	"BT_NO_CONNECTION",
5161 	"BT_CONNECT_IDLE",
5162 	"BT_INQ_OR_PAG",
5163 	"BT_ACL_ONLY_BUSY",
5164 	"BT_SCO_ONLY_BUSY",
5165 	"BT_ACL_SCO_BUSY",
5166 	"BT_ACL_INQ_OR_PAG",
5167 	"BT_STATE_NOT_DEFINED"
5168 };
5169 
5170 /*  ===== Below this line is sync from SD7 driver HAL/BTCoexist/HalBtc87231Ant.c ===== */
5171 
btdm_SetFwIgnoreWlanAct(struct rtw_adapter * padapter,u8 bEnable)5172 static void btdm_SetFwIgnoreWlanAct(struct rtw_adapter *padapter, u8 bEnable)
5173 {
5174 	struct hal_data_8723a *pHalData = GET_HAL_DATA(padapter);
5175 	u8 H2C_Parameter[1] = {0};
5176 
5177 	if (bEnable) {
5178 		RTPRINT(FBT, BT_TRACE, ("[BTCoex], BT Ignore Wlan_Act !!\n"));
5179 		H2C_Parameter[0] |= BIT(0);		/*  function enable */
5180 		pHalData->bt_coexist.bFWCoexistAllOff = false;
5181 	} else {
5182 		RTPRINT(FBT, BT_TRACE, ("[BTCoex], BT don't ignore Wlan_Act !!\n"));
5183 	}
5184 
5185 	RTPRINT(FBT, BT_TRACE, ("[BTCoex], set FW for BT Ignore Wlan_Act, write 0x25 = 0x%02x\n",
5186 		H2C_Parameter[0]));
5187 
5188 	FillH2CCmd(padapter, BT_IGNORE_WLAN_ACT_EID, 1, H2C_Parameter);
5189 }
5190 
btdm_NotifyFwScan(struct rtw_adapter * padapter,u8 scanType)5191 static void btdm_NotifyFwScan(struct rtw_adapter *padapter, u8 scanType)
5192 {
5193 	u8 H2C_Parameter[1] = {0};
5194 
5195 	if (scanType == true)
5196 		H2C_Parameter[0] = 0x1;
5197 
5198 	RTPRINT(FBT, BT_TRACE, ("[BTCoex], Notify FW for wifi scan, write 0x3b = 0x%02x\n",
5199 		H2C_Parameter[0]));
5200 
5201 	FillH2CCmd(padapter, 0x3b, 1, H2C_Parameter);
5202 }
5203 
btdm_1AntSetPSMode(struct rtw_adapter * padapter,u8 enable,u8 smartps,u8 mode)5204 static void btdm_1AntSetPSMode(struct rtw_adapter *padapter,
5205 			       u8 enable, u8 smartps, u8 mode)
5206 {
5207 	struct pwrctrl_priv *pwrctrl;
5208 
5209 	RTPRINT(FBT, BT_TRACE, ("[BTCoex], Current LPS(%s, %d), smartps =%d\n", enable == true?"ON":"OFF", mode, smartps));
5210 
5211 	pwrctrl = &padapter->pwrctrlpriv;
5212 
5213 	if (enable == true) {
5214 		rtw_set_ps_mode23a(padapter, PS_MODE_MIN, smartps, mode);
5215 	} else {
5216 		rtw_set_ps_mode23a(padapter, PS_MODE_ACTIVE, 0, 0);
5217 		LPS_RF_ON_check23a(padapter, 100);
5218 	}
5219 }
5220 
btdm_1AntTSFSwitch(struct rtw_adapter * padapter,u8 enable)5221 static void btdm_1AntTSFSwitch(struct rtw_adapter *padapter, u8 enable)
5222 {
5223 	u8 oldVal, newVal;
5224 
5225 	oldVal = rtl8723au_read8(padapter, 0x550);
5226 
5227 	if (enable)
5228 		newVal = oldVal | EN_BCN_FUNCTION;
5229 	else
5230 		newVal = oldVal & ~EN_BCN_FUNCTION;
5231 
5232 	if (oldVal != newVal)
5233 		rtl8723au_write8(padapter, 0x550, newVal);
5234 }
5235 
btdm_Is1AntPsTdmaStateChange(struct rtw_adapter * padapter)5236 static u8 btdm_Is1AntPsTdmaStateChange(struct rtw_adapter *padapter)
5237 {
5238 	struct hal_data_8723a *pHalData = GET_HAL_DATA(padapter);
5239 	struct btdm_8723a_1ant *pBtdm8723 = &pHalData->bt_coexist.halCoex8723.btdm1Ant;
5240 
5241 	if ((pBtdm8723->bPrePsTdmaOn != pBtdm8723->bCurPsTdmaOn) ||
5242 		(pBtdm8723->prePsTdma != pBtdm8723->curPsTdma))
5243 		return true;
5244 	else
5245 		return false;
5246 }
5247 
5248 /*  Before enter TDMA, make sure Power Saving is enable! */
5249 static void
btdm_1AntPsTdma(struct rtw_adapter * padapter,u8 bTurnOn,u8 type)5250 btdm_1AntPsTdma(
5251 	struct rtw_adapter *padapter,
5252 	u8 bTurnOn,
5253 	u8 type
5254 	)
5255 {
5256 	struct hal_data_8723a *pHalData = GET_HAL_DATA(padapter);
5257 	struct btdm_8723a_1ant *pBtdm8723 = &pHalData->bt_coexist.halCoex8723.btdm1Ant;
5258 
5259 	pBtdm8723->bCurPsTdmaOn = bTurnOn;
5260 	pBtdm8723->curPsTdma = type;
5261 	if (bTurnOn) {
5262 		switch (type) {
5263 		case 1:	/*  A2DP Level-1 or FTP/OPP */
5264 		default:
5265 			if (btdm_Is1AntPsTdmaStateChange(padapter)) {
5266 				/*  wide duration for WiFi */
5267 				BTDM_SetFw3a(padapter, 0xd3, 0x1a, 0x1a, 0x0, 0x58);
5268 			}
5269 			break;
5270 		case 2:	/*  A2DP Level-2 */
5271 			if (btdm_Is1AntPsTdmaStateChange(padapter)) {
5272 				/*  normal duration for WiFi */
5273 				BTDM_SetFw3a(padapter, 0xd3, 0x12, 0x12, 0x0, 0x58);
5274 			}
5275 			break;
5276 		case 3:	/*  BT FTP/OPP */
5277 			if (btdm_Is1AntPsTdmaStateChange(padapter)) {
5278 				/*  normal duration for WiFi */
5279 				BTDM_SetFw3a(padapter, 0xd3, 0x30, 0x03, 0x10, 0x58);
5280 
5281 			}
5282 			break;
5283 		case 4:	/*  for wifi scan & BT is connected */
5284 			if (btdm_Is1AntPsTdmaStateChange(padapter)) {
5285 				/*  protect 3 beacons in 3-beacon period & no Tx pause at BT slot */
5286 				BTDM_SetFw3a(padapter, 0x93, 0x15, 0x03, 0x14, 0x0);
5287 			}
5288 			break;
5289 		case 5:	/*  for WiFi connected-busy & BT is Non-Connected-Idle */
5290 			if (btdm_Is1AntPsTdmaStateChange(padapter)) {
5291 				/*  SCO mode, Ant fixed at WiFi, WLAN_Act toggle */
5292 				BTDM_SetFw3a(padapter, 0x61, 0x15, 0x03, 0x31, 0x00);
5293 			}
5294 			break;
5295 		case 9:	/*  ACL high-retry type - 2 */
5296 			if (btdm_Is1AntPsTdmaStateChange(padapter)) {
5297 				/*  narrow duration for WiFi */
5298 				BTDM_SetFw3a(padapter, 0xd3, 0xa, 0xa, 0x0, 0x58); /* narrow duration for WiFi */
5299 			}
5300 			break;
5301 		case 10: /*  for WiFi connect idle & BT ACL busy or WiFi Connected-Busy & BT is Inquiry */
5302 			if (btdm_Is1AntPsTdmaStateChange(padapter))
5303 				BTDM_SetFw3a(padapter, 0x13, 0xa, 0xa, 0x0, 0x40);
5304 			break;
5305 		case 11: /*  ACL high-retry type - 3 */
5306 			if (btdm_Is1AntPsTdmaStateChange(padapter)) {
5307 				/*  narrow duration for WiFi */
5308 				BTDM_SetFw3a(padapter, 0xd3, 0x05, 0x05, 0x00, 0x58);
5309 			}
5310 			break;
5311 		case 12: /*  for WiFi Connected-Busy & BT is Connected-Idle */
5312 			if (btdm_Is1AntPsTdmaStateChange(padapter)) {
5313 				/*  Allow High-Pri BT */
5314 				BTDM_SetFw3a(padapter, 0xeb, 0x0a, 0x03, 0x31, 0x18);
5315 			}
5316 			break;
5317 		case 20: /*  WiFi only busy , TDMA mode for power saving */
5318 			if (btdm_Is1AntPsTdmaStateChange(padapter))
5319 				BTDM_SetFw3a(padapter, 0x13, 0x25, 0x25, 0x00, 0x00);
5320 			break;
5321 		case 27: /*  WiFi DHCP/Site Survey & BT SCO busy */
5322 			if (btdm_Is1AntPsTdmaStateChange(padapter))
5323 				BTDM_SetFw3a(padapter, 0xa3, 0x25, 0x03, 0x31, 0x98);
5324 			break;
5325 		case 28: /*  WiFi DHCP/Site Survey & BT idle */
5326 			if (btdm_Is1AntPsTdmaStateChange(padapter))
5327 				BTDM_SetFw3a(padapter, 0x69, 0x25, 0x03, 0x31, 0x00);
5328 			break;
5329 		case 29: /*  WiFi DHCP/Site Survey & BT ACL busy */
5330 			if (btdm_Is1AntPsTdmaStateChange(padapter)) {
5331 				BTDM_SetFw3a(padapter, 0xeb, 0x1a, 0x1a, 0x01, 0x18);
5332 				rtl8723au_write32(padapter, 0x6c0, 0x5afa5afa);
5333 				rtl8723au_write32(padapter, 0x6c4, 0x5afa5afa);
5334 			}
5335 			break;
5336 		case 30: /*  WiFi idle & BT Inquiry */
5337 			if (btdm_Is1AntPsTdmaStateChange(padapter))
5338 				BTDM_SetFw3a(padapter, 0x93, 0x15, 0x03, 0x14, 0x00);
5339 			break;
5340 		case 31:  /*  BT HID */
5341 			if (btdm_Is1AntPsTdmaStateChange(padapter))
5342 				BTDM_SetFw3a(padapter, 0xd3, 0x1a, 0x1a, 0x00, 0x58);
5343 			break;
5344 		case 32:  /*  BT SCO & Inquiry */
5345 			if (btdm_Is1AntPsTdmaStateChange(padapter))
5346 				BTDM_SetFw3a(padapter, 0xab, 0x0a, 0x03, 0x11, 0x98);
5347 			break;
5348 		case 33:  /*  BT SCO & WiFi site survey */
5349 			if (btdm_Is1AntPsTdmaStateChange(padapter))
5350 				BTDM_SetFw3a(padapter, 0xa3, 0x25, 0x03, 0x30, 0x98);
5351 			break;
5352 		case 34:  /*  BT HID & WiFi site survey */
5353 			if (btdm_Is1AntPsTdmaStateChange(padapter))
5354 				BTDM_SetFw3a(padapter, 0xd3, 0x1a, 0x1a, 0x00, 0x18);
5355 			break;
5356 		case 35:  /*  BT HID & WiFi Connecting */
5357 			if (btdm_Is1AntPsTdmaStateChange(padapter))
5358 				BTDM_SetFw3a(padapter, 0xe3, 0x1a, 0x1a, 0x00, 0x18);
5359 			break;
5360 		}
5361 	} else {
5362 		/*  disable PS-TDMA */
5363 		switch (type) {
5364 		case 8:
5365 			if (btdm_Is1AntPsTdmaStateChange(padapter)) {
5366 				/*  Antenna control by PTA, 0x870 = 0x310 */
5367 				BTDM_SetFw3a(padapter, 0x8, 0x0, 0x0, 0x0, 0x0);
5368 			}
5369 			break;
5370 		case 0:
5371 		default:
5372 			if (btdm_Is1AntPsTdmaStateChange(padapter)) {
5373 				/*  Antenna control by PTA, 0x870 = 0x310 */
5374 				BTDM_SetFw3a(padapter, 0x0, 0x0, 0x0, 0x8, 0x0);
5375 			}
5376 			/*  Switch Antenna to BT */
5377 			rtl8723au_write16(padapter, 0x860, 0x210);
5378 			RTPRINT(FBT, BT_TRACE, ("[BTCoex], 0x860 = 0x210, Switch Antenna to BT\n"));
5379 			break;
5380 		case 9:
5381 			if (btdm_Is1AntPsTdmaStateChange(padapter)) {
5382 				/*  Antenna control by PTA, 0x870 = 0x310 */
5383 				BTDM_SetFw3a(padapter, 0x0, 0x0, 0x0, 0x8, 0x0);
5384 			}
5385 			/*  Switch Antenna to WiFi */
5386 			rtl8723au_write16(padapter, 0x860, 0x110);
5387 			RTPRINT(FBT, BT_TRACE, ("[BTCoex], 0x860 = 0x110, Switch Antenna to WiFi\n"));
5388 			break;
5389 		}
5390 	}
5391 
5392 	RTPRINT(FBT, BT_TRACE, ("[BTCoex], Current TDMA(%s, %d)\n",
5393 		pBtdm8723->bCurPsTdmaOn?"ON":"OFF", pBtdm8723->curPsTdma));
5394 
5395 	/*  update pre state */
5396 	pBtdm8723->bPrePsTdmaOn = pBtdm8723->bCurPsTdmaOn;
5397 	pBtdm8723->prePsTdma = pBtdm8723->curPsTdma;
5398 }
5399 
5400 static void
_btdm_1AntSetPSTDMA(struct rtw_adapter * padapter,u8 bPSEn,u8 smartps,u8 psOption,u8 bTDMAOn,u8 tdmaType)5401 _btdm_1AntSetPSTDMA(struct rtw_adapter *padapter, u8 bPSEn, u8 smartps,
5402 		    u8 psOption, u8 bTDMAOn, u8 tdmaType)
5403 {
5404 	struct pwrctrl_priv *pwrctrl;
5405 	struct hal_data_8723a *pHalData;
5406 	struct btdm_8723a_1ant *pBtdm8723;
5407 	u8 psMode;
5408 	u8 bSwitchPS;
5409 
5410 	if (!check_fwstate(&padapter->mlmepriv, WIFI_STATION_STATE) &&
5411 	    (get_fwstate(&padapter->mlmepriv) != WIFI_NULL_STATE)) {
5412 		btdm_1AntPsTdma(padapter, bTDMAOn, tdmaType);
5413 		return;
5414 	}
5415 	psOption &= ~BIT(0);
5416 
5417 	RTPRINT(FBT, BT_TRACE,
5418 		("[BTCoex], Set LPS(%s, %d) TDMA(%s, %d)\n",
5419 		bPSEn == true?"ON":"OFF", psOption,
5420 		bTDMAOn == true?"ON":"OFF", tdmaType));
5421 
5422 	pwrctrl = &padapter->pwrctrlpriv;
5423 	pHalData = GET_HAL_DATA(padapter);
5424 	pBtdm8723 = &pHalData->bt_coexist.halCoex8723.btdm1Ant;
5425 
5426 	if (bPSEn) {
5427 		if (pBtdm8723->bWiFiHalt) {
5428 			RTPRINT(FBT, BT_TRACE, ("[BTCoex], Enable PS Fail, WiFi in Halt!!\n"));
5429 			return;
5430 		}
5431 
5432 		if (pwrctrl->bInSuspend) {
5433 			RTPRINT(FBT, BT_TRACE, ("[BTCoex], Enable PS Fail, WiFi in Suspend!!\n"));
5434 			return;
5435 		}
5436 
5437 		if (padapter->bDriverStopped) {
5438 			RTPRINT(FBT, BT_TRACE, ("[BTCoex], Enable PS Fail, WiFi driver stopped!!\n"));
5439 			return;
5440 		}
5441 
5442 		if (padapter->bSurpriseRemoved) {
5443 			RTPRINT(FBT, BT_TRACE, ("[BTCoex], Enable PS Fail, WiFi Surprise Removed!!\n"));
5444 			return;
5445 		}
5446 
5447 		psMode = PS_MODE_MIN;
5448 	} else {
5449 		psMode = PS_MODE_ACTIVE;
5450 		psOption = 0;
5451 	}
5452 
5453 	if (psMode != pwrctrl->pwr_mode) {
5454 		bSwitchPS = true;
5455 	} else if (psMode != PS_MODE_ACTIVE) {
5456 		if (psOption != pwrctrl->bcn_ant_mode)
5457 			bSwitchPS = true;
5458 		else if (smartps != pwrctrl->smart_ps)
5459 			bSwitchPS = true;
5460 		else
5461 			bSwitchPS = false;
5462 	} else {
5463 		bSwitchPS = false;
5464 	}
5465 
5466 	if (bSwitchPS) {
5467 		/*  disable TDMA */
5468 		if (pBtdm8723->bCurPsTdmaOn) {
5469 			if (!bTDMAOn) {
5470 				btdm_1AntPsTdma(padapter, false, tdmaType);
5471 			} else {
5472 				if (!rtl8723a_BT_enabled(padapter) ||
5473 				    (pHalData->bt_coexist.halCoex8723.c2hBtInfo == BT_INFO_STATE_NO_CONNECTION) ||
5474 				    (pHalData->bt_coexist.halCoex8723.c2hBtInfo == BT_INFO_STATE_CONNECT_IDLE) ||
5475 				    (tdmaType == 29))
5476 					btdm_1AntPsTdma(padapter, false, 9);
5477 				else
5478 					btdm_1AntPsTdma(padapter, false, 0);
5479 			}
5480 		}
5481 
5482 		/*  change Power Save State */
5483 		btdm_1AntSetPSMode(padapter, bPSEn, smartps, psOption);
5484 	}
5485 
5486 	btdm_1AntPsTdma(padapter, bTDMAOn, tdmaType);
5487 }
5488 
5489 static void
btdm_1AntSetPSTDMA(struct rtw_adapter * padapter,u8 bPSEn,u8 psOption,u8 bTDMAOn,u8 tdmaType)5490 btdm_1AntSetPSTDMA(struct rtw_adapter *padapter, u8 bPSEn,
5491 		   u8 psOption, u8 bTDMAOn, u8 tdmaType)
5492 {
5493 	_btdm_1AntSetPSTDMA(padapter, bPSEn, 0, psOption, bTDMAOn, tdmaType);
5494 }
5495 
btdm_1AntWifiParaAdjust(struct rtw_adapter * padapter,u8 bEnable)5496 static void btdm_1AntWifiParaAdjust(struct rtw_adapter *padapter, u8 bEnable)
5497 {
5498 	struct hal_data_8723a *pHalData = GET_HAL_DATA(padapter);
5499 	struct btdm_8723a_1ant *pBtdm8723 = &pHalData->bt_coexist.halCoex8723.btdm1Ant;
5500 
5501 	if (bEnable) {
5502 		pBtdm8723->curWifiPara = 1;
5503 		if (pBtdm8723->preWifiPara != pBtdm8723->curWifiPara)
5504 			BTDM_SetSwPenaltyTxRateAdaptive(padapter, BT_TX_RATE_ADAPTIVE_LOW_PENALTY);
5505 	} else {
5506 		pBtdm8723->curWifiPara = 2;
5507 		if (pBtdm8723->preWifiPara != pBtdm8723->curWifiPara)
5508 			BTDM_SetSwPenaltyTxRateAdaptive(padapter, BT_TX_RATE_ADAPTIVE_NORMAL);
5509 	}
5510 
5511 }
5512 
btdm_1AntPtaParaReload(struct rtw_adapter * padapter)5513 static void btdm_1AntPtaParaReload(struct rtw_adapter *padapter)
5514 {
5515 	/*  PTA parameter */
5516 	rtl8723au_write8(padapter, 0x6cc, 0x0);		/*  1-Ant coex */
5517 	rtl8723au_write32(padapter, 0x6c8, 0xffff);	/*  wifi break table */
5518 	rtl8723au_write32(padapter, 0x6c4, 0x55555555);	/*  coex table */
5519 
5520 	/*  Antenna switch control parameter */
5521 	rtl8723au_write32(padapter, 0x858, 0xaaaaaaaa);
5522 	if (IS_8723A_A_CUT(GET_HAL_DATA(padapter)->VersionID)) {
5523 		/*  SPDT(connected with TRSW) control by hardware PTA */
5524 		rtl8723au_write32(padapter, 0x870, 0x0);
5525 		rtl8723au_write8(padapter, 0x40, 0x24);
5526 	} else {
5527 		rtl8723au_write8(padapter, 0x40, 0x20);
5528 		/*  set antenna at bt side if ANTSW is software control */
5529 		rtl8723au_write16(padapter, 0x860, 0x210);
5530 		/*  SPDT(connected with TRSW) control by hardware PTA */
5531 		rtl8723au_write32(padapter, 0x870, 0x300);
5532 		/*  ANTSW keep by GNT_BT */
5533 		rtl8723au_write32(padapter, 0x874, 0x22804000);
5534 	}
5535 
5536 	/*  coexistence parameters */
5537 	rtl8723au_write8(padapter, 0x778, 0x1);	/*  enable RTK mode PTA */
5538 
5539 	/*  BT don't ignore WLAN_Act */
5540 	btdm_SetFwIgnoreWlanAct(padapter, false);
5541 }
5542 
5543 /*
5544  * Return
5545  *1: upgrade (add WiFi duration time)
5546  *0: keep
5547  *-1: downgrade (add BT duration time)
5548  */
btdm_1AntTdmaJudgement(struct rtw_adapter * padapter,u8 retry)5549 static s8 btdm_1AntTdmaJudgement(struct rtw_adapter *padapter, u8 retry)
5550 {
5551 	struct hal_data_8723a *pHalData;
5552 	struct btdm_8723a_1ant *pBtdm8723;
5553 	static s8 up, dn, m = 1, n = 3, WaitCount;
5554 	s8 ret;
5555 
5556 	pHalData = GET_HAL_DATA(padapter);
5557 	pBtdm8723 = &pHalData->bt_coexist.halCoex8723.btdm1Ant;
5558 	ret = 0;
5559 
5560 	if (pBtdm8723->psTdmaMonitorCnt == 0) {
5561 		up = 0;
5562 		dn = 0;
5563 		m = 1;
5564 		n = 3;
5565 		WaitCount = 0;
5566 	} else {
5567 		WaitCount++;
5568 	}
5569 
5570 	if (retry == 0) {
5571 	/*  no retry in the last 2-second duration */
5572 		up++;
5573 		dn--;
5574 		if (dn < 0)
5575 			dn = 0;
5576 		if (up >= 3*m) {
5577 			/*  retry = 0 in consecutive 3m*(2s), add WiFi duration */
5578 			ret = 1;
5579 
5580 			n = 3;
5581 			up = 0;
5582 			dn = 0;
5583 			WaitCount = 0;
5584 		}
5585 	} else if (retry <= 3) {
5586 		/*  retry<= 3 in the last 2-second duration */
5587 		up--;
5588 		dn++;
5589 		if (up < 0)
5590 			up = 0;
5591 
5592 		if (dn == 2) {
5593 			/*  retry<= 3 in consecutive 2*(2s), minus WiFi duration (add BT duration) */
5594 			ret = -1;
5595 
5596 			/*  record how many time downgrad WiFi duration */
5597 			if (WaitCount <= 2)
5598 				m++;
5599 			else
5600 				m = 1;
5601 			/*  the max number of m is 20 */
5602 			/*  the longest time of upgrade WiFi duration is 20*3*2s = 120s */
5603 			if (m >= 20)
5604 				m = 20;
5605 			up = 0;
5606 			dn = 0;
5607 			WaitCount = 0;
5608 		}
5609 	} else {
5610 		/*  retry count > 3 */
5611 		/*  retry>3, minus WiFi duration (add BT duration) */
5612 		ret = -1;
5613 
5614 		/*  record how many time downgrad WiFi duration */
5615 		if (WaitCount == 1)
5616 			m++;
5617 		else
5618 			m = 1;
5619 		if (m >= 20)
5620 			m = 20;
5621 
5622 		up = 0;
5623 		dn = 0;
5624 		WaitCount = 0;
5625 	}
5626 	return ret;
5627 }
5628 
btdm_1AntTdmaDurationAdjustForACL(struct rtw_adapter * padapter)5629 static void btdm_1AntTdmaDurationAdjustForACL(struct rtw_adapter *padapter)
5630 {
5631 	struct hal_data_8723a *pHalData = GET_HAL_DATA(padapter);
5632 	struct btdm_8723a_1ant *pBtdm8723 = &pHalData->bt_coexist.halCoex8723.btdm1Ant;
5633 
5634 	if (pBtdm8723->psTdmaGlobalCnt != pBtdm8723->psTdmaMonitorCnt) {
5635 		pBtdm8723->psTdmaMonitorCnt = 0;
5636 		pBtdm8723->psTdmaGlobalCnt = 0;
5637 	}
5638 	if (pBtdm8723->psTdmaMonitorCnt == 0) {
5639 		btdm_1AntSetPSTDMA(padapter, true, 0, true, 2);
5640 		pBtdm8723->psTdmaDuAdjType = 2;
5641 	} else {
5642 		/*  Now we only have 4 level Ps Tdma, */
5643 		/*  if that's not the following 4 level(will changed by wifi scan, dhcp...), */
5644 		/*  then we have to adjust it back to the previous record one. */
5645 		if ((pBtdm8723->curPsTdma != 1) &&
5646 		    (pBtdm8723->curPsTdma != 2) &&
5647 		    (pBtdm8723->curPsTdma != 9) &&
5648 		    (pBtdm8723->curPsTdma != 11)) {
5649 			btdm_1AntSetPSTDMA(padapter, true, 0, true, pBtdm8723->psTdmaDuAdjType);
5650 		} else {
5651 			s32 judge = 0;
5652 
5653 			judge = btdm_1AntTdmaJudgement(padapter, pHalData->bt_coexist.halCoex8723.btRetryCnt);
5654 			if (judge == -1) {
5655 				if (pBtdm8723->curPsTdma == 1) {
5656 					/*  Decrease WiFi duration for high BT retry */
5657 					if (pHalData->bt_coexist.halCoex8723.btInfoExt)
5658 						pBtdm8723->psTdmaDuAdjType = 9;
5659 					else
5660 						pBtdm8723->psTdmaDuAdjType = 2;
5661 					btdm_1AntSetPSTDMA(padapter, true, 0, true, pBtdm8723->psTdmaDuAdjType);
5662 				} else if (pBtdm8723->curPsTdma == 2) {
5663 					btdm_1AntSetPSTDMA(padapter, true, 0, true, 9);
5664 					pBtdm8723->psTdmaDuAdjType = 9;
5665 				} else if (pBtdm8723->curPsTdma == 9) {
5666 					btdm_1AntSetPSTDMA(padapter, true, 0, true, 11);
5667 					pBtdm8723->psTdmaDuAdjType = 11;
5668 				}
5669 			} else if (judge == 1) {
5670 				if (pBtdm8723->curPsTdma == 11) {
5671 					btdm_1AntSetPSTDMA(padapter, true, 0, true, 9);
5672 					pBtdm8723->psTdmaDuAdjType = 9;
5673 				} else if (pBtdm8723->curPsTdma == 9) {
5674 					if (pHalData->bt_coexist.halCoex8723.btInfoExt)
5675 						pBtdm8723->psTdmaDuAdjType = 9;
5676 					else
5677 						pBtdm8723->psTdmaDuAdjType = 2;
5678 					btdm_1AntSetPSTDMA(padapter, true, 0, true, pBtdm8723->psTdmaDuAdjType);
5679 				} else if (pBtdm8723->curPsTdma == 2) {
5680 					if (pHalData->bt_coexist.halCoex8723.btInfoExt)
5681 						pBtdm8723->psTdmaDuAdjType = 9;
5682 					else
5683 						pBtdm8723->psTdmaDuAdjType = 1;
5684 					btdm_1AntSetPSTDMA(padapter, true, 0, true, pBtdm8723->psTdmaDuAdjType);
5685 				}
5686 			}
5687 		}
5688 		RTPRINT(FBT, BT_TRACE,
5689 			("[BTCoex], ACL current TDMA(%s, %d)\n",
5690 			(pBtdm8723->bCurPsTdmaOn ? "ON" : "OFF"), pBtdm8723->curPsTdma));
5691 	}
5692 	pBtdm8723->psTdmaMonitorCnt++;
5693 }
5694 
btdm_1AntCoexProcessForWifiConnect(struct rtw_adapter * padapter)5695 static void btdm_1AntCoexProcessForWifiConnect(struct rtw_adapter *padapter)
5696 {
5697 	struct mlme_priv *pmlmepriv;
5698 	struct hal_data_8723a *pHalData;
5699 	struct bt_coexist_8723a *pBtCoex;
5700 	struct btdm_8723a_1ant *pBtdm8723;
5701 	u8 BtState;
5702 
5703 	pmlmepriv = &padapter->mlmepriv;
5704 	pHalData = GET_HAL_DATA(padapter);
5705 	pBtCoex = &pHalData->bt_coexist.halCoex8723;
5706 	pBtdm8723 = &pBtCoex->btdm1Ant;
5707 	BtState = pBtCoex->c2hBtInfo;
5708 
5709 	RTPRINT(FBT, BT_TRACE, ("[BTCoex], WiFi is %s\n",
5710 				BTDM_IsWifiBusy(padapter)?"Busy":"IDLE"));
5711 	RTPRINT(FBT, BT_TRACE, ("[BTCoex], BT is %s\n",
5712 				BtStateString[BtState]));
5713 
5714 	padapter->pwrctrlpriv.btcoex_rfon = false;
5715 
5716 	if (!BTDM_IsWifiBusy(padapter) &&
5717 	    !check_fwstate(&padapter->mlmepriv, WIFI_AP_STATE) &&
5718 	    (BtState == BT_INFO_STATE_NO_CONNECTION ||
5719 	     BtState == BT_INFO_STATE_CONNECT_IDLE)) {
5720 		switch (BtState) {
5721 		case BT_INFO_STATE_NO_CONNECTION:
5722 			_btdm_1AntSetPSTDMA(padapter, true, 2, 0x26, false, 9);
5723 			break;
5724 		case BT_INFO_STATE_CONNECT_IDLE:
5725 			_btdm_1AntSetPSTDMA(padapter, true, 2, 0x26, false, 0);
5726 			break;
5727 		}
5728 	} else {
5729 		switch (BtState) {
5730 		case BT_INFO_STATE_NO_CONNECTION:
5731 		case BT_INFO_STATE_CONNECT_IDLE:
5732 			/*  WiFi is Busy */
5733 			btdm_1AntSetPSTDMA(padapter, false, 0, true, 5);
5734 			rtl8723au_write32(padapter, 0x6c0, 0x5a5a5a5a);
5735 			rtl8723au_write32(padapter, 0x6c4, 0x5a5a5a5a);
5736 			break;
5737 		case BT_INFO_STATE_ACL_INQ_OR_PAG:
5738 			RTPRINT(FBT, BT_TRACE,
5739 				("[BTCoex], BT PROFILE is "
5740 				 "BT_INFO_STATE_ACL_INQ_OR_PAG\n"));
5741 		case BT_INFO_STATE_INQ_OR_PAG:
5742 			padapter->pwrctrlpriv.btcoex_rfon = true;
5743 			btdm_1AntSetPSTDMA(padapter, true, 0, true, 30);
5744 			break;
5745 		case BT_INFO_STATE_SCO_ONLY_BUSY:
5746 		case BT_INFO_STATE_ACL_SCO_BUSY:
5747 			if (true == pBtCoex->bC2hBtInquiryPage)
5748 				btdm_1AntSetPSTDMA(padapter, false, 0,
5749 						   true, 32);
5750 			else {
5751 #ifdef BTCOEX_CMCC_TEST
5752 				btdm_1AntSetPSTDMA(padapter, false, 0,
5753 						   true, 23);
5754 #else /*  !BTCOEX_CMCC_TEST */
5755 				btdm_1AntSetPSTDMA(padapter, false, 0,
5756 						   false, 8);
5757 				rtl8723au_write32(padapter, 0x6c0, 0x5a5a5a5a);
5758 				rtl8723au_write32(padapter, 0x6c4, 0x5a5a5a5a);
5759 #endif /*  !BTCOEX_CMCC_TEST */
5760 			}
5761 			break;
5762 		case BT_INFO_STATE_ACL_ONLY_BUSY:
5763 			padapter->pwrctrlpriv.btcoex_rfon = true;
5764 			if (pBtCoex->c2hBtProfile == BT_INFO_HID) {
5765 				RTPRINT(FBT, BT_TRACE,
5766 					("[BTCoex], BT PROFILE is HID\n"));
5767 				btdm_1AntSetPSTDMA(padapter, true, 0, true, 31);
5768 			} else if (pBtCoex->c2hBtProfile == BT_INFO_FTP) {
5769 				RTPRINT(FBT, BT_TRACE,
5770 					("[BTCoex], BT PROFILE is FTP/OPP\n"));
5771 				btdm_1AntSetPSTDMA(padapter, true, 0, true, 3);
5772 			} else if (pBtCoex->c2hBtProfile == (BT_INFO_A2DP|BT_INFO_FTP)) {
5773 				RTPRINT(FBT, BT_TRACE,
5774 					("[BTCoex], BT PROFILE is A2DP_FTP\n"));
5775 				btdm_1AntSetPSTDMA(padapter, true, 0, true, 11);
5776 			} else {
5777 				if (pBtCoex->c2hBtProfile == BT_INFO_A2DP)
5778 					RTPRINT(FBT, BT_TRACE,
5779 						("[BTCoex], BT PROFILE is "
5780 						 "A2DP\n"));
5781 				else
5782 					RTPRINT(FBT, BT_TRACE,
5783 						("[BTCoex], BT PROFILE is "
5784 						 "UNKNOWN(0x%02X)! Use A2DP "
5785 						 "Profile\n",
5786 						 pBtCoex->c2hBtProfile));
5787 				btdm_1AntTdmaDurationAdjustForACL(padapter);
5788 			}
5789 			break;
5790 		}
5791 	}
5792 
5793 	pBtdm8723->psTdmaGlobalCnt++;
5794 }
5795 
5796 static void
btdm_1AntUpdateHalRAMask(struct rtw_adapter * padapter,u32 mac_id,u32 filter)5797 btdm_1AntUpdateHalRAMask(struct rtw_adapter *padapter, u32 mac_id, u32 filter)
5798 {
5799 	u8 init_rate = 0;
5800 	u8 raid, arg;
5801 	u32 mask;
5802 	u8 shortGIrate = false;
5803 	int supportRateNum = 0;
5804 	struct sta_info	*psta;
5805 	struct hal_data_8723a *pHalData;
5806 	struct dm_priv *pdmpriv;
5807 	struct mlme_ext_priv *pmlmeext;
5808 	struct mlme_ext_info *pmlmeinfo;
5809 	struct wlan_bssid_ex *cur_network;
5810 
5811 	RTPRINT(FBT, BT_TRACE, ("[BTCoex], %s, MACID =%d, filter = 0x%08x!!\n",
5812 				__func__, mac_id, filter));
5813 
5814 	pHalData = GET_HAL_DATA(padapter);
5815 	pdmpriv = &pHalData->dmpriv;
5816 	pmlmeext = &padapter->mlmeextpriv;
5817 	pmlmeinfo = &pmlmeext->mlmext_info;
5818 	cur_network = &pmlmeinfo->network;
5819 
5820 	if (mac_id >= NUM_STA) { /* CAM_SIZE */
5821 		RTPRINT(FBT, BT_TRACE, ("[BTCoex], %s, MACID =%d illegal!!\n",
5822 					__func__, mac_id));
5823 		return;
5824 	}
5825 
5826 	psta = pmlmeinfo->FW_sta_info[mac_id].psta;
5827 	if (!psta) {
5828 		RTPRINT(FBT, BT_TRACE, ("[BTCoex], %s, Can't find station!!\n",
5829 					__func__));
5830 		return;
5831 	}
5832 
5833 	raid = psta->raid;
5834 
5835 	switch (mac_id) {
5836 	case 0:/*  for infra mode */
5837 		supportRateNum =
5838 			rtw_get_rateset_len23a(cur_network->SupportedRates);
5839 		mask = update_supported_rate23a(cur_network->SupportedRates,
5840 						supportRateNum);
5841 		mask |= (pmlmeinfo->HT_enable) ?
5842 			update_MSC_rate23a(&pmlmeinfo->ht_cap):0;
5843 		if (support_short_GI23a(padapter, &pmlmeinfo->ht_cap))
5844 			shortGIrate = true;
5845 		break;
5846 	case 1:/* for broadcast/multicast */
5847 		supportRateNum = rtw_get_rateset_len23a(
5848 			pmlmeinfo->FW_sta_info[mac_id].SupportedRates);
5849 		mask = update_basic_rate23a(cur_network->SupportedRates,
5850 					    supportRateNum);
5851 		break;
5852 	default: /* for each sta in IBSS */
5853 		supportRateNum = rtw_get_rateset_len23a(
5854 			pmlmeinfo->FW_sta_info[mac_id].SupportedRates);
5855 		mask = update_supported_rate23a(cur_network->SupportedRates,
5856 						supportRateNum);
5857 		break;
5858 	}
5859 	mask |= ((raid<<28)&0xf0000000);
5860 	mask &= 0xffffffff;
5861 	mask &= ~filter;
5862 	init_rate = get_highest_rate_idx23a(mask)&0x3f;
5863 
5864 	arg = mac_id&0x1f;/* MACID */
5865 	arg |= BIT(7);
5866 	if (true == shortGIrate)
5867 		arg |= BIT(5);
5868 
5869 	RTPRINT(FBT, BT_TRACE,
5870 		("[BTCoex], Update FW RAID entry, MASK = 0x%08x, "
5871 		 "arg = 0x%02x\n", mask, arg));
5872 
5873 	rtl8723a_set_raid_cmd(padapter, mask, arg);
5874 
5875 	psta->init_rate = init_rate;
5876 	pdmpriv->INIDATA_RATE[mac_id] = init_rate;
5877 }
5878 
5879 static void
btdm_1AntUpdateHalRAMaskForSCO(struct rtw_adapter * padapter,u8 forceUpdate)5880 btdm_1AntUpdateHalRAMaskForSCO(struct rtw_adapter *padapter, u8 forceUpdate)
5881 {
5882 	struct btdm_8723a_1ant *pBtdm8723;
5883 	struct sta_priv *pstapriv;
5884 	struct wlan_bssid_ex *cur_network;
5885 	struct sta_info *psta;
5886 	u32 macid;
5887 	u32 filter = 0;
5888 
5889 	pBtdm8723 = &GET_HAL_DATA(padapter)->bt_coexist.halCoex8723.btdm1Ant;
5890 
5891 	if (pBtdm8723->bRAChanged == true && forceUpdate == false)
5892 		return;
5893 
5894 	pstapriv = &padapter->stapriv;
5895 	cur_network = &padapter->mlmeextpriv.mlmext_info.network;
5896 	psta = rtw_get_stainfo23a(pstapriv, cur_network->MacAddress);
5897 	macid = psta->mac_id;
5898 
5899 	filter |= BIT(_1M_RATE_);
5900 	filter |= BIT(_2M_RATE_);
5901 	filter |= BIT(_5M_RATE_);
5902 	filter |= BIT(_11M_RATE_);
5903 	filter |= BIT(_6M_RATE_);
5904 	filter |= BIT(_9M_RATE_);
5905 
5906 	btdm_1AntUpdateHalRAMask(padapter, macid, filter);
5907 
5908 	pBtdm8723->bRAChanged = true;
5909 }
5910 
btdm_1AntRecoverHalRAMask(struct rtw_adapter * padapter)5911 static void btdm_1AntRecoverHalRAMask(struct rtw_adapter *padapter)
5912 {
5913 	struct btdm_8723a_1ant *pBtdm8723;
5914 	struct sta_priv *pstapriv;
5915 	struct wlan_bssid_ex *cur_network;
5916 	struct sta_info *psta;
5917 
5918 	pBtdm8723 = &GET_HAL_DATA(padapter)->bt_coexist.halCoex8723.btdm1Ant;
5919 
5920 	if (pBtdm8723->bRAChanged == false)
5921 		return;
5922 
5923 	pstapriv = &padapter->stapriv;
5924 	cur_network = &padapter->mlmeextpriv.mlmext_info.network;
5925 	psta = rtw_get_stainfo23a(pstapriv, cur_network->MacAddress);
5926 
5927 	Update_RA_Entry23a(padapter, psta);
5928 
5929 	pBtdm8723->bRAChanged = false;
5930 }
5931 
5932 static void
btdm_1AntBTStateChangeHandler(struct rtw_adapter * padapter,enum bt_state_1ant oldState,enum bt_state_1ant newState)5933 btdm_1AntBTStateChangeHandler(struct rtw_adapter *padapter,
5934 			      enum bt_state_1ant oldState,
5935 			      enum bt_state_1ant newState)
5936 {
5937 	struct hal_data_8723a *phaldata;
5938 	RTPRINT(FBT, BT_TRACE, ("[BTCoex], BT state change, %s => %s\n",
5939 				BtStateString[oldState],
5940 				BtStateString[newState]));
5941 
5942 	/*  BT default ignore wlan active, */
5943 	/*  WiFi MUST disable this when BT is enable */
5944 	if (newState > BT_INFO_STATE_DISABLED)
5945 		btdm_SetFwIgnoreWlanAct(padapter, false);
5946 
5947 	if ((check_fwstate(&padapter->mlmepriv, WIFI_STATION_STATE)) &&
5948 	    (BTDM_IsWifiConnectionExist(padapter))) {
5949 		if ((newState == BT_INFO_STATE_SCO_ONLY_BUSY) ||
5950 		    (newState == BT_INFO_STATE_ACL_SCO_BUSY)) {
5951 			btdm_1AntUpdateHalRAMaskForSCO(padapter, false);
5952 		} else {
5953 			/*  Recover original RA setting */
5954 			btdm_1AntRecoverHalRAMask(padapter);
5955 		}
5956 	} else {
5957 		phaldata = GET_HAL_DATA(padapter);
5958 		phaldata->bt_coexist.halCoex8723.btdm1Ant.bRAChanged = false;
5959 	}
5960 
5961 	if (oldState == newState)
5962 		return;
5963 
5964 	if (oldState == BT_INFO_STATE_ACL_ONLY_BUSY) {
5965 		struct hal_data_8723a *Hal = GET_HAL_DATA(padapter);
5966 		Hal->bt_coexist.halCoex8723.btdm1Ant.psTdmaMonitorCnt = 0;
5967 		Hal->bt_coexist.halCoex8723.btdm1Ant.psTdmaMonitorCntForSCO = 0;
5968 	}
5969 
5970 	if ((oldState == BT_INFO_STATE_SCO_ONLY_BUSY) ||
5971 	    (oldState == BT_INFO_STATE_ACL_SCO_BUSY)) {
5972 		struct hal_data_8723a *Hal = GET_HAL_DATA(padapter);
5973 		Hal->bt_coexist.halCoex8723.btdm1Ant.psTdmaMonitorCntForSCO = 0;
5974 	}
5975 
5976 	/*  Active 2Ant mechanism when BT Connected */
5977 	if ((oldState == BT_INFO_STATE_DISABLED) ||
5978 	    (oldState == BT_INFO_STATE_NO_CONNECTION)) {
5979 		if ((newState != BT_INFO_STATE_DISABLED) &&
5980 		    (newState != BT_INFO_STATE_NO_CONNECTION)) {
5981 			BTDM_SetSwRfRxLpfCorner(padapter,
5982 						BT_RF_RX_LPF_CORNER_SHRINK);
5983 			BTDM_AGCTable(padapter, BT_AGCTABLE_ON);
5984 			BTDM_BBBackOffLevel(padapter, BT_BB_BACKOFF_ON);
5985 		}
5986 	} else {
5987 		if ((newState == BT_INFO_STATE_DISABLED) ||
5988 		    (newState == BT_INFO_STATE_NO_CONNECTION)) {
5989 			BTDM_SetSwRfRxLpfCorner(padapter,
5990 						BT_RF_RX_LPF_CORNER_RESUME);
5991 			BTDM_AGCTable(padapter, BT_AGCTABLE_OFF);
5992 			BTDM_BBBackOffLevel(padapter, BT_BB_BACKOFF_OFF);
5993 		}
5994 	}
5995 }
5996 
btdm_1AntBtCoexistHandler(struct rtw_adapter * padapter)5997 static void btdm_1AntBtCoexistHandler(struct rtw_adapter *padapter)
5998 {
5999 	struct hal_data_8723a *pHalData;
6000 	struct bt_coexist_8723a *pBtCoex8723;
6001 	struct btdm_8723a_1ant *pBtdm8723;
6002 
6003 	pHalData = GET_HAL_DATA(padapter);
6004 	pBtCoex8723 = &pHalData->bt_coexist.halCoex8723;
6005 	pBtdm8723 = &pBtCoex8723->btdm1Ant;
6006 	padapter->pwrctrlpriv.btcoex_rfon = false;
6007 	if (!rtl8723a_BT_enabled(padapter)) {
6008 		RTPRINT(FBT, BT_TRACE, ("[BTCoex], BT is disabled\n"));
6009 
6010 		if (BTDM_IsWifiConnectionExist(padapter)) {
6011 			RTPRINT(FBT, BT_TRACE,
6012 				("[BTCoex], wifi is connected\n"));
6013 
6014 			if (BTDM_IsWifiBusy(padapter)) {
6015 				RTPRINT(FBT, BT_TRACE,
6016 					("[BTCoex], Wifi is busy\n"));
6017 				btdm_1AntSetPSTDMA(padapter, false, 0,
6018 						   false, 9);
6019 			} else {
6020 				RTPRINT(FBT, BT_TRACE,
6021 					("[BTCoex], Wifi is idle\n"));
6022 				_btdm_1AntSetPSTDMA(padapter, true, 2, 1,
6023 						    false, 9);
6024 			}
6025 		} else {
6026 			RTPRINT(FBT, BT_TRACE,
6027 				("[BTCoex], wifi is disconnected\n"));
6028 
6029 			btdm_1AntSetPSTDMA(padapter, false, 0, false, 9);
6030 		}
6031 	} else {
6032 		RTPRINT(FBT, BT_TRACE, ("[BTCoex], BT is enabled\n"));
6033 
6034 		if (BTDM_IsWifiConnectionExist(padapter)) {
6035 			RTPRINT(FBT, BT_TRACE,
6036 				("[BTCoex], wifi is connected\n"));
6037 
6038 			btdm_1AntWifiParaAdjust(padapter, true);
6039 			btdm_1AntCoexProcessForWifiConnect(padapter);
6040 		} else {
6041 			RTPRINT(FBT, BT_TRACE,
6042 				("[BTCoex], wifi is disconnected\n"));
6043 
6044 			/*  Antenna switch at BT side(0x870 = 0x300,
6045 			    0x860 = 0x210) after PSTDMA off */
6046 			btdm_1AntWifiParaAdjust(padapter, false);
6047 			btdm_1AntSetPSTDMA(padapter, false, 0, false, 0);
6048 		}
6049 	}
6050 
6051 	btdm_1AntBTStateChangeHandler(padapter, pBtCoex8723->prec2hBtInfo,
6052 				      pBtCoex8723->c2hBtInfo);
6053 	pBtCoex8723->prec2hBtInfo = pBtCoex8723->c2hBtInfo;
6054 }
6055 
BTDM_1AntSignalCompensation(struct rtw_adapter * padapter,u8 * rssi_wifi,u8 * rssi_bt)6056 void BTDM_1AntSignalCompensation(struct rtw_adapter *padapter,
6057 				 u8 *rssi_wifi, u8 *rssi_bt)
6058 {
6059 	struct hal_data_8723a *pHalData;
6060 	struct btdm_8723a_1ant *pBtdm8723;
6061 	u8 RSSI_WiFi_Cmpnstn, RSSI_BT_Cmpnstn;
6062 
6063 	pHalData = GET_HAL_DATA(padapter);
6064 	pBtdm8723 = &pHalData->bt_coexist.halCoex8723.btdm1Ant;
6065 	RSSI_WiFi_Cmpnstn = 0;
6066 	RSSI_BT_Cmpnstn = 0;
6067 
6068 	switch (pBtdm8723->curPsTdma) {
6069 	case 1: /*  WiFi 52ms */
6070 		RSSI_WiFi_Cmpnstn = 11; /*  22*0.48 */
6071 		break;
6072 	case 2: /*  WiFi 36ms */
6073 		RSSI_WiFi_Cmpnstn = 14; /*  22*0.64 */
6074 		break;
6075 	case 9: /*  WiFi 20ms */
6076 		RSSI_WiFi_Cmpnstn = 18; /*  22*0.80 */
6077 		break;
6078 	case 11: /*  WiFi 10ms */
6079 		RSSI_WiFi_Cmpnstn = 20; /*  22*0.90 */
6080 		break;
6081 	case 4: /*  WiFi 21ms */
6082 		RSSI_WiFi_Cmpnstn = 17; /*  22*0.79 */
6083 		break;
6084 	case 16: /*  WiFi 24ms */
6085 		RSSI_WiFi_Cmpnstn = 18; /*  22*0.76 */
6086 		break;
6087 	case 18: /*  WiFi 37ms */
6088 		RSSI_WiFi_Cmpnstn = 14; /*  22*0.64 */
6089 		break;
6090 	case 23: /* Level-1, Antenna switch to BT at all time */
6091 	case 24: /* Level-2, Antenna switch to BT at all time */
6092 	case 25: /* Level-3a, Antenna switch to BT at all time */
6093 	case 26: /* Level-3b, Antenna switch to BT at all time */
6094 	case 27: /* Level-3b, Antenna switch to BT at all time */
6095 	case 33: /* BT SCO & WiFi site survey */
6096 		RSSI_WiFi_Cmpnstn = 22;
6097 		break;
6098 	default:
6099 		break;
6100 	}
6101 
6102 	if (rssi_wifi && RSSI_WiFi_Cmpnstn) {
6103 		RTPRINT(FBT, BT_TRACE,
6104 			("[BTCoex], 1AntSgnlCmpnstn, case %d, WiFiCmpnstn "
6105 			 "=%d(%d => %d)\n", pBtdm8723->curPsTdma,
6106 			 RSSI_WiFi_Cmpnstn, *rssi_wifi,
6107 			 *rssi_wifi+RSSI_WiFi_Cmpnstn));
6108 		*rssi_wifi += RSSI_WiFi_Cmpnstn;
6109 	}
6110 
6111 	if (rssi_bt && RSSI_BT_Cmpnstn) {
6112 		RTPRINT(FBT, BT_TRACE,
6113 			("[BTCoex], 1AntSgnlCmpnstn, case %d, BTCmpnstn "
6114 			 "=%d(%d => %d)\n", pBtdm8723->curPsTdma,
6115 			 RSSI_BT_Cmpnstn, *rssi_bt, *rssi_bt+RSSI_BT_Cmpnstn));
6116 		*rssi_bt += RSSI_BT_Cmpnstn;
6117 	}
6118 }
6119 
BTDM_1AntParaInit(struct rtw_adapter * padapter)6120 static void BTDM_1AntParaInit(struct rtw_adapter *padapter)
6121 {
6122 	struct hal_data_8723a *pHalData;
6123 	struct bt_coexist_8723a *pBtCoex;
6124 	struct btdm_8723a_1ant *pBtdm8723;
6125 
6126 	pHalData = GET_HAL_DATA(padapter);
6127 	pBtCoex = &pHalData->bt_coexist.halCoex8723;
6128 	pBtdm8723 = &pBtCoex->btdm1Ant;
6129 
6130 	/*  Enable counter statistics */
6131 	rtl8723au_write8(padapter, 0x76e, 0x4);
6132 	btdm_1AntPtaParaReload(padapter);
6133 
6134 	pBtdm8723->wifiRssiThresh = 48;
6135 
6136 	pBtdm8723->bWiFiHalt = false;
6137 	pBtdm8723->bRAChanged = false;
6138 
6139 	if ((pBtCoex->c2hBtInfo != BT_INFO_STATE_DISABLED) &&
6140 	    (pBtCoex->c2hBtInfo != BT_INFO_STATE_NO_CONNECTION)) {
6141 		BTDM_SetSwRfRxLpfCorner(padapter, BT_RF_RX_LPF_CORNER_SHRINK);
6142 		BTDM_AGCTable(padapter, BT_AGCTABLE_ON);
6143 		BTDM_BBBackOffLevel(padapter, BT_BB_BACKOFF_ON);
6144 	}
6145 }
6146 
BTDM_1AntForHalt(struct rtw_adapter * padapter)6147 static void BTDM_1AntForHalt(struct rtw_adapter *padapter)
6148 {
6149 	RTPRINT(FBT, BT_TRACE, ("\n[BTCoex], 1Ant for halt\n"));
6150 
6151 	GET_HAL_DATA(padapter)->bt_coexist.halCoex8723.btdm1Ant.bWiFiHalt =
6152 		true;
6153 
6154 	btdm_1AntWifiParaAdjust(padapter, false);
6155 
6156 	/*  don't use btdm_1AntSetPSTDMA() here */
6157 	/*  it will call rtw_set_ps_mode23a() and request pwrpriv->lock. */
6158 	/*  This will lead to deadlock, if this function is called in IPS */
6159 	/*  Lucas@20130205 */
6160 	btdm_1AntPsTdma(padapter, false, 0);
6161 
6162 	btdm_SetFwIgnoreWlanAct(padapter, true);
6163 }
6164 
BTDM_1AntLpsLeave(struct rtw_adapter * padapter)6165 static void BTDM_1AntLpsLeave(struct rtw_adapter *padapter)
6166 {
6167 	RTPRINT(FBT, BT_TRACE, ("\n[BTCoex], 1Ant for LPS Leave\n"));
6168 
6169 	/*  Prevent from entering LPS again */
6170 	GET_HAL_DATA(padapter)->bt_coexist.halCoex8723.btdm1Ant.bWiFiHalt =
6171 		true;
6172 
6173 	btdm_1AntSetPSTDMA(padapter, false, 0, false, 8);
6174 /*btdm_1AntPsTdma(padapter, false, 8); */
6175 }
6176 
BTDM_1AntWifiAssociateNotify(struct rtw_adapter * padapter,u8 type)6177 static void BTDM_1AntWifiAssociateNotify(struct rtw_adapter *padapter, u8 type)
6178 {
6179 	struct hal_data_8723a *pHalData = GET_HAL_DATA(padapter);
6180 
6181 	RTPRINT(FBT, BT_TRACE,
6182 		("\n[BTCoex], 1Ant for associate, type =%d\n", type));
6183 
6184 	if (type) {
6185 		rtl8723a_CheckAntenna_Selection(padapter);
6186 		if (!rtl8723a_BT_enabled(padapter))
6187 			btdm_1AntSetPSTDMA(padapter, false, 0, false, 9);
6188 		else {
6189 			struct bt_coexist_8723a *pBtCoex;
6190 			u8 BtState;
6191 
6192 			pBtCoex = &pHalData->bt_coexist.halCoex8723;
6193 			BtState = pBtCoex->c2hBtInfo;
6194 
6195 			btdm_1AntTSFSwitch(padapter, true);
6196 
6197 			if (BtState == BT_INFO_STATE_NO_CONNECTION ||
6198 			    BtState == BT_INFO_STATE_CONNECT_IDLE) {
6199 				btdm_1AntSetPSTDMA(padapter, false, 0,
6200 						   true, 28);
6201 			} else if (BtState == BT_INFO_STATE_SCO_ONLY_BUSY ||
6202 				   BtState == BT_INFO_STATE_ACL_SCO_BUSY) {
6203 				btdm_1AntSetPSTDMA(padapter, false, 0,
6204 						   false, 8);
6205 				rtl8723au_write32(padapter, 0x6c0, 0x5a5a5a5a);
6206 				rtl8723au_write32(padapter, 0x6c4, 0x5a5a5a5a);
6207 			} else if (BtState == BT_INFO_STATE_ACL_ONLY_BUSY ||
6208 				   BtState == BT_INFO_STATE_ACL_INQ_OR_PAG) {
6209 				if (pBtCoex->c2hBtProfile == BT_INFO_HID)
6210 					btdm_1AntSetPSTDMA(padapter, false, 0,
6211 							   true, 35);
6212 				else
6213 					btdm_1AntSetPSTDMA(padapter, false, 0,
6214 							   true, 29);
6215 			}
6216 		}
6217 	} else {
6218 		if (!rtl8723a_BT_enabled(padapter)) {
6219 			if (!BTDM_IsWifiConnectionExist(padapter)) {
6220 				btdm_1AntPsTdma(padapter, false, 0);
6221 				btdm_1AntTSFSwitch(padapter, false);
6222 			}
6223 		}
6224 
6225 		btdm_1AntBtCoexistHandler(padapter);
6226 	}
6227 }
6228 
6229 static void
BTDM_1AntMediaStatusNotify(struct rtw_adapter * padapter,enum rt_media_status mstatus)6230 BTDM_1AntMediaStatusNotify(struct rtw_adapter *padapter,
6231 			   enum rt_media_status mstatus)
6232 {
6233 	struct bt_coexist_8723a *pBtCoex;
6234 
6235 	pBtCoex = &GET_HAL_DATA(padapter)->bt_coexist.halCoex8723;
6236 
6237 	RTPRINT(FBT, BT_TRACE,
6238 		("\n\n[BTCoex]******************************\n"));
6239 	RTPRINT(FBT, BT_TRACE, ("[BTCoex], MediaStatus, WiFi %s !!\n",
6240 			mstatus == RT_MEDIA_CONNECT?"CONNECT":"DISCONNECT"));
6241 	RTPRINT(FBT, BT_TRACE, ("[BTCoex]******************************\n"));
6242 
6243 	if (RT_MEDIA_CONNECT == mstatus) {
6244 		if (check_fwstate(&padapter->mlmepriv, WIFI_STATION_STATE)) {
6245 			if (pBtCoex->c2hBtInfo == BT_INFO_STATE_SCO_ONLY_BUSY ||
6246 			    pBtCoex->c2hBtInfo == BT_INFO_STATE_ACL_SCO_BUSY)
6247 				btdm_1AntUpdateHalRAMaskForSCO(padapter, true);
6248 		}
6249 
6250 		padapter->pwrctrlpriv.DelayLPSLastTimeStamp = jiffies;
6251 		BTDM_1AntForDhcp(padapter);
6252 	} else {
6253 		/* DBG_8723A("%s rtl8723a_DeinitAntenna_Selection\n",
6254 		   __func__); */
6255 		rtl8723a_DeinitAntenna_Selection(padapter);
6256 		btdm_1AntBtCoexistHandler(padapter);
6257 		pBtCoex->btdm1Ant.bRAChanged = false;
6258 	}
6259 }
6260 
BTDM_1AntForDhcp(struct rtw_adapter * padapter)6261 void BTDM_1AntForDhcp(struct rtw_adapter *padapter)
6262 {
6263 	struct hal_data_8723a *pHalData;
6264 	u8 BtState;
6265 	struct bt_coexist_8723a *pBtCoex;
6266 	struct btdm_8723a_1ant *pBtdm8723;
6267 
6268 	pHalData = GET_HAL_DATA(padapter);
6269 	pBtCoex = &pHalData->bt_coexist.halCoex8723;
6270 	BtState = pBtCoex->c2hBtInfo;
6271 	pBtdm8723 = &pBtCoex->btdm1Ant;
6272 
6273 	RTPRINT(FBT, BT_TRACE, ("\n[BTCoex], 1Ant for DHCP\n"));
6274 	RTPRINT(FBT, BT_TRACE, ("[BTCoex], 1Ant for DHCP, WiFi is %s\n",
6275 				BTDM_IsWifiBusy(padapter)?"Busy":"IDLE"));
6276 	RTPRINT(FBT, BT_TRACE, ("[BTCoex], 1Ant for DHCP, %s\n",
6277 				BtStateString[BtState]));
6278 
6279 	BTDM_1AntWifiAssociateNotify(padapter, true);
6280 }
6281 
BTDM_1AntWifiScanNotify(struct rtw_adapter * padapter,u8 scanType)6282 static void BTDM_1AntWifiScanNotify(struct rtw_adapter *padapter, u8 scanType)
6283 {
6284 	struct hal_data_8723a *pHalData;
6285 	u8 BtState;
6286 	struct bt_coexist_8723a *pBtCoex;
6287 	struct btdm_8723a_1ant *pBtdm8723;
6288 
6289 	pHalData = GET_HAL_DATA(padapter);
6290 	BtState = pHalData->bt_coexist.halCoex8723.c2hBtInfo;
6291 	pBtCoex = &pHalData->bt_coexist.halCoex8723;
6292 	pBtdm8723 = &pBtCoex->btdm1Ant;
6293 
6294 	RTPRINT(FBT, BT_TRACE, ("\n[BTCoex], 1Ant for wifi scan =%d!!\n",
6295 				scanType));
6296 	RTPRINT(FBT, BT_TRACE, ("[BTCoex], 1Ant for wifi scan, WiFi is %s\n",
6297 				BTDM_IsWifiBusy(padapter)?"Busy":"IDLE"));
6298 	RTPRINT(FBT, BT_TRACE, ("[BTCoex], 1Ant for wifi scan, %s\n",
6299 				BtStateString[BtState]));
6300 
6301 	if (scanType) {
6302 		rtl8723a_CheckAntenna_Selection(padapter);
6303 		if (!rtl8723a_BT_enabled(padapter)) {
6304 			btdm_1AntSetPSTDMA(padapter, false, 0, false, 9);
6305 		} else if (BTDM_IsWifiConnectionExist(padapter) == false) {
6306 			BTDM_1AntWifiAssociateNotify(padapter, true);
6307 		} else {
6308 			if ((BtState == BT_INFO_STATE_SCO_ONLY_BUSY) ||
6309 			    (BtState == BT_INFO_STATE_ACL_SCO_BUSY)) {
6310 				if (pBtCoex->bC2hBtInquiryPage) {
6311 					btdm_1AntSetPSTDMA(padapter, false, 0,
6312 							   true, 32);
6313 				} else {
6314 					padapter->pwrctrlpriv.btcoex_rfon =
6315 						true;
6316 					btdm_1AntSetPSTDMA(padapter, true, 0,
6317 							   true, 33);
6318 				}
6319 			} else if (true == pBtCoex->bC2hBtInquiryPage) {
6320 				padapter->pwrctrlpriv.btcoex_rfon = true;
6321 				btdm_1AntSetPSTDMA(padapter, true, 0, true, 30);
6322 			} else if (BtState == BT_INFO_STATE_ACL_ONLY_BUSY) {
6323 				padapter->pwrctrlpriv.btcoex_rfon = true;
6324 				if (pBtCoex->c2hBtProfile == BT_INFO_HID)
6325 					btdm_1AntSetPSTDMA(padapter, true, 0,
6326 							   true, 34);
6327 				else
6328 					btdm_1AntSetPSTDMA(padapter, true, 0,
6329 							   true, 4);
6330 			} else {
6331 				padapter->pwrctrlpriv.btcoex_rfon = true;
6332 				btdm_1AntSetPSTDMA(padapter, true, 0, true, 5);
6333 			}
6334 		}
6335 
6336 		btdm_NotifyFwScan(padapter, 1);
6337 	} else {
6338 		/*  WiFi_Finish_Scan */
6339 		btdm_NotifyFwScan(padapter, 0);
6340 		btdm_1AntBtCoexistHandler(padapter);
6341 	}
6342 }
6343 
BTDM_1AntFwC2hBtInfo8723A(struct rtw_adapter * padapter)6344 static void BTDM_1AntFwC2hBtInfo8723A(struct rtw_adapter *padapter)
6345 {
6346 	struct hal_data_8723a *pHalData;
6347 	struct bt_30info *pBTInfo;
6348 	struct bt_mgnt *pBtMgnt;
6349 	struct bt_coexist_8723a *pBtCoex;
6350 	u8 u1tmp, btState;
6351 
6352 	pHalData = GET_HAL_DATA(padapter);
6353 	pBTInfo = GET_BT_INFO(padapter);
6354 	pBtMgnt = &pBTInfo->BtMgnt;
6355 	pBtCoex = &pHalData->bt_coexist.halCoex8723;
6356 
6357 	u1tmp = pBtCoex->c2hBtInfoOriginal;
6358 	/*  sco BUSY bit is not used on voice over PCM platform */
6359 	btState = u1tmp & 0xF;
6360 	pBtCoex->c2hBtProfile = u1tmp & 0xE0;
6361 
6362 	/*  default set bt to idle state. */
6363 	pBtMgnt->ExtConfig.bBTBusy = false;
6364 	pHalData->bt_coexist.CurrentState |= BT_COEX_STATE_BT_IDLE;
6365 
6366 	/*  check BIT2 first ==> check if bt is under inquiry or page scan */
6367 	if (btState & BIT(2))
6368 		pBtCoex->bC2hBtInquiryPage = true;
6369 	else
6370 		pBtCoex->bC2hBtInquiryPage = false;
6371 	btState &= ~BIT(2);
6372 
6373 	if (!(btState & BIT(0)))
6374 		pBtCoex->c2hBtInfo = BT_INFO_STATE_NO_CONNECTION;
6375 	else {
6376 		if (btState == 0x1)
6377 			pBtCoex->c2hBtInfo = BT_INFO_STATE_CONNECT_IDLE;
6378 		else if (btState == 0x9) {
6379 			if (pBtCoex->bC2hBtInquiryPage == true)
6380 				pBtCoex->c2hBtInfo =
6381 					BT_INFO_STATE_ACL_INQ_OR_PAG;
6382 			else
6383 				pBtCoex->c2hBtInfo =
6384 					BT_INFO_STATE_ACL_ONLY_BUSY;
6385 			pBtMgnt->ExtConfig.bBTBusy = true;
6386 		} else if (btState == 0x3) {
6387 			pBtCoex->c2hBtInfo = BT_INFO_STATE_SCO_ONLY_BUSY;
6388 			pBtMgnt->ExtConfig.bBTBusy = true;
6389 		} else if (btState == 0xb) {
6390 			pBtCoex->c2hBtInfo = BT_INFO_STATE_ACL_SCO_BUSY;
6391 			pBtMgnt->ExtConfig.bBTBusy = true;
6392 		} else
6393 			pBtCoex->c2hBtInfo = BT_INFO_STATE_MAX;
6394 		if (pBtMgnt->ExtConfig.bBTBusy)
6395 			pHalData->bt_coexist.CurrentState &=
6396 				~BT_COEX_STATE_BT_IDLE;
6397 	}
6398 
6399 	if (BT_INFO_STATE_NO_CONNECTION == pBtCoex->c2hBtInfo ||
6400 	    BT_INFO_STATE_CONNECT_IDLE == pBtCoex->c2hBtInfo) {
6401 		if (pBtCoex->bC2hBtInquiryPage)
6402 			pBtCoex->c2hBtInfo = BT_INFO_STATE_INQ_OR_PAG;
6403 	}
6404 
6405 	RTPRINT(FBT, BT_TRACE, ("[BTC2H], %s(%d)\n",
6406 			BtStateString[pBtCoex->c2hBtInfo], pBtCoex->c2hBtInfo));
6407 
6408 	if (pBtCoex->c2hBtProfile != BT_INFO_HID)
6409 		pBtCoex->c2hBtProfile &= ~BT_INFO_HID;
6410 }
6411 
BTDM_1AntBtCoexist8723A(struct rtw_adapter * padapter)6412 void BTDM_1AntBtCoexist8723A(struct rtw_adapter *padapter)
6413 {
6414 	struct mlme_priv *pmlmepriv;
6415 	struct hal_data_8723a *pHalData;
6416 	unsigned long delta_time;
6417 
6418 	pmlmepriv = &padapter->mlmepriv;
6419 	pHalData = GET_HAL_DATA(padapter);
6420 
6421 	if (check_fwstate(pmlmepriv, WIFI_SITE_MONITOR)) {
6422 		/*  already done in BTDM_1AntForScan() */
6423 		RTPRINT(FBT, BT_TRACE,
6424 			("[BTCoex], wifi is under scan progress!!\n"));
6425 		return;
6426 	}
6427 
6428 	if (check_fwstate(pmlmepriv, WIFI_UNDER_LINKING)) {
6429 		RTPRINT(FBT, BT_TRACE,
6430 			("[BTCoex], wifi is under link progress!!\n"));
6431 		return;
6432 	}
6433 
6434 	/*  under DHCP(Special packet) */
6435 	delta_time = jiffies - padapter->pwrctrlpriv.DelayLPSLastTimeStamp;
6436 	delta_time = jiffies_to_msecs(delta_time);
6437 	if (delta_time < 500) {
6438 		RTPRINT(FBT, BT_TRACE, ("[BTCoex], wifi is under DHCP "
6439 					"progress(%li ms)!!\n", delta_time));
6440 		return;
6441 	}
6442 
6443 	BTDM_CheckWiFiState(padapter);
6444 
6445 	btdm_1AntBtCoexistHandler(padapter);
6446 }
6447 
6448 /*  ===== End of sync from SD7 driver HAL/BTCoexist/HalBtc87231Ant.c ===== */
6449 
6450 /*  ===== Below this line is sync from SD7 driver HAL/BTCoexist/HalBtc87232Ant.c ===== */
6451 
6452 /*  local function start with btdm_ */
btdm_ActionAlgorithm(struct rtw_adapter * padapter)6453 static u8 btdm_ActionAlgorithm(struct rtw_adapter *padapter)
6454 {
6455 	struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
6456 	struct bt_mgnt *pBtMgnt = &pBTInfo->BtMgnt;
6457 	struct hal_data_8723a *pHalData = GET_HAL_DATA(padapter);
6458 	struct btdm_8723a_2ant *pBtdm8723 = &pHalData->bt_coexist.halCoex8723.btdm2Ant;
6459 	u8 bScoExist = false, bBtLinkExist = false, bBtHsModeExist = false;
6460 	u8 algorithm = BT_2ANT_COEX_ALGO_UNDEFINED;
6461 
6462 	if (pBtMgnt->ExtConfig.NumberOfHandle)
6463 		bBtLinkExist = true;
6464 	if (pBtMgnt->ExtConfig.NumberOfSCO)
6465 		bScoExist = true;
6466 	if (BT_HsConnectionEstablished(padapter))
6467 		bBtHsModeExist = true;
6468 
6469 	/*  here we get BT status first */
6470 	/*  1) initialize */
6471 	pBtdm8723->btStatus = BT_2ANT_BT_STATUS_IDLE;
6472 
6473 	if ((bScoExist) || (bBtHsModeExist) ||
6474 	    (BTHCI_CheckProfileExist(padapter, BT_PROFILE_HID))) {
6475 		RTPRINT(FBT, BT_TRACE, ("[BTCoex], SCO or HID or HS exists, set BT non-idle !!!\n"));
6476 		pBtdm8723->btStatus = BT_2ANT_BT_STATUS_NON_IDLE;
6477 	} else {
6478 		/*  A2dp profile */
6479 		if ((pBtMgnt->ExtConfig.NumberOfHandle == 1) &&
6480 		    (BTHCI_CheckProfileExist(padapter, BT_PROFILE_A2DP))) {
6481 			if (BTDM_BtTxRxCounterL(padapter) < 100) {
6482 				RTPRINT(FBT, BT_TRACE, ("[BTCoex], A2DP, low priority tx+rx < 100, set BT connected-idle!!!\n"));
6483 				pBtdm8723->btStatus = BT_2ANT_BT_STATUS_CONNECTED_IDLE;
6484 			} else {
6485 				RTPRINT(FBT, BT_TRACE, ("[BTCoex], A2DP, low priority tx+rx >= 100, set BT non-idle!!!\n"));
6486 				pBtdm8723->btStatus = BT_2ANT_BT_STATUS_NON_IDLE;
6487 			}
6488 		}
6489 		/*  Pan profile */
6490 		if ((pBtMgnt->ExtConfig.NumberOfHandle == 1) &&
6491 		    (BTHCI_CheckProfileExist(padapter, BT_PROFILE_PAN))) {
6492 			if (BTDM_BtTxRxCounterL(padapter) < 600) {
6493 				RTPRINT(FBT, BT_TRACE, ("[BTCoex], PAN, low priority tx+rx < 600, set BT connected-idle!!!\n"));
6494 				pBtdm8723->btStatus = BT_2ANT_BT_STATUS_CONNECTED_IDLE;
6495 			} else {
6496 				if (pHalData->bt_coexist.halCoex8723.lowPriorityTx) {
6497 					if ((pHalData->bt_coexist.halCoex8723.lowPriorityRx /
6498 					    pHalData->bt_coexist.halCoex8723.lowPriorityTx) > 9) {
6499 						RTPRINT(FBT, BT_TRACE, ("[BTCoex], PAN, low priority rx/tx > 9, set BT connected-idle!!!\n"));
6500 						pBtdm8723->btStatus = BT_2ANT_BT_STATUS_CONNECTED_IDLE;
6501 					}
6502 				}
6503 			}
6504 			if (BT_2ANT_BT_STATUS_CONNECTED_IDLE != pBtdm8723->btStatus) {
6505 				RTPRINT(FBT, BT_TRACE, ("[BTCoex], PAN, set BT non-idle!!!\n"));
6506 				pBtdm8723->btStatus = BT_2ANT_BT_STATUS_NON_IDLE;
6507 			}
6508 		}
6509 		/*  Pan+A2dp profile */
6510 		if ((pBtMgnt->ExtConfig.NumberOfHandle == 2) &&
6511 		    (BTHCI_CheckProfileExist(padapter, BT_PROFILE_A2DP)) &&
6512 		    (BTHCI_CheckProfileExist(padapter, BT_PROFILE_PAN))) {
6513 			if (BTDM_BtTxRxCounterL(padapter) < 600) {
6514 				RTPRINT(FBT, BT_TRACE, ("[BTCoex], PAN+A2DP, low priority tx+rx < 600, set BT connected-idle!!!\n"));
6515 				pBtdm8723->btStatus = BT_2ANT_BT_STATUS_CONNECTED_IDLE;
6516 			} else {
6517 				if (pHalData->bt_coexist.halCoex8723.lowPriorityTx) {
6518 					if ((pHalData->bt_coexist.halCoex8723.lowPriorityRx /
6519 					    pHalData->bt_coexist.halCoex8723.lowPriorityTx) > 9) {
6520 						RTPRINT(FBT, BT_TRACE, ("[BTCoex], PAN+A2DP, low priority rx/tx > 9, set BT connected-idle!!!\n"));
6521 						pBtdm8723->btStatus = BT_2ANT_BT_STATUS_CONNECTED_IDLE;
6522 					}
6523 				}
6524 			}
6525 			if (BT_2ANT_BT_STATUS_CONNECTED_IDLE != pBtdm8723->btStatus) {
6526 				RTPRINT(FBT, BT_TRACE, ("[BTCoex], PAN+A2DP, set BT non-idle!!!\n"));
6527 				pBtdm8723->btStatus = BT_2ANT_BT_STATUS_NON_IDLE;
6528 			}
6529 		}
6530 	}
6531 	if (BT_2ANT_BT_STATUS_IDLE != pBtdm8723->btStatus)
6532 		pBtMgnt->ExtConfig.bBTBusy = true;
6533 	else
6534 		pBtMgnt->ExtConfig.bBTBusy = false;
6535 
6536 	if (!bBtLinkExist) {
6537 		RTPRINT(FBT, BT_TRACE, ("[BTCoex], No profile exists!!!\n"));
6538 		return algorithm;
6539 	}
6540 
6541 	if (pBtMgnt->ExtConfig.NumberOfHandle == 1) {
6542 		if (bScoExist) {
6543 			RTPRINT(FBT, BT_TRACE, ("[BTCoex], SCO only\n"));
6544 			algorithm = BT_2ANT_COEX_ALGO_SCO;
6545 		} else {
6546 			if (BTHCI_CheckProfileExist(padapter, BT_PROFILE_HID)) {
6547 				RTPRINT(FBT, BT_TRACE, ("[BTCoex], HID only\n"));
6548 				algorithm = BT_2ANT_COEX_ALGO_HID;
6549 			} else if (BTHCI_CheckProfileExist(padapter, BT_PROFILE_A2DP)) {
6550 				RTPRINT(FBT, BT_TRACE, ("[BTCoex], A2DP only\n"));
6551 				algorithm = BT_2ANT_COEX_ALGO_A2DP;
6552 			} else if (BTHCI_CheckProfileExist(padapter, BT_PROFILE_PAN)) {
6553 				if (bBtHsModeExist) {
6554 					RTPRINT(FBT, BT_TRACE, ("[BTCoex], PAN(HS) only\n"));
6555 					algorithm = BT_2ANT_COEX_ALGO_PANHS;
6556 				} else {
6557 					RTPRINT(FBT, BT_TRACE, ("[BTCoex], PAN(EDR) only\n"));
6558 					algorithm = BT_2ANT_COEX_ALGO_PANEDR;
6559 				}
6560 			} else {
6561 				RTPRINT(FBT, BT_TRACE, ("[BTCoex], Error!!! NO matched profile for NumberOfHandle =%d \n",
6562 				pBtMgnt->ExtConfig.NumberOfHandle));
6563 			}
6564 		}
6565 	} else if (pBtMgnt->ExtConfig.NumberOfHandle == 2) {
6566 		if (bScoExist) {
6567 			if (BTHCI_CheckProfileExist(padapter, BT_PROFILE_HID)) {
6568 				RTPRINT(FBT, BT_TRACE, ("[BTCoex], SCO + HID\n"));
6569 				algorithm = BT_2ANT_COEX_ALGO_HID;
6570 			} else if (BTHCI_CheckProfileExist(padapter, BT_PROFILE_A2DP)) {
6571 				RTPRINT(FBT, BT_TRACE, ("[BTCoex], Error!!! SCO + A2DP\n"));
6572 			} else if (BTHCI_CheckProfileExist(padapter, BT_PROFILE_PAN)) {
6573 				if (bBtHsModeExist) {
6574 					RTPRINT(FBT, BT_TRACE, ("[BTCoex], SCO + PAN(HS)\n"));
6575 					algorithm = BT_2ANT_COEX_ALGO_SCO;
6576 				} else {
6577 					RTPRINT(FBT, BT_TRACE, ("[BTCoex], SCO + PAN(EDR)\n"));
6578 					algorithm = BT_2ANT_COEX_ALGO_PANEDR_HID;
6579 				}
6580 			} else {
6581 				RTPRINT(FBT, BT_TRACE, ("[BTCoex], Error!!! SCO exists but why NO matched ACL profile for NumberOfHandle =%d\n",
6582 				pBtMgnt->ExtConfig.NumberOfHandle));
6583 			}
6584 		} else {
6585 			if (BTHCI_CheckProfileExist(padapter, BT_PROFILE_HID) &&
6586 			    BTHCI_CheckProfileExist(padapter, BT_PROFILE_A2DP)) {
6587 				RTPRINT(FBT, BT_TRACE, ("[BTCoex], HID + A2DP\n"));
6588 				algorithm = BT_2ANT_COEX_ALGO_HID_A2DP;
6589 		} else if (BTHCI_CheckProfileExist(padapter, BT_PROFILE_HID) &&
6590 			   BTHCI_CheckProfileExist(padapter, BT_PROFILE_PAN)) {
6591 				if (bBtHsModeExist) {
6592 					RTPRINT(FBT, BT_TRACE, ("[BTCoex], HID + PAN(HS)\n"));
6593 					algorithm = BT_2ANT_COEX_ALGO_HID_A2DP;
6594 				} else {
6595 					RTPRINT(FBT, BT_TRACE, ("[BTCoex], HID + PAN(EDR)\n"));
6596 					algorithm = BT_2ANT_COEX_ALGO_PANEDR_HID;
6597 				}
6598 			} else if (BTHCI_CheckProfileExist(padapter, BT_PROFILE_PAN) &&
6599 				   BTHCI_CheckProfileExist(padapter, BT_PROFILE_A2DP)) {
6600 				if (bBtHsModeExist) {
6601 					RTPRINT(FBT, BT_TRACE, ("[BTCoex], A2DP + PAN(HS)\n"));
6602 					algorithm = BT_2ANT_COEX_ALGO_A2DP;
6603 				} else {
6604 					RTPRINT(FBT, BT_TRACE, ("[BTCoex], A2DP + PAN(EDR)\n"));
6605 					algorithm = BT_2ANT_COEX_ALGO_PANEDR_A2DP;
6606 				}
6607 			} else {
6608 				RTPRINT(FBT, BT_TRACE, ("[BTCoex], Error!!! NO matched profile for NumberOfHandle =%d\n",
6609 					pBtMgnt->ExtConfig.NumberOfHandle));
6610 			}
6611 		}
6612 	} else if (pBtMgnt->ExtConfig.NumberOfHandle == 3) {
6613 		if (bScoExist) {
6614 			if (BTHCI_CheckProfileExist(padapter, BT_PROFILE_HID) &&
6615 			    BTHCI_CheckProfileExist(padapter, BT_PROFILE_A2DP)) {
6616 				RTPRINT(FBT, BT_TRACE, ("[BTCoex], Error!!! SCO + HID + A2DP\n"));
6617 			} else if (BTHCI_CheckProfileExist(padapter, BT_PROFILE_HID) &&
6618 				   BTHCI_CheckProfileExist(padapter, BT_PROFILE_PAN)) {
6619 				if (bBtHsModeExist) {
6620 					RTPRINT(FBT, BT_TRACE, ("[BTCoex], SCO + HID + PAN(HS)\n"));
6621 					algorithm = BT_2ANT_COEX_ALGO_HID_A2DP;
6622 				} else {
6623 					RTPRINT(FBT, BT_TRACE, ("[BTCoex], SCO + HID + PAN(EDR)\n"));
6624 					algorithm = BT_2ANT_COEX_ALGO_PANEDR_HID;
6625 				}
6626 			} else if (BTHCI_CheckProfileExist(padapter, BT_PROFILE_PAN) &&
6627 				   BTHCI_CheckProfileExist(padapter, BT_PROFILE_A2DP)) {
6628 				if (bBtHsModeExist) {
6629 					RTPRINT(FBT, BT_TRACE, ("[BTCoex], Error!!! SCO + A2DP + PAN(HS)\n"));
6630 					algorithm = BT_2ANT_COEX_ALGO_SCO;
6631 				} else {
6632 					RTPRINT(FBT, BT_TRACE, ("[BTCoex], Error!!! SCO + A2DP + PAN(EDR)\n"));
6633 				}
6634 			} else {
6635 				RTPRINT(FBT, BT_TRACE, ("[BTCoex], Error!!! SCO exists but why NO matched profile for NumberOfHandle =%d\n",
6636 					pBtMgnt->ExtConfig.NumberOfHandle));
6637 			}
6638 		} else {
6639 			if (BTHCI_CheckProfileExist(padapter, BT_PROFILE_HID) &&
6640 			    BTHCI_CheckProfileExist(padapter, BT_PROFILE_PAN) &&
6641 			    BTHCI_CheckProfileExist(padapter, BT_PROFILE_A2DP)) {
6642 				if (bBtHsModeExist) {
6643 					RTPRINT(FBT, BT_TRACE, ("[BTCoex], HID + A2DP + PAN(HS)\n"));
6644 					algorithm = BT_2ANT_COEX_ALGO_HID_A2DP_PANHS;
6645 				} else {
6646 					RTPRINT(FBT, BT_TRACE, ("[BTCoex], HID + A2DP + PAN(EDR)\n"));
6647 					algorithm = BT_2ANT_COEX_ALGO_HID_A2DP_PANEDR;
6648 				}
6649 			} else {
6650 				RTPRINT(FBT, BT_TRACE, ("[BTCoex], Error!!! NO matched profile for NumberOfHandle =%d\n",
6651 					pBtMgnt->ExtConfig.NumberOfHandle));
6652 			}
6653 		}
6654 	} else if (pBtMgnt->ExtConfig.NumberOfHandle >= 3) {
6655 		if (bScoExist) {
6656 			if (BTHCI_CheckProfileExist(padapter, BT_PROFILE_HID) &&
6657 			    BTHCI_CheckProfileExist(padapter, BT_PROFILE_PAN) &&
6658 			    BTHCI_CheckProfileExist(padapter, BT_PROFILE_A2DP)) {
6659 				if (bBtHsModeExist)
6660 					RTPRINT(FBT, BT_TRACE, ("[BTCoex], Error!!! SCO + HID + A2DP + PAN(HS)\n"));
6661 				else
6662 					RTPRINT(FBT, BT_TRACE, ("[BTCoex], Error!!! SCO + HID + A2DP + PAN(EDR)\n"));
6663 			} else {
6664 				RTPRINT(FBT, BT_TRACE, ("[BTCoex], Error!!! SCO exists but why NO matched profile for NumberOfHandle =%d\n",
6665 					pBtMgnt->ExtConfig.NumberOfHandle));
6666 			}
6667 		} else {
6668 			RTPRINT(FBT, BT_TRACE, ("[BTCoex], Error!!! NO matched profile for NumberOfHandle =%d\n",
6669 				pBtMgnt->ExtConfig.NumberOfHandle));
6670 		}
6671 	}
6672 	return algorithm;
6673 }
6674 
btdm_NeedToDecBtPwr(struct rtw_adapter * padapter)6675 static u8 btdm_NeedToDecBtPwr(struct rtw_adapter *padapter)
6676 {
6677 	struct hal_data_8723a *pHalData = GET_HAL_DATA(padapter);
6678 	u8 bRet = false;
6679 
6680 	if (BT_Operation(padapter)) {
6681 		if (pHalData->dmpriv.EntryMinUndecoratedSmoothedPWDB > 47) {
6682 			RTPRINT(FBT, BT_TRACE, ("Need to decrease bt power for HS mode!!\n"));
6683 			bRet = true;
6684 		} else {
6685 			RTPRINT(FBT, BT_TRACE, ("NO Need to decrease bt power for HS mode!!\n"));
6686 		}
6687 	} else {
6688 		if (BTDM_IsWifiConnectionExist(padapter)) {
6689 			RTPRINT(FBT, BT_TRACE, ("Need to decrease bt power for Wifi is connected!!\n"));
6690 			bRet = true;
6691 		}
6692 	}
6693 	return bRet;
6694 }
6695 
6696 static void
btdm_SetCoexTable(struct rtw_adapter * padapter,u32 val0x6c0,u32 val0x6c8,u8 val0x6cc)6697 btdm_SetCoexTable(struct rtw_adapter *padapter, u32 val0x6c0,
6698 		  u32 val0x6c8, u8 val0x6cc)
6699 {
6700 	RTPRINT(FBT, BT_TRACE, ("set coex table, set 0x6c0 = 0x%x\n", val0x6c0));
6701 	rtl8723au_write32(padapter, 0x6c0, val0x6c0);
6702 
6703 	RTPRINT(FBT, BT_TRACE, ("set coex table, set 0x6c8 = 0x%x\n", val0x6c8));
6704 	rtl8723au_write32(padapter, 0x6c8, val0x6c8);
6705 
6706 	RTPRINT(FBT, BT_TRACE, ("set coex table, set 0x6cc = 0x%x\n", val0x6cc));
6707 	rtl8723au_write8(padapter, 0x6cc, val0x6cc);
6708 }
6709 
6710 static void
btdm_SetSwFullTimeDacSwing(struct rtw_adapter * padapter,u8 bSwDacSwingOn,u32 swDacSwingLvl)6711 btdm_SetSwFullTimeDacSwing(struct rtw_adapter *padapter, u8 bSwDacSwingOn,
6712 			   u32 swDacSwingLvl)
6713 {
6714 	struct hal_data_8723a *pHalData = GET_HAL_DATA(padapter);
6715 
6716 	if (bSwDacSwingOn) {
6717 		RTPRINT(FBT, BT_TRACE, ("[BTCoex], SwDacSwing = 0x%x\n", swDacSwingLvl));
6718 		PHY_SetBBReg(padapter, 0x880, 0xff000000, swDacSwingLvl);
6719 		pHalData->bt_coexist.bSWCoexistAllOff = false;
6720 	} else {
6721 		RTPRINT(FBT, BT_TRACE, ("[BTCoex], SwDacSwing Off!\n"));
6722 		PHY_SetBBReg(padapter, 0x880, 0xff000000, 0xc0);
6723 	}
6724 }
6725 
6726 static void
btdm_SetFwDacSwingLevel(struct rtw_adapter * padapter,u8 dacSwingLvl)6727 btdm_SetFwDacSwingLevel(struct rtw_adapter *padapter, u8 dacSwingLvl)
6728 {
6729 	u8 H2C_Parameter[1] = {0};
6730 
6731 	H2C_Parameter[0] = dacSwingLvl;
6732 
6733 	RTPRINT(FBT, BT_TRACE, ("[BTCoex], Set Dac Swing Level = 0x%x\n", dacSwingLvl));
6734 	RTPRINT(FBT, BT_TRACE, ("[BTCoex], write 0x29 = 0x%x\n", H2C_Parameter[0]));
6735 
6736 	FillH2CCmd(padapter, 0x29, 1, H2C_Parameter);
6737 }
6738 
btdm_2AntDecBtPwr(struct rtw_adapter * padapter,u8 bDecBtPwr)6739 static void btdm_2AntDecBtPwr(struct rtw_adapter *padapter, u8 bDecBtPwr)
6740 {
6741 	struct hal_data_8723a *pHalData = GET_HAL_DATA(padapter);
6742 	struct btdm_8723a_2ant *pBtdm8723 = &pHalData->bt_coexist.halCoex8723.btdm2Ant;
6743 
6744 	RTPRINT(FBT, BT_TRACE,
6745 		("[BTCoex], Dec BT power = %s\n",
6746 		((bDecBtPwr) ? "ON" : "OFF")));
6747 	pBtdm8723->bCurDecBtPwr = bDecBtPwr;
6748 
6749 	if (pBtdm8723->bPreDecBtPwr == pBtdm8723->bCurDecBtPwr)
6750 		return;
6751 
6752 	BTDM_SetFwDecBtPwr(padapter, pBtdm8723->bCurDecBtPwr);
6753 
6754 	pBtdm8723->bPreDecBtPwr = pBtdm8723->bCurDecBtPwr;
6755 }
6756 
6757 static void
btdm_2AntFwDacSwingLvl(struct rtw_adapter * padapter,u8 fwDacSwingLvl)6758 btdm_2AntFwDacSwingLvl(struct rtw_adapter *padapter, u8 fwDacSwingLvl)
6759 {
6760 	struct hal_data_8723a *pHalData = GET_HAL_DATA(padapter);
6761 	struct btdm_8723a_2ant *pBtdm8723 = &pHalData->bt_coexist.halCoex8723.btdm2Ant;
6762 
6763 	RTPRINT(FBT, BT_TRACE, ("[BTCoex], set FW Dac Swing level = %d\n",  fwDacSwingLvl));
6764 	pBtdm8723->curFwDacSwingLvl = fwDacSwingLvl;
6765 
6766 	/* RTPRINT(FBT, BT_TRACE, ("[BTCoex], preFwDacSwingLvl =%d, curFwDacSwingLvl =%d\n", */
6767 	/*pBtdm8723->preFwDacSwingLvl, pBtdm8723->curFwDacSwingLvl)); */
6768 
6769 	if (pBtdm8723->preFwDacSwingLvl == pBtdm8723->curFwDacSwingLvl)
6770 		return;
6771 
6772 	btdm_SetFwDacSwingLevel(padapter, pBtdm8723->curFwDacSwingLvl);
6773 
6774 	pBtdm8723->preFwDacSwingLvl = pBtdm8723->curFwDacSwingLvl;
6775 }
6776 
6777 static void
btdm_2AntRfShrink(struct rtw_adapter * padapter,u8 bRxRfShrinkOn)6778 btdm_2AntRfShrink(struct rtw_adapter *padapter, u8 bRxRfShrinkOn)
6779 {
6780 	struct hal_data_8723a *pHalData = GET_HAL_DATA(padapter);
6781 	struct btdm_8723a_2ant *pBtdm8723 = &pHalData->bt_coexist.halCoex8723.btdm2Ant;
6782 
6783 	RTPRINT(FBT, BT_TRACE,
6784 		("[BTCoex], turn Rx RF Shrink = %s\n",
6785 		((bRxRfShrinkOn) ? "ON" : "OFF")));
6786 	pBtdm8723->bCurRfRxLpfShrink = bRxRfShrinkOn;
6787 
6788 	/* RTPRINT(FBT, BT_TRACE, ("[BTCoex], bPreRfRxLpfShrink =%d, bCurRfRxLpfShrink =%d\n", */
6789 	/*pBtdm8723->bPreRfRxLpfShrink, pBtdm8723->bCurRfRxLpfShrink)); */
6790 
6791 	if (pBtdm8723->bPreRfRxLpfShrink == pBtdm8723->bCurRfRxLpfShrink)
6792 		return;
6793 
6794 	BTDM_SetSwRfRxLpfCorner(padapter, (u8)pBtdm8723->bCurRfRxLpfShrink);
6795 
6796 	pBtdm8723->bPreRfRxLpfShrink = pBtdm8723->bCurRfRxLpfShrink;
6797 }
6798 
6799 static void
btdm_2AntLowPenaltyRa(struct rtw_adapter * padapter,u8 bLowPenaltyRa)6800 btdm_2AntLowPenaltyRa(struct rtw_adapter *padapter, u8 bLowPenaltyRa)
6801 {
6802 	struct hal_data_8723a *pHalData = GET_HAL_DATA(padapter);
6803 	struct btdm_8723a_2ant *pBtdm8723 = &pHalData->bt_coexist.halCoex8723.btdm2Ant;
6804 
6805 	RTPRINT(FBT, BT_TRACE,
6806 		("[BTCoex], turn LowPenaltyRA = %s\n",
6807 		((bLowPenaltyRa) ? "ON" : "OFF")));
6808 	pBtdm8723->bCurLowPenaltyRa = bLowPenaltyRa;
6809 
6810 	/* RTPRINT(FBT, BT_TRACE, ("[BTCoex], bPreLowPenaltyRa =%d, bCurLowPenaltyRa =%d\n", */
6811 	/*pBtdm8723->bPreLowPenaltyRa, pBtdm8723->bCurLowPenaltyRa)); */
6812 
6813 	if (pBtdm8723->bPreLowPenaltyRa == pBtdm8723->bCurLowPenaltyRa)
6814 		return;
6815 
6816 	BTDM_SetSwPenaltyTxRateAdaptive(padapter, (u8)pBtdm8723->bCurLowPenaltyRa);
6817 
6818 	pBtdm8723->bPreLowPenaltyRa = pBtdm8723->bCurLowPenaltyRa;
6819 }
6820 
6821 static void
btdm_2AntDacSwing(struct rtw_adapter * padapter,u8 bDacSwingOn,u32 dacSwingLvl)6822 btdm_2AntDacSwing(struct rtw_adapter *padapter,
6823 		  u8 bDacSwingOn, u32 dacSwingLvl)
6824 {
6825 	struct hal_data_8723a *pHalData = GET_HAL_DATA(padapter);
6826 	struct btdm_8723a_2ant *pBtdm8723 = &pHalData->bt_coexist.halCoex8723.btdm2Ant;
6827 
6828 	RTPRINT(FBT, BT_TRACE,
6829 		("[BTCoex], turn DacSwing =%s, dacSwingLvl = 0x%x\n",
6830 		(bDacSwingOn ? "ON" : "OFF"), dacSwingLvl));
6831 	pBtdm8723->bCurDacSwingOn = bDacSwingOn;
6832 	pBtdm8723->curDacSwingLvl = dacSwingLvl;
6833 
6834 	if ((pBtdm8723->bPreDacSwingOn == pBtdm8723->bCurDacSwingOn) &&
6835 	    (pBtdm8723->preDacSwingLvl == pBtdm8723->curDacSwingLvl))
6836 		return;
6837 
6838 	mdelay(30);
6839 	btdm_SetSwFullTimeDacSwing(padapter, bDacSwingOn, dacSwingLvl);
6840 
6841 	pBtdm8723->bPreDacSwingOn = pBtdm8723->bCurDacSwingOn;
6842 	pBtdm8723->preDacSwingLvl = pBtdm8723->curDacSwingLvl;
6843 }
6844 
btdm_2AntAdcBackOff(struct rtw_adapter * padapter,u8 bAdcBackOff)6845 static void btdm_2AntAdcBackOff(struct rtw_adapter *padapter, u8 bAdcBackOff)
6846 {
6847 	struct hal_data_8723a *pHalData = GET_HAL_DATA(padapter);
6848 	struct btdm_8723a_2ant *pBtdm8723 = &pHalData->bt_coexist.halCoex8723.btdm2Ant;
6849 
6850 	RTPRINT(FBT, BT_TRACE,
6851 		("[BTCoex], turn AdcBackOff = %s\n",
6852 		((bAdcBackOff) ? "ON" : "OFF")));
6853 	pBtdm8723->bCurAdcBackOff = bAdcBackOff;
6854 
6855 	if (pBtdm8723->bPreAdcBackOff == pBtdm8723->bCurAdcBackOff)
6856 		return;
6857 
6858 	BTDM_BBBackOffLevel(padapter, (u8)pBtdm8723->bCurAdcBackOff);
6859 
6860 	pBtdm8723->bPreAdcBackOff = pBtdm8723->bCurAdcBackOff;
6861 }
6862 
btdm_2AntAgcTable(struct rtw_adapter * padapter,u8 bAgcTableEn)6863 static void btdm_2AntAgcTable(struct rtw_adapter *padapter, u8 bAgcTableEn)
6864 {
6865 	struct hal_data_8723a *pHalData = GET_HAL_DATA(padapter);
6866 	struct btdm_8723a_2ant *pBtdm8723 = &pHalData->bt_coexist.halCoex8723.btdm2Ant;
6867 
6868 	RTPRINT(FBT, BT_TRACE,
6869 		("[BTCoex], %s Agc Table\n", ((bAgcTableEn) ? "Enable" : "Disable")));
6870 	pBtdm8723->bCurAgcTableEn = bAgcTableEn;
6871 
6872 	/* RTPRINT(FBT, BT_TRACE, ("[BTCoex], bPreAgcTableEn =%d, bCurAgcTableEn =%d\n", */
6873 	/*pBtdm8723->bPreAgcTableEn, pBtdm8723->bCurAgcTableEn)); */
6874 
6875 	if (pBtdm8723->bPreAgcTableEn == pBtdm8723->bCurAgcTableEn)
6876 		return;
6877 
6878 	BTDM_AGCTable(padapter, (u8)bAgcTableEn);
6879 
6880 	pBtdm8723->bPreAgcTableEn = pBtdm8723->bCurAgcTableEn;
6881 }
6882 
6883 static void
btdm_2AntCoexTable(struct rtw_adapter * padapter,u32 val0x6c0,u32 val0x6c8,u8 val0x6cc)6884 btdm_2AntCoexTable(struct rtw_adapter *padapter,
6885 		   u32 val0x6c0, u32 val0x6c8, u8 val0x6cc)
6886 {
6887 	struct hal_data_8723a *pHalData = GET_HAL_DATA(padapter);
6888 	struct btdm_8723a_2ant *pBtdm8723 = &pHalData->bt_coexist.halCoex8723.btdm2Ant;
6889 
6890 	RTPRINT(FBT, BT_TRACE, ("[BTCoex], write Coex Table 0x6c0 = 0x%x, 0x6c8 = 0x%x, 0x6cc = 0x%x\n",
6891 		val0x6c0, val0x6c8, val0x6cc));
6892 	pBtdm8723->curVal0x6c0 = val0x6c0;
6893 	pBtdm8723->curVal0x6c8 = val0x6c8;
6894 	pBtdm8723->curVal0x6cc = val0x6cc;
6895 
6896 	/* RTPRINT(FBT, BT_TRACE, ("[BTCoex], preVal0x6c0 = 0x%x, preVal0x6c8 = 0x%x, preVal0x6cc = 0x%x !!\n", */
6897 	/*pBtdm8723->preVal0x6c0, pBtdm8723->preVal0x6c8, pBtdm8723->preVal0x6cc)); */
6898 	/* RTPRINT(FBT, BT_TRACE, ("[BTCoex], curVal0x6c0 = 0x%x, curVal0x6c8 = 0x%x, curVal0x6cc = 0x%x !!\n", */
6899 	/*pBtdm8723->curVal0x6c0, pBtdm8723->curVal0x6c8, pBtdm8723->curVal0x6cc)); */
6900 
6901 	if ((pBtdm8723->preVal0x6c0 == pBtdm8723->curVal0x6c0) &&
6902 	    (pBtdm8723->preVal0x6c8 == pBtdm8723->curVal0x6c8) &&
6903 	    (pBtdm8723->preVal0x6cc == pBtdm8723->curVal0x6cc))
6904 		return;
6905 
6906 	btdm_SetCoexTable(padapter, val0x6c0, val0x6c8, val0x6cc);
6907 
6908 	pBtdm8723->preVal0x6c0 = pBtdm8723->curVal0x6c0;
6909 	pBtdm8723->preVal0x6c8 = pBtdm8723->curVal0x6c8;
6910 	pBtdm8723->preVal0x6cc = pBtdm8723->curVal0x6cc;
6911 }
6912 
btdm_2AntIgnoreWlanAct(struct rtw_adapter * padapter,u8 bEnable)6913 static void btdm_2AntIgnoreWlanAct(struct rtw_adapter *padapter, u8 bEnable)
6914 {
6915 	struct hal_data_8723a *pHalData = GET_HAL_DATA(padapter);
6916 	struct btdm_8723a_2ant *pBtdm8723 = &pHalData->bt_coexist.halCoex8723.btdm2Ant;
6917 
6918 	RTPRINT(FBT, BT_TRACE,
6919 		("[BTCoex], turn Ignore WlanAct %s\n", (bEnable ? "ON" : "OFF")));
6920 	pBtdm8723->bCurIgnoreWlanAct = bEnable;
6921 
6922 
6923 	if (pBtdm8723->bPreIgnoreWlanAct == pBtdm8723->bCurIgnoreWlanAct)
6924 		return;
6925 
6926 	btdm_SetFwIgnoreWlanAct(padapter, bEnable);
6927 	pBtdm8723->bPreIgnoreWlanAct = pBtdm8723->bCurIgnoreWlanAct;
6928 }
6929 
6930 static void
btdm_2AntSetFw3a(struct rtw_adapter * padapter,u8 byte1,u8 byte2,u8 byte3,u8 byte4,u8 byte5)6931 btdm_2AntSetFw3a(struct rtw_adapter *padapter, u8 byte1, u8 byte2,
6932 		 u8 byte3, u8 byte4, u8 byte5)
6933 {
6934 	u8 H2C_Parameter[5] = {0};
6935 
6936 	struct hal_data_8723a *pHalData = GET_HAL_DATA(padapter);
6937 
6938 	/*  byte1[1:0] != 0 means enable pstdma */
6939 	/*  for 2Ant bt coexist, if byte1 != 0 means enable pstdma */
6940 	if (byte1)
6941 		pHalData->bt_coexist.bFWCoexistAllOff = false;
6942 	H2C_Parameter[0] = byte1;
6943 	H2C_Parameter[1] = byte2;
6944 	H2C_Parameter[2] = byte3;
6945 	H2C_Parameter[3] = byte4;
6946 	H2C_Parameter[4] = byte5;
6947 
6948 	pHalData->bt_coexist.fw3aVal[0] = byte1;
6949 	pHalData->bt_coexist.fw3aVal[1] = byte2;
6950 	pHalData->bt_coexist.fw3aVal[2] = byte3;
6951 	pHalData->bt_coexist.fw3aVal[3] = byte4;
6952 	pHalData->bt_coexist.fw3aVal[4] = byte5;
6953 
6954 	RTPRINT(FBT, BT_TRACE, ("[BTCoex], FW write 0x3a(5bytes) = 0x%x%08x\n",
6955 		H2C_Parameter[0],
6956 		H2C_Parameter[1]<<24|H2C_Parameter[2]<<16|H2C_Parameter[3]<<8|H2C_Parameter[4]));
6957 
6958 	FillH2CCmd(padapter, 0x3a, 5, H2C_Parameter);
6959 	}
6960 
btdm_2AntPsTdma(struct rtw_adapter * padapter,u8 bTurnOn,u8 type)6961 static void btdm_2AntPsTdma(struct rtw_adapter *padapter, u8 bTurnOn, u8 type)
6962 {
6963 	struct hal_data_8723a *pHalData = GET_HAL_DATA(padapter);
6964 	struct btdm_8723a_2ant *pBtdm8723 = &pHalData->bt_coexist.halCoex8723.btdm2Ant;
6965 	u32			btTxRxCnt = 0;
6966 	u8 bTurnOnByCnt = false;
6967 	u8 psTdmaTypeByCnt = 0;
6968 
6969 	btTxRxCnt = BTDM_BtTxRxCounterH(padapter)+BTDM_BtTxRxCounterL(padapter);
6970 	RTPRINT(FBT, BT_TRACE, ("[BTCoex], BT TxRx Counters = %d\n", btTxRxCnt));
6971 	if (btTxRxCnt > 3000) {
6972 		bTurnOnByCnt = true;
6973 		psTdmaTypeByCnt = 8;
6974 
6975 		RTPRINT(FBT, BT_TRACE,
6976 			("[BTCoex], For BTTxRxCounters, turn %s PS TDMA, type =%d\n",
6977 			(bTurnOnByCnt ? "ON" : "OFF"), psTdmaTypeByCnt));
6978 		pBtdm8723->bCurPsTdmaOn = bTurnOnByCnt;
6979 		pBtdm8723->curPsTdma = psTdmaTypeByCnt;
6980 	} else {
6981 		RTPRINT(FBT, BT_TRACE,
6982 			("[BTCoex], turn %s PS TDMA, type =%d\n",
6983 			(bTurnOn ? "ON" : "OFF"), type));
6984 		pBtdm8723->bCurPsTdmaOn = bTurnOn;
6985 		pBtdm8723->curPsTdma = type;
6986 	}
6987 
6988 	if ((pBtdm8723->bPrePsTdmaOn == pBtdm8723->bCurPsTdmaOn) &&
6989 	    (pBtdm8723->prePsTdma == pBtdm8723->curPsTdma))
6990 		return;
6991 
6992 	if (bTurnOn) {
6993 		switch (type) {
6994 		case 1:
6995 		default:
6996 			btdm_2AntSetFw3a(padapter, 0xe3, 0x1a, 0x1a, 0xa1, 0x98);
6997 			break;
6998 		case 2:
6999 			btdm_2AntSetFw3a(padapter, 0xe3, 0x12, 0x12, 0xa1, 0x98);
7000 			break;
7001 		case 3:
7002 			btdm_2AntSetFw3a(padapter, 0xe3, 0xa, 0xa, 0xa1, 0x98);
7003 			break;
7004 		case 4:
7005 			btdm_2AntSetFw3a(padapter, 0xa3, 0x5, 0x5, 0xa1, 0x80);
7006 			break;
7007 		case 5:
7008 			btdm_2AntSetFw3a(padapter, 0xe3, 0x1a, 0x1a, 0x20, 0x98);
7009 			break;
7010 		case 6:
7011 			btdm_2AntSetFw3a(padapter, 0xe3, 0x12, 0x12, 0x20, 0x98);
7012 			break;
7013 		case 7:
7014 			btdm_2AntSetFw3a(padapter, 0xe3, 0xa, 0xa, 0x20, 0x98);
7015 			break;
7016 		case 8:
7017 			btdm_2AntSetFw3a(padapter, 0xa3, 0x5, 0x5, 0x20, 0x80);
7018 			break;
7019 		case 9:
7020 			btdm_2AntSetFw3a(padapter, 0xe3, 0x1a, 0x1a, 0xa1, 0x98);
7021 			break;
7022 		case 10:
7023 			btdm_2AntSetFw3a(padapter, 0xe3, 0x12, 0x12, 0xa1, 0x98);
7024 			break;
7025 		case 11:
7026 			btdm_2AntSetFw3a(padapter, 0xe3, 0xa, 0xa, 0xa1, 0x98);
7027 			break;
7028 		case 12:
7029 			btdm_2AntSetFw3a(padapter, 0xe3, 0x5, 0x5, 0xa1, 0x98);
7030 			break;
7031 		case 13:
7032 			btdm_2AntSetFw3a(padapter, 0xe3, 0x1a, 0x1a, 0x20, 0x98);
7033 			break;
7034 		case 14:
7035 			btdm_2AntSetFw3a(padapter, 0xe3, 0x12, 0x12, 0x20, 0x98);
7036 			break;
7037 		case 15:
7038 			btdm_2AntSetFw3a(padapter, 0xe3, 0xa, 0xa, 0x20, 0x98);
7039 			break;
7040 		case 16:
7041 			btdm_2AntSetFw3a(padapter, 0xe3, 0x5, 0x5, 0x20, 0x98);
7042 			break;
7043 		case 17:
7044 			btdm_2AntSetFw3a(padapter, 0xa3, 0x2f, 0x2f, 0x20, 0x80);
7045 			break;
7046 		case 18:
7047 			btdm_2AntSetFw3a(padapter, 0xe3, 0x5, 0x5, 0xa1, 0x98);
7048 			break;
7049 		case 19:
7050 			btdm_2AntSetFw3a(padapter, 0xe3, 0x25, 0x25, 0xa1, 0x98);
7051 			break;
7052 		case 20:
7053 			btdm_2AntSetFw3a(padapter, 0xe3, 0x25, 0x25, 0x20, 0x98);
7054 			break;
7055 		}
7056 	} else {
7057 		/*  disable PS tdma */
7058 		switch (type) {
7059 		case 0:
7060 			btdm_2AntSetFw3a(padapter, 0x0, 0x0, 0x0, 0x8, 0x0);
7061 			break;
7062 		case 1:
7063 			btdm_2AntSetFw3a(padapter, 0x0, 0x0, 0x0, 0x0, 0x0);
7064 			break;
7065 		default:
7066 			btdm_2AntSetFw3a(padapter, 0x0, 0x0, 0x0, 0x8, 0x0);
7067 			break;
7068 		}
7069 	}
7070 
7071 	/*  update pre state */
7072 	pBtdm8723->bPrePsTdmaOn =  pBtdm8723->bCurPsTdmaOn;
7073 	pBtdm8723->prePsTdma = pBtdm8723->curPsTdma;
7074 }
7075 
btdm_2AntBtInquiryPage(struct rtw_adapter * padapter)7076 static void btdm_2AntBtInquiryPage(struct rtw_adapter *padapter)
7077 {
7078 	btdm_2AntCoexTable(padapter, 0x55555555, 0xffff, 0x3);
7079 	btdm_2AntIgnoreWlanAct(padapter, false);
7080 	btdm_2AntPsTdma(padapter, true, 8);
7081 }
7082 
btdm_HoldForBtInqPage(struct rtw_adapter * padapter)7083 static u8 btdm_HoldForBtInqPage(struct rtw_adapter *padapter)
7084 {
7085 	struct hal_data_8723a *pHalData = GET_HAL_DATA(padapter);
7086 	u32 curTime = jiffies;
7087 
7088 	if (pHalData->bt_coexist.halCoex8723.bC2hBtInquiryPage) {
7089 		/*  bt inquiry or page is started. */
7090 		if (pHalData->bt_coexist.halCoex8723.btInqPageStartTime == 0) {
7091 			pHalData->bt_coexist.halCoex8723.btInqPageStartTime = curTime;
7092 			RTPRINT(FBT, BT_TRACE, ("[BTCoex], BT Inquiry/page is started at time : 0x%lx \n",
7093 			pHalData->bt_coexist.halCoex8723.btInqPageStartTime));
7094 		}
7095 	}
7096 	RTPRINT(FBT, BT_TRACE, ("[BTCoex], BT Inquiry/page started time : 0x%lx, curTime : 0x%x \n",
7097 		pHalData->bt_coexist.halCoex8723.btInqPageStartTime, curTime));
7098 
7099 	if (pHalData->bt_coexist.halCoex8723.btInqPageStartTime) {
7100 		if (((curTime - pHalData->bt_coexist.halCoex8723.btInqPageStartTime)/1000000) >= 10) {
7101 			RTPRINT(FBT, BT_TRACE, ("[BTCoex], BT Inquiry/page >= 10sec!!!"));
7102 			pHalData->bt_coexist.halCoex8723.btInqPageStartTime = 0;
7103 		}
7104 	}
7105 
7106 	if (pHalData->bt_coexist.halCoex8723.btInqPageStartTime) {
7107 		btdm_2AntCoexTable(padapter, 0x55555555, 0xffff, 0x3);
7108 		btdm_2AntIgnoreWlanAct(padapter, false);
7109 		btdm_2AntPsTdma(padapter, true, 8);
7110 		return true;
7111 	} else {
7112 		return false;
7113 	}
7114 }
7115 
btdm_Is2Ant8723ACommonAction(struct rtw_adapter * padapter)7116 static u8 btdm_Is2Ant8723ACommonAction(struct rtw_adapter *padapter)
7117 {
7118 	struct hal_data_8723a *pHalData = GET_HAL_DATA(padapter);
7119 	struct btdm_8723a_2ant *pBtdm8723 = &pHalData->bt_coexist.halCoex8723.btdm2Ant;
7120 	u8 bCommon = false;
7121 
7122 	RTPRINT(FBT, BT_TRACE, ("%s :BTDM_IsWifiConnectionExist =%x check_fwstate =%x pmlmepriv->fw_state = 0x%x\n", __func__, BTDM_IsWifiConnectionExist(padapter), check_fwstate(&padapter->mlmepriv, (_FW_UNDER_SURVEY|_FW_UNDER_LINKING)), padapter->mlmepriv.fw_state));
7123 
7124 	if ((!BTDM_IsWifiConnectionExist(padapter)) &&
7125 	    (!check_fwstate(&padapter->mlmepriv, (_FW_UNDER_SURVEY|_FW_UNDER_LINKING))) &&
7126 	    (BT_2ANT_BT_STATUS_IDLE == pBtdm8723->btStatus)) {
7127 		RTPRINT(FBT, BT_TRACE, ("Wifi idle + Bt idle!!\n"));
7128 
7129 		btdm_2AntLowPenaltyRa(padapter, false);
7130 		btdm_2AntRfShrink(padapter, false);
7131 		btdm_2AntCoexTable(padapter, 0x55555555, 0xffff, 0x3);
7132 
7133 		btdm_2AntIgnoreWlanAct(padapter, false);
7134 		btdm_2AntPsTdma(padapter, false, 0);
7135 		btdm_2AntFwDacSwingLvl(padapter, 0x20);
7136 		btdm_2AntDecBtPwr(padapter, false);
7137 
7138 		btdm_2AntAgcTable(padapter, false);
7139 		btdm_2AntAdcBackOff(padapter, false);
7140 		btdm_2AntDacSwing(padapter, false, 0xc0);
7141 
7142 		bCommon = true;
7143 	} else if (((BTDM_IsWifiConnectionExist(padapter)) ||
7144 		   (check_fwstate(&padapter->mlmepriv, (_FW_UNDER_SURVEY|_FW_UNDER_LINKING)))) &&
7145 		   (BT_2ANT_BT_STATUS_IDLE == pBtdm8723->btStatus)) {
7146 		RTPRINT(FBT, BT_TRACE, ("Wifi non-idle + BT idle!!\n"));
7147 
7148 		btdm_2AntLowPenaltyRa(padapter, true);
7149 		btdm_2AntRfShrink(padapter, false);
7150 		btdm_2AntCoexTable(padapter, 0x55555555, 0xffff, 0x3);
7151 
7152 		btdm_2AntIgnoreWlanAct(padapter, false);
7153 		btdm_2AntPsTdma(padapter, false, 0);
7154 		btdm_2AntFwDacSwingLvl(padapter, 0x20);
7155 		btdm_2AntDecBtPwr(padapter, true);
7156 
7157 		btdm_2AntAgcTable(padapter, false);
7158 		btdm_2AntAdcBackOff(padapter, false);
7159 		btdm_2AntDacSwing(padapter, false, 0xc0);
7160 
7161 		bCommon = true;
7162 	} else if ((!BTDM_IsWifiConnectionExist(padapter)) &&
7163 		   (!check_fwstate(&padapter->mlmepriv, (_FW_UNDER_SURVEY|_FW_UNDER_LINKING))) &&
7164 		   (BT_2ANT_BT_STATUS_CONNECTED_IDLE == pBtdm8723->btStatus)) {
7165 		RTPRINT(FBT, BT_TRACE, ("Wifi idle + Bt connected idle!!\n"));
7166 
7167 		btdm_2AntLowPenaltyRa(padapter, true);
7168 		btdm_2AntRfShrink(padapter, true);
7169 		btdm_2AntCoexTable(padapter, 0x55555555, 0xffff, 0x3);
7170 
7171 		btdm_2AntIgnoreWlanAct(padapter, false);
7172 		btdm_2AntPsTdma(padapter, false, 0);
7173 		btdm_2AntFwDacSwingLvl(padapter, 0x20);
7174 		btdm_2AntDecBtPwr(padapter, false);
7175 
7176 		btdm_2AntAgcTable(padapter, false);
7177 		btdm_2AntAdcBackOff(padapter, false);
7178 		btdm_2AntDacSwing(padapter, false, 0xc0);
7179 
7180 		bCommon = true;
7181 	} else if (((BTDM_IsWifiConnectionExist(padapter)) ||
7182 		   (check_fwstate(&padapter->mlmepriv, (_FW_UNDER_SURVEY|_FW_UNDER_LINKING)))) &&
7183 		   (BT_2ANT_BT_STATUS_CONNECTED_IDLE == pBtdm8723->btStatus)) {
7184 		RTPRINT(FBT, BT_TRACE, ("Wifi non-idle + Bt connected idle!!\n"));
7185 
7186 		btdm_2AntLowPenaltyRa(padapter, true);
7187 		btdm_2AntRfShrink(padapter, true);
7188 		btdm_2AntCoexTable(padapter, 0x55555555, 0xffff, 0x3);
7189 
7190 		btdm_2AntIgnoreWlanAct(padapter, false);
7191 		btdm_2AntPsTdma(padapter, false, 0);
7192 		btdm_2AntFwDacSwingLvl(padapter, 0x20);
7193 		btdm_2AntDecBtPwr(padapter, true);
7194 
7195 		btdm_2AntAgcTable(padapter, false);
7196 		btdm_2AntAdcBackOff(padapter, false);
7197 		btdm_2AntDacSwing(padapter, false, 0xc0);
7198 
7199 		bCommon = true;
7200 	} else if ((!BTDM_IsWifiConnectionExist(padapter)) &&
7201 		   (!check_fwstate(&padapter->mlmepriv, (_FW_UNDER_SURVEY|_FW_UNDER_LINKING))) &&
7202 		   (BT_2ANT_BT_STATUS_NON_IDLE == pBtdm8723->btStatus)) {
7203 		RTPRINT(FBT, BT_TRACE, ("Wifi idle + BT non-idle!!\n"));
7204 
7205 		btdm_2AntLowPenaltyRa(padapter, true);
7206 		btdm_2AntRfShrink(padapter, true);
7207 		btdm_2AntCoexTable(padapter, 0x55555555, 0xffff, 0x3);
7208 
7209 		btdm_2AntIgnoreWlanAct(padapter, false);
7210 		btdm_2AntPsTdma(padapter, false, 0);
7211 		btdm_2AntFwDacSwingLvl(padapter, 0x20);
7212 		btdm_2AntDecBtPwr(padapter, false);
7213 
7214 		btdm_2AntAgcTable(padapter, false);
7215 		btdm_2AntAdcBackOff(padapter, false);
7216 		btdm_2AntDacSwing(padapter, false, 0xc0);
7217 
7218 		bCommon = true;
7219 	} else {
7220 		RTPRINT(FBT, BT_TRACE, ("Wifi non-idle + BT non-idle!!\n"));
7221 		btdm_2AntLowPenaltyRa(padapter, true);
7222 		btdm_2AntRfShrink(padapter, true);
7223 		btdm_2AntCoexTable(padapter, 0x55555555, 0xffff, 0x3);
7224 		btdm_2AntIgnoreWlanAct(padapter, false);
7225 		btdm_2AntFwDacSwingLvl(padapter, 0x20);
7226 
7227 		bCommon = false;
7228 	}
7229 	return bCommon;
7230 }
7231 
7232 static void
btdm_2AntTdmaDurationAdjust(struct rtw_adapter * padapter,u8 bScoHid,u8 bTxPause,u8 maxInterval)7233 btdm_2AntTdmaDurationAdjust(struct rtw_adapter *padapter, u8 bScoHid,
7234 			    u8 bTxPause, u8 maxInterval)
7235 {
7236 	struct hal_data_8723a *pHalData = GET_HAL_DATA(padapter);
7237 	struct btdm_8723a_2ant *pBtdm8723 = &pHalData->bt_coexist.halCoex8723.btdm2Ant;
7238 	static s32		up, dn, m, n, WaitCount;
7239 	s32			result;   /* 0: no change, +1: increase WiFi duration, -1: decrease WiFi duration */
7240 	u8 retryCount = 0;
7241 
7242 	RTPRINT(FBT, BT_TRACE, ("[BTCoex], TdmaDurationAdjust()\n"));
7243 
7244 	if (pBtdm8723->bResetTdmaAdjust) {
7245 		pBtdm8723->bResetTdmaAdjust = false;
7246 		RTPRINT(FBT, BT_TRACE, ("[BTCoex], first run TdmaDurationAdjust()!!\n"));
7247 		if (bScoHid) {
7248 			if (bTxPause) {
7249 				btdm_2AntPsTdma(padapter, true, 15);
7250 				pBtdm8723->psTdmaDuAdjType = 15;
7251 			} else {
7252 				btdm_2AntPsTdma(padapter, true, 11);
7253 				pBtdm8723->psTdmaDuAdjType = 11;
7254 			}
7255 		} else {
7256 			if (bTxPause) {
7257 				btdm_2AntPsTdma(padapter, true, 7);
7258 				pBtdm8723->psTdmaDuAdjType = 7;
7259 			} else {
7260 				btdm_2AntPsTdma(padapter, true, 3);
7261 				pBtdm8723->psTdmaDuAdjType = 3;
7262 			}
7263 		}
7264 		up = 0;
7265 		dn = 0;
7266 		m = 1;
7267 		n = 3;
7268 		result = 0;
7269 		WaitCount = 0;
7270 	} else {
7271 		/* accquire the BT TRx retry count from BT_Info byte2 */
7272 		retryCount = pHalData->bt_coexist.halCoex8723.btRetryCnt;
7273 		RTPRINT(FBT, BT_TRACE, ("[BTCoex], retryCount = %d\n", retryCount));
7274 		result = 0;
7275 		WaitCount++;
7276 
7277 		if (retryCount == 0) {  /*  no retry in the last 2-second duration */
7278 			up++;
7279 			dn--;
7280 
7281 			if (dn <= 0)
7282 				dn = 0;
7283 
7284 			if (up >= n) {	/*  if �s�� n ��2�� retry count��0, �h�ռeWiFi duration */
7285 				WaitCount = 0;
7286 				n = 3;
7287 				up = 0;
7288 				dn = 0;
7289 				result = 1;
7290 				RTPRINT(FBT, BT_TRACE, ("[BTCoex], Increase wifi duration!!\n"));
7291 			}
7292 		} else if (retryCount <= 3) {	/*  <= 3 retry in the last 2-second duration */
7293 			up--;
7294 			dn++;
7295 
7296 			if (up <= 0)
7297 				up = 0;
7298 
7299 			if (dn == 2) {	/*  if �s�� 2 ��2�� retry count< 3, �h�կ�WiFi duration */
7300 				if (WaitCount <= 2)
7301 					m++; /*  �קK�@���b���level���Ӧ^ */
7302 				else
7303 					m = 1;
7304 
7305 				if (m >= 20) /* m �̤j�� = 20 ' �̤j120�� recheck�O�_�վ� WiFi duration. */
7306 					m = 20;
7307 
7308 				n = 3*m;
7309 				up = 0;
7310 				dn = 0;
7311 				WaitCount = 0;
7312 				result = -1;
7313 				RTPRINT(FBT, BT_TRACE, ("[BTCoex], Decrease wifi duration for retryCounter<3!!\n"));
7314 			}
7315 		} else {  /* retry count > 3, �u�n1�� retry count > 3, �h�կ�WiFi duration */
7316 			if (WaitCount == 1)
7317 				m++; /*  �קK�@���b���level���Ӧ^ */
7318 			else
7319 				m = 1;
7320 
7321 			if (m >= 20) /* m �̤j�� = 20 ' �̤j120�� recheck�O�_�վ� WiFi duration. */
7322 				m = 20;
7323 			n = 3*m;
7324 			up = 0;
7325 			dn = 0;
7326 			WaitCount = 0;
7327 			result = -1;
7328 			RTPRINT(FBT, BT_TRACE, ("[BTCoex], Decrease wifi duration for retryCounter>3!!\n"));
7329 		}
7330 
7331 		RTPRINT(FBT, BT_TRACE, ("[BTCoex], max Interval = %d\n", maxInterval));
7332 		if (maxInterval == 1) {
7333 			if (bTxPause) {
7334 				RTPRINT(FBT, BT_TRACE, ("[BTCoex], TxPause = 1\n"));
7335 				if (pBtdm8723->curPsTdma == 1) {
7336 					btdm_2AntPsTdma(padapter, true, 5);
7337 					pBtdm8723->psTdmaDuAdjType = 5;
7338 				} else if (pBtdm8723->curPsTdma == 2) {
7339 					btdm_2AntPsTdma(padapter, true, 6);
7340 					pBtdm8723->psTdmaDuAdjType = 6;
7341 				} else if (pBtdm8723->curPsTdma == 3) {
7342 					btdm_2AntPsTdma(padapter, true, 7);
7343 					pBtdm8723->psTdmaDuAdjType = 7;
7344 				} else if (pBtdm8723->curPsTdma == 4) {
7345 					btdm_2AntPsTdma(padapter, true, 8);
7346 					pBtdm8723->psTdmaDuAdjType = 8;
7347 				}
7348 				if (pBtdm8723->curPsTdma == 9) {
7349 					btdm_2AntPsTdma(padapter, true, 13);
7350 					pBtdm8723->psTdmaDuAdjType = 13;
7351 				} else if (pBtdm8723->curPsTdma == 10) {
7352 					btdm_2AntPsTdma(padapter, true, 14);
7353 					pBtdm8723->psTdmaDuAdjType = 14;
7354 				} else if (pBtdm8723->curPsTdma == 11) {
7355 					btdm_2AntPsTdma(padapter, true, 15);
7356 					pBtdm8723->psTdmaDuAdjType = 15;
7357 				} else if (pBtdm8723->curPsTdma == 12) {
7358 					btdm_2AntPsTdma(padapter, true, 16);
7359 					pBtdm8723->psTdmaDuAdjType = 16;
7360 				}
7361 
7362 				if (result == -1) {
7363 					if (pBtdm8723->curPsTdma == 5) {
7364 						btdm_2AntPsTdma(padapter, true, 6);
7365 						pBtdm8723->psTdmaDuAdjType = 6;
7366 					} else if (pBtdm8723->curPsTdma == 6) {
7367 						btdm_2AntPsTdma(padapter, true, 7);
7368 						pBtdm8723->psTdmaDuAdjType = 7;
7369 					} else if (pBtdm8723->curPsTdma == 7) {
7370 						btdm_2AntPsTdma(padapter, true, 8);
7371 						pBtdm8723->psTdmaDuAdjType = 8;
7372 					} else if (pBtdm8723->curPsTdma == 13) {
7373 						btdm_2AntPsTdma(padapter, true, 14);
7374 						pBtdm8723->psTdmaDuAdjType = 14;
7375 					} else if (pBtdm8723->curPsTdma == 14) {
7376 						btdm_2AntPsTdma(padapter, true, 15);
7377 						pBtdm8723->psTdmaDuAdjType = 15;
7378 					} else if (pBtdm8723->curPsTdma == 15) {
7379 						btdm_2AntPsTdma(padapter, true, 16);
7380 						pBtdm8723->psTdmaDuAdjType = 16;
7381 					}
7382 				} else if (result == 1) {
7383 					if (pBtdm8723->curPsTdma == 8) {
7384 						btdm_2AntPsTdma(padapter, true, 7);
7385 						pBtdm8723->psTdmaDuAdjType = 7;
7386 					} else if (pBtdm8723->curPsTdma == 7) {
7387 						btdm_2AntPsTdma(padapter, true, 6);
7388 						pBtdm8723->psTdmaDuAdjType = 6;
7389 					} else if (pBtdm8723->curPsTdma == 6) {
7390 						btdm_2AntPsTdma(padapter, true, 5);
7391 						pBtdm8723->psTdmaDuAdjType = 5;
7392 					} else if (pBtdm8723->curPsTdma == 16) {
7393 						btdm_2AntPsTdma(padapter, true, 15);
7394 						pBtdm8723->psTdmaDuAdjType = 15;
7395 					} else if (pBtdm8723->curPsTdma == 15) {
7396 						btdm_2AntPsTdma(padapter, true, 14);
7397 						pBtdm8723->psTdmaDuAdjType = 14;
7398 					} else if (pBtdm8723->curPsTdma == 14) {
7399 						btdm_2AntPsTdma(padapter, true, 13);
7400 						pBtdm8723->psTdmaDuAdjType = 13;
7401 					}
7402 				}
7403 			} else {
7404 				RTPRINT(FBT, BT_TRACE, ("[BTCoex], TxPause = 0\n"));
7405 				if (pBtdm8723->curPsTdma == 5) {
7406 					btdm_2AntPsTdma(padapter, true, 1);
7407 					pBtdm8723->psTdmaDuAdjType = 1;
7408 				} else if (pBtdm8723->curPsTdma == 6) {
7409 					btdm_2AntPsTdma(padapter, true, 2);
7410 					pBtdm8723->psTdmaDuAdjType = 2;
7411 				} else if (pBtdm8723->curPsTdma == 7) {
7412 					btdm_2AntPsTdma(padapter, true, 3);
7413 					pBtdm8723->psTdmaDuAdjType = 3;
7414 				} else if (pBtdm8723->curPsTdma == 8) {
7415 					btdm_2AntPsTdma(padapter, true, 4);
7416 					pBtdm8723->psTdmaDuAdjType = 4;
7417 				}
7418 				if (pBtdm8723->curPsTdma == 13) {
7419 					btdm_2AntPsTdma(padapter, true, 9);
7420 					pBtdm8723->psTdmaDuAdjType = 9;
7421 				} else if (pBtdm8723->curPsTdma == 14) {
7422 					btdm_2AntPsTdma(padapter, true, 10);
7423 					pBtdm8723->psTdmaDuAdjType = 10;
7424 				} else if (pBtdm8723->curPsTdma == 15) {
7425 					btdm_2AntPsTdma(padapter, true, 11);
7426 					pBtdm8723->psTdmaDuAdjType = 11;
7427 				} else if (pBtdm8723->curPsTdma == 16) {
7428 					btdm_2AntPsTdma(padapter, true, 12);
7429 					pBtdm8723->psTdmaDuAdjType = 12;
7430 				}
7431 
7432 				if (result == -1) {
7433 					if (pBtdm8723->curPsTdma == 1) {
7434 						btdm_2AntPsTdma(padapter, true, 2);
7435 						pBtdm8723->psTdmaDuAdjType = 2;
7436 					} else if (pBtdm8723->curPsTdma == 2) {
7437 						btdm_2AntPsTdma(padapter, true, 3);
7438 						pBtdm8723->psTdmaDuAdjType = 3;
7439 					} else if (pBtdm8723->curPsTdma == 3) {
7440 						btdm_2AntPsTdma(padapter, true, 4);
7441 						pBtdm8723->psTdmaDuAdjType = 4;
7442 					} else if (pBtdm8723->curPsTdma == 9) {
7443 						btdm_2AntPsTdma(padapter, true, 10);
7444 						pBtdm8723->psTdmaDuAdjType = 10;
7445 					} else if (pBtdm8723->curPsTdma == 10) {
7446 						btdm_2AntPsTdma(padapter, true, 11);
7447 						pBtdm8723->psTdmaDuAdjType = 11;
7448 					} else if (pBtdm8723->curPsTdma == 11) {
7449 						btdm_2AntPsTdma(padapter, true, 12);
7450 						pBtdm8723->psTdmaDuAdjType = 12;
7451 					}
7452 				} else if (result == 1) {
7453 					if (pBtdm8723->curPsTdma == 4) {
7454 						btdm_2AntPsTdma(padapter, true, 3);
7455 						pBtdm8723->psTdmaDuAdjType = 3;
7456 					} else if (pBtdm8723->curPsTdma == 3) {
7457 						btdm_2AntPsTdma(padapter, true, 2);
7458 						pBtdm8723->psTdmaDuAdjType = 2;
7459 					} else if (pBtdm8723->curPsTdma == 2) {
7460 						btdm_2AntPsTdma(padapter, true, 1);
7461 						pBtdm8723->psTdmaDuAdjType = 1;
7462 					} else if (pBtdm8723->curPsTdma == 12) {
7463 						btdm_2AntPsTdma(padapter, true, 11);
7464 						pBtdm8723->psTdmaDuAdjType = 11;
7465 					} else if (pBtdm8723->curPsTdma == 11) {
7466 						btdm_2AntPsTdma(padapter, true, 10);
7467 						pBtdm8723->psTdmaDuAdjType = 10;
7468 					} else if (pBtdm8723->curPsTdma == 10) {
7469 						btdm_2AntPsTdma(padapter, true, 9);
7470 						pBtdm8723->psTdmaDuAdjType = 9;
7471 					}
7472 				}
7473 			}
7474 		} else if (maxInterval == 2) {
7475 			if (bTxPause) {
7476 				RTPRINT(FBT, BT_TRACE, ("[BTCoex], TxPause = 1\n"));
7477 				if (pBtdm8723->curPsTdma == 1) {
7478 					btdm_2AntPsTdma(padapter, true, 6);
7479 					pBtdm8723->psTdmaDuAdjType = 6;
7480 				} else if (pBtdm8723->curPsTdma == 2) {
7481 					btdm_2AntPsTdma(padapter, true, 6);
7482 					pBtdm8723->psTdmaDuAdjType = 6;
7483 				} else if (pBtdm8723->curPsTdma == 3) {
7484 					btdm_2AntPsTdma(padapter, true, 7);
7485 					pBtdm8723->psTdmaDuAdjType = 7;
7486 				} else if (pBtdm8723->curPsTdma == 4) {
7487 					btdm_2AntPsTdma(padapter, true, 8);
7488 					pBtdm8723->psTdmaDuAdjType = 8;
7489 				}
7490 				if (pBtdm8723->curPsTdma == 9) {
7491 					btdm_2AntPsTdma(padapter, true, 14);
7492 					pBtdm8723->psTdmaDuAdjType = 14;
7493 				} else if (pBtdm8723->curPsTdma == 10) {
7494 					btdm_2AntPsTdma(padapter, true, 14);
7495 					pBtdm8723->psTdmaDuAdjType = 14;
7496 				} else if (pBtdm8723->curPsTdma == 11) {
7497 					btdm_2AntPsTdma(padapter, true, 15);
7498 					pBtdm8723->psTdmaDuAdjType = 15;
7499 				} else if (pBtdm8723->curPsTdma == 12) {
7500 					btdm_2AntPsTdma(padapter, true, 16);
7501 					pBtdm8723->psTdmaDuAdjType = 16;
7502 				}
7503 				if (result == -1) {
7504 					if (pBtdm8723->curPsTdma == 5) {
7505 						btdm_2AntPsTdma(padapter, true, 6);
7506 						pBtdm8723->psTdmaDuAdjType = 6;
7507 					} else if (pBtdm8723->curPsTdma == 6) {
7508 						btdm_2AntPsTdma(padapter, true, 7);
7509 						pBtdm8723->psTdmaDuAdjType = 7;
7510 					} else if (pBtdm8723->curPsTdma == 7) {
7511 						btdm_2AntPsTdma(padapter, true, 8);
7512 						pBtdm8723->psTdmaDuAdjType = 8;
7513 					} else if (pBtdm8723->curPsTdma == 13) {
7514 						btdm_2AntPsTdma(padapter, true, 14);
7515 						pBtdm8723->psTdmaDuAdjType = 14;
7516 					} else if (pBtdm8723->curPsTdma == 14) {
7517 						btdm_2AntPsTdma(padapter, true, 15);
7518 						pBtdm8723->psTdmaDuAdjType = 15;
7519 					} else if (pBtdm8723->curPsTdma == 15) {
7520 						btdm_2AntPsTdma(padapter, true, 16);
7521 						pBtdm8723->psTdmaDuAdjType = 16;
7522 					}
7523 				} else if (result == 1) {
7524 					if (pBtdm8723->curPsTdma == 8) {
7525 						btdm_2AntPsTdma(padapter, true, 7);
7526 						pBtdm8723->psTdmaDuAdjType = 7;
7527 					} else if (pBtdm8723->curPsTdma == 7) {
7528 						btdm_2AntPsTdma(padapter, true, 6);
7529 						pBtdm8723->psTdmaDuAdjType = 6;
7530 					} else if (pBtdm8723->curPsTdma == 6) {
7531 						btdm_2AntPsTdma(padapter, true, 6);
7532 						pBtdm8723->psTdmaDuAdjType = 6;
7533 					} else if (pBtdm8723->curPsTdma == 16) {
7534 						btdm_2AntPsTdma(padapter, true, 15);
7535 						pBtdm8723->psTdmaDuAdjType = 15;
7536 					} else if (pBtdm8723->curPsTdma == 15) {
7537 						btdm_2AntPsTdma(padapter, true, 14);
7538 						pBtdm8723->psTdmaDuAdjType = 14;
7539 					} else if (pBtdm8723->curPsTdma == 14) {
7540 						btdm_2AntPsTdma(padapter, true, 14);
7541 						pBtdm8723->psTdmaDuAdjType = 14;
7542 					}
7543 				}
7544 			} else {
7545 				RTPRINT(FBT, BT_TRACE, ("[BTCoex], TxPause = 0\n"));
7546 				if (pBtdm8723->curPsTdma == 5) {
7547 					btdm_2AntPsTdma(padapter, true, 2);
7548 					pBtdm8723->psTdmaDuAdjType = 2;
7549 				} else if (pBtdm8723->curPsTdma == 6) {
7550 					btdm_2AntPsTdma(padapter, true, 2);
7551 					pBtdm8723->psTdmaDuAdjType = 2;
7552 				} else if (pBtdm8723->curPsTdma == 7) {
7553 					btdm_2AntPsTdma(padapter, true, 3);
7554 					pBtdm8723->psTdmaDuAdjType = 3;
7555 				} else if (pBtdm8723->curPsTdma == 8) {
7556 					btdm_2AntPsTdma(padapter, true, 4);
7557 					pBtdm8723->psTdmaDuAdjType = 4;
7558 				}
7559 				if (pBtdm8723->curPsTdma == 13) {
7560 					btdm_2AntPsTdma(padapter, true, 10);
7561 					pBtdm8723->psTdmaDuAdjType = 10;
7562 				} else if (pBtdm8723->curPsTdma == 14) {
7563 					btdm_2AntPsTdma(padapter, true, 10);
7564 					pBtdm8723->psTdmaDuAdjType = 10;
7565 				} else if (pBtdm8723->curPsTdma == 15) {
7566 					btdm_2AntPsTdma(padapter, true, 11);
7567 					pBtdm8723->psTdmaDuAdjType = 11;
7568 				} else if (pBtdm8723->curPsTdma == 16) {
7569 					btdm_2AntPsTdma(padapter, true, 12);
7570 					pBtdm8723->psTdmaDuAdjType = 12;
7571 				}
7572 				if (result == -1) {
7573 					if (pBtdm8723->curPsTdma == 1) {
7574 						btdm_2AntPsTdma(padapter, true, 2);
7575 						pBtdm8723->psTdmaDuAdjType = 2;
7576 					} else if (pBtdm8723->curPsTdma == 2) {
7577 						btdm_2AntPsTdma(padapter, true, 3);
7578 						pBtdm8723->psTdmaDuAdjType = 3;
7579 					} else if (pBtdm8723->curPsTdma == 3) {
7580 						btdm_2AntPsTdma(padapter, true, 4);
7581 						pBtdm8723->psTdmaDuAdjType = 4;
7582 					} else if (pBtdm8723->curPsTdma == 9) {
7583 						btdm_2AntPsTdma(padapter, true, 10);
7584 						pBtdm8723->psTdmaDuAdjType = 10;
7585 					} else if (pBtdm8723->curPsTdma == 10) {
7586 						btdm_2AntPsTdma(padapter, true, 11);
7587 						pBtdm8723->psTdmaDuAdjType = 11;
7588 					} else if (pBtdm8723->curPsTdma == 11) {
7589 						btdm_2AntPsTdma(padapter, true, 12);
7590 						pBtdm8723->psTdmaDuAdjType = 12;
7591 					}
7592 				} else if (result == 1) {
7593 					if (pBtdm8723->curPsTdma == 4) {
7594 						btdm_2AntPsTdma(padapter, true, 3);
7595 						pBtdm8723->psTdmaDuAdjType = 3;
7596 					} else if (pBtdm8723->curPsTdma == 3) {
7597 						btdm_2AntPsTdma(padapter, true, 2);
7598 						pBtdm8723->psTdmaDuAdjType = 2;
7599 					} else if (pBtdm8723->curPsTdma == 2) {
7600 						btdm_2AntPsTdma(padapter, true, 2);
7601 						pBtdm8723->psTdmaDuAdjType = 2;
7602 					} else if (pBtdm8723->curPsTdma == 12) {
7603 						btdm_2AntPsTdma(padapter, true, 11);
7604 						pBtdm8723->psTdmaDuAdjType = 11;
7605 					} else if (pBtdm8723->curPsTdma == 11) {
7606 						btdm_2AntPsTdma(padapter, true, 10);
7607 						pBtdm8723->psTdmaDuAdjType = 10;
7608 					} else if (pBtdm8723->curPsTdma == 10) {
7609 						btdm_2AntPsTdma(padapter, true, 10);
7610 						pBtdm8723->psTdmaDuAdjType = 10;
7611 					}
7612 				}
7613 			}
7614 		} else if (maxInterval == 3) {
7615 			if (bTxPause) {
7616 				RTPRINT(FBT, BT_TRACE, ("[BTCoex], TxPause = 1\n"));
7617 				if (pBtdm8723->curPsTdma == 1) {
7618 					btdm_2AntPsTdma(padapter, true, 7);
7619 					pBtdm8723->psTdmaDuAdjType = 7;
7620 				} else if (pBtdm8723->curPsTdma == 2) {
7621 					btdm_2AntPsTdma(padapter, true, 7);
7622 					pBtdm8723->psTdmaDuAdjType = 7;
7623 				} else if (pBtdm8723->curPsTdma == 3) {
7624 					btdm_2AntPsTdma(padapter, true, 7);
7625 					pBtdm8723->psTdmaDuAdjType = 7;
7626 				} else if (pBtdm8723->curPsTdma == 4) {
7627 					btdm_2AntPsTdma(padapter, true, 8);
7628 					pBtdm8723->psTdmaDuAdjType = 8;
7629 				}
7630 				if (pBtdm8723->curPsTdma == 9) {
7631 					btdm_2AntPsTdma(padapter, true, 15);
7632 					pBtdm8723->psTdmaDuAdjType = 15;
7633 				} else if (pBtdm8723->curPsTdma == 10) {
7634 					btdm_2AntPsTdma(padapter, true, 15);
7635 					pBtdm8723->psTdmaDuAdjType = 15;
7636 				} else if (pBtdm8723->curPsTdma == 11) {
7637 					btdm_2AntPsTdma(padapter, true, 15);
7638 					pBtdm8723->psTdmaDuAdjType = 15;
7639 				} else if (pBtdm8723->curPsTdma == 12) {
7640 					btdm_2AntPsTdma(padapter, true, 16);
7641 					pBtdm8723->psTdmaDuAdjType = 16;
7642 				}
7643 				if (result == -1) {
7644 					if (pBtdm8723->curPsTdma == 5) {
7645 						btdm_2AntPsTdma(padapter, true, 7);
7646 						pBtdm8723->psTdmaDuAdjType = 7;
7647 					} else if (pBtdm8723->curPsTdma == 6) {
7648 						btdm_2AntPsTdma(padapter, true, 7);
7649 						pBtdm8723->psTdmaDuAdjType = 7;
7650 					} else if (pBtdm8723->curPsTdma == 7) {
7651 						btdm_2AntPsTdma(padapter, true, 8);
7652 						pBtdm8723->psTdmaDuAdjType = 8;
7653 					} else if (pBtdm8723->curPsTdma == 13) {
7654 						btdm_2AntPsTdma(padapter, true, 15);
7655 						pBtdm8723->psTdmaDuAdjType = 15;
7656 					} else if (pBtdm8723->curPsTdma == 14) {
7657 						btdm_2AntPsTdma(padapter, true, 15);
7658 						pBtdm8723->psTdmaDuAdjType = 15;
7659 					} else if (pBtdm8723->curPsTdma == 15) {
7660 						btdm_2AntPsTdma(padapter, true, 16);
7661 						pBtdm8723->psTdmaDuAdjType = 16;
7662 					}
7663 				} else if (result == 1) {
7664 					if (pBtdm8723->curPsTdma == 8) {
7665 						btdm_2AntPsTdma(padapter, true, 7);
7666 						pBtdm8723->psTdmaDuAdjType = 7;
7667 					} else if (pBtdm8723->curPsTdma == 7) {
7668 						btdm_2AntPsTdma(padapter, true, 7);
7669 						pBtdm8723->psTdmaDuAdjType = 7;
7670 					} else if (pBtdm8723->curPsTdma == 6) {
7671 						btdm_2AntPsTdma(padapter, true, 7);
7672 						pBtdm8723->psTdmaDuAdjType = 7;
7673 					} else if (pBtdm8723->curPsTdma == 16) {
7674 						btdm_2AntPsTdma(padapter, true, 15);
7675 						pBtdm8723->psTdmaDuAdjType = 15;
7676 					} else if (pBtdm8723->curPsTdma == 15) {
7677 						btdm_2AntPsTdma(padapter, true, 15);
7678 						pBtdm8723->psTdmaDuAdjType = 15;
7679 					} else if (pBtdm8723->curPsTdma == 14) {
7680 						btdm_2AntPsTdma(padapter, true, 15);
7681 						pBtdm8723->psTdmaDuAdjType = 15;
7682 					}
7683 				}
7684 			} else {
7685 				RTPRINT(FBT, BT_TRACE, ("[BTCoex], TxPause = 0\n"));
7686 				if (pBtdm8723->curPsTdma == 5) {
7687 					btdm_2AntPsTdma(padapter, true, 3);
7688 					pBtdm8723->psTdmaDuAdjType = 3;
7689 				} else if (pBtdm8723->curPsTdma == 6) {
7690 					btdm_2AntPsTdma(padapter, true, 3);
7691 					pBtdm8723->psTdmaDuAdjType = 3;
7692 				} else if (pBtdm8723->curPsTdma == 7) {
7693 					btdm_2AntPsTdma(padapter, true, 3);
7694 					pBtdm8723->psTdmaDuAdjType = 3;
7695 				} else if (pBtdm8723->curPsTdma == 8) {
7696 					btdm_2AntPsTdma(padapter, true, 4);
7697 					pBtdm8723->psTdmaDuAdjType = 4;
7698 				}
7699 				if (pBtdm8723->curPsTdma == 13) {
7700 					btdm_2AntPsTdma(padapter, true, 11);
7701 					pBtdm8723->psTdmaDuAdjType = 11;
7702 				} else if (pBtdm8723->curPsTdma == 14) {
7703 					btdm_2AntPsTdma(padapter, true, 11);
7704 					pBtdm8723->psTdmaDuAdjType = 11;
7705 				} else if (pBtdm8723->curPsTdma == 15) {
7706 					btdm_2AntPsTdma(padapter, true, 11);
7707 					pBtdm8723->psTdmaDuAdjType = 11;
7708 				} else if (pBtdm8723->curPsTdma == 16) {
7709 					btdm_2AntPsTdma(padapter, true, 12);
7710 					pBtdm8723->psTdmaDuAdjType = 12;
7711 				}
7712 				if (result == -1) {
7713 					if (pBtdm8723->curPsTdma == 1) {
7714 						btdm_2AntPsTdma(padapter, true, 3);
7715 						pBtdm8723->psTdmaDuAdjType = 3;
7716 					} else if (pBtdm8723->curPsTdma == 2) {
7717 						btdm_2AntPsTdma(padapter, true, 3);
7718 						pBtdm8723->psTdmaDuAdjType = 3;
7719 					} else if (pBtdm8723->curPsTdma == 3) {
7720 						btdm_2AntPsTdma(padapter, true, 4);
7721 						pBtdm8723->psTdmaDuAdjType = 4;
7722 					} else if (pBtdm8723->curPsTdma == 9) {
7723 						btdm_2AntPsTdma(padapter, true, 11);
7724 						pBtdm8723->psTdmaDuAdjType = 11;
7725 					} else if (pBtdm8723->curPsTdma == 10) {
7726 						btdm_2AntPsTdma(padapter, true, 11);
7727 						pBtdm8723->psTdmaDuAdjType = 11;
7728 					} else if (pBtdm8723->curPsTdma == 11) {
7729 						btdm_2AntPsTdma(padapter, true, 12);
7730 						pBtdm8723->psTdmaDuAdjType = 12;
7731 					}
7732 				} else if (result == 1) {
7733 					if (pBtdm8723->curPsTdma == 4) {
7734 						btdm_2AntPsTdma(padapter, true, 3);
7735 						pBtdm8723->psTdmaDuAdjType = 3;
7736 					} else if (pBtdm8723->curPsTdma == 3) {
7737 						btdm_2AntPsTdma(padapter, true, 3);
7738 						pBtdm8723->psTdmaDuAdjType = 3;
7739 					} else if (pBtdm8723->curPsTdma == 2) {
7740 						btdm_2AntPsTdma(padapter, true, 3);
7741 						pBtdm8723->psTdmaDuAdjType = 3;
7742 					} else if (pBtdm8723->curPsTdma == 12) {
7743 						btdm_2AntPsTdma(padapter, true, 11);
7744 						pBtdm8723->psTdmaDuAdjType = 11;
7745 					} else if (pBtdm8723->curPsTdma == 11) {
7746 						btdm_2AntPsTdma(padapter, true, 11);
7747 						pBtdm8723->psTdmaDuAdjType = 11;
7748 					} else if (pBtdm8723->curPsTdma == 10) {
7749 						btdm_2AntPsTdma(padapter, true, 11);
7750 						pBtdm8723->psTdmaDuAdjType = 11;
7751 					}
7752 				}
7753 			}
7754 		}
7755 	}
7756 	RTPRINT(FBT, BT_TRACE, ("[BTCoex], PsTdma type : recordPsTdma =%d\n", pBtdm8723->psTdmaDuAdjType));
7757 	/*  if current PsTdma not match with the recorded one (when scan, dhcp...), */
7758 	/*  then we have to adjust it back to the previous record one. */
7759 	if (pBtdm8723->curPsTdma != pBtdm8723->psTdmaDuAdjType) {
7760 		RTPRINT(FBT, BT_TRACE, ("[BTCoex], PsTdma type dismatch!!!, curPsTdma =%d, recordPsTdma =%d\n",
7761 			pBtdm8723->curPsTdma, pBtdm8723->psTdmaDuAdjType));
7762 
7763 		if (!check_fwstate(&padapter->mlmepriv, _FW_UNDER_SURVEY|_FW_UNDER_LINKING))
7764 			btdm_2AntPsTdma(padapter, true, pBtdm8723->psTdmaDuAdjType);
7765 		else
7766 			RTPRINT(FBT, BT_TRACE, ("[BTCoex], roaming/link/scan is under progress, will adjust next time!!!\n"));
7767 	}
7768 }
7769 
7770 /*  default Action */
7771 /*  SCO only or SCO+PAN(HS) */
btdm_2Ant8723ASCOAction(struct rtw_adapter * padapter)7772 static void btdm_2Ant8723ASCOAction(struct rtw_adapter *padapter)
7773 {
7774 	u8 btRssiState, btRssiState1;
7775 
7776 	if (btdm_NeedToDecBtPwr(padapter))
7777 		btdm_2AntDecBtPwr(padapter, true);
7778 	else
7779 		btdm_2AntDecBtPwr(padapter, false);
7780 
7781 	if (BTDM_IsHT40(padapter)) {
7782 		RTPRINT(FBT, BT_TRACE, ("HT40\n"));
7783 		btRssiState = BTDM_CheckCoexRSSIState(padapter, 2, 37, 0);
7784 		/*  fw mechanism */
7785 		if ((btRssiState == BT_RSSI_STATE_HIGH) ||
7786 		    (btRssiState == BT_RSSI_STATE_STAY_HIGH)) {
7787 			RTPRINT(FBT, BT_TRACE, ("Wifi rssi-1 high \n"));
7788 			PlatformEFIOWrite1Byte(padapter, 0x883, 0x40);
7789 			btdm_2AntPsTdma(padapter, true, 11);
7790 		} else {
7791 			RTPRINT(FBT, BT_TRACE, ("Wifi rssi-1 low \n"));
7792 			btdm_2AntPsTdma(padapter, true, 15);
7793 		}
7794 
7795 		/*  sw mechanism */
7796 		btdm_2AntAgcTable(padapter, false);
7797 		btdm_2AntAdcBackOff(padapter, true);
7798 		btdm_2AntDacSwing(padapter, false, 0xc0);
7799 	} else {
7800 		RTPRINT(FBT, BT_TRACE, ("HT20 or Legacy\n"));
7801 		btRssiState = BTDM_CheckCoexRSSIState(padapter, 2, 37, 0);
7802 		btRssiState1 = BTDM_CheckCoexRSSIState1(padapter, 2, 27, 0);
7803 
7804 		/*  fw mechanism */
7805 		if ((btRssiState1 == BT_RSSI_STATE_HIGH) ||
7806 		    (btRssiState1 == BT_RSSI_STATE_STAY_HIGH)) {
7807 			RTPRINT(FBT, BT_TRACE, ("Wifi rssi-1 high \n"));
7808 			PlatformEFIOWrite1Byte(padapter, 0x883, 0x40);
7809 			btdm_2AntPsTdma(padapter, true, 11);
7810 		} else {
7811 			RTPRINT(FBT, BT_TRACE, ("Wifi rssi-1 low \n"));
7812 			btdm_2AntPsTdma(padapter, true, 15);
7813 		}
7814 
7815 		/*  sw mechanism */
7816 		if ((btRssiState == BT_RSSI_STATE_HIGH) ||
7817 		    (btRssiState == BT_RSSI_STATE_STAY_HIGH)) {
7818 			RTPRINT(FBT, BT_TRACE, ("Wifi rssi high \n"));
7819 			btdm_2AntAgcTable(padapter, true);
7820 			btdm_2AntAdcBackOff(padapter, true);
7821 			btdm_2AntDacSwing(padapter, false, 0xc0);
7822 		} else {
7823 			RTPRINT(FBT, BT_TRACE, ("Wifi rssi low \n"));
7824 			btdm_2AntAgcTable(padapter, false);
7825 			btdm_2AntAdcBackOff(padapter, false);
7826 			btdm_2AntDacSwing(padapter, false, 0xc0);
7827 		}
7828 	}
7829 }
7830 
btdm_2Ant8723AHIDAction(struct rtw_adapter * padapter)7831 static void btdm_2Ant8723AHIDAction(struct rtw_adapter *padapter)
7832 {
7833 	u8 btRssiState, btRssiState1;
7834 
7835 	if (btdm_NeedToDecBtPwr(padapter))
7836 		btdm_2AntDecBtPwr(padapter, true);
7837 	else
7838 		btdm_2AntDecBtPwr(padapter, false);
7839 
7840 	if (BTDM_IsHT40(padapter)) {
7841 		RTPRINT(FBT, BT_TRACE, ("HT40\n"));
7842 		btRssiState = BTDM_CheckCoexRSSIState(padapter, 2, 37, 0);
7843 			/*  fw mechanism */
7844 		if ((btRssiState == BT_RSSI_STATE_HIGH) ||
7845 		    (btRssiState == BT_RSSI_STATE_STAY_HIGH)) {
7846 			RTPRINT(FBT, BT_TRACE, ("Wifi rssi-1 high \n"));
7847 			PlatformEFIOWrite1Byte(padapter, 0x883, 0x40);
7848 			btdm_2AntPsTdma(padapter, true, 9);
7849 		} else {
7850 			RTPRINT(FBT, BT_TRACE, ("Wifi rssi-1 low \n"));
7851 			btdm_2AntPsTdma(padapter, true, 13);
7852 		}
7853 
7854 		/*  sw mechanism */
7855 		btdm_2AntAgcTable(padapter, false);
7856 		btdm_2AntAdcBackOff(padapter, false);
7857 		btdm_2AntDacSwing(padapter, false, 0xc0);
7858 	} else {
7859 		RTPRINT(FBT, BT_TRACE, ("HT20 or Legacy\n"));
7860 		btRssiState = BTDM_CheckCoexRSSIState(padapter, 2, 37, 0);
7861 		btRssiState1 = BTDM_CheckCoexRSSIState1(padapter, 2, 27, 0);
7862 
7863 		/*  fw mechanism */
7864 		if ((btRssiState1 == BT_RSSI_STATE_HIGH) ||
7865 		    (btRssiState1 == BT_RSSI_STATE_STAY_HIGH)) {
7866 			RTPRINT(FBT, BT_TRACE, ("Wifi rssi-1 high \n"));
7867 			PlatformEFIOWrite1Byte(padapter, 0x883, 0x40);
7868 			btdm_2AntPsTdma(padapter, true, 9);
7869 		} else {
7870 			RTPRINT(FBT, BT_TRACE, ("Wifi rssi-1 low \n"));
7871 			btdm_2AntPsTdma(padapter, true, 13);
7872 		}
7873 
7874 		/*  sw mechanism */
7875 		if ((btRssiState == BT_RSSI_STATE_HIGH) ||
7876 		    (btRssiState == BT_RSSI_STATE_STAY_HIGH)) {
7877 			RTPRINT(FBT, BT_TRACE, ("Wifi rssi high \n"));
7878 			btdm_2AntAgcTable(padapter, true);
7879 			btdm_2AntAdcBackOff(padapter, true);
7880 			btdm_2AntDacSwing(padapter, false, 0xc0);
7881 		} else {
7882 			RTPRINT(FBT, BT_TRACE, ("Wifi rssi low \n"));
7883 			btdm_2AntAgcTable(padapter, false);
7884 			btdm_2AntAdcBackOff(padapter, false);
7885 			btdm_2AntDacSwing(padapter, false, 0xc0);
7886 		}
7887 	}
7888 }
7889 
7890 /* A2DP only / PAN(EDR) only/ A2DP+PAN(HS) */
btdm_2Ant8723AA2DPAction(struct rtw_adapter * padapter)7891 static void btdm_2Ant8723AA2DPAction(struct rtw_adapter *padapter)
7892 {
7893 	u8 btRssiState, btRssiState1;
7894 	struct hal_data_8723a *pHalData = GET_HAL_DATA(padapter);
7895 	u8 btInfoExt = pHalData->bt_coexist.halCoex8723.btInfoExt;
7896 
7897 	if (btdm_NeedToDecBtPwr(padapter))
7898 		btdm_2AntDecBtPwr(padapter, true);
7899 	else
7900 		btdm_2AntDecBtPwr(padapter, false);
7901 
7902 	if (BTDM_IsHT40(padapter)) {
7903 		RTPRINT(FBT, BT_TRACE, ("HT40\n"));
7904 		btRssiState = BTDM_CheckCoexRSSIState(padapter, 2, 37, 0);
7905 
7906 		/*  fw mechanism */
7907 		if ((btRssiState == BT_RSSI_STATE_HIGH) ||
7908 		    (btRssiState == BT_RSSI_STATE_STAY_HIGH)) {
7909 			RTPRINT(FBT, BT_TRACE, ("Wifi rssi high \n"));
7910 			PlatformEFIOWrite1Byte(padapter, 0x883, 0x40);
7911 
7912 			if (btInfoExt&BIT(0)) {	/* a2dp rate, 1:basic /0:edr */
7913 				RTPRINT(FBT, BT_TRACE, ("a2dp basic rate \n"));
7914 				btdm_2AntTdmaDurationAdjust(padapter, false, false, 3);
7915 			} else {
7916 				RTPRINT(FBT, BT_TRACE, ("a2dp edr rate \n"));
7917 				btdm_2AntTdmaDurationAdjust(padapter, false, false, 1);
7918 			}
7919 		} else {
7920 			RTPRINT(FBT, BT_TRACE, ("Wifi rssi low \n"));
7921 			if (btInfoExt&BIT(0)) {	/* a2dp rate, 1:basic /0:edr */
7922 				RTPRINT(FBT, BT_TRACE, ("a2dp basic rate \n"));
7923 				btdm_2AntTdmaDurationAdjust(padapter, false, true, 3);
7924 			} else {
7925 				RTPRINT(FBT, BT_TRACE, ("a2dp edr rate \n"));
7926 			btdm_2AntTdmaDurationAdjust(padapter, false, true, 1);
7927 			}
7928 		}
7929 
7930 		/*  sw mechanism */
7931 		btdm_2AntAgcTable(padapter, false);
7932 		btdm_2AntAdcBackOff(padapter, true);
7933 		btdm_2AntDacSwing(padapter, false, 0xc0);
7934 	} else {
7935 		RTPRINT(FBT, BT_TRACE, ("HT20 or Legacy\n"));
7936 		btRssiState = BTDM_CheckCoexRSSIState(padapter, 2, 37, 0);
7937 		btRssiState1 = BTDM_CheckCoexRSSIState1(padapter, 2, 27, 0);
7938 
7939 		/*  fw mechanism */
7940 		if ((btRssiState1 == BT_RSSI_STATE_HIGH) ||
7941 		    (btRssiState1 == BT_RSSI_STATE_STAY_HIGH)) {
7942 			RTPRINT(FBT, BT_TRACE, ("Wifi rssi-1 high \n"));
7943 			PlatformEFIOWrite1Byte(padapter, 0x883, 0x40);
7944 			if (btInfoExt&BIT(0)) {	/* a2dp rate, 1:basic /0:edr */
7945 				RTPRINT(FBT, BT_TRACE, ("a2dp basic rate \n"));
7946 				btdm_2AntTdmaDurationAdjust(padapter, false, false, 3);
7947 			} else {
7948 				RTPRINT(FBT, BT_TRACE, ("a2dp edr rate \n"));
7949 				btdm_2AntTdmaDurationAdjust(padapter, false, false, 1);
7950 			}
7951 		} else {
7952 			RTPRINT(FBT, BT_TRACE, ("Wifi rssi-1 low \n"));
7953 			if (btInfoExt&BIT(0)) {	/* a2dp rate, 1:basic /0:edr */
7954 				RTPRINT(FBT, BT_TRACE, ("a2dp basic rate \n"));
7955 				btdm_2AntTdmaDurationAdjust(padapter, false, true, 3);
7956 			} else {
7957 				RTPRINT(FBT, BT_TRACE, ("a2dp edr rate \n"));
7958 				btdm_2AntTdmaDurationAdjust(padapter, false, true, 1);
7959 			}
7960 		}
7961 
7962 		/*  sw mechanism */
7963 		if ((btRssiState == BT_RSSI_STATE_HIGH) ||
7964 		    (btRssiState == BT_RSSI_STATE_STAY_HIGH)) {
7965 			RTPRINT(FBT, BT_TRACE, ("Wifi rssi high \n"));
7966 			btdm_2AntAgcTable(padapter, true);
7967 			btdm_2AntAdcBackOff(padapter, true);
7968 			btdm_2AntDacSwing(padapter, false, 0xc0);
7969 		} else {
7970 			RTPRINT(FBT, BT_TRACE, ("Wifi rssi low \n"));
7971 			btdm_2AntAgcTable(padapter, false);
7972 			btdm_2AntAdcBackOff(padapter, false);
7973 			btdm_2AntDacSwing(padapter, false, 0xc0);
7974 		}
7975 	}
7976 }
7977 
btdm_2Ant8723APANEDRAction(struct rtw_adapter * padapter)7978 static void btdm_2Ant8723APANEDRAction(struct rtw_adapter *padapter)
7979 {
7980 	u8 btRssiState, btRssiState1;
7981 
7982 	if (btdm_NeedToDecBtPwr(padapter))
7983 		btdm_2AntDecBtPwr(padapter, true);
7984 	else
7985 		btdm_2AntDecBtPwr(padapter, false);
7986 
7987 	if (BTDM_IsHT40(padapter)) {
7988 		RTPRINT(FBT, BT_TRACE, ("HT40\n"));
7989 		btRssiState = BTDM_CheckCoexRSSIState(padapter, 2, 37, 0);
7990 
7991 		/*  fw mechanism */
7992 		if ((btRssiState == BT_RSSI_STATE_HIGH) ||
7993 		    (btRssiState == BT_RSSI_STATE_STAY_HIGH)) {
7994 			RTPRINT(FBT, BT_TRACE, ("Wifi rssi high \n"));
7995 			PlatformEFIOWrite1Byte(padapter, 0x883, 0x40);
7996 			btdm_2AntPsTdma(padapter, true, 2);
7997 		} else {
7998 			RTPRINT(FBT, BT_TRACE, ("Wifi rssi low \n"));
7999 			btdm_2AntPsTdma(padapter, true, 6);
8000 		}
8001 
8002 		/*  sw mechanism */
8003 		btdm_2AntAgcTable(padapter, false);
8004 		btdm_2AntAdcBackOff(padapter, true);
8005 		btdm_2AntDacSwing(padapter, false, 0xc0);
8006 	} else {
8007 		RTPRINT(FBT, BT_TRACE, ("HT20 or Legacy\n"));
8008 		btRssiState = BTDM_CheckCoexRSSIState(padapter, 2, 37, 0);
8009 		btRssiState1 = BTDM_CheckCoexRSSIState1(padapter, 2, 27, 0);
8010 
8011 		/*  fw mechanism */
8012 		if ((btRssiState1 == BT_RSSI_STATE_HIGH) ||
8013 		    (btRssiState1 == BT_RSSI_STATE_STAY_HIGH)) {
8014 			RTPRINT(FBT, BT_TRACE, ("Wifi rssi-1 high \n"));
8015 			PlatformEFIOWrite1Byte(padapter, 0x883, 0x40);
8016 			btdm_2AntPsTdma(padapter, true, 2);
8017 		} else {
8018 			RTPRINT(FBT, BT_TRACE, ("Wifi rssi-1 low \n"));
8019 			btdm_2AntPsTdma(padapter, true, 6);
8020 		}
8021 
8022 		/*  sw mechanism */
8023 		if ((btRssiState == BT_RSSI_STATE_HIGH) ||
8024 		    (btRssiState == BT_RSSI_STATE_STAY_HIGH)) {
8025 			RTPRINT(FBT, BT_TRACE, ("Wifi rssi high \n"));
8026 			btdm_2AntAgcTable(padapter, true);
8027 			btdm_2AntAdcBackOff(padapter, true);
8028 			btdm_2AntDacSwing(padapter, false, 0xc0);
8029 		} else {
8030 			RTPRINT(FBT, BT_TRACE, ("Wifi rssi low \n"));
8031 			btdm_2AntAgcTable(padapter, false);
8032 			btdm_2AntAdcBackOff(padapter, false);
8033 			btdm_2AntDacSwing(padapter, false, 0xc0);
8034 		}
8035 	}
8036 }
8037 
8038 /* PAN(HS) only */
btdm_2Ant8723APANHSAction(struct rtw_adapter * padapter)8039 static void btdm_2Ant8723APANHSAction(struct rtw_adapter *padapter)
8040 {
8041 	u8 btRssiState;
8042 
8043 	if (BTDM_IsHT40(padapter)) {
8044 		RTPRINT(FBT, BT_TRACE, ("HT40\n"));
8045 		btRssiState = BTDM_CheckCoexRSSIState(padapter, 2, 47, 0);
8046 		/*  fw mechanism */
8047 		if ((btRssiState == BT_RSSI_STATE_HIGH) ||
8048 		    (btRssiState == BT_RSSI_STATE_STAY_HIGH)) {
8049 			RTPRINT(FBT, BT_TRACE, ("Wifi rssi high \n"));
8050 			btdm_2AntDecBtPwr(padapter, true);
8051 		} else {
8052 			RTPRINT(FBT, BT_TRACE, ("Wifi rssi low \n"));
8053 			btdm_2AntDecBtPwr(padapter, false);
8054 		}
8055 		btdm_2AntPsTdma(padapter, false, 0);
8056 
8057 		/*  sw mechanism */
8058 		btdm_2AntAgcTable(padapter, false);
8059 		btdm_2AntAdcBackOff(padapter, true);
8060 		btdm_2AntDacSwing(padapter, false, 0xc0);
8061 	} else {
8062 		RTPRINT(FBT, BT_TRACE, ("HT20 or Legacy\n"));
8063 		btRssiState = BTDM_CheckCoexRSSIState(padapter, 2, 47, 0);
8064 
8065 		if ((btRssiState == BT_RSSI_STATE_HIGH) ||
8066 		    (btRssiState == BT_RSSI_STATE_STAY_HIGH)) {
8067 			RTPRINT(FBT, BT_TRACE, ("Wifi rssi high\n"));
8068 			/*  fw mechanism */
8069 			btdm_2AntDecBtPwr(padapter, true);
8070 			btdm_2AntPsTdma(padapter, false, 0);
8071 
8072 			/*  sw mechanism */
8073 			btdm_2AntAgcTable(padapter, true);
8074 			btdm_2AntAdcBackOff(padapter, true);
8075 			btdm_2AntDacSwing(padapter, false, 0xc0);
8076 		} else {
8077 			RTPRINT(FBT, BT_TRACE, ("Wifi rssi low\n"));
8078 			/*  fw mechanism */
8079 			btdm_2AntDecBtPwr(padapter, false);
8080 			btdm_2AntPsTdma(padapter, false, 0);
8081 
8082 			/*  sw mechanism */
8083 			btdm_2AntAgcTable(padapter, false);
8084 			btdm_2AntAdcBackOff(padapter, false);
8085 			btdm_2AntDacSwing(padapter, false, 0xc0);
8086 		}
8087 	}
8088 }
8089 
8090 /* PAN(EDR)+A2DP */
btdm_2Ant8723APANEDRA2DPAction(struct rtw_adapter * padapter)8091 static void btdm_2Ant8723APANEDRA2DPAction(struct rtw_adapter *padapter)
8092 {
8093 	u8 btRssiState, btRssiState1, btInfoExt;
8094 	struct hal_data_8723a *pHalData = GET_HAL_DATA(padapter);
8095 
8096 	btInfoExt = pHalData->bt_coexist.halCoex8723.btInfoExt;
8097 
8098 	if (btdm_NeedToDecBtPwr(padapter))
8099 		btdm_2AntDecBtPwr(padapter, true);
8100 	else
8101 		btdm_2AntDecBtPwr(padapter, false);
8102 
8103 	if (BTDM_IsHT40(padapter)) {
8104 		RTPRINT(FBT, BT_TRACE, ("HT40\n"));
8105 		btRssiState = BTDM_CheckCoexRSSIState(padapter, 2, 37, 0);
8106 
8107 		if ((btRssiState == BT_RSSI_STATE_HIGH) ||
8108 		    (btRssiState == BT_RSSI_STATE_STAY_HIGH)) {
8109 			RTPRINT(FBT, BT_TRACE, ("Wifi rssi high \n"));
8110 			/*  fw mechanism */
8111 			PlatformEFIOWrite1Byte(padapter, 0x883, 0x40);
8112 
8113 			if (btInfoExt&BIT(0)) {	/* a2dp rate, 1:basic /0:edr */
8114 				RTPRINT(FBT, BT_TRACE, ("a2dp basic rate \n"));
8115 				btdm_2AntPsTdma(padapter, true, 4);
8116 			} else {
8117 				RTPRINT(FBT, BT_TRACE, ("a2dp edr rate \n"));
8118 				btdm_2AntPsTdma(padapter, true, 2);
8119 			}
8120 		} else {
8121 			RTPRINT(FBT, BT_TRACE, ("Wifi rssi low \n"));
8122 			/*  fw mechanism */
8123 			if (btInfoExt&BIT(0)) {	/* a2dp rate, 1:basic /0:edr */
8124 				RTPRINT(FBT, BT_TRACE, ("a2dp basic rate \n"));
8125 				btdm_2AntPsTdma(padapter, true, 8);
8126 			} else {
8127 				RTPRINT(FBT, BT_TRACE, ("a2dp edr rate \n"));
8128 				btdm_2AntPsTdma(padapter, true, 6);
8129 			}
8130 		}
8131 
8132 		/*  sw mechanism */
8133 		btdm_2AntAgcTable(padapter, false);
8134 		btdm_2AntAdcBackOff(padapter, true);
8135 		btdm_2AntDacSwing(padapter, false, 0xc0);
8136 	} else {
8137 		RTPRINT(FBT, BT_TRACE, ("HT20 or Legacy\n"));
8138 		btRssiState = BTDM_CheckCoexRSSIState(padapter, 2, 37, 0);
8139 		btRssiState1 = BTDM_CheckCoexRSSIState1(padapter, 2, 27, 0);
8140 
8141 		if ((btRssiState1 == BT_RSSI_STATE_HIGH) ||
8142 		    (btRssiState1 == BT_RSSI_STATE_STAY_HIGH)) {
8143 			RTPRINT(FBT, BT_TRACE, ("Wifi rssi-1 high \n"));
8144 			PlatformEFIOWrite1Byte(padapter, 0x883, 0x40);
8145 			/*  fw mechanism */
8146 			if (btInfoExt&BIT(0)) {	/* a2dp rate, 1:basic /0:edr */
8147 				RTPRINT(FBT, BT_TRACE, ("a2dp basic rate \n"));
8148 				btdm_2AntPsTdma(padapter, true, 4);
8149 			} else {
8150 				RTPRINT(FBT, BT_TRACE, ("a2dp edr rate \n"));
8151 				btdm_2AntPsTdma(padapter, true, 2);
8152 			}
8153 		} else {
8154 			RTPRINT(FBT, BT_TRACE, ("Wifi rssi-1 low \n"));
8155 			/*  fw mechanism */
8156 			if (btInfoExt&BIT(0)) {	/* a2dp rate, 1:basic /0:edr */
8157 				RTPRINT(FBT, BT_TRACE, ("a2dp basic rate \n"));
8158 				btdm_2AntPsTdma(padapter, true, 8);
8159 			} else {
8160 				RTPRINT(FBT, BT_TRACE, ("a2dp edr rate \n"));
8161 				btdm_2AntPsTdma(padapter, true, 6);
8162 			}
8163 		}
8164 
8165 		/*  sw mechanism */
8166 		if ((btRssiState == BT_RSSI_STATE_HIGH) ||
8167 		    (btRssiState == BT_RSSI_STATE_STAY_HIGH)) {
8168 			RTPRINT(FBT, BT_TRACE, ("Wifi rssi high \n"));
8169 			btdm_2AntAgcTable(padapter, true);
8170 			btdm_2AntAdcBackOff(padapter, true);
8171 			btdm_2AntDacSwing(padapter, false, 0xc0);
8172 		} else {
8173 			RTPRINT(FBT, BT_TRACE, ("Wifi rssi low \n"));
8174 			btdm_2AntAgcTable(padapter, false);
8175 			btdm_2AntAdcBackOff(padapter, false);
8176 			btdm_2AntDacSwing(padapter, false, 0xc0);
8177 		}
8178 	}
8179 }
8180 
btdm_2Ant8723APANEDRHIDAction(struct rtw_adapter * padapter)8181 static void btdm_2Ant8723APANEDRHIDAction(struct rtw_adapter *padapter)
8182 {
8183 	u8 btRssiState, btRssiState1;
8184 
8185 	if (btdm_NeedToDecBtPwr(padapter))
8186 		btdm_2AntDecBtPwr(padapter, true);
8187 	else
8188 		btdm_2AntDecBtPwr(padapter, false);
8189 
8190 	if (BTDM_IsHT40(padapter)) {
8191 		RTPRINT(FBT, BT_TRACE, ("HT40\n"));
8192 		btRssiState = BTDM_CheckCoexRSSIState(padapter, 2, 37, 0);
8193 		/*  fw mechanism */
8194 		if ((btRssiState == BT_RSSI_STATE_HIGH) ||
8195 		    (btRssiState == BT_RSSI_STATE_STAY_HIGH)) {
8196 			RTPRINT(FBT, BT_TRACE, ("Wifi rssi high \n"));
8197 			PlatformEFIOWrite1Byte(padapter, 0x883, 0x40);
8198 			btdm_2AntPsTdma(padapter, true, 10);
8199 		} else {
8200 			RTPRINT(FBT, BT_TRACE, ("Wifi rssi low \n"));
8201 			btdm_2AntPsTdma(padapter, true, 14);
8202 		}
8203 
8204 		/*  sw mechanism */
8205 		btdm_2AntAgcTable(padapter, false);
8206 		btdm_2AntAdcBackOff(padapter, true);
8207 		btdm_2AntDacSwing(padapter, false, 0xc0);
8208 	} else {
8209 		RTPRINT(FBT, BT_TRACE, ("HT20 or Legacy\n"));
8210 		btRssiState = BTDM_CheckCoexRSSIState(padapter, 2, 37, 0);
8211 		btRssiState1 = BTDM_CheckCoexRSSIState1(padapter, 2, 27, 0);
8212 
8213 		/*  fw mechanism */
8214 		if ((btRssiState1 == BT_RSSI_STATE_HIGH) ||
8215 		    (btRssiState1 == BT_RSSI_STATE_STAY_HIGH)) {
8216 			RTPRINT(FBT, BT_TRACE, ("Wifi rssi-1 high \n"));
8217 			PlatformEFIOWrite1Byte(padapter, 0x883, 0x40);
8218 			btdm_2AntPsTdma(padapter, true, 10);
8219 		} else {
8220 			RTPRINT(FBT, BT_TRACE, ("Wifi rssi-1 low \n"));
8221 			btdm_2AntPsTdma(padapter, true, 14);
8222 		}
8223 
8224 		/*  sw mechanism */
8225 		if ((btRssiState == BT_RSSI_STATE_HIGH) ||
8226 		    (btRssiState == BT_RSSI_STATE_STAY_HIGH)) {
8227 			RTPRINT(FBT, BT_TRACE, ("Wifi rssi high \n"));
8228 			btdm_2AntAgcTable(padapter, true);
8229 			btdm_2AntAdcBackOff(padapter, true);
8230 			btdm_2AntDacSwing(padapter, false, 0xc0);
8231 		} else {
8232 			RTPRINT(FBT, BT_TRACE, ("Wifi rssi low \n"));
8233 			btdm_2AntAgcTable(padapter, false);
8234 			btdm_2AntAdcBackOff(padapter, false);
8235 			btdm_2AntDacSwing(padapter, false, 0xc0);
8236 		}
8237 	}
8238 }
8239 
8240 /*  HID+A2DP+PAN(EDR) */
btdm_2Ant8723AHIDA2DPPANEDRAction(struct rtw_adapter * padapter)8241 static void btdm_2Ant8723AHIDA2DPPANEDRAction(struct rtw_adapter *padapter)
8242 {
8243 	u8 btRssiState, btRssiState1, btInfoExt;
8244 	struct hal_data_8723a *pHalData = GET_HAL_DATA(padapter);
8245 
8246 	btInfoExt = pHalData->bt_coexist.halCoex8723.btInfoExt;
8247 
8248 	if (btdm_NeedToDecBtPwr(padapter))
8249 		btdm_2AntDecBtPwr(padapter, true);
8250 	else
8251 		btdm_2AntDecBtPwr(padapter, false);
8252 
8253 	if (BTDM_IsHT40(padapter)) {
8254 		RTPRINT(FBT, BT_TRACE, ("HT40\n"));
8255 		btRssiState = BTDM_CheckCoexRSSIState(padapter, 2, 37, 0);
8256 		if ((btRssiState == BT_RSSI_STATE_HIGH) ||
8257 		    (btRssiState == BT_RSSI_STATE_STAY_HIGH)) {
8258 			RTPRINT(FBT, BT_TRACE, ("Wifi rssi high \n"));
8259 			PlatformEFIOWrite1Byte(padapter, 0x883, 0x40);
8260 
8261 			if (btInfoExt&BIT(0)) {	/* a2dp rate, 1:basic /0:edr */
8262 				RTPRINT(FBT, BT_TRACE, ("a2dp basic rate \n"));
8263 				btdm_2AntPsTdma(padapter, true, 12);
8264 			} else {
8265 				RTPRINT(FBT, BT_TRACE, ("a2dp edr rate \n"));
8266 				btdm_2AntPsTdma(padapter, true, 10);
8267 			}
8268 		} else {
8269 			RTPRINT(FBT, BT_TRACE, ("Wifi rssi low \n"));
8270 			if (btInfoExt&BIT(0)) {	/* a2dp rate, 1:basic /0:edr */
8271 				RTPRINT(FBT, BT_TRACE, ("a2dp basic rate \n"));
8272 				btdm_2AntPsTdma(padapter, true, 16);
8273 			} else {
8274 				RTPRINT(FBT, BT_TRACE, ("a2dp edr rate \n"));
8275 				btdm_2AntPsTdma(padapter, true, 14);
8276 			}
8277 		}
8278 
8279 		/*  sw mechanism */
8280 		btdm_2AntAgcTable(padapter, false);
8281 		btdm_2AntAdcBackOff(padapter, true);
8282 		btdm_2AntDacSwing(padapter, false, 0xc0);
8283 	} else {
8284 		RTPRINT(FBT, BT_TRACE, ("HT20 or Legacy\n"));
8285 		btRssiState1 = BTDM_CheckCoexRSSIState1(padapter, 2, 37, 0);
8286 		btRssiState = BTDM_CheckCoexRSSIState(padapter, 2, 27, 0);
8287 		if ((btRssiState == BT_RSSI_STATE_HIGH) ||
8288 		    (btRssiState == BT_RSSI_STATE_STAY_HIGH)) {
8289 			RTPRINT(FBT, BT_TRACE, ("Wifi rssi high \n"));
8290 			PlatformEFIOWrite1Byte(padapter, 0x883, 0x40);
8291 
8292 			if (btInfoExt&BIT(0)) {	/* a2dp rate, 1:basic /0:edr */
8293 				RTPRINT(FBT, BT_TRACE, ("a2dp basic rate \n"));
8294 				btdm_2AntPsTdma(padapter, true, 12);
8295 			} else {
8296 				RTPRINT(FBT, BT_TRACE, ("a2dp edr rate \n"));
8297 				btdm_2AntPsTdma(padapter, true, 10);
8298 			}
8299 		} else {
8300 			RTPRINT(FBT, BT_TRACE, ("Wifi rssi low \n"));
8301 			if (btInfoExt&BIT(0)) {	/* a2dp rate, 1:basic /0:edr */
8302 				RTPRINT(FBT, BT_TRACE, ("a2dp basic rate \n"));
8303 				btdm_2AntPsTdma(padapter, true, 16);
8304 			} else {
8305 				RTPRINT(FBT, BT_TRACE, ("a2dp edr rate \n"));
8306 				btdm_2AntPsTdma(padapter, true, 14);
8307 			}
8308 		}
8309 
8310 		/*  sw mechanism */
8311 		if ((btRssiState1 == BT_RSSI_STATE_HIGH) ||
8312 		    (btRssiState1 == BT_RSSI_STATE_STAY_HIGH)) {
8313 			RTPRINT(FBT, BT_TRACE, ("Wifi rssi-1 high \n"));
8314 			btdm_2AntAgcTable(padapter, true);
8315 			btdm_2AntAdcBackOff(padapter, true);
8316 			btdm_2AntDacSwing(padapter, false, 0xc0);
8317 		} else {
8318 			RTPRINT(FBT, BT_TRACE, ("Wifi rssi-1 high \n"));
8319 			btdm_2AntAgcTable(padapter, false);
8320 			btdm_2AntAdcBackOff(padapter, false);
8321 			btdm_2AntDacSwing(padapter, false, 0xc0);
8322 		}
8323 	}
8324 }
8325 
btdm_2Ant8723AHIDA2DPAction(struct rtw_adapter * padapter)8326 static void btdm_2Ant8723AHIDA2DPAction(struct rtw_adapter *padapter)
8327 {
8328 	struct hal_data_8723a *pHalData = GET_HAL_DATA(padapter);
8329 	u8 btRssiState, btRssiState1, btInfoExt;
8330 
8331 	btInfoExt = pHalData->bt_coexist.halCoex8723.btInfoExt;
8332 
8333 	if (btdm_NeedToDecBtPwr(padapter))
8334 		btdm_2AntDecBtPwr(padapter, true);
8335 	else
8336 		btdm_2AntDecBtPwr(padapter, false);
8337 
8338 	if (BTDM_IsHT40(padapter)) {
8339 		RTPRINT(FBT, BT_TRACE, ("HT40\n"));
8340 		btRssiState = BTDM_CheckCoexRSSIState(padapter, 2, 37, 0);
8341 		if ((btRssiState == BT_RSSI_STATE_HIGH) ||
8342 		    (btRssiState == BT_RSSI_STATE_STAY_HIGH)) {
8343 			RTPRINT(FBT, BT_TRACE, ("Wifi rssi high \n"));
8344 			PlatformEFIOWrite1Byte(padapter, 0x883, 0x40);
8345 
8346 			if (btInfoExt&BIT(0)) {	/* a2dp rate, 1:basic /0:edr */
8347 				RTPRINT(FBT, BT_TRACE, ("a2dp basic rate \n"));
8348 				btdm_2AntTdmaDurationAdjust(padapter, true, false, 3);
8349 			} else {
8350 				RTPRINT(FBT, BT_TRACE, ("a2dp edr rate \n"));
8351 				btdm_2AntTdmaDurationAdjust(padapter, true, false, 1);
8352 			}
8353 		} else {
8354 			RTPRINT(FBT, BT_TRACE, ("Wifi rssi low \n"));
8355 			if (btInfoExt&BIT(0)) {	/* a2dp rate, 1:basic /0:edr */
8356 				RTPRINT(FBT, BT_TRACE, ("a2dp basic rate \n"));
8357 				btdm_2AntTdmaDurationAdjust(padapter, true, true, 3);
8358 			} else {
8359 				RTPRINT(FBT, BT_TRACE, ("a2dp edr rate \n"));
8360 				btdm_2AntTdmaDurationAdjust(padapter, true, true, 1);
8361 			}
8362 		}
8363 		/*  sw mechanism */
8364 		btdm_2AntAgcTable(padapter, false);
8365 		btdm_2AntAdcBackOff(padapter, true);
8366 		btdm_2AntDacSwing(padapter, false, 0xc0);
8367 	} else {
8368 		RTPRINT(FBT, BT_TRACE, ("HT20 or Legacy\n"));
8369 		btRssiState = BTDM_CheckCoexRSSIState(padapter, 2, 37, 0);
8370 		btRssiState1 = BTDM_CheckCoexRSSIState(padapter, 2, 27, 0);
8371 
8372 		if ((btRssiState == BT_RSSI_STATE_HIGH) ||
8373 		    (btRssiState == BT_RSSI_STATE_STAY_HIGH)) {
8374 			RTPRINT(FBT, BT_TRACE, ("Wifi rssi high \n"));
8375 			PlatformEFIOWrite1Byte(padapter, 0x883, 0x40);
8376 
8377 			if (btInfoExt&BIT(0)) {	/* a2dp rate, 1:basic /0:edr */
8378 				RTPRINT(FBT, BT_TRACE, ("a2dp basic rate \n"));
8379 				btdm_2AntTdmaDurationAdjust(padapter, true, false, 3);
8380 			} else {
8381 				RTPRINT(FBT, BT_TRACE, ("a2dp edr rate \n"));
8382 				btdm_2AntTdmaDurationAdjust(padapter, true, false, 1);
8383 			}
8384 		} else {
8385 			RTPRINT(FBT, BT_TRACE, ("Wifi rssi low \n"));
8386 			if (btInfoExt&BIT(0)) {	/* a2dp rate, 1:basic /0:edr */
8387 				RTPRINT(FBT, BT_TRACE, ("a2dp basic rate \n"));
8388 				btdm_2AntTdmaDurationAdjust(padapter, true, true, 3);
8389 			} else {
8390 				RTPRINT(FBT, BT_TRACE, ("a2dp edr rate \n"));
8391 				btdm_2AntTdmaDurationAdjust(padapter, true, true, 1);
8392 			}
8393 		}
8394 		if ((btRssiState1 == BT_RSSI_STATE_HIGH) ||
8395 		    (btRssiState1 == BT_RSSI_STATE_STAY_HIGH)) {
8396 			RTPRINT(FBT, BT_TRACE, ("Wifi rssi-1 high \n"));
8397 			/*  sw mechanism */
8398 			btdm_2AntAgcTable(padapter, true);
8399 			btdm_2AntAdcBackOff(padapter, true);
8400 			btdm_2AntDacSwing(padapter, false, 0xc0);
8401 		} else {
8402 			RTPRINT(FBT, BT_TRACE, ("Wifi rssi-1 low \n"));
8403 			/*  sw mechanism */
8404 			btdm_2AntAgcTable(padapter, false);
8405 			btdm_2AntAdcBackOff(padapter, false);
8406 			btdm_2AntDacSwing(padapter, false, 0xc0);
8407 		}
8408 	}
8409 }
8410 
btdm_2Ant8723AA2dp(struct rtw_adapter * padapter)8411 static void btdm_2Ant8723AA2dp(struct rtw_adapter *padapter)
8412 {
8413 	struct hal_data_8723a *pHalData = GET_HAL_DATA(padapter);
8414 	u8 btRssiState, btRssiState1, btInfoExt;
8415 
8416 	btInfoExt = pHalData->bt_coexist.halCoex8723.btInfoExt;
8417 
8418 	if (btdm_NeedToDecBtPwr(padapter))
8419 		btdm_2AntDecBtPwr(padapter, true);
8420 	else
8421 		btdm_2AntDecBtPwr(padapter, false);
8422 	/*  coex table */
8423 	btdm_2AntCoexTable(padapter, 0x55555555, 0xffff, 0x3);
8424 	btdm_2AntIgnoreWlanAct(padapter, false);
8425 
8426 	if (BTDM_IsHT40(padapter)) {
8427 		RTPRINT(FBT, BT_TRACE, ("HT40\n"));
8428 		btRssiState = BTDM_CheckCoexRSSIState(padapter, 2, 37, 0);
8429 		/*  fw mechanism */
8430 		if ((btRssiState == BT_RSSI_STATE_HIGH) ||
8431 		    (btRssiState == BT_RSSI_STATE_STAY_HIGH)) {
8432 			RTPRINT(FBT, BT_TRACE, ("Wifi rssi-1 high \n"));
8433 			PlatformEFIOWrite1Byte(padapter, 0x883, 0x40);
8434 			btdm_2AntTdmaDurationAdjust(padapter, false, false, 1);
8435 		} else {
8436 			RTPRINT(FBT, BT_TRACE, ("Wifi rssi-1 low \n"));
8437 			btdm_2AntTdmaDurationAdjust(padapter, false, true, 1);
8438 		}
8439 
8440 		/*  sw mechanism */
8441 		btdm_2AntAgcTable(padapter, false);
8442 		btdm_2AntAdcBackOff(padapter, true);
8443 		btdm_2AntDacSwing(padapter, false, 0xc0);
8444 	} else {
8445 		RTPRINT(FBT, BT_TRACE, ("HT20 or Legacy\n"));
8446 		btRssiState = BTDM_CheckCoexRSSIState(padapter, 2, 47, 0);
8447 		btRssiState1 = BTDM_CheckCoexRSSIState1(padapter, 2, 27, 0);
8448 
8449 		/*  fw mechanism */
8450 		if ((btRssiState1 == BT_RSSI_STATE_HIGH) ||
8451 		    (btRssiState1 == BT_RSSI_STATE_STAY_HIGH)) {
8452 			RTPRINT(FBT, BT_TRACE, ("Wifi rssi-1 high \n"));
8453 			PlatformEFIOWrite1Byte(padapter, 0x883, 0x40);
8454 			btdm_2AntTdmaDurationAdjust(padapter, false, false, 1);
8455 		} else {
8456 			RTPRINT(FBT, BT_TRACE, ("Wifi rssi-1 low \n"));
8457 			btdm_2AntTdmaDurationAdjust(padapter, false, true, 1);
8458 		}
8459 
8460 		/*  sw mechanism */
8461 		if ((btRssiState == BT_RSSI_STATE_HIGH) ||
8462 		    (btRssiState == BT_RSSI_STATE_STAY_HIGH)) {
8463 			RTPRINT(FBT, BT_TRACE, ("Wifi rssi high \n"));
8464 			btdm_2AntAgcTable(padapter, true);
8465 			btdm_2AntAdcBackOff(padapter, true);
8466 			btdm_2AntDacSwing(padapter, false, 0xc0);
8467 		} else {
8468 			RTPRINT(FBT, BT_TRACE, ("Wifi rssi low \n"));
8469 			btdm_2AntAgcTable(padapter, false);
8470 			btdm_2AntAdcBackOff(padapter, false);
8471 			btdm_2AntDacSwing(padapter, false, 0xc0);
8472 		}
8473 	}
8474 }
8475 
8476 /*  extern function start with BTDM_ */
BTDM_2AntParaInit(struct rtw_adapter * padapter)8477 static void BTDM_2AntParaInit(struct rtw_adapter *padapter)
8478 {
8479 
8480 	struct hal_data_8723a *pHalData = GET_HAL_DATA(padapter);
8481 	struct btdm_8723a_2ant *pBtdm8723 = &pHalData->bt_coexist.halCoex8723.btdm2Ant;
8482 
8483 	RTPRINT(FBT, BT_TRACE, ("[BTCoex], 2Ant Parameter Init!!\n"));
8484 
8485 	/*  Enable counter statistics */
8486 	rtl8723au_write8(padapter, 0x76e, 0x4);
8487 	rtl8723au_write8(padapter, 0x778, 0x3);
8488 	rtl8723au_write8(padapter, 0x40, 0x20);
8489 
8490 	/*  force to reset coex mechanism */
8491 	pBtdm8723->preVal0x6c0 = 0x0;
8492 	btdm_2AntCoexTable(padapter, 0x55555555, 0xffff, 0x3);
8493 
8494 	pBtdm8723->bPrePsTdmaOn = true;
8495 	btdm_2AntPsTdma(padapter, false, 0);
8496 
8497 	pBtdm8723->preFwDacSwingLvl = 0x10;
8498 	btdm_2AntFwDacSwingLvl(padapter, 0x20);
8499 
8500 	pBtdm8723->bPreDecBtPwr = true;
8501 	btdm_2AntDecBtPwr(padapter, false);
8502 
8503 	pBtdm8723->bPreAgcTableEn = true;
8504 	btdm_2AntAgcTable(padapter, false);
8505 
8506 	pBtdm8723->bPreAdcBackOff = true;
8507 	btdm_2AntAdcBackOff(padapter, false);
8508 
8509 	pBtdm8723->bPreLowPenaltyRa = true;
8510 	btdm_2AntLowPenaltyRa(padapter, false);
8511 
8512 	pBtdm8723->bPreRfRxLpfShrink = true;
8513 	btdm_2AntRfShrink(padapter, false);
8514 
8515 	pBtdm8723->bPreDacSwingOn = true;
8516 	btdm_2AntDacSwing(padapter, false, 0xc0);
8517 
8518 	pBtdm8723->bPreIgnoreWlanAct = true;
8519 	btdm_2AntIgnoreWlanAct(padapter, false);
8520 }
8521 
BTDM_2AntHwCoexAllOff8723A(struct rtw_adapter * padapter)8522 static void BTDM_2AntHwCoexAllOff8723A(struct rtw_adapter *padapter)
8523 {
8524 	btdm_2AntCoexTable(padapter, 0x55555555, 0xffff, 0x3);
8525 }
8526 
BTDM_2AntFwCoexAllOff8723A(struct rtw_adapter * padapter)8527 static void BTDM_2AntFwCoexAllOff8723A(struct rtw_adapter *padapter)
8528 {
8529 	btdm_2AntIgnoreWlanAct(padapter, false);
8530 	btdm_2AntPsTdma(padapter, false, 0);
8531 	btdm_2AntFwDacSwingLvl(padapter, 0x20);
8532 	btdm_2AntDecBtPwr(padapter, false);
8533 }
8534 
BTDM_2AntSwCoexAllOff8723A(struct rtw_adapter * padapter)8535 static void BTDM_2AntSwCoexAllOff8723A(struct rtw_adapter *padapter)
8536 {
8537 	btdm_2AntAgcTable(padapter, false);
8538 	btdm_2AntAdcBackOff(padapter, false);
8539 	btdm_2AntLowPenaltyRa(padapter, false);
8540 	btdm_2AntRfShrink(padapter, false);
8541 	btdm_2AntDacSwing(padapter, false, 0xc0);
8542 }
8543 
BTDM_2AntFwC2hBtInfo8723A(struct rtw_adapter * padapter)8544 static void BTDM_2AntFwC2hBtInfo8723A(struct rtw_adapter *padapter)
8545 {
8546 	struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
8547 	struct bt_mgnt *pBtMgnt = &pBTInfo->BtMgnt;
8548 	struct hal_data_8723a *pHalData = GET_HAL_DATA(padapter);
8549 	struct btdm_8723a_2ant *pBtdm8723 = &pHalData->bt_coexist.halCoex8723.btdm2Ant;
8550 	u8 btInfo = 0;
8551 	u8 algorithm = BT_2ANT_COEX_ALGO_UNDEFINED;
8552 	u8 bBtLinkExist = false, bBtHsModeExist = false;
8553 
8554 	btInfo = pHalData->bt_coexist.halCoex8723.c2hBtInfoOriginal;
8555 	pBtdm8723->btStatus = BT_2ANT_BT_STATUS_IDLE;
8556 
8557 	/*  check BIT2 first ==> check if bt is under inquiry or page scan */
8558 	if (btInfo & BIT(2)) {
8559 		if (!pHalData->bt_coexist.halCoex8723.bC2hBtInquiryPage) {
8560 			pBtMgnt->ExtConfig.bHoldForBtOperation = true;
8561 			pBtMgnt->ExtConfig.bHoldPeriodCnt = 1;
8562 			btdm_2AntBtInquiryPage(padapter);
8563 		} else {
8564 			pBtMgnt->ExtConfig.bHoldPeriodCnt++;
8565 			btdm_HoldForBtInqPage(padapter);
8566 		}
8567 		pHalData->bt_coexist.halCoex8723.bC2hBtInquiryPage = true;
8568 
8569 	} else {
8570 		pHalData->bt_coexist.halCoex8723.bC2hBtInquiryPage = false;
8571 		pBtMgnt->ExtConfig.bHoldForBtOperation = false;
8572 		pBtMgnt->ExtConfig.bHoldPeriodCnt = 0;
8573 
8574 	}
8575 	RTPRINT(FBT, BT_TRACE,
8576 		("[BTC2H], pHalData->bt_coexist.halCoex8723.bC2hBtInquiryPage =%x pBtMgnt->ExtConfig.bHoldPeriodCnt =%x pBtMgnt->ExtConfig.bHoldForBtOperation =%x\n",
8577 		pHalData->bt_coexist.halCoex8723.bC2hBtInquiryPage,
8578 		pBtMgnt->ExtConfig.bHoldPeriodCnt,
8579 		pBtMgnt->ExtConfig.bHoldForBtOperation));
8580 
8581 	RTPRINT(FBT, BT_TRACE,
8582 		("[BTC2H],   btInfo =%x   pHalData->bt_coexist.halCoex8723.c2hBtInfoOriginal =%x\n",
8583 		btInfo, pHalData->bt_coexist.halCoex8723.c2hBtInfoOriginal));
8584 	if (btInfo&BT_INFO_ACL) {
8585 		RTPRINT(FBT, BT_TRACE, ("[BTC2H], BTInfo: bConnect = true   btInfo =%x\n", btInfo));
8586 		bBtLinkExist = true;
8587 		if (((btInfo&(BT_INFO_FTP|BT_INFO_A2DP|BT_INFO_HID|BT_INFO_SCO_BUSY)) != 0) ||
8588 		    pHalData->bt_coexist.halCoex8723.btRetryCnt > 0) {
8589 			pBtdm8723->btStatus = BT_2ANT_BT_STATUS_NON_IDLE;
8590 		} else {
8591 			pBtdm8723->btStatus = BT_2ANT_BT_STATUS_CONNECTED_IDLE;
8592 		}
8593 
8594 		if (btInfo&BT_INFO_SCO || btInfo&BT_INFO_SCO_BUSY) {
8595 			if (btInfo&BT_INFO_FTP || btInfo&BT_INFO_A2DP || btInfo&BT_INFO_HID) {
8596 				switch (btInfo&0xe0) {
8597 				case BT_INFO_HID:
8598 					RTPRINT(FBT, BT_TRACE, ("[BTCoex], SCO + HID\n"));
8599 					algorithm = BT_2ANT_COEX_ALGO_HID;
8600 					break;
8601 				case BT_INFO_A2DP:
8602 					RTPRINT(FBT, BT_TRACE, ("[BTCoex], Error!!! SCO + A2DP\n"));
8603 					break;
8604 				case BT_INFO_FTP:
8605 					if (bBtHsModeExist) {
8606 						RTPRINT(FBT, BT_TRACE, ("[BTCoex], SCO + PAN(HS)\n"));
8607 						algorithm = BT_2ANT_COEX_ALGO_SCO;
8608 					} else {
8609 						RTPRINT(FBT, BT_TRACE, ("[BTCoex], SCO + PAN(EDR)\n"));
8610 						algorithm = BT_2ANT_COEX_ALGO_PANEDR_HID;
8611 					}
8612 					break;
8613 				case (BT_INFO_HID | BT_INFO_A2DP):
8614 					RTPRINT(FBT, BT_TRACE, ("[BTCoex], HID + A2DP\n"));
8615 					algorithm = BT_2ANT_COEX_ALGO_HID_A2DP;
8616 					break;
8617 				case (BT_INFO_HID | BT_INFO_FTP):
8618 					if (bBtHsModeExist) {
8619 						RTPRINT(FBT, BT_TRACE, ("[BTCoex], HID + PAN(HS)\n"));
8620 						algorithm = BT_2ANT_COEX_ALGO_HID_A2DP;
8621 					} else {
8622 						RTPRINT(FBT, BT_TRACE, ("[BTCoex], HID + PAN(EDR)\n"));
8623 						algorithm = BT_2ANT_COEX_ALGO_PANEDR_HID;
8624 					}
8625 					break;
8626 				case (BT_INFO_A2DP | BT_INFO_FTP):
8627 					if (bBtHsModeExist) {
8628 						RTPRINT(FBT, BT_TRACE, ("[BTCoex], A2DP + PAN(HS)\n"));
8629 						algorithm = BT_2ANT_COEX_ALGO_A2DP;
8630 					} else {
8631 						RTPRINT(FBT, BT_TRACE, ("[BTCoex], A2DP + PAN(EDR)\n"));
8632 						algorithm = BT_2ANT_COEX_ALGO_PANEDR_A2DP;
8633 					}
8634 					break;
8635 				case (BT_INFO_HID | BT_INFO_A2DP | BT_INFO_FTP):
8636 					if (bBtHsModeExist) {
8637 						RTPRINT(FBT, BT_TRACE, ("[BTCoex], HID + A2DP + PAN(HS)\n"));
8638 						algorithm = BT_2ANT_COEX_ALGO_HID_A2DP;
8639 					} else {
8640 						RTPRINT(FBT, BT_TRACE, ("[BTCoex], HID + A2DP + PAN(EDR)\n"));
8641 						algorithm = BT_2ANT_COEX_ALGO_HID_A2DP_PANEDR;
8642 					}
8643 					break;
8644 				}
8645 			} else {
8646 				RTPRINT(FBT, BT_TRACE, ("[BTCoex], SCO only\n"));
8647 				algorithm = BT_2ANT_COEX_ALGO_SCO;
8648 			}
8649 		} else {
8650 			RTPRINT(FBT, BT_TRACE, ("[BTCoex], non SCO\n"));
8651 			switch (btInfo&0xe0) {
8652 			case BT_INFO_HID:
8653 				RTPRINT(FBT, BT_TRACE, ("[BTCoex], HID\n"));
8654 				algorithm = BT_2ANT_COEX_ALGO_HID;
8655 				break;
8656 			case BT_INFO_A2DP:
8657 				RTPRINT(FBT, BT_TRACE, ("[BTCoex],  A2DP\n"));
8658 				algorithm = BT_2ANT_COEX_ALGO_A2DP;
8659 				break;
8660 			case BT_INFO_FTP:
8661 				RTPRINT(FBT, BT_TRACE, ("[BTCoex], PAN(EDR)\n"));
8662 				algorithm = BT_2ANT_COEX_ALGO_PANEDR_HID;
8663 				break;
8664 			case (BT_INFO_HID | BT_INFO_A2DP):
8665 				RTPRINT(FBT, BT_TRACE, ("[BTCoex], HID + A2DP\n"));
8666 				algorithm = BT_2ANT_COEX_ALGO_HID_A2DP;
8667 				break;
8668 			case (BT_INFO_HID|BT_INFO_FTP):
8669 				if (bBtHsModeExist) {
8670 					RTPRINT(FBT, BT_TRACE, ("[BTCoex], HID + PAN(HS)\n"));
8671 					algorithm = BT_2ANT_COEX_ALGO_HID_A2DP;
8672 				} else {
8673 					RTPRINT(FBT, BT_TRACE, ("[BTCoex], HID + PAN(EDR)\n"));
8674 					algorithm = BT_2ANT_COEX_ALGO_PANEDR_HID;
8675 				}
8676 				break;
8677 			case (BT_INFO_A2DP|BT_INFO_FTP):
8678 				if (bBtHsModeExist) {
8679 					RTPRINT(FBT, BT_TRACE, ("[BTCoex], A2DP + PAN(HS)\n"));
8680 					algorithm = BT_2ANT_COEX_ALGO_A2DP;
8681 				} else {
8682 					RTPRINT(FBT, BT_TRACE, ("[BTCoex], A2DP + PAN(EDR)\n"));
8683 					algorithm = BT_2ANT_COEX_ALGO_PANEDR_A2DP;
8684 				}
8685 				break;
8686 			case (BT_INFO_HID|BT_INFO_A2DP|BT_INFO_FTP):
8687 				if (bBtHsModeExist) {
8688 					RTPRINT(FBT, BT_TRACE, ("[BTCoex], HID + A2DP + PAN(HS)\n"));
8689 					algorithm = BT_2ANT_COEX_ALGO_HID_A2DP;
8690 				} else {
8691 					RTPRINT(FBT, BT_TRACE, ("[BTCoex], HID + A2DP + PAN(EDR)\n"));
8692 					algorithm = BT_2ANT_COEX_ALGO_HID_A2DP_PANEDR;
8693 				}
8694 				break;
8695 			}
8696 
8697 		}
8698 	} else {
8699 		RTPRINT(FBT, BT_TRACE, ("[BTC2H], BTInfo: bConnect = false\n"));
8700 		pBtdm8723->btStatus = BT_2ANT_BT_STATUS_IDLE;
8701 	}
8702 
8703 	pBtdm8723->curAlgorithm = algorithm;
8704 	RTPRINT(FBT, BT_TRACE, ("[BTCoex], Algorithm = %d \n", pBtdm8723->curAlgorithm));
8705 
8706 /* From */
8707 	BTDM_CheckWiFiState(padapter);
8708 	if (pBtMgnt->ExtConfig.bManualControl) {
8709 		RTPRINT(FBT, BT_TRACE, ("Action Manual control, won't execute bt coexist mechanism!!\n"));
8710 		return;
8711 	}
8712 }
8713 
BTDM_2AntBtCoexist8723A(struct rtw_adapter * padapter)8714 void BTDM_2AntBtCoexist8723A(struct rtw_adapter *padapter)
8715 {
8716 	struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
8717 	struct bt_mgnt *pBtMgnt = &pBTInfo->BtMgnt;
8718 	struct bt_dgb *pBtDbg = &pBTInfo->BtDbg;
8719 	u8 btInfoOriginal = 0;
8720 	struct hal_data_8723a *pHalData = GET_HAL_DATA(padapter);
8721 	struct btdm_8723a_2ant *pBtdm8723 = &pHalData->bt_coexist.halCoex8723.btdm2Ant;
8722 
8723 	if (BTDM_BtProfileSupport(padapter)) {
8724 		if (pBtMgnt->ExtConfig.bHoldForBtOperation) {
8725 			RTPRINT(FBT, BT_TRACE, ("Action for BT Operation adjust!!\n"));
8726 			return;
8727 		}
8728 		if (pBtMgnt->ExtConfig.bHoldPeriodCnt) {
8729 			RTPRINT(FBT, BT_TRACE, ("Hold BT inquiry/page scan setting (cnt = %d)!!\n",
8730 				pBtMgnt->ExtConfig.bHoldPeriodCnt));
8731 			if (pBtMgnt->ExtConfig.bHoldPeriodCnt >= 11) {
8732 				pBtMgnt->ExtConfig.bHoldPeriodCnt = 0;
8733 				/*  next time the coexist parameters should be reset again. */
8734 			} else {
8735 				pBtMgnt->ExtConfig.bHoldPeriodCnt++;
8736 			}
8737 			return;
8738 		}
8739 
8740 		if (pBtDbg->dbgCtrl)
8741 			RTPRINT(FBT, BT_TRACE, ("[Dbg control], "));
8742 
8743 		pBtdm8723->curAlgorithm = btdm_ActionAlgorithm(padapter);
8744 		RTPRINT(FBT, BT_TRACE, ("[BTCoex], Algorithm = %d \n", pBtdm8723->curAlgorithm));
8745 
8746 		if (btdm_Is2Ant8723ACommonAction(padapter)) {
8747 			RTPRINT(FBT, BT_TRACE, ("Action 2-Ant common.\n"));
8748 			pBtdm8723->bResetTdmaAdjust = true;
8749 		} else {
8750 			if (pBtdm8723->curAlgorithm != pBtdm8723->preAlgorithm) {
8751 				RTPRINT(FBT, BT_TRACE, ("[BTCoex], preAlgorithm =%d, curAlgorithm =%d\n",
8752 				pBtdm8723->preAlgorithm, pBtdm8723->curAlgorithm));
8753 				pBtdm8723->bResetTdmaAdjust = true;
8754 			}
8755 			switch (pBtdm8723->curAlgorithm) {
8756 			case BT_2ANT_COEX_ALGO_SCO:
8757 				RTPRINT(FBT, BT_TRACE, ("Action 2-Ant, algorithm = SCO.\n"));
8758 				btdm_2Ant8723ASCOAction(padapter);
8759 				break;
8760 			case BT_2ANT_COEX_ALGO_HID:
8761 				RTPRINT(FBT, BT_TRACE, ("Action 2-Ant, algorithm = HID.\n"));
8762 				btdm_2Ant8723AHIDAction(padapter);
8763 				break;
8764 			case BT_2ANT_COEX_ALGO_A2DP:
8765 				RTPRINT(FBT, BT_TRACE, ("Action 2-Ant, algorithm = A2DP.\n"));
8766 				btdm_2Ant8723AA2DPAction(padapter);
8767 				break;
8768 			case BT_2ANT_COEX_ALGO_PANEDR:
8769 				RTPRINT(FBT, BT_TRACE, ("Action 2-Ant, algorithm = PAN(EDR).\n"));
8770 				btdm_2Ant8723APANEDRAction(padapter);
8771 				break;
8772 			case BT_2ANT_COEX_ALGO_PANHS:
8773 				RTPRINT(FBT, BT_TRACE, ("Action 2-Ant, algorithm = HS mode.\n"));
8774 				btdm_2Ant8723APANHSAction(padapter);
8775 				break;
8776 			case BT_2ANT_COEX_ALGO_PANEDR_A2DP:
8777 				RTPRINT(FBT, BT_TRACE, ("Action 2-Ant, algorithm = PAN+A2DP.\n"));
8778 				btdm_2Ant8723APANEDRA2DPAction(padapter);
8779 				break;
8780 			case BT_2ANT_COEX_ALGO_PANEDR_HID:
8781 				RTPRINT(FBT, BT_TRACE, ("Action 2-Ant, algorithm = PAN(EDR)+HID.\n"));
8782 				btdm_2Ant8723APANEDRHIDAction(padapter);
8783 				break;
8784 			case BT_2ANT_COEX_ALGO_HID_A2DP_PANEDR:
8785 				RTPRINT(FBT, BT_TRACE, ("Action 2-Ant, algorithm = HID+A2DP+PAN.\n"));
8786 				btdm_2Ant8723AHIDA2DPPANEDRAction(padapter);
8787 				break;
8788 			case BT_2ANT_COEX_ALGO_HID_A2DP:
8789 				RTPRINT(FBT, BT_TRACE, ("Action 2-Ant, algorithm = HID+A2DP.\n"));
8790 				btdm_2Ant8723AHIDA2DPAction(padapter);
8791 				break;
8792 			default:
8793 				RTPRINT(FBT, BT_TRACE, ("Action 2-Ant, algorithm = 0.\n"));
8794 				btdm_2Ant8723AA2DPAction(padapter);
8795 				break;
8796 			}
8797 			pBtdm8723->preAlgorithm = pBtdm8723->curAlgorithm;
8798 		}
8799 	} else {
8800 		RTPRINT(FBT, BT_TRACE, ("[BTCoex] Get bt info by fw!!\n"));
8801 		/* msg shows c2h rsp for bt_info is received or not. */
8802 		if (pHalData->bt_coexist.halCoex8723.bC2hBtInfoReqSent)
8803 			RTPRINT(FBT, BT_TRACE, ("[BTCoex] c2h for btInfo not rcvd yet!!\n"));
8804 
8805 		btInfoOriginal = pHalData->bt_coexist.halCoex8723.c2hBtInfoOriginal;
8806 
8807 		if (pBtMgnt->ExtConfig.bHoldForBtOperation) {
8808 			RTPRINT(FBT, BT_TRACE, ("Action for BT Operation adjust!!\n"));
8809 			return;
8810 		}
8811 		if (pBtMgnt->ExtConfig.bHoldPeriodCnt) {
8812 			RTPRINT(FBT, BT_TRACE,
8813 				("Hold BT inquiry/page scan setting (cnt = %d)!!\n",
8814 				pBtMgnt->ExtConfig.bHoldPeriodCnt));
8815 			if (pBtMgnt->ExtConfig.bHoldPeriodCnt >= 11) {
8816 				pBtMgnt->ExtConfig.bHoldPeriodCnt = 0;
8817 				/*  next time the coexist parameters should be reset again. */
8818 			} else {
8819 				 pBtMgnt->ExtConfig.bHoldPeriodCnt++;
8820 			}
8821 			return;
8822 		}
8823 
8824 		if (pBtDbg->dbgCtrl)
8825 			RTPRINT(FBT, BT_TRACE, ("[Dbg control], "));
8826 		if (btdm_Is2Ant8723ACommonAction(padapter)) {
8827 			RTPRINT(FBT, BT_TRACE, ("Action 2-Ant common.\n"));
8828 			pBtdm8723->bResetTdmaAdjust = true;
8829 		} else {
8830 			if (pBtdm8723->curAlgorithm != pBtdm8723->preAlgorithm) {
8831 				RTPRINT(FBT, BT_TRACE,
8832 					("[BTCoex], preAlgorithm =%d, curAlgorithm =%d\n",
8833 					pBtdm8723->preAlgorithm,
8834 					pBtdm8723->curAlgorithm));
8835 				pBtdm8723->bResetTdmaAdjust = true;
8836 			}
8837 			switch (pBtdm8723->curAlgorithm) {
8838 			case BT_2ANT_COEX_ALGO_SCO:
8839 				RTPRINT(FBT, BT_TRACE, ("Action 2-Ant, algorithm = SCO.\n"));
8840 				btdm_2Ant8723ASCOAction(padapter);
8841 				break;
8842 			case BT_2ANT_COEX_ALGO_HID:
8843 				RTPRINT(FBT, BT_TRACE, ("Action 2-Ant, algorithm = HID.\n"));
8844 				btdm_2Ant8723AHIDAction(padapter);
8845 				break;
8846 			case BT_2ANT_COEX_ALGO_A2DP:
8847 				RTPRINT(FBT, BT_TRACE, ("Action 2-Ant, algorithm = A2DP.\n"));
8848 				btdm_2Ant8723AA2dp(padapter);
8849 				break;
8850 			case BT_2ANT_COEX_ALGO_PANEDR:
8851 				RTPRINT(FBT, BT_TRACE, ("Action 2-Ant, algorithm = PAN(EDR).\n"));
8852 				btdm_2Ant8723APANEDRAction(padapter);
8853 				break;
8854 			case BT_2ANT_COEX_ALGO_PANHS:
8855 				RTPRINT(FBT, BT_TRACE, ("Action 2-Ant, algorithm = HS mode.\n"));
8856 				btdm_2Ant8723APANHSAction(padapter);
8857 				break;
8858 			case BT_2ANT_COEX_ALGO_PANEDR_A2DP:
8859 				RTPRINT(FBT, BT_TRACE, ("Action 2-Ant, algorithm = PAN+A2DP.\n"));
8860 				btdm_2Ant8723APANEDRA2DPAction(padapter);
8861 				break;
8862 			case BT_2ANT_COEX_ALGO_PANEDR_HID:
8863 				RTPRINT(FBT, BT_TRACE, ("Action 2-Ant, algorithm = PAN(EDR)+HID.\n"));
8864 				btdm_2Ant8723APANEDRHIDAction(padapter);
8865 				break;
8866 			case BT_2ANT_COEX_ALGO_HID_A2DP_PANEDR:
8867 				RTPRINT(FBT, BT_TRACE, ("Action 2-Ant, algorithm = HID+A2DP+PAN.\n"));
8868 				btdm_2Ant8723AHIDA2DPPANEDRAction(padapter);
8869 				break;
8870 			case BT_2ANT_COEX_ALGO_HID_A2DP:
8871 				RTPRINT(FBT, BT_TRACE, ("Action 2-Ant, algorithm = HID+A2DP.\n"));
8872 				btdm_2Ant8723AHIDA2DPAction(padapter);
8873 				break;
8874 			default:
8875 				RTPRINT(FBT, BT_TRACE, ("Action 2-Ant, algorithm = 0.\n"));
8876 				btdm_2Ant8723AA2DPAction(padapter);
8877 				break;
8878 			}
8879 			pBtdm8723->preAlgorithm = pBtdm8723->curAlgorithm;
8880 		}
8881 	}
8882 }
8883 
8884 /*  ===== End of sync from SD7 driver HAL/BTCoexist/HalBtc87232Ant.c ===== */
8885 
8886 /*  ===== Below this line is sync from SD7 driver HAL/BTCoexist/HalBtc8723.c ===== */
8887 
8888 static u8 btCoexDbgBuf[BT_TMP_BUF_SIZE];
8889 
8890 static const char *const BtProfileString[] = {
8891 	"NONE",
8892 	"A2DP",
8893 	"PAN",
8894 	"HID",
8895 	"SCO",
8896 };
8897 
8898 static const char *const BtSpecString[] = {
8899 	"1.0b",
8900 	"1.1",
8901 	"1.2",
8902 	"2.0+EDR",
8903 	"2.1+EDR",
8904 	"3.0+HS",
8905 	"4.0",
8906 };
8907 
8908 static const char *const BtLinkRoleString[] = {
8909 	"Master",
8910 	"Slave",
8911 };
8912 
btdm_BtWifiAntNum(struct rtw_adapter * padapter)8913 static u8 btdm_BtWifiAntNum(struct rtw_adapter *padapter)
8914 {
8915 	struct hal_data_8723a *pHalData = GET_HAL_DATA(padapter);
8916 	struct bt_coexist_8723a *pBtCoex = &pHalData->bt_coexist.halCoex8723;
8917 
8918 	if (Ant_x2 == pHalData->bt_coexist.BT_Ant_Num) {
8919 		if (Ant_x2 == pBtCoex->TotalAntNum)
8920 			return Ant_x2;
8921 		else
8922 			return Ant_x1;
8923 	} else {
8924 		return Ant_x1;
8925 	}
8926 	return Ant_x2;
8927 }
8928 
btdm_BtHwCountersMonitor(struct rtw_adapter * padapter)8929 static void btdm_BtHwCountersMonitor(struct rtw_adapter *padapter)
8930 {
8931 	struct hal_data_8723a *pHalData = GET_HAL_DATA(padapter);
8932 	u32	regHPTxRx, regLPTxRx, u4Tmp;
8933 	u32	regHPTx = 0, regHPRx = 0, regLPTx = 0, regLPRx = 0;
8934 
8935 	regHPTxRx = REG_HIGH_PRIORITY_TXRX;
8936 	regLPTxRx = REG_LOW_PRIORITY_TXRX;
8937 
8938 	u4Tmp = rtl8723au_read32(padapter, regHPTxRx);
8939 	regHPTx = u4Tmp & bMaskLWord;
8940 	regHPRx = (u4Tmp & bMaskHWord)>>16;
8941 
8942 	u4Tmp = rtl8723au_read32(padapter, regLPTxRx);
8943 	regLPTx = u4Tmp & bMaskLWord;
8944 	regLPRx = (u4Tmp & bMaskHWord)>>16;
8945 
8946 	pHalData->bt_coexist.halCoex8723.highPriorityTx = regHPTx;
8947 	pHalData->bt_coexist.halCoex8723.highPriorityRx = regHPRx;
8948 	pHalData->bt_coexist.halCoex8723.lowPriorityTx = regLPTx;
8949 	pHalData->bt_coexist.halCoex8723.lowPriorityRx = regLPRx;
8950 
8951 	RTPRINT(FBT, BT_TRACE, ("High Priority Tx/Rx = %d / %d\n", regHPTx, regHPRx));
8952 	RTPRINT(FBT, BT_TRACE, ("Low Priority Tx/Rx = %d / %d\n", regLPTx, regLPRx));
8953 
8954 	/*  reset counter */
8955 	rtl8723au_write8(padapter, 0x76e, 0xc);
8956 }
8957 
8958 /*  This function check if 8723 bt is disabled */
btdm_BtEnableDisableCheck8723A(struct rtw_adapter * padapter)8959 static void btdm_BtEnableDisableCheck8723A(struct rtw_adapter *padapter)
8960 {
8961 	u8 btAlife = true;
8962 	struct hal_data_8723a *pHalData = GET_HAL_DATA(padapter);
8963 
8964 #ifdef CHECK_BT_EXIST_FROM_REG
8965 	u8 val8;
8966 
8967 	/*  ox68[28]= 1 => BT enable; otherwise disable */
8968 	val8 = rtl8723au_read8(padapter, 0x6B);
8969 	if (!(val8 & BIT(4)))
8970 		btAlife = false;
8971 
8972 	if (btAlife)
8973 		pHalData->bt_coexist.bCurBtDisabled = false;
8974 	else
8975 		pHalData->bt_coexist.bCurBtDisabled = true;
8976 #else
8977 	if (pHalData->bt_coexist.halCoex8723.highPriorityTx == 0 &&
8978 	    pHalData->bt_coexist.halCoex8723.highPriorityRx == 0 &&
8979 	    pHalData->bt_coexist.halCoex8723.lowPriorityTx == 0 &&
8980 	    pHalData->bt_coexist.halCoex8723.lowPriorityRx == 0)
8981 		btAlife = false;
8982 	if (pHalData->bt_coexist.halCoex8723.highPriorityTx == 0xeaea &&
8983 	    pHalData->bt_coexist.halCoex8723.highPriorityRx == 0xeaea &&
8984 	    pHalData->bt_coexist.halCoex8723.lowPriorityTx == 0xeaea &&
8985 	    pHalData->bt_coexist.halCoex8723.lowPriorityRx == 0xeaea)
8986 		btAlife = false;
8987 	if (pHalData->bt_coexist.halCoex8723.highPriorityTx == 0xffff &&
8988 	    pHalData->bt_coexist.halCoex8723.highPriorityRx == 0xffff &&
8989 	    pHalData->bt_coexist.halCoex8723.lowPriorityTx == 0xffff &&
8990 	    pHalData->bt_coexist.halCoex8723.lowPriorityRx == 0xffff)
8991 		btAlife = false;
8992 	if (btAlife) {
8993 		pHalData->bt_coexist.btActiveZeroCnt = 0;
8994 		pHalData->bt_coexist.bCurBtDisabled = false;
8995 		RTPRINT(FBT, BT_TRACE, ("8723A BT is enabled !!\n"));
8996 	} else {
8997 		pHalData->bt_coexist.btActiveZeroCnt++;
8998 		RTPRINT(FBT, BT_TRACE, ("8723A bt all counters = 0, %d times!!\n",
8999 				pHalData->bt_coexist.btActiveZeroCnt));
9000 		if (pHalData->bt_coexist.btActiveZeroCnt >= 2) {
9001 			pHalData->bt_coexist.bCurBtDisabled = true;
9002 			RTPRINT(FBT, BT_TRACE, ("8723A BT is disabled !!\n"));
9003 		}
9004 	}
9005 #endif
9006 
9007 	if (!pHalData->bt_coexist.bCurBtDisabled) {
9008 		if (BTDM_IsWifiConnectionExist(padapter))
9009 			BTDM_SetFwChnlInfo(padapter, RT_MEDIA_CONNECT);
9010 		else
9011 			BTDM_SetFwChnlInfo(padapter, RT_MEDIA_DISCONNECT);
9012 	}
9013 
9014 	if (pHalData->bt_coexist.bPreBtDisabled !=
9015 	    pHalData->bt_coexist.bCurBtDisabled) {
9016 		RTPRINT(FBT, BT_TRACE, ("8723A BT is from %s to %s!!\n",
9017 			(pHalData->bt_coexist.bPreBtDisabled ? "disabled":"enabled"),
9018 			(pHalData->bt_coexist.bCurBtDisabled ? "disabled":"enabled")));
9019 		pHalData->bt_coexist.bPreBtDisabled = pHalData->bt_coexist.bCurBtDisabled;
9020 	}
9021 }
9022 
btdm_BTCoexist8723AHandler(struct rtw_adapter * padapter)9023 static void btdm_BTCoexist8723AHandler(struct rtw_adapter *padapter)
9024 {
9025 	struct hal_data_8723a *pHalData;
9026 
9027 	pHalData = GET_HAL_DATA(padapter);
9028 
9029 	if (btdm_BtWifiAntNum(padapter) == Ant_x2) {
9030 		RTPRINT(FBT, BT_TRACE, ("[BTCoex], 2 Ant mechanism\n"));
9031 		BTDM_2AntBtCoexist8723A(padapter);
9032 	} else {
9033 		RTPRINT(FBT, BT_TRACE, ("[BTCoex], 1 Ant mechanism\n"));
9034 		BTDM_1AntBtCoexist8723A(padapter);
9035 	}
9036 
9037 	if (!BTDM_IsSameCoexistState(padapter)) {
9038 		RTPRINT(FBT, BT_TRACE, ("[BTCoex], Coexist State[bitMap] change from 0x%"i64fmt"x to 0x%"i64fmt"x\n",
9039 			pHalData->bt_coexist.PreviousState,
9040 			pHalData->bt_coexist.CurrentState));
9041 		pHalData->bt_coexist.PreviousState = pHalData->bt_coexist.CurrentState;
9042 
9043 		RTPRINT(FBT, BT_TRACE, ("["));
9044 		if (pHalData->bt_coexist.CurrentState & BT_COEX_STATE_BT30)
9045 			RTPRINT(FBT, BT_TRACE, ("BT 3.0, "));
9046 		if (pHalData->bt_coexist.CurrentState & BT_COEX_STATE_WIFI_HT20)
9047 			RTPRINT(FBT, BT_TRACE, ("HT20, "));
9048 		if (pHalData->bt_coexist.CurrentState & BT_COEX_STATE_WIFI_HT40)
9049 			RTPRINT(FBT, BT_TRACE, ("HT40, "));
9050 		if (pHalData->bt_coexist.CurrentState & BT_COEX_STATE_WIFI_LEGACY)
9051 			RTPRINT(FBT, BT_TRACE, ("Legacy, "));
9052 		if (pHalData->bt_coexist.CurrentState & BT_COEX_STATE_WIFI_RSSI_LOW)
9053 			RTPRINT(FBT, BT_TRACE, ("Rssi_Low, "));
9054 		if (pHalData->bt_coexist.CurrentState & BT_COEX_STATE_WIFI_RSSI_MEDIUM)
9055 			RTPRINT(FBT, BT_TRACE, ("Rssi_Mid, "));
9056 		if (pHalData->bt_coexist.CurrentState & BT_COEX_STATE_WIFI_RSSI_HIGH)
9057 			RTPRINT(FBT, BT_TRACE, ("Rssi_High, "));
9058 		if (pHalData->bt_coexist.CurrentState & BT_COEX_STATE_WIFI_IDLE)
9059 			RTPRINT(FBT, BT_TRACE, ("Wifi_Idle, "));
9060 		if (pHalData->bt_coexist.CurrentState & BT_COEX_STATE_WIFI_UPLINK)
9061 			RTPRINT(FBT, BT_TRACE, ("Wifi_Uplink, "));
9062 		if (pHalData->bt_coexist.CurrentState & BT_COEX_STATE_WIFI_DOWNLINK)
9063 			RTPRINT(FBT, BT_TRACE, ("Wifi_Downlink, "));
9064 		if (pHalData->bt_coexist.CurrentState & BT_COEX_STATE_BT_IDLE)
9065 			RTPRINT(FBT, BT_TRACE, ("BT_idle, "));
9066 		if (pHalData->bt_coexist.CurrentState & BT_COEX_STATE_PROFILE_HID)
9067 			RTPRINT(FBT, BT_TRACE, ("PRO_HID, "));
9068 		if (pHalData->bt_coexist.CurrentState & BT_COEX_STATE_PROFILE_A2DP)
9069 			RTPRINT(FBT, BT_TRACE, ("PRO_A2DP, "));
9070 		if (pHalData->bt_coexist.CurrentState & BT_COEX_STATE_PROFILE_PAN)
9071 			RTPRINT(FBT, BT_TRACE, ("PRO_PAN, "));
9072 		if (pHalData->bt_coexist.CurrentState & BT_COEX_STATE_PROFILE_SCO)
9073 			RTPRINT(FBT, BT_TRACE, ("PRO_SCO, "));
9074 		RTPRINT(FBT, BT_TRACE, ("]\n"));
9075 	}
9076 }
9077 
9078 /*  extern function start with BTDM_ */
BTDM_BtTxRxCounterH(struct rtw_adapter * padapter)9079 u32 BTDM_BtTxRxCounterH(struct rtw_adapter *padapter)
9080 {
9081 	struct hal_data_8723a *pHalData = GET_HAL_DATA(padapter);
9082 	u32	counters = 0;
9083 
9084 	counters = pHalData->bt_coexist.halCoex8723.highPriorityTx+
9085 		pHalData->bt_coexist.halCoex8723.highPriorityRx;
9086 	return counters;
9087 }
9088 
BTDM_BtTxRxCounterL(struct rtw_adapter * padapter)9089 u32 BTDM_BtTxRxCounterL(struct rtw_adapter *padapter)
9090 {
9091 	struct hal_data_8723a *pHalData = GET_HAL_DATA(padapter);
9092 	u32	counters = 0;
9093 
9094 	counters = pHalData->bt_coexist.halCoex8723.lowPriorityTx+
9095 		pHalData->bt_coexist.halCoex8723.lowPriorityRx;
9096 	return counters;
9097 }
9098 
BTDM_SetFwChnlInfo(struct rtw_adapter * padapter,enum rt_media_status mstatus)9099 void BTDM_SetFwChnlInfo(struct rtw_adapter *padapter, enum rt_media_status mstatus)
9100 {
9101 	struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
9102 	struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
9103 	struct bt_mgnt *pBtMgnt = &pBTInfo->BtMgnt;
9104 	u8 H2C_Parameter[3] = {0};
9105 	u8 chnl;
9106 
9107 	/*  opMode */
9108 	if (RT_MEDIA_CONNECT == mstatus)
9109 		H2C_Parameter[0] = 0x1;	/*  0: disconnected, 1:connected */
9110 
9111 	if (check_fwstate(&padapter->mlmepriv, WIFI_ASOC_STATE)) {
9112 		/*  channel */
9113 		chnl = pmlmeext->cur_channel;
9114 		if (BTDM_IsHT40(padapter)) {
9115 			if (pmlmeext->cur_ch_offset == HAL_PRIME_CHNL_OFFSET_UPPER)
9116 				chnl -= 2;
9117 			else if (pmlmeext->cur_ch_offset == HAL_PRIME_CHNL_OFFSET_LOWER)
9118 				chnl += 2;
9119 		}
9120 		H2C_Parameter[1] = chnl;
9121 	} else {	/*  check if HS link is exists */
9122 		/*  channel */
9123 		if (BT_Operation(padapter))
9124 			H2C_Parameter[1] = pBtMgnt->BTChannel;
9125 		else
9126 			H2C_Parameter[1] = pmlmeext->cur_channel;
9127 	}
9128 
9129 	if (BTDM_IsHT40(padapter))
9130 		H2C_Parameter[2] = 0x30;
9131 	else
9132 		H2C_Parameter[2] = 0x20;
9133 
9134 	FillH2CCmd(padapter, 0x19, 3, H2C_Parameter);
9135 }
9136 
BTDM_IsWifiConnectionExist(struct rtw_adapter * padapter)9137 u8 BTDM_IsWifiConnectionExist(struct rtw_adapter *padapter)
9138 {
9139 	u8 bRet = false;
9140 
9141 	if (BTHCI_HsConnectionEstablished(padapter))
9142 		bRet = true;
9143 
9144 	if (check_fwstate(&padapter->mlmepriv, WIFI_ASOC_STATE) == true)
9145 		bRet = true;
9146 
9147 	return bRet;
9148 }
9149 
BTDM_SetFw3a(struct rtw_adapter * padapter,u8 byte1,u8 byte2,u8 byte3,u8 byte4,u8 byte5)9150 void BTDM_SetFw3a(
9151 	struct rtw_adapter *padapter,
9152 	u8 byte1,
9153 	u8 byte2,
9154 	u8 byte3,
9155 	u8 byte4,
9156 	u8 byte5
9157 	)
9158 {
9159 	u8 H2C_Parameter[5] = {0};
9160 
9161 	if (rtl8723a_BT_using_antenna_1(padapter)) {
9162 		if ((!check_fwstate(&padapter->mlmepriv, WIFI_STATION_STATE)) &&
9163 		    (get_fwstate(&padapter->mlmepriv) != WIFI_NULL_STATE)) {
9164 			/*  for softap mode */
9165 			struct hal_data_8723a *pHalData = GET_HAL_DATA(padapter);
9166 			struct bt_coexist_8723a *pBtCoex = &pHalData->bt_coexist.halCoex8723;
9167 			u8 BtState = pBtCoex->c2hBtInfo;
9168 
9169 			if ((BtState != BT_INFO_STATE_NO_CONNECTION) &&
9170 			    (BtState != BT_INFO_STATE_CONNECT_IDLE)) {
9171 				if (byte1 & BIT(4)) {
9172 					byte1 &= ~BIT(4);
9173 					byte1 |= BIT(5);
9174 				}
9175 
9176 				byte5 |= BIT(5);
9177 				if (byte5 & BIT(6))
9178 					byte5 &= ~BIT(6);
9179 			}
9180 		}
9181 	}
9182 
9183 	H2C_Parameter[0] = byte1;
9184 	H2C_Parameter[1] = byte2;
9185 	H2C_Parameter[2] = byte3;
9186 	H2C_Parameter[3] = byte4;
9187 	H2C_Parameter[4] = byte5;
9188 
9189 	RTPRINT(FBT, BT_TRACE, ("[BTCoex], FW write 0x3a(5bytes) = 0x%02x%08x\n",
9190 		H2C_Parameter[0],
9191 		H2C_Parameter[1]<<24|H2C_Parameter[2]<<16|H2C_Parameter[3]<<8|H2C_Parameter[4]));
9192 
9193 	FillH2CCmd(padapter, 0x3a, 5, H2C_Parameter);
9194 }
9195 
BTDM_QueryBtInformation(struct rtw_adapter * padapter)9196 void BTDM_QueryBtInformation(struct rtw_adapter *padapter)
9197 {
9198 	u8 H2C_Parameter[1] = {0};
9199 	struct hal_data_8723a *pHalData;
9200 	struct bt_coexist_8723a *pBtCoex;
9201 
9202 	pHalData = GET_HAL_DATA(padapter);
9203 	pBtCoex = &pHalData->bt_coexist.halCoex8723;
9204 
9205 	if (!rtl8723a_BT_enabled(padapter)) {
9206 		pBtCoex->c2hBtInfo = BT_INFO_STATE_DISABLED;
9207 		pBtCoex->bC2hBtInfoReqSent = false;
9208 		return;
9209 	}
9210 
9211 	if (pBtCoex->c2hBtInfo == BT_INFO_STATE_DISABLED)
9212 		pBtCoex->c2hBtInfo = BT_INFO_STATE_NO_CONNECTION;
9213 
9214 	if (pBtCoex->bC2hBtInfoReqSent == true)
9215 		RTPRINT(FBT, BT_TRACE, ("[BTCoex], didn't recv previous BtInfo report!\n"));
9216 	else
9217 		pBtCoex->bC2hBtInfoReqSent = true;
9218 
9219 	H2C_Parameter[0] |= BIT(0);	/*  trigger */
9220 
9221 /*RTPRINT(FBT, BT_TRACE, ("[BTCoex], Query Bt information, write 0x38 = 0x%x\n", */
9222 /*H2C_Parameter[0])); */
9223 
9224 	FillH2CCmd(padapter, 0x38, 1, H2C_Parameter);
9225 }
9226 
BTDM_SetSwRfRxLpfCorner(struct rtw_adapter * padapter,u8 type)9227 void BTDM_SetSwRfRxLpfCorner(struct rtw_adapter *padapter, u8 type)
9228 {
9229 	struct hal_data_8723a *pHalData = GET_HAL_DATA(padapter);
9230 
9231 	if (BT_RF_RX_LPF_CORNER_SHRINK == type) {
9232 		/* Shrink RF Rx LPF corner */
9233 		RTPRINT(FBT, BT_TRACE, ("Shrink RF Rx LPF corner!!\n"));
9234 		PHY_SetRFReg(padapter, PathA, 0x1e, bRFRegOffsetMask, 0xf0ff7);
9235 		pHalData->bt_coexist.bSWCoexistAllOff = false;
9236 	} else if (BT_RF_RX_LPF_CORNER_RESUME == type) {
9237 		/* Resume RF Rx LPF corner */
9238 		RTPRINT(FBT, BT_TRACE, ("Resume RF Rx LPF corner!!\n"));
9239 		PHY_SetRFReg(padapter, PathA, 0x1e, bRFRegOffsetMask, pHalData->bt_coexist.BtRfRegOrigin1E);
9240 	}
9241 }
9242 
9243 void
BTDM_SetSwPenaltyTxRateAdaptive(struct rtw_adapter * padapter,u8 raType)9244 BTDM_SetSwPenaltyTxRateAdaptive(
9245 	struct rtw_adapter *padapter,
9246 	u8 raType
9247 	)
9248 {
9249 	struct hal_data_8723a *pHalData = GET_HAL_DATA(padapter);
9250 	u8 tmpU1;
9251 
9252 	tmpU1 = rtl8723au_read8(padapter, 0x4fd);
9253 	tmpU1 |= BIT(0);
9254 	if (BT_TX_RATE_ADAPTIVE_LOW_PENALTY == raType) {
9255 		tmpU1 &= ~BIT(2);
9256 		pHalData->bt_coexist.bSWCoexistAllOff = false;
9257 	} else if (BT_TX_RATE_ADAPTIVE_NORMAL == raType) {
9258 		tmpU1 |= BIT(2);
9259 	}
9260 
9261 	rtl8723au_write8(padapter, 0x4fd, tmpU1);
9262 }
9263 
BTDM_SetFwDecBtPwr(struct rtw_adapter * padapter,u8 bDecBtPwr)9264 void BTDM_SetFwDecBtPwr(struct rtw_adapter *padapter, u8 bDecBtPwr)
9265 {
9266 	struct hal_data_8723a *pHalData = GET_HAL_DATA(padapter);
9267 	u8 H2C_Parameter[1] = {0};
9268 
9269 	H2C_Parameter[0] = 0;
9270 
9271 	if (bDecBtPwr) {
9272 		H2C_Parameter[0] |= BIT(1);
9273 		pHalData->bt_coexist.bFWCoexistAllOff = false;
9274 	}
9275 
9276 	RTPRINT(FBT, BT_TRACE, ("[BTCoex], decrease Bt Power : %s, write 0x21 = 0x%x\n",
9277 		(bDecBtPwr ? "Yes!!" : "No!!"), H2C_Parameter[0]));
9278 
9279 	FillH2CCmd(padapter, 0x21, 1, H2C_Parameter);
9280 }
9281 
BTDM_BtProfileSupport(struct rtw_adapter * padapter)9282 u8 BTDM_BtProfileSupport(struct rtw_adapter *padapter)
9283 {
9284 	u8 bRet = false;
9285 	struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
9286 	struct bt_mgnt *pBtMgnt = &pBTInfo->BtMgnt;
9287 	struct hal_data_8723a *pHalData = GET_HAL_DATA(padapter);
9288 
9289 	if (pBtMgnt->bSupportProfile &&
9290 	    !pHalData->bt_coexist.halCoex8723.bForceFwBtInfo)
9291 		bRet = true;
9292 
9293 	return bRet;
9294 }
9295 
BTDM_AdjustForBtOperation8723A(struct rtw_adapter * padapter)9296 static void BTDM_AdjustForBtOperation8723A(struct rtw_adapter *padapter)
9297 {
9298 	/* BTDM_2AntAdjustForBtOperation8723(padapter); */
9299 }
9300 
BTDM_FwC2hBtRssi8723A(struct rtw_adapter * padapter,u8 * tmpBuf)9301 static void BTDM_FwC2hBtRssi8723A(struct rtw_adapter *padapter, u8 *tmpBuf)
9302 {
9303 	struct hal_data_8723a *pHalData = GET_HAL_DATA(padapter);
9304 	u8 percent = 0, u1tmp = 0;
9305 
9306 	u1tmp = tmpBuf[0];
9307 	percent = u1tmp*2+10;
9308 
9309 	pHalData->bt_coexist.halCoex8723.btRssi = percent;
9310 /*RTPRINT(FBT, BT_TRACE, ("[BTC2H], BT RSSI =%d\n", percent)); */
9311 }
9312 
9313 void
rtl8723a_fw_c2h_BT_info(struct rtw_adapter * padapter,u8 * tmpBuf,u8 length)9314 rtl8723a_fw_c2h_BT_info(struct rtw_adapter *padapter, u8 *tmpBuf, u8 length)
9315 {
9316 	struct hal_data_8723a *pHalData;
9317 	struct bt_30info *pBTInfo;
9318 	struct bt_mgnt *pBtMgnt;
9319 	struct bt_coexist_8723a *pBtCoex;
9320 	u8 i;
9321 
9322 	pHalData = GET_HAL_DATA(padapter);
9323 	pBTInfo = GET_BT_INFO(padapter);
9324 	pBtMgnt = &pBTInfo->BtMgnt;
9325 	pBtCoex = &pHalData->bt_coexist.halCoex8723;
9326 
9327 	pBtCoex->bC2hBtInfoReqSent = false;
9328 
9329 	RTPRINT(FBT, BT_TRACE, ("[BTC2H], BT info[%d]=[", length));
9330 
9331 	pBtCoex->btRetryCnt = 0;
9332 	for (i = 0; i < length; i++) {
9333 		switch (i) {
9334 		case 0:
9335 			pBtCoex->c2hBtInfoOriginal = tmpBuf[i];
9336 			break;
9337 		case 1:
9338 			pBtCoex->btRetryCnt = tmpBuf[i];
9339 			break;
9340 		case 2:
9341 			BTDM_FwC2hBtRssi8723A(padapter, &tmpBuf[i]);
9342 			break;
9343 		case 3:
9344 			pBtCoex->btInfoExt = tmpBuf[i]&BIT(0);
9345 			break;
9346 		}
9347 
9348 		if (i == length-1)
9349 			RTPRINT(FBT, BT_TRACE, ("0x%02x]\n", tmpBuf[i]));
9350 		else
9351 			RTPRINT(FBT, BT_TRACE, ("0x%02x, ", tmpBuf[i]));
9352 	}
9353 	RTPRINT(FBT, BT_TRACE, ("[BTC2H], BT RSSI =%d\n", pBtCoex->btRssi));
9354 	if (pBtCoex->btInfoExt)
9355 		RTPRINT(FBT, BT_TRACE, ("[BTC2H], pBtCoex->btInfoExt =%x\n", pBtCoex->btInfoExt));
9356 
9357 	if (btdm_BtWifiAntNum(padapter) == Ant_x1)
9358 		BTDM_1AntFwC2hBtInfo8723A(padapter);
9359 	else
9360 		BTDM_2AntFwC2hBtInfo8723A(padapter);
9361 
9362 	if (pBtMgnt->ExtConfig.bManualControl) {
9363 		RTPRINT(FBT, BT_TRACE, ("%s: Action Manual control!!\n", __func__));
9364 		return;
9365 	}
9366 
9367 	btdm_BTCoexist8723AHandler(padapter);
9368 }
9369 
BTDM_Display8723ABtCoexInfo(struct rtw_adapter * padapter)9370 static void BTDM_Display8723ABtCoexInfo(struct rtw_adapter *padapter)
9371 {
9372 	struct hal_data_8723a *pHalData = GET_HAL_DATA(padapter);
9373 	struct bt_coexist_8723a *pBtCoex = &pHalData->bt_coexist.halCoex8723;
9374 	struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
9375 	struct bt_mgnt *pBtMgnt = &pBTInfo->BtMgnt;
9376 	u8 u1Tmp, u1Tmp1, u1Tmp2, i, btInfoExt, psTdmaCase = 0;
9377 	u32 u4Tmp[4];
9378 	u8 antNum = Ant_x2;
9379 
9380 	rsprintf(btCoexDbgBuf, BT_TMP_BUF_SIZE, "\r\n ============[BT Coexist info]============");
9381 	DCMD_Printf(btCoexDbgBuf);
9382 
9383 	if (!rtl8723a_BT_coexist(padapter)) {
9384 		rsprintf(btCoexDbgBuf, BT_TMP_BUF_SIZE, "\r\n BT not exists !!!");
9385 		DCMD_Printf(btCoexDbgBuf);
9386 		return;
9387 	}
9388 
9389 	antNum = btdm_BtWifiAntNum(padapter);
9390 	rsprintf(btCoexDbgBuf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d/%d ", "Ant mechanism PG/Now run :", \
9391 		((pHalData->bt_coexist.BT_Ant_Num == Ant_x2) ? 2 : 1), ((antNum == Ant_x2) ? 2 : 1));
9392 	DCMD_Printf(btCoexDbgBuf);
9393 
9394 	if (pBtMgnt->ExtConfig.bManualControl) {
9395 		rsprintf(btCoexDbgBuf, BT_TMP_BUF_SIZE, "\r\n %-35s", "[Action Manual control]!!");
9396 		DCMD_Printf(btCoexDbgBuf);
9397 	} else {
9398 		rsprintf(btCoexDbgBuf, BT_TMP_BUF_SIZE, "\r\n %-35s = %s / %d", "BT stack/ hci ext ver", \
9399 			((pBtMgnt->bSupportProfile) ? "Yes" : "No"), pBtMgnt->ExtConfig.HCIExtensionVer);
9400 		DCMD_Printf(btCoexDbgBuf);
9401 	}
9402 
9403 	rsprintf(btCoexDbgBuf, BT_TMP_BUF_SIZE, "\n %-35s = / %d", "Dot11 channel / BT channel", \
9404 		pBtMgnt->BTChannel);
9405 		DCMD_Printf(btCoexDbgBuf);
9406 
9407 	rsprintf(btCoexDbgBuf, BT_TMP_BUF_SIZE, "\n %-35s = %d / %d / %d", "Wifi/BT/HS rssi", \
9408 		BTDM_GetRxSS(padapter),
9409 		pHalData->bt_coexist.halCoex8723.btRssi,
9410 		pHalData->dmpriv.EntryMinUndecoratedSmoothedPWDB);
9411 			DCMD_Printf(btCoexDbgBuf);
9412 
9413 	if (!pBtMgnt->ExtConfig.bManualControl) {
9414 		rsprintf(btCoexDbgBuf, BT_TMP_BUF_SIZE, "\n %-35s = %s / %s ", "WIfi status",
9415 			((BTDM_Legacy(padapter)) ? "Legacy" : (((BTDM_IsHT40(padapter)) ? "HT40" : "HT20"))),
9416 			((!BTDM_IsWifiBusy(padapter)) ? "idle" : ((BTDM_IsWifiUplink(padapter)) ? "uplink" : "downlink")));
9417 		DCMD_Printf(btCoexDbgBuf);
9418 
9419 		if (pBtMgnt->bSupportProfile) {
9420 			rsprintf(btCoexDbgBuf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d / %d / %d / %d", "SCO/HID/PAN/A2DP",
9421 				((BTHCI_CheckProfileExist(padapter, BT_PROFILE_SCO)) ? 1 : 0),
9422 				((BTHCI_CheckProfileExist(padapter, BT_PROFILE_HID)) ? 1 : 0),
9423 				((BTHCI_CheckProfileExist(padapter, BT_PROFILE_PAN)) ? 1 : 0),
9424 				((BTHCI_CheckProfileExist(padapter, BT_PROFILE_A2DP)) ? 1 : 0));
9425 		DCMD_Printf(btCoexDbgBuf);
9426 
9427 			for (i = 0; i < pBtMgnt->ExtConfig.NumberOfHandle; i++) {
9428 				if (pBtMgnt->ExtConfig.HCIExtensionVer >= 1) {
9429 					rsprintf(btCoexDbgBuf, BT_TMP_BUF_SIZE, "\r\n %-35s = %s/ %s/ %s", "Bt link type/spec/role",
9430 						BtProfileString[pBtMgnt->ExtConfig.linkInfo[i].BTProfile],
9431 						BtSpecString[pBtMgnt->ExtConfig.linkInfo[i].BTCoreSpec],
9432 						BtLinkRoleString[pBtMgnt->ExtConfig.linkInfo[i].linkRole]);
9433 					DCMD_Printf(btCoexDbgBuf);
9434 
9435 					btInfoExt = pHalData->bt_coexist.halCoex8723.btInfoExt;
9436 					rsprintf(btCoexDbgBuf, BT_TMP_BUF_SIZE, "\r\n %-35s = %s", "A2DP rate", \
9437 						 (btInfoExt & BIT(0)) ?
9438 						 "Basic rate" : "EDR rate");
9439 					DCMD_Printf(btCoexDbgBuf);
9440 				} else {
9441 					rsprintf(btCoexDbgBuf, BT_TMP_BUF_SIZE, "\r\n %-35s = %s/ %s", "Bt link type/spec", \
9442 						BtProfileString[pBtMgnt->ExtConfig.linkInfo[i].BTProfile],
9443 						BtSpecString[pBtMgnt->ExtConfig.linkInfo[i].BTCoreSpec]);
9444 					DCMD_Printf(btCoexDbgBuf);
9445 				}
9446 			}
9447 		}
9448 	}
9449 
9450 	/*  Sw mechanism */
9451 	if (!pBtMgnt->ExtConfig.bManualControl) {
9452 		rsprintf(btCoexDbgBuf, BT_TMP_BUF_SIZE, "\r\n %-35s", "============[Sw BT Coex mechanism]============");
9453 		DCMD_Printf(btCoexDbgBuf);
9454 		rsprintf(btCoexDbgBuf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d ", "AGC Table", \
9455 			pBtCoex->btdm2Ant.bCurAgcTableEn);
9456 		DCMD_Printf(btCoexDbgBuf);
9457 		rsprintf(btCoexDbgBuf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d ", "ADC Backoff", \
9458 			pBtCoex->btdm2Ant.bCurAdcBackOff);
9459 		DCMD_Printf(btCoexDbgBuf);
9460 		rsprintf(btCoexDbgBuf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d ", "Low penalty RA", \
9461 			pBtCoex->btdm2Ant.bCurLowPenaltyRa);
9462 		DCMD_Printf(btCoexDbgBuf);
9463 		rsprintf(btCoexDbgBuf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d ", "RF Rx LPF Shrink", \
9464 			pBtCoex->btdm2Ant.bCurRfRxLpfShrink);
9465 		DCMD_Printf(btCoexDbgBuf);
9466 	}
9467 	u4Tmp[0] = PHY_QueryRFReg(padapter, PathA, 0x1e, 0xff0);
9468 	rsprintf(btCoexDbgBuf, BT_TMP_BUF_SIZE, "\r\n %-35s = 0x%x/ 0x%x", "RF-A, 0x1e[11:4]/original val", \
9469 		u4Tmp[0], pHalData->bt_coexist.BtRfRegOrigin1E);
9470 	DCMD_Printf(btCoexDbgBuf);
9471 
9472 	/*  Fw mechanism */
9473 	if (!pBtMgnt->ExtConfig.bManualControl) {
9474 		rsprintf(btCoexDbgBuf, BT_TMP_BUF_SIZE, "\r\n %-35s", "============[Fw BT Coex mechanism]============");
9475 		DCMD_Printf(btCoexDbgBuf);
9476 	}
9477 	if (!pBtMgnt->ExtConfig.bManualControl) {
9478 		if (btdm_BtWifiAntNum(padapter) == Ant_x1)
9479 			psTdmaCase = pHalData->bt_coexist.halCoex8723.btdm1Ant.curPsTdma;
9480 		else
9481 			psTdmaCase = pHalData->bt_coexist.halCoex8723.btdm2Ant.curPsTdma;
9482 		rsprintf(btCoexDbgBuf, BT_TMP_BUF_SIZE, "\r\n %-35s = %02x %02x %02x %02x %02x case-%d", "PS TDMA(0x3a)", \
9483 			pHalData->bt_coexist.fw3aVal[0], pHalData->bt_coexist.fw3aVal[1],
9484 			pHalData->bt_coexist.fw3aVal[2], pHalData->bt_coexist.fw3aVal[3],
9485 			pHalData->bt_coexist.fw3aVal[4], psTdmaCase);
9486 		DCMD_Printf(btCoexDbgBuf);
9487 
9488 		rsprintf(btCoexDbgBuf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d ", "Decrease Bt Power", \
9489 			pBtCoex->btdm2Ant.bCurDecBtPwr);
9490 		DCMD_Printf(btCoexDbgBuf);
9491 	}
9492 	u1Tmp = rtl8723au_read8(padapter, 0x778);
9493 	u1Tmp1 = rtl8723au_read8(padapter, 0x783);
9494 	u1Tmp2 = rtl8723au_read8(padapter, 0x796);
9495 	rsprintf(btCoexDbgBuf, BT_TMP_BUF_SIZE, "\r\n %-35s = 0x%x/ 0x%x/ 0x%x", "0x778/ 0x783/ 0x796", \
9496 		u1Tmp, u1Tmp1, u1Tmp2);
9497 	DCMD_Printf(btCoexDbgBuf);
9498 
9499 	if (!pBtMgnt->ExtConfig.bManualControl) {
9500 		rsprintf(btCoexDbgBuf, BT_TMP_BUF_SIZE, "\r\n %-35s = 0x%x / 0x%x", "Sw DacSwing Ctrl/Val", \
9501 			pBtCoex->btdm2Ant.bCurDacSwingOn, pBtCoex->btdm2Ant.curDacSwingLvl);
9502 		DCMD_Printf(btCoexDbgBuf);
9503 	}
9504 	u4Tmp[0] =  rtl8723au_read32(padapter, 0x880);
9505 	rsprintf(btCoexDbgBuf, BT_TMP_BUF_SIZE, "\r\n %-35s = 0x%x", "0x880", \
9506 		u4Tmp[0]);
9507 	DCMD_Printf(btCoexDbgBuf);
9508 
9509 	/*  Hw mechanism */
9510 	if (!pBtMgnt->ExtConfig.bManualControl) {
9511 		rsprintf(btCoexDbgBuf, BT_TMP_BUF_SIZE, "\r\n %-35s", "============[Hw BT Coex mechanism]============");
9512 		DCMD_Printf(btCoexDbgBuf);
9513 	}
9514 
9515 	u1Tmp = rtl8723au_read8(padapter, 0x40);
9516 	rsprintf(btCoexDbgBuf, BT_TMP_BUF_SIZE, "\r\n %-35s = 0x%x", "0x40", \
9517 		u1Tmp);
9518 	DCMD_Printf(btCoexDbgBuf);
9519 
9520 	u4Tmp[0] = rtl8723au_read32(padapter, 0x550);
9521 	u1Tmp = rtl8723au_read8(padapter, 0x522);
9522 	rsprintf(btCoexDbgBuf, BT_TMP_BUF_SIZE, "\r\n %-35s = 0x%x/0x%x", "0x550(bcn contrl)/0x522", \
9523 		u4Tmp[0], u1Tmp);
9524 	DCMD_Printf(btCoexDbgBuf);
9525 
9526 	u4Tmp[0] = rtl8723au_read32(padapter, 0x484);
9527 	rsprintf(btCoexDbgBuf, BT_TMP_BUF_SIZE, "\r\n %-35s = 0x%x", "0x484(rate adaptive)", \
9528 		u4Tmp[0]);
9529 	DCMD_Printf(btCoexDbgBuf);
9530 
9531 	u4Tmp[0] = rtl8723au_read32(padapter, 0x50);
9532 	rsprintf(btCoexDbgBuf, BT_TMP_BUF_SIZE, "\r\n %-35s = 0x%x", "0xc50(dig)", \
9533 		u4Tmp[0]);
9534 	DCMD_Printf(btCoexDbgBuf);
9535 
9536 	u4Tmp[0] = rtl8723au_read32(padapter, 0xda0);
9537 	u4Tmp[1] = rtl8723au_read32(padapter, 0xda4);
9538 	u4Tmp[2] = rtl8723au_read32(padapter, 0xda8);
9539 	u4Tmp[3] = rtl8723au_read32(padapter, 0xdac);
9540 	rsprintf(btCoexDbgBuf, BT_TMP_BUF_SIZE, "\r\n %-35s = 0x%x/ 0x%x/ 0x%x/ 0x%x", "0xda0/0xda4/0xda8/0xdac(FA cnt)", \
9541 		u4Tmp[0], u4Tmp[1], u4Tmp[2], u4Tmp[3]);
9542 	DCMD_Printf(btCoexDbgBuf);
9543 
9544 	u4Tmp[0] = rtl8723au_read32(padapter, 0x6c0);
9545 	u4Tmp[1] = rtl8723au_read32(padapter, 0x6c4);
9546 	u4Tmp[2] = rtl8723au_read32(padapter, 0x6c8);
9547 	u1Tmp = rtl8723au_read8(padapter, 0x6cc);
9548 	rsprintf(btCoexDbgBuf, BT_TMP_BUF_SIZE, "\r\n %-35s = 0x%x/ 0x%x/ 0x%x/ 0x%x", "0x6c0/0x6c4/0x6c8/0x6cc(coexTable)", \
9549 		u4Tmp[0], u4Tmp[1], u4Tmp[2], u1Tmp);
9550 	DCMD_Printf(btCoexDbgBuf);
9551 
9552 	/* u4Tmp = rtl8723au_read32(padapter, 0x770); */
9553 	rsprintf(btCoexDbgBuf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d / %d", "0x770(Hi pri Rx[31:16]/Tx[15:0])", \
9554 		pHalData->bt_coexist.halCoex8723.highPriorityRx,
9555 		pHalData->bt_coexist.halCoex8723.highPriorityTx);
9556 	DCMD_Printf(btCoexDbgBuf);
9557 	/* u4Tmp = rtl8723au_read32(padapter, 0x774); */
9558 	rsprintf(btCoexDbgBuf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d / %d", "0x774(Lo pri Rx[31:16]/Tx[15:0])", \
9559 		pHalData->bt_coexist.halCoex8723.lowPriorityRx,
9560 		pHalData->bt_coexist.halCoex8723.lowPriorityTx);
9561 	DCMD_Printf(btCoexDbgBuf);
9562 
9563 	/*  Tx mgnt queue hang or not, 0x41b should = 0xf, ex: 0xd ==>hang */
9564 	u1Tmp = rtl8723au_read8(padapter, 0x41b);
9565 	rsprintf(btCoexDbgBuf, BT_TMP_BUF_SIZE, "\r\n %-35s = 0x%x", "0x41b (hang chk == 0xf)", \
9566 		u1Tmp);
9567 	DCMD_Printf(btCoexDbgBuf);
9568 	rsprintf(btCoexDbgBuf, BT_TMP_BUF_SIZE, "\r\n %-35s = 0x%x", "lastHMEBoxNum", \
9569 		pHalData->LastHMEBoxNum);
9570 	DCMD_Printf(btCoexDbgBuf);
9571 }
9572 
9573 static void
BTDM_8723ASignalCompensation(struct rtw_adapter * padapter,u8 * rssi_wifi,u8 * rssi_bt)9574 BTDM_8723ASignalCompensation(struct rtw_adapter *padapter,
9575 			     u8 *rssi_wifi, u8 *rssi_bt)
9576 {
9577 	if (btdm_BtWifiAntNum(padapter) == Ant_x1)
9578 		BTDM_1AntSignalCompensation(padapter, rssi_wifi, rssi_bt);
9579 }
9580 
BTDM_8723AInit(struct rtw_adapter * padapter)9581 static void BTDM_8723AInit(struct rtw_adapter *padapter)
9582 {
9583 	if (btdm_BtWifiAntNum(padapter) == Ant_x2)
9584 		BTDM_2AntParaInit(padapter);
9585 	else
9586 		BTDM_1AntParaInit(padapter);
9587 }
9588 
BTDM_HWCoexAllOff8723A(struct rtw_adapter * padapter)9589 static void BTDM_HWCoexAllOff8723A(struct rtw_adapter *padapter)
9590 {
9591 	struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
9592 	struct bt_mgnt *pBtMgnt = &pBTInfo->BtMgnt;
9593 
9594 	if (pBtMgnt->ExtConfig.bManualControl)
9595 		return;
9596 
9597 	if (btdm_BtWifiAntNum(padapter) == Ant_x2)
9598 		BTDM_2AntHwCoexAllOff8723A(padapter);
9599 }
9600 
BTDM_FWCoexAllOff8723A(struct rtw_adapter * padapter)9601 static void BTDM_FWCoexAllOff8723A(struct rtw_adapter *padapter)
9602 {
9603 	struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
9604 	struct bt_mgnt *pBtMgnt = &pBTInfo->BtMgnt;
9605 
9606 	if (pBtMgnt->ExtConfig.bManualControl)
9607 		return;
9608 
9609 	if (btdm_BtWifiAntNum(padapter) == Ant_x2)
9610 		BTDM_2AntFwCoexAllOff8723A(padapter);
9611 }
9612 
BTDM_SWCoexAllOff8723A(struct rtw_adapter * padapter)9613 static void BTDM_SWCoexAllOff8723A(struct rtw_adapter *padapter)
9614 {
9615 	struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
9616 	struct bt_mgnt *pBtMgnt = &pBTInfo->BtMgnt;
9617 
9618 	if (pBtMgnt->ExtConfig.bManualControl)
9619 		return;
9620 
9621 	if (btdm_BtWifiAntNum(padapter) == Ant_x2)
9622 		BTDM_2AntSwCoexAllOff8723A(padapter);
9623 }
9624 
9625 static void
BTDM_Set8723ABtCoexCurrAntNum(struct rtw_adapter * padapter,u8 antNum)9626 BTDM_Set8723ABtCoexCurrAntNum(struct rtw_adapter *padapter, u8 antNum)
9627 {
9628 	struct hal_data_8723a *pHalData = GET_HAL_DATA(padapter);
9629 	struct bt_coexist_8723a *pBtCoex = &pHalData->bt_coexist.halCoex8723;
9630 
9631 	if (antNum == 1)
9632 		pBtCoex->TotalAntNum = Ant_x1;
9633 	else if (antNum == 2)
9634 		pBtCoex->TotalAntNum = Ant_x2;
9635 }
9636 
rtl8723a_BT_lps_leave(struct rtw_adapter * padapter)9637 void rtl8723a_BT_lps_leave(struct rtw_adapter *padapter)
9638 {
9639 	struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
9640 	struct bt_mgnt *pBtMgnt = &pBTInfo->BtMgnt;
9641 
9642 	if (pBtMgnt->ExtConfig.bManualControl)
9643 		return;
9644 
9645 	if (btdm_BtWifiAntNum(padapter) == Ant_x1)
9646 		BTDM_1AntLpsLeave(padapter);
9647 }
9648 
BTDM_ForHalt8723A(struct rtw_adapter * padapter)9649 static void BTDM_ForHalt8723A(struct rtw_adapter *padapter)
9650 {
9651 	struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
9652 	struct bt_mgnt *pBtMgnt = &pBTInfo->BtMgnt;
9653 
9654 	if (pBtMgnt->ExtConfig.bManualControl)
9655 		return;
9656 
9657 	if (btdm_BtWifiAntNum(padapter) == Ant_x1)
9658 		BTDM_1AntForHalt(padapter);
9659 }
9660 
BTDM_WifiScanNotify8723A(struct rtw_adapter * padapter,u8 scanType)9661 static void BTDM_WifiScanNotify8723A(struct rtw_adapter *padapter, u8 scanType)
9662 {
9663 	struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
9664 	struct bt_mgnt *pBtMgnt = &pBTInfo->BtMgnt;
9665 
9666 	if (pBtMgnt->ExtConfig.bManualControl)
9667 		return;
9668 
9669 	if (btdm_BtWifiAntNum(padapter) == Ant_x1)
9670 		BTDM_1AntWifiScanNotify(padapter, scanType);
9671 }
9672 
9673 static void
BTDM_WifiAssociateNotify8723A(struct rtw_adapter * padapter,u8 action)9674 BTDM_WifiAssociateNotify8723A(struct rtw_adapter *padapter, u8 action)
9675 {
9676 	struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
9677 	struct bt_mgnt *pBtMgnt = &pBTInfo->BtMgnt;
9678 
9679 	if (pBtMgnt->ExtConfig.bManualControl)
9680 		return;
9681 
9682 	if (btdm_BtWifiAntNum(padapter) == Ant_x1)
9683 		BTDM_1AntWifiAssociateNotify(padapter, action);
9684 }
9685 
9686 static void
BTDM_MediaStatusNotify8723A(struct rtw_adapter * padapter,enum rt_media_status mstatus)9687 BTDM_MediaStatusNotify8723A(struct rtw_adapter *padapter,
9688 			    enum rt_media_status mstatus)
9689 {
9690 	struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
9691 	struct bt_mgnt *pBtMgnt = &pBTInfo->BtMgnt;
9692 
9693 	RTPRINT(FBT, BT_TRACE, ("[BTCoex], MediaStatusNotify, %s\n",
9694 		mstatus?"connect":"disconnect"));
9695 
9696 	BTDM_SetFwChnlInfo(padapter, mstatus);
9697 
9698 	if (pBtMgnt->ExtConfig.bManualControl)
9699 		return;
9700 
9701 	if (btdm_BtWifiAntNum(padapter) == Ant_x1)
9702 		BTDM_1AntMediaStatusNotify(padapter, mstatus);
9703 }
9704 
BTDM_ForDhcp8723A(struct rtw_adapter * padapter)9705 static void BTDM_ForDhcp8723A(struct rtw_adapter *padapter)
9706 {
9707 	struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
9708 	struct bt_mgnt *pBtMgnt = &pBTInfo->BtMgnt;
9709 
9710 	if (pBtMgnt->ExtConfig.bManualControl)
9711 		return;
9712 
9713 	if (btdm_BtWifiAntNum(padapter) == Ant_x1)
9714 		BTDM_1AntForDhcp(padapter);
9715 }
9716 
rtl8723a_BT_using_antenna_1(struct rtw_adapter * padapter)9717 bool rtl8723a_BT_using_antenna_1(struct rtw_adapter *padapter)
9718 {
9719 	if (btdm_BtWifiAntNum(padapter) == Ant_x1)
9720 		return true;
9721 	else
9722 		return false;
9723 }
9724 
BTDM_BTCoexist8723A(struct rtw_adapter * padapter)9725 static void BTDM_BTCoexist8723A(struct rtw_adapter *padapter)
9726 {
9727 	struct hal_data_8723a *pHalData;
9728 	struct bt_30info *pBTInfo;
9729 	struct bt_mgnt *pBtMgnt;
9730 	struct bt_coexist_8723a *pBtCoex;
9731 
9732 	pHalData = GET_HAL_DATA(padapter);
9733 	pBTInfo = GET_BT_INFO(padapter);
9734 	pBtMgnt = &pBTInfo->BtMgnt;
9735 	pBtCoex = &pHalData->bt_coexist.halCoex8723;
9736 
9737 	RTPRINT(FBT, BT_TRACE, ("[BTCoex], beacon RSSI = 0x%x(%d)\n",
9738 		pHalData->dmpriv.EntryMinUndecoratedSmoothedPWDB,
9739 		pHalData->dmpriv.EntryMinUndecoratedSmoothedPWDB));
9740 
9741 	btdm_BtHwCountersMonitor(padapter);
9742 	btdm_BtEnableDisableCheck8723A(padapter);
9743 
9744 	if (pBtMgnt->ExtConfig.bManualControl) {
9745 		RTPRINT(FBT, BT_TRACE, ("%s: Action Manual control!!\n", __func__));
9746 		return;
9747 	}
9748 
9749 	if (pBtCoex->bC2hBtInfoReqSent) {
9750 		if (!rtl8723a_BT_enabled(padapter)) {
9751 			pBtCoex->c2hBtInfo = BT_INFO_STATE_DISABLED;
9752 		} else {
9753 			if (pBtCoex->c2hBtInfo == BT_INFO_STATE_DISABLED)
9754 				pBtCoex->c2hBtInfo = BT_INFO_STATE_NO_CONNECTION;
9755 		}
9756 
9757 		btdm_BTCoexist8723AHandler(padapter);
9758 	} else if (!rtl8723a_BT_enabled(padapter)) {
9759 		pBtCoex->c2hBtInfo = BT_INFO_STATE_DISABLED;
9760 		btdm_BTCoexist8723AHandler(padapter);
9761 	}
9762 
9763 	BTDM_QueryBtInformation(padapter);
9764 }
9765 
9766 /*  ===== End of sync from SD7 driver HAL/BTCoexist/HalBtc8723.c ===== */
9767 
9768 /*  ===== Below this line is sync from SD7 driver HAL/BTCoexist/HalBtcCsr1Ant.c ===== */
9769 
9770 /*  local function start with btdm_ */
9771 /*  extern function start with BTDM_ */
9772 
BTDM_SetAntenna(struct rtw_adapter * padapter,u8 who)9773 static void BTDM_SetAntenna(struct rtw_adapter *padapter, u8 who)
9774 {
9775 }
9776 
9777 void
BTDM_SingleAnt(struct rtw_adapter * padapter,u8 bSingleAntOn,u8 bInterruptOn,u8 bMultiNAVOn)9778 BTDM_SingleAnt(
9779 	struct rtw_adapter *padapter,
9780 	u8 bSingleAntOn,
9781 	u8 bInterruptOn,
9782 	u8 bMultiNAVOn
9783 	)
9784 {
9785 	struct hal_data_8723a *pHalData = GET_HAL_DATA(padapter);
9786 	u8 H2C_Parameter[3] = {0};
9787 
9788 	if (pHalData->bt_coexist.BT_Ant_Num != Ant_x1)
9789 		return;
9790 
9791 	H2C_Parameter[2] = 0;
9792 	H2C_Parameter[1] = 0;
9793 	H2C_Parameter[0] = 0;
9794 
9795 	if (bInterruptOn) {
9796 		H2C_Parameter[2] |= 0x02;	/* BIT1 */
9797 		pHalData->bt_coexist.bFWCoexistAllOff = false;
9798 	}
9799 	pHalData->bt_coexist.bInterruptOn = bInterruptOn;
9800 
9801 	if (bSingleAntOn) {
9802 		H2C_Parameter[2] |= 0x10;	/* BIT4 */
9803 		pHalData->bt_coexist.bFWCoexistAllOff = false;
9804 	}
9805 	pHalData->bt_coexist.bSingleAntOn = bSingleAntOn;
9806 
9807 	if (bMultiNAVOn) {
9808 		H2C_Parameter[2] |= 0x20;	/* BIT5 */
9809 		pHalData->bt_coexist.bFWCoexistAllOff = false;
9810 	}
9811 	pHalData->bt_coexist.bMultiNAVOn = bMultiNAVOn;
9812 
9813 	RTPRINT(FBT, BT_TRACE, ("[DM][BT], SingleAntenna =[%s:%s:%s], write 0xe = 0x%x\n",
9814 		bSingleAntOn?"ON":"OFF", bInterruptOn?"ON":"OFF", bMultiNAVOn?"ON":"OFF",
9815 		H2C_Parameter[0]<<16|H2C_Parameter[1]<<8|H2C_Parameter[2]));
9816 }
9817 
BTDM_CheckBTIdleChange1Ant(struct rtw_adapter * padapter)9818 void BTDM_CheckBTIdleChange1Ant(struct rtw_adapter *padapter)
9819 {
9820 	struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
9821 	struct bt_mgnt *pBtMgnt = &pBTInfo->BtMgnt;
9822 	struct hal_data_8723a *pHalData = GET_HAL_DATA(padapter);
9823 /*PMGNT_INFO		pMgntInfo = &padapter->MgntInfo; */
9824 	u8 	stateChange = false;
9825 	u32			BT_Polling, Ratio_Act, Ratio_STA;
9826 	u32				BT_Active, BT_State;
9827 	u32				regBTActive = 0, regBTState = 0, regBTPolling = 0;
9828 
9829 	if (!rtl8723a_BT_coexist(padapter))
9830 		return;
9831 	if (pBtMgnt->ExtConfig.bManualControl)
9832 		return;
9833 	if (pHalData->bt_coexist.BT_CoexistType != BT_CSR_BC8)
9834 		return;
9835 	if (pHalData->bt_coexist.BT_Ant_Num != Ant_x1)
9836 		return;
9837 
9838 	/*  The following we only consider CSR BC8 and fw version should be >= 62 */
9839 	RTPRINT(FBT, BT_TRACE, ("[DM][BT], FirmwareVersion = 0x%x(%d)\n",
9840 	pHalData->FirmwareVersion, pHalData->FirmwareVersion));
9841 	regBTActive = REG_BT_ACTIVE;
9842 	regBTState = REG_BT_STATE;
9843 	if (pHalData->FirmwareVersion >= FW_VER_BT_REG1)
9844 		regBTPolling = REG_BT_POLLING1;
9845 	else
9846 		regBTPolling = REG_BT_POLLING;
9847 
9848 	BT_Active = rtl8723au_read32(padapter, regBTActive);
9849 	RTPRINT(FBT, BT_TRACE, ("[DM][BT], BT_Active(0x%x) =%x\n", regBTActive, BT_Active));
9850 	BT_Active = BT_Active & 0x00ffffff;
9851 
9852 	BT_State = rtl8723au_read32(padapter, regBTState);
9853 	RTPRINT(FBT, BT_TRACE, ("[DM][BT], BT_State(0x%x) =%x\n", regBTState, BT_State));
9854 	BT_State = BT_State & 0x00ffffff;
9855 
9856 	BT_Polling = rtl8723au_read32(padapter, regBTPolling);
9857 	RTPRINT(FBT, BT_TRACE, ("[DM][BT], BT_Polling(0x%x) =%x\n", regBTPolling, BT_Polling));
9858 
9859 	if (BT_Active == 0xffffffff && BT_State == 0xffffffff && BT_Polling == 0xffffffff)
9860 		return;
9861 	if (BT_Polling == 0)
9862 		return;
9863 
9864 	Ratio_Act = BT_Active*1000/BT_Polling;
9865 	Ratio_STA = BT_State*1000/BT_Polling;
9866 
9867 	pHalData->bt_coexist.Ratio_Tx = Ratio_Act;
9868 	pHalData->bt_coexist.Ratio_PRI = Ratio_STA;
9869 
9870 	RTPRINT(FBT, BT_TRACE, ("[DM][BT], Ratio_Act =%d\n", Ratio_Act));
9871 	RTPRINT(FBT, BT_TRACE, ("[DM][BT], Ratio_STA =%d\n", Ratio_STA));
9872 
9873 	if (Ratio_STA < 60 && Ratio_Act < 500) {	/*  BT PAN idle */
9874 		pHalData->bt_coexist.CurrentState |= BT_COEX_STATE_BT_PAN_IDLE;
9875 		pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_BT_PAN_DOWNLINK;
9876 		pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_BT_PAN_UPLINK;
9877 	} else {
9878 		pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_BT_PAN_IDLE;
9879 
9880 		if (Ratio_STA) {
9881 			/*  Check if BT PAN (under BT 2.1) is uplink or downlink */
9882 			if ((Ratio_Act/Ratio_STA) < 2) {
9883 				/*  BT PAN Uplink */
9884 				pHalData->bt_coexist.BT21TrafficStatistics.bTxBusyTraffic = true;
9885 				pHalData->bt_coexist.CurrentState |= BT_COEX_STATE_BT_PAN_UPLINK;
9886 				pHalData->bt_coexist.BT21TrafficStatistics.bRxBusyTraffic = false;
9887 				pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_BT_PAN_DOWNLINK;
9888 			} else {
9889 				/*  BT PAN downlink */
9890 				pHalData->bt_coexist.BT21TrafficStatistics.bTxBusyTraffic = false;
9891 				pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_BT_PAN_UPLINK;
9892 				pHalData->bt_coexist.BT21TrafficStatistics.bRxBusyTraffic = true;
9893 				pHalData->bt_coexist.CurrentState |= BT_COEX_STATE_BT_PAN_DOWNLINK;
9894 			}
9895 		} else {
9896 			/*  BT PAN downlink */
9897 			pHalData->bt_coexist.BT21TrafficStatistics.bTxBusyTraffic = false;
9898 			pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_BT_PAN_UPLINK;
9899 			pHalData->bt_coexist.BT21TrafficStatistics.bRxBusyTraffic = true;
9900 			pHalData->bt_coexist.CurrentState |= BT_COEX_STATE_BT_PAN_DOWNLINK;
9901 		}
9902 	}
9903 
9904 	/*  Check BT is idle or not */
9905 	if (pBtMgnt->ExtConfig.NumberOfHandle == 0 &&
9906 	    pBtMgnt->ExtConfig.NumberOfSCO == 0) {
9907 		pBtMgnt->ExtConfig.bBTBusy = false;
9908 		pHalData->bt_coexist.CurrentState |= BT_COEX_STATE_BT_IDLE;
9909 	} else {
9910 		if (Ratio_STA < 60) {
9911 			pBtMgnt->ExtConfig.bBTBusy = false;
9912 			pHalData->bt_coexist.CurrentState |= BT_COEX_STATE_BT_IDLE;
9913 		} else {
9914 			pBtMgnt->ExtConfig.bBTBusy = true;
9915 			pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_BT_IDLE;
9916 		}
9917 	}
9918 
9919 	if (pBtMgnt->ExtConfig.NumberOfHandle == 0 &&
9920 	    pBtMgnt->ExtConfig.NumberOfSCO == 0) {
9921 		pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_BT_RSSI_LOW;
9922 		pBtMgnt->ExtConfig.MIN_BT_RSSI = 0;
9923 		BTDM_SetAntenna(padapter, BTDM_ANT_BT_IDLE);
9924 	} else {
9925 		if (pBtMgnt->ExtConfig.MIN_BT_RSSI <= -5) {
9926 			pHalData->bt_coexist.CurrentState |= BT_COEX_STATE_BT_RSSI_LOW;
9927 			RTPRINT(FBT, BT_TRACE, ("[DM][BT], core stack notify bt rssi Low\n"));
9928 		} else {
9929 			pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_BT_RSSI_LOW;
9930 			RTPRINT(FBT, BT_TRACE, ("[DM][BT], core stack notify bt rssi Normal\n"));
9931 		}
9932 	}
9933 
9934 	if (pHalData->bt_coexist.bBTBusyTraffic != pBtMgnt->ExtConfig.bBTBusy) {
9935 		/*  BT idle or BT non-idle */
9936 		pHalData->bt_coexist.bBTBusyTraffic = pBtMgnt->ExtConfig.bBTBusy;
9937 		stateChange = true;
9938 	}
9939 
9940 	if (stateChange) {
9941 		if (!pBtMgnt->ExtConfig.bBTBusy)
9942 			RTPRINT(FBT, BT_TRACE, ("[DM][BT], BT is idle or disable\n"));
9943 		else
9944 			RTPRINT(FBT, BT_TRACE, ("[DM][BT], BT is non-idle\n"));
9945 	}
9946 	if (!pBtMgnt->ExtConfig.bBTBusy) {
9947 		RTPRINT(FBT, BT_TRACE, ("[DM][BT], BT is idle or disable\n"));
9948 		if (check_fwstate(&padapter->mlmepriv, WIFI_UNDER_LINKING|WIFI_SITE_MONITOR) == true)
9949 			BTDM_SetAntenna(padapter, BTDM_ANT_WIFI);
9950 	}
9951 }
9952 
9953 /*  ===== End of sync from SD7 driver HAL/BTCoexist/HalBtcCsr1Ant.c ===== */
9954 
9955 /*  ===== Below this line is sync from SD7 driver HAL/BTCoexist/HalBtcCsr2Ant.c ===== */
9956 
9957 /*  local function start with btdm_ */
9958 
9959 /*  Note: */
9960 /*  In the following, FW should be done before SW mechanism. */
9961 /*  BTDM_Balance(), BTDM_DiminishWiFi(), BT_NAV() should be done */
9962 /*  before BTDM_AGCTable(), BTDM_BBBackOffLevel(), btdm_DacSwing(). */
9963 
9964 /*  extern function start with BTDM_ */
9965 
9966 void
BTDM_DiminishWiFi(struct rtw_adapter * padapter,u8 bDACOn,u8 bInterruptOn,u8 DACSwingLevel,u8 bNAVOn)9967 BTDM_DiminishWiFi(
9968 	struct rtw_adapter *padapter,
9969 	u8 bDACOn,
9970 	u8 bInterruptOn,
9971 	u8 DACSwingLevel,
9972 	u8 bNAVOn
9973 	)
9974 {
9975 	struct hal_data_8723a *pHalData = GET_HAL_DATA(padapter);
9976 	u8 H2C_Parameter[3] = {0};
9977 
9978 	if (pHalData->bt_coexist.BT_Ant_Num != Ant_x2)
9979 		return;
9980 
9981 	if ((pHalData->bt_coexist.CurrentState & BT_COEX_STATE_BT_RSSI_LOW) &&
9982 	    (DACSwingLevel == 0x20)) {
9983 		RTPRINT(FBT, BT_TRACE, ("[BT]DiminishWiFi 0x20 original, but set 0x18 for Low RSSI!\n"));
9984 		DACSwingLevel = 0x18;
9985 	}
9986 
9987 	H2C_Parameter[2] = 0;
9988 	H2C_Parameter[1] = DACSwingLevel;
9989 	H2C_Parameter[0] = 0;
9990 	if (bDACOn) {
9991 		H2C_Parameter[2] |= 0x01;	/* BIT0 */
9992 		if (bInterruptOn)
9993 			H2C_Parameter[2] |= 0x02;	/* BIT1 */
9994 		pHalData->bt_coexist.bFWCoexistAllOff = false;
9995 	}
9996 	if (bNAVOn) {
9997 		H2C_Parameter[2] |= 0x08;	/* BIT3 */
9998 		pHalData->bt_coexist.bFWCoexistAllOff = false;
9999 	}
10000 
10001 	RTPRINT(FBT, BT_TRACE, ("[DM][BT], bDACOn = %s, bInterruptOn = %s, write 0xe = 0x%x\n",
10002 		bDACOn?"ON":"OFF", bInterruptOn?"ON":"OFF",
10003 		H2C_Parameter[0]<<16|H2C_Parameter[1]<<8|H2C_Parameter[2]));
10004 	RTPRINT(FBT, BT_TRACE, ("[DM][BT], bNAVOn = %s\n",
10005 		bNAVOn?"ON":"OFF"));
10006 }
10007 
10008 /*  ===== End of sync from SD7 driver HAL/BTCoexist/HalBtcCsr2Ant.c ===== */
10009 
10010 /*  ===== Below this line is sync from SD7 driver HAL/BTCoexist/HalBtCoexist.c ===== */
10011 
10012 /*  local function */
btdm_ResetFWCoexState(struct rtw_adapter * padapter)10013 static void btdm_ResetFWCoexState(struct rtw_adapter *padapter)
10014 {
10015 	struct hal_data_8723a *pHalData = GET_HAL_DATA(padapter);
10016 
10017 	pHalData->bt_coexist.CurrentState = 0;
10018 	pHalData->bt_coexist.PreviousState = 0;
10019 }
10020 
btdm_InitBtCoexistDM(struct rtw_adapter * padapter)10021 static void btdm_InitBtCoexistDM(struct rtw_adapter *padapter)
10022 {
10023 	struct hal_data_8723a *pHalData = GET_HAL_DATA(padapter);
10024 
10025 	/*  20100415 Joseph: Restore RF register 0x1E and 0x1F value for further usage. */
10026 	pHalData->bt_coexist.BtRfRegOrigin1E = PHY_QueryRFReg(padapter, PathA, RF_RCK1, bRFRegOffsetMask);
10027 	pHalData->bt_coexist.BtRfRegOrigin1F = PHY_QueryRFReg(padapter, PathA, RF_RCK2, 0xf0);
10028 
10029 	pHalData->bt_coexist.CurrentState = 0;
10030 	pHalData->bt_coexist.PreviousState = 0;
10031 
10032 	BTDM_8723AInit(padapter);
10033 	pHalData->bt_coexist.bInitlized = true;
10034 }
10035 
10036 /*  */
10037 /*  extern function */
10038 /*  */
BTDM_CheckAntSelMode(struct rtw_adapter * padapter)10039 void BTDM_CheckAntSelMode(struct rtw_adapter *padapter)
10040 {
10041 }
10042 
BTDM_FwC2hBtRssi(struct rtw_adapter * padapter,u8 * tmpBuf)10043 void BTDM_FwC2hBtRssi(struct rtw_adapter *padapter, u8 *tmpBuf)
10044 {
10045 	BTDM_FwC2hBtRssi8723A(padapter, tmpBuf);
10046 }
10047 
BTDM_DisplayBtCoexInfo(struct rtw_adapter * padapter)10048 void BTDM_DisplayBtCoexInfo(struct rtw_adapter *padapter)
10049 {
10050 	BTDM_Display8723ABtCoexInfo(padapter);
10051 }
10052 
BTDM_RejectAPAggregatedPacket(struct rtw_adapter * padapter,u8 bReject)10053 void BTDM_RejectAPAggregatedPacket(struct rtw_adapter *padapter, u8 bReject)
10054 {
10055 }
10056 
BTDM_IsHT40(struct rtw_adapter * padapter)10057 u8 BTDM_IsHT40(struct rtw_adapter *padapter)
10058 {
10059 	u8 isht40 = true;
10060 	enum ht_channel_width bw;
10061 
10062 	bw = padapter->mlmeextpriv.cur_bwmode;
10063 
10064 	if (bw == HT_CHANNEL_WIDTH_20)
10065 		isht40 = false;
10066 	else if (bw == HT_CHANNEL_WIDTH_40)
10067 		isht40 = true;
10068 
10069 	return isht40;
10070 }
10071 
BTDM_Legacy(struct rtw_adapter * padapter)10072 u8 BTDM_Legacy(struct rtw_adapter *padapter)
10073 {
10074 	struct mlme_ext_priv *pmlmeext;
10075 	u8 isLegacy = false;
10076 
10077 	pmlmeext = &padapter->mlmeextpriv;
10078 	if ((pmlmeext->cur_wireless_mode == WIRELESS_11B) ||
10079 		(pmlmeext->cur_wireless_mode == WIRELESS_11G) ||
10080 		(pmlmeext->cur_wireless_mode == WIRELESS_11BG))
10081 		isLegacy = true;
10082 
10083 	return isLegacy;
10084 }
10085 
BTDM_CheckWiFiState(struct rtw_adapter * padapter)10086 void BTDM_CheckWiFiState(struct rtw_adapter *padapter)
10087 {
10088 	struct hal_data_8723a *pHalData;
10089 	struct mlme_priv *pmlmepriv;
10090 	struct bt_30info *pBTInfo;
10091 	struct bt_mgnt *pBtMgnt;
10092 
10093 	pHalData = GET_HAL_DATA(padapter);
10094 	pmlmepriv = &padapter->mlmepriv;
10095 	pBTInfo = GET_BT_INFO(padapter);
10096 	pBtMgnt = &pBTInfo->BtMgnt;
10097 
10098 	if (pmlmepriv->LinkDetectInfo.bBusyTraffic) {
10099 		pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_WIFI_IDLE;
10100 
10101 		if (pmlmepriv->LinkDetectInfo.bTxBusyTraffic)
10102 			pHalData->bt_coexist.CurrentState |= BT_COEX_STATE_WIFI_UPLINK;
10103 		else
10104 			pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_WIFI_UPLINK;
10105 
10106 		if (pmlmepriv->LinkDetectInfo.bRxBusyTraffic)
10107 			pHalData->bt_coexist.CurrentState |= BT_COEX_STATE_WIFI_DOWNLINK;
10108 		else
10109 			pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_WIFI_DOWNLINK;
10110 	} else {
10111 		pHalData->bt_coexist.CurrentState |= BT_COEX_STATE_WIFI_IDLE;
10112 		pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_WIFI_UPLINK;
10113 		pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_WIFI_DOWNLINK;
10114 	}
10115 
10116 	if (BTDM_Legacy(padapter)) {
10117 		pHalData->bt_coexist.CurrentState |= BT_COEX_STATE_WIFI_LEGACY;
10118 		pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_WIFI_HT20;
10119 		pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_WIFI_HT40;
10120 	} else {
10121 		pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_WIFI_LEGACY;
10122 		if (BTDM_IsHT40(padapter)) {
10123 			pHalData->bt_coexist.CurrentState |= BT_COEX_STATE_WIFI_HT40;
10124 			pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_WIFI_HT20;
10125 		} else {
10126 			pHalData->bt_coexist.CurrentState |= BT_COEX_STATE_WIFI_HT20;
10127 			pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_WIFI_HT40;
10128 		}
10129 	}
10130 
10131 	if (pBtMgnt->BtOperationOn)
10132 		pHalData->bt_coexist.CurrentState |= BT_COEX_STATE_BT30;
10133 	else
10134 		pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_BT30;
10135 }
10136 
BTDM_GetRxSS(struct rtw_adapter * padapter)10137 s32 BTDM_GetRxSS(struct rtw_adapter *padapter)
10138 {
10139 /*PMGNT_INFO		pMgntInfo = &padapter->MgntInfo; */
10140 	struct mlme_priv *pmlmepriv;
10141 	struct hal_data_8723a *pHalData;
10142 	s32			UndecoratedSmoothedPWDB = 0;
10143 
10144 	pmlmepriv = &padapter->mlmepriv;
10145 	pHalData = GET_HAL_DATA(padapter);
10146 
10147 	if (check_fwstate(pmlmepriv, _FW_LINKED)) {
10148 		UndecoratedSmoothedPWDB = GET_UNDECORATED_AVERAGE_RSSI(padapter);
10149 	} else { /*  associated entry pwdb */
10150 		UndecoratedSmoothedPWDB = pHalData->dmpriv.EntryMinUndecoratedSmoothedPWDB;
10151 		/* pHalData->BT_EntryMinUndecoratedSmoothedPWDB */
10152 	}
10153 	RTPRINT(FBT, BT_TRACE, ("BTDM_GetRxSS() = %d\n", UndecoratedSmoothedPWDB));
10154 	return UndecoratedSmoothedPWDB;
10155 }
10156 
BTDM_GetRxBeaconSS(struct rtw_adapter * padapter)10157 static s32 BTDM_GetRxBeaconSS(struct rtw_adapter *padapter)
10158 {
10159 /*PMGNT_INFO		pMgntInfo = &padapter->MgntInfo; */
10160 	struct mlme_priv *pmlmepriv;
10161 	struct hal_data_8723a *pHalData;
10162 	s32			pwdbBeacon = 0;
10163 
10164 	pmlmepriv = &padapter->mlmepriv;
10165 	pHalData = GET_HAL_DATA(padapter);
10166 
10167 	if (check_fwstate(pmlmepriv, _FW_LINKED)) {
10168 		/* pwdbBeacon = pHalData->dmpriv.UndecoratedSmoothedBeacon; */
10169 		pwdbBeacon = pHalData->dmpriv.EntryMinUndecoratedSmoothedPWDB;
10170 	}
10171 	RTPRINT(FBT, BT_TRACE, ("BTDM_GetRxBeaconSS() = %d\n", pwdbBeacon));
10172 	return pwdbBeacon;
10173 }
10174 
10175 /*  Get beacon rssi state */
BTDM_CheckCoexBcnRssiState(struct rtw_adapter * padapter,u8 levelNum,u8 RssiThresh,u8 RssiThresh1)10176 u8 BTDM_CheckCoexBcnRssiState(struct rtw_adapter *padapter, u8 levelNum,
10177 			      u8 RssiThresh, u8 RssiThresh1)
10178 {
10179 	struct hal_data_8723a *pHalData = GET_HAL_DATA(padapter);
10180 	s32 pwdbBeacon = 0;
10181 	u8 bcnRssiState = 0;
10182 
10183 	pwdbBeacon = BTDM_GetRxBeaconSS(padapter);
10184 
10185 	if (levelNum == 2) {
10186 		pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_WIFI_RSSI_BEACON_MEDIUM;
10187 
10188 		if ((pHalData->bt_coexist.preRssiStateBeacon == BT_RSSI_STATE_LOW) ||
10189 		    (pHalData->bt_coexist.preRssiStateBeacon == BT_RSSI_STATE_STAY_LOW)) {
10190 			if (pwdbBeacon >= (RssiThresh+BT_FW_COEX_THRESH_TOL)) {
10191 				bcnRssiState = BT_RSSI_STATE_HIGH;
10192 				pHalData->bt_coexist.CurrentState |= BT_COEX_STATE_WIFI_RSSI_BEACON_HIGH;
10193 				pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_WIFI_RSSI_BEACON_LOW;
10194 				RTPRINT(FBT, BT_TRACE, ("[DM][BT], RSSI_BEACON state switch to High\n"));
10195 			} else {
10196 				bcnRssiState = BT_RSSI_STATE_STAY_LOW;
10197 				RTPRINT(FBT, BT_TRACE, ("[DM][BT], RSSI_BEACON state stay at Low\n"));
10198 			}
10199 		} else {
10200 			if (pwdbBeacon < RssiThresh) {
10201 				bcnRssiState = BT_RSSI_STATE_LOW;
10202 				pHalData->bt_coexist.CurrentState |= BT_COEX_STATE_WIFI_RSSI_BEACON_LOW;
10203 				pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_WIFI_RSSI_BEACON_HIGH;
10204 				RTPRINT(FBT, BT_TRACE, ("[DM][BT], RSSI_BEACON state switch to Low\n"));
10205 			} else {
10206 				bcnRssiState = BT_RSSI_STATE_STAY_HIGH;
10207 				RTPRINT(FBT, BT_TRACE, ("[DM][BT], RSSI_BEACON state stay at High\n"));
10208 			}
10209 		}
10210 	} else if (levelNum == 3) {
10211 		if (RssiThresh > RssiThresh1) {
10212 			RTPRINT(FBT, BT_TRACE, ("[DM][BT], RSSI_BEACON thresh error!!\n"));
10213 			return pHalData->bt_coexist.preRssiStateBeacon;
10214 		}
10215 
10216 		if ((pHalData->bt_coexist.preRssiStateBeacon == BT_RSSI_STATE_LOW) ||
10217 		    (pHalData->bt_coexist.preRssiStateBeacon == BT_RSSI_STATE_STAY_LOW)) {
10218 			if (pwdbBeacon >= (RssiThresh+BT_FW_COEX_THRESH_TOL)) {
10219 				bcnRssiState = BT_RSSI_STATE_MEDIUM;
10220 				pHalData->bt_coexist.CurrentState |= BT_COEX_STATE_WIFI_RSSI_BEACON_MEDIUM;
10221 				pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_WIFI_RSSI_BEACON_LOW;
10222 				pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_WIFI_RSSI_BEACON_HIGH;
10223 				RTPRINT(FBT, BT_TRACE, ("[DM][BT], RSSI_BEACON state switch to Medium\n"));
10224 			} else {
10225 				bcnRssiState = BT_RSSI_STATE_STAY_LOW;
10226 				RTPRINT(FBT, BT_TRACE, ("[DM][BT], RSSI_BEACON state stay at Low\n"));
10227 			}
10228 		} else if ((pHalData->bt_coexist.preRssiStateBeacon == BT_RSSI_STATE_MEDIUM) ||
10229 			   (pHalData->bt_coexist.preRssiStateBeacon == BT_RSSI_STATE_STAY_MEDIUM)) {
10230 			if (pwdbBeacon >= (RssiThresh1+BT_FW_COEX_THRESH_TOL)) {
10231 				bcnRssiState = BT_RSSI_STATE_HIGH;
10232 				pHalData->bt_coexist.CurrentState |= BT_COEX_STATE_WIFI_RSSI_BEACON_HIGH;
10233 				pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_WIFI_RSSI_BEACON_LOW;
10234 				pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_WIFI_RSSI_BEACON_MEDIUM;
10235 				RTPRINT(FBT, BT_TRACE, ("[DM][BT], RSSI_BEACON state switch to High\n"));
10236 			} else if (pwdbBeacon < RssiThresh) {
10237 				bcnRssiState = BT_RSSI_STATE_LOW;
10238 				pHalData->bt_coexist.CurrentState |= BT_COEX_STATE_WIFI_RSSI_BEACON_LOW;
10239 				pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_WIFI_RSSI_BEACON_HIGH;
10240 				pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_WIFI_RSSI_BEACON_MEDIUM;
10241 				RTPRINT(FBT, BT_TRACE, ("[DM][BT], RSSI_BEACON state switch to Low\n"));
10242 			} else {
10243 				bcnRssiState = BT_RSSI_STATE_STAY_MEDIUM;
10244 				RTPRINT(FBT, BT_TRACE, ("[DM][BT], RSSI_BEACON state stay at Medium\n"));
10245 			}
10246 		} else {
10247 			if (pwdbBeacon < RssiThresh1) {
10248 				bcnRssiState = BT_RSSI_STATE_MEDIUM;
10249 				pHalData->bt_coexist.CurrentState |= BT_COEX_STATE_WIFI_RSSI_BEACON_MEDIUM;
10250 				pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_WIFI_RSSI_BEACON_HIGH;
10251 				pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_WIFI_RSSI_BEACON_LOW;
10252 				RTPRINT(FBT, BT_TRACE, ("[DM][BT], RSSI_BEACON state switch to Medium\n"));
10253 			} else {
10254 				bcnRssiState = BT_RSSI_STATE_STAY_HIGH;
10255 				RTPRINT(FBT, BT_TRACE, ("[DM][BT], RSSI_BEACON state stay at High\n"));
10256 			}
10257 		}
10258 	}
10259 
10260 	pHalData->bt_coexist.preRssiStateBeacon = bcnRssiState;
10261 
10262 	return bcnRssiState;
10263 }
10264 
BTDM_CheckCoexRSSIState1(struct rtw_adapter * padapter,u8 levelNum,u8 RssiThresh,u8 RssiThresh1)10265 u8 BTDM_CheckCoexRSSIState1(struct rtw_adapter *padapter, u8 levelNum,
10266 			    u8 RssiThresh, u8 RssiThresh1)
10267 {
10268 	struct hal_data_8723a *pHalData = GET_HAL_DATA(padapter);
10269 	s32 UndecoratedSmoothedPWDB = 0;
10270 	u8 btRssiState = 0;
10271 
10272 	UndecoratedSmoothedPWDB = BTDM_GetRxSS(padapter);
10273 
10274 	if (levelNum == 2) {
10275 		pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_WIFI_RSSI_1_MEDIUM;
10276 
10277 		if ((pHalData->bt_coexist.preRssiState1 == BT_RSSI_STATE_LOW) ||
10278 		    (pHalData->bt_coexist.preRssiState1 == BT_RSSI_STATE_STAY_LOW)) {
10279 			if (UndecoratedSmoothedPWDB >= (RssiThresh+BT_FW_COEX_THRESH_TOL)) {
10280 				btRssiState = BT_RSSI_STATE_HIGH;
10281 				pHalData->bt_coexist.CurrentState |= BT_COEX_STATE_WIFI_RSSI_1_HIGH;
10282 				pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_WIFI_RSSI_1_LOW;
10283 				RTPRINT(FBT, BT_TRACE, ("[DM][BT], RSSI_1 state switch to High\n"));
10284 			} else {
10285 				btRssiState = BT_RSSI_STATE_STAY_LOW;
10286 				RTPRINT(FBT, BT_TRACE, ("[DM][BT], RSSI_1 state stay at Low\n"));
10287 			}
10288 		} else {
10289 			if (UndecoratedSmoothedPWDB < RssiThresh) {
10290 				btRssiState = BT_RSSI_STATE_LOW;
10291 				pHalData->bt_coexist.CurrentState |= BT_COEX_STATE_WIFI_RSSI_1_LOW;
10292 				pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_WIFI_RSSI_1_HIGH;
10293 				RTPRINT(FBT, BT_TRACE, ("[DM][BT], RSSI_1 state switch to Low\n"));
10294 			} else {
10295 				btRssiState = BT_RSSI_STATE_STAY_HIGH;
10296 				RTPRINT(FBT, BT_TRACE, ("[DM][BT], RSSI_1 state stay at High\n"));
10297 			}
10298 		}
10299 	} else if (levelNum == 3) {
10300 		if (RssiThresh > RssiThresh1) {
10301 			RTPRINT(FBT, BT_TRACE, ("[DM][BT], RSSI_1 thresh error!!\n"));
10302 			return pHalData->bt_coexist.preRssiState1;
10303 		}
10304 
10305 		if ((pHalData->bt_coexist.preRssiState1 == BT_RSSI_STATE_LOW) ||
10306 		    (pHalData->bt_coexist.preRssiState1 == BT_RSSI_STATE_STAY_LOW)) {
10307 			if (UndecoratedSmoothedPWDB >= (RssiThresh+BT_FW_COEX_THRESH_TOL)) {
10308 				btRssiState = BT_RSSI_STATE_MEDIUM;
10309 				pHalData->bt_coexist.CurrentState |= BT_COEX_STATE_WIFI_RSSI_1_MEDIUM;
10310 				pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_WIFI_RSSI_1_LOW;
10311 				pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_WIFI_RSSI_1_HIGH;
10312 				RTPRINT(FBT, BT_TRACE, ("[DM][BT], RSSI_1 state switch to Medium\n"));
10313 			} else {
10314 				btRssiState = BT_RSSI_STATE_STAY_LOW;
10315 				RTPRINT(FBT, BT_TRACE, ("[DM][BT], RSSI_1 state stay at Low\n"));
10316 			}
10317 		} else if ((pHalData->bt_coexist.preRssiState1 == BT_RSSI_STATE_MEDIUM) ||
10318 			   (pHalData->bt_coexist.preRssiState1 == BT_RSSI_STATE_STAY_MEDIUM)) {
10319 			if (UndecoratedSmoothedPWDB >= (RssiThresh1+BT_FW_COEX_THRESH_TOL)) {
10320 				btRssiState = BT_RSSI_STATE_HIGH;
10321 				pHalData->bt_coexist.CurrentState |= BT_COEX_STATE_WIFI_RSSI_1_HIGH;
10322 				pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_WIFI_RSSI_1_LOW;
10323 				pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_WIFI_RSSI_1_MEDIUM;
10324 				RTPRINT(FBT, BT_TRACE, ("[DM][BT], RSSI_1 state switch to High\n"));
10325 			} else if (UndecoratedSmoothedPWDB < RssiThresh) {
10326 				btRssiState = BT_RSSI_STATE_LOW;
10327 				pHalData->bt_coexist.CurrentState |= BT_COEX_STATE_WIFI_RSSI_1_LOW;
10328 				pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_WIFI_RSSI_1_HIGH;
10329 				pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_WIFI_RSSI_1_MEDIUM;
10330 				RTPRINT(FBT, BT_TRACE, ("[DM][BT], RSSI_1 state switch to Low\n"));
10331 			} else {
10332 				btRssiState = BT_RSSI_STATE_STAY_MEDIUM;
10333 				RTPRINT(FBT, BT_TRACE, ("[DM][BT], RSSI_1 state stay at Medium\n"));
10334 			}
10335 		} else {
10336 			if (UndecoratedSmoothedPWDB < RssiThresh1) {
10337 				btRssiState = BT_RSSI_STATE_MEDIUM;
10338 				pHalData->bt_coexist.CurrentState |= BT_COEX_STATE_WIFI_RSSI_1_MEDIUM;
10339 				pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_WIFI_RSSI_1_HIGH;
10340 				pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_WIFI_RSSI_1_LOW;
10341 				RTPRINT(FBT, BT_TRACE, ("[DM][BT], RSSI_1 state switch to Medium\n"));
10342 			} else {
10343 				btRssiState = BT_RSSI_STATE_STAY_HIGH;
10344 				RTPRINT(FBT, BT_TRACE, ("[DM][BT], RSSI_1 state stay at High\n"));
10345 			}
10346 		}
10347 	}
10348 
10349 	pHalData->bt_coexist.preRssiState1 = btRssiState;
10350 
10351 	return btRssiState;
10352 }
10353 
BTDM_CheckCoexRSSIState(struct rtw_adapter * padapter,u8 levelNum,u8 RssiThresh,u8 RssiThresh1)10354 u8 BTDM_CheckCoexRSSIState(struct rtw_adapter *padapter, u8 levelNum,
10355 			   u8 RssiThresh, u8 RssiThresh1)
10356 {
10357 	struct hal_data_8723a *pHalData = GET_HAL_DATA(padapter);
10358 	s32 UndecoratedSmoothedPWDB = 0;
10359 	u8 btRssiState = 0;
10360 
10361 	UndecoratedSmoothedPWDB = BTDM_GetRxSS(padapter);
10362 
10363 	if (levelNum == 2) {
10364 		pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_WIFI_RSSI_MEDIUM;
10365 
10366 		if ((pHalData->bt_coexist.preRssiState == BT_RSSI_STATE_LOW) ||
10367 		    (pHalData->bt_coexist.preRssiState == BT_RSSI_STATE_STAY_LOW)) {
10368 			if (UndecoratedSmoothedPWDB >= (RssiThresh+BT_FW_COEX_THRESH_TOL)) {
10369 				btRssiState = BT_RSSI_STATE_HIGH;
10370 				pHalData->bt_coexist.CurrentState |= BT_COEX_STATE_WIFI_RSSI_HIGH;
10371 				pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_WIFI_RSSI_LOW;
10372 				RTPRINT(FBT, BT_TRACE, ("[DM][BT], RSSI state switch to High\n"));
10373 			} else {
10374 				btRssiState = BT_RSSI_STATE_STAY_LOW;
10375 				RTPRINT(FBT, BT_TRACE, ("[DM][BT], RSSI state stay at Low\n"));
10376 			}
10377 		} else {
10378 			if (UndecoratedSmoothedPWDB < RssiThresh) {
10379 				btRssiState = BT_RSSI_STATE_LOW;
10380 				pHalData->bt_coexist.CurrentState |= BT_COEX_STATE_WIFI_RSSI_LOW;
10381 				pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_WIFI_RSSI_HIGH;
10382 				RTPRINT(FBT, BT_TRACE, ("[DM][BT], RSSI state switch to Low\n"));
10383 			} else {
10384 				btRssiState = BT_RSSI_STATE_STAY_HIGH;
10385 				RTPRINT(FBT, BT_TRACE, ("[DM][BT], RSSI state stay at High\n"));
10386 			}
10387 		}
10388 	} else if (levelNum == 3) {
10389 		if (RssiThresh > RssiThresh1) {
10390 			RTPRINT(FBT, BT_TRACE, ("[DM][BT], RSSI thresh error!!\n"));
10391 			return pHalData->bt_coexist.preRssiState;
10392 		}
10393 
10394 		if ((pHalData->bt_coexist.preRssiState == BT_RSSI_STATE_LOW) ||
10395 		    (pHalData->bt_coexist.preRssiState == BT_RSSI_STATE_STAY_LOW)) {
10396 			if (UndecoratedSmoothedPWDB >= (RssiThresh+BT_FW_COEX_THRESH_TOL)) {
10397 				btRssiState = BT_RSSI_STATE_MEDIUM;
10398 				pHalData->bt_coexist.CurrentState |= BT_COEX_STATE_WIFI_RSSI_MEDIUM;
10399 				pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_WIFI_RSSI_LOW;
10400 				pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_WIFI_RSSI_HIGH;
10401 				RTPRINT(FBT, BT_TRACE, ("[DM][BT], RSSI state switch to Medium\n"));
10402 			} else {
10403 				btRssiState = BT_RSSI_STATE_STAY_LOW;
10404 				RTPRINT(FBT, BT_TRACE, ("[DM][BT], RSSI state stay at Low\n"));
10405 			}
10406 		} else if ((pHalData->bt_coexist.preRssiState == BT_RSSI_STATE_MEDIUM) ||
10407 			   (pHalData->bt_coexist.preRssiState == BT_RSSI_STATE_STAY_MEDIUM)) {
10408 			if (UndecoratedSmoothedPWDB >= (RssiThresh1+BT_FW_COEX_THRESH_TOL)) {
10409 				btRssiState = BT_RSSI_STATE_HIGH;
10410 				pHalData->bt_coexist.CurrentState |= BT_COEX_STATE_WIFI_RSSI_HIGH;
10411 				pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_WIFI_RSSI_LOW;
10412 				pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_WIFI_RSSI_MEDIUM;
10413 				RTPRINT(FBT, BT_TRACE, ("[DM][BT], RSSI state switch to High\n"));
10414 			} else if (UndecoratedSmoothedPWDB < RssiThresh) {
10415 				btRssiState = BT_RSSI_STATE_LOW;
10416 				pHalData->bt_coexist.CurrentState |= BT_COEX_STATE_WIFI_RSSI_LOW;
10417 				pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_WIFI_RSSI_HIGH;
10418 				pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_WIFI_RSSI_MEDIUM;
10419 				RTPRINT(FBT, BT_TRACE, ("[DM][BT], RSSI state switch to Low\n"));
10420 			} else {
10421 				btRssiState = BT_RSSI_STATE_STAY_MEDIUM;
10422 				RTPRINT(FBT, BT_TRACE, ("[DM][BT], RSSI state stay at Medium\n"));
10423 			}
10424 		} else {
10425 			if (UndecoratedSmoothedPWDB < RssiThresh1) {
10426 				btRssiState = BT_RSSI_STATE_MEDIUM;
10427 				pHalData->bt_coexist.CurrentState |= BT_COEX_STATE_WIFI_RSSI_MEDIUM;
10428 				pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_WIFI_RSSI_HIGH;
10429 				pHalData->bt_coexist.CurrentState &= ~BT_COEX_STATE_WIFI_RSSI_LOW;
10430 				RTPRINT(FBT, BT_TRACE, ("[DM][BT], RSSI state switch to Medium\n"));
10431 			} else {
10432 				btRssiState = BT_RSSI_STATE_STAY_HIGH;
10433 				RTPRINT(FBT, BT_TRACE, ("[DM][BT], RSSI state stay at High\n"));
10434 			}
10435 		}
10436 	}
10437 
10438 	pHalData->bt_coexist.preRssiState = btRssiState;
10439 
10440 	return btRssiState;
10441 }
10442 
rtl8723a_BT_disable_EDCA_turbo(struct rtw_adapter * padapter)10443 bool rtl8723a_BT_disable_EDCA_turbo(struct rtw_adapter *padapter)
10444 {
10445 	struct bt_mgnt *pBtMgnt;
10446 	struct hal_data_8723a *pHalData;
10447 	u8 bBtChangeEDCA = false;
10448 	u32 EDCA_BT_BE = 0x5ea42b, cur_EDCA_reg;
10449 	bool bRet = false;
10450 
10451 	pHalData = GET_HAL_DATA(padapter);
10452 	pBtMgnt = &pHalData->BtInfo.BtMgnt;
10453 
10454 	if (!rtl8723a_BT_coexist(padapter)) {
10455 		bRet = false;
10456 		pHalData->bt_coexist.lastBtEdca = 0;
10457 		return bRet;
10458 	}
10459 	if (!((pBtMgnt->bSupportProfile) ||
10460 	    (pHalData->bt_coexist.BT_CoexistType == BT_CSR_BC8))) {
10461 		bRet = false;
10462 		pHalData->bt_coexist.lastBtEdca = 0;
10463 		return bRet;
10464 	}
10465 
10466 	if (rtl8723a_BT_using_antenna_1(padapter)) {
10467 		bRet = false;
10468 		pHalData->bt_coexist.lastBtEdca = 0;
10469 		return bRet;
10470 	}
10471 
10472 	if (pHalData->bt_coexist.exec_cnt < 3)
10473 		pHalData->bt_coexist.exec_cnt++;
10474 	else
10475 		pHalData->bt_coexist.bEDCAInitialized = true;
10476 
10477 	/*  When BT is non idle */
10478 	if (!(pHalData->bt_coexist.CurrentState & BT_COEX_STATE_BT_IDLE)) {
10479 		RTPRINT(FBT, BT_TRACE, ("BT state non idle, set bt EDCA\n"));
10480 
10481 		/* aggr_num = 0x0909; */
10482 		if (pHalData->odmpriv.DM_EDCA_Table.bCurrentTurboEDCA) {
10483 			bBtChangeEDCA = true;
10484 			pHalData->odmpriv.DM_EDCA_Table.bCurrentTurboEDCA = false;
10485 			pHalData->dmpriv.prv_traffic_idx = 3;
10486 		}
10487 		cur_EDCA_reg = rtl8723au_read32(padapter, REG_EDCA_BE_PARAM);
10488 
10489 		if (cur_EDCA_reg != EDCA_BT_BE)
10490 			bBtChangeEDCA = true;
10491 		if (bBtChangeEDCA || !pHalData->bt_coexist.bEDCAInitialized) {
10492 			rtl8723au_write32(padapter, REG_EDCA_BE_PARAM,
10493 					  EDCA_BT_BE);
10494 			pHalData->bt_coexist.lastBtEdca = EDCA_BT_BE;
10495 		}
10496 		bRet = true;
10497 	} else {
10498 		RTPRINT(FBT, BT_TRACE, ("BT state idle, set original EDCA\n"));
10499 		pHalData->bt_coexist.lastBtEdca = 0;
10500 		bRet = false;
10501 	}
10502 	return bRet;
10503 }
10504 
10505 void
BTDM_Balance(struct rtw_adapter * padapter,u8 bBalanceOn,u8 ms0,u8 ms1)10506 BTDM_Balance(
10507 	struct rtw_adapter *padapter,
10508 	u8 bBalanceOn,
10509 	u8 ms0,
10510 	u8 ms1
10511 	)
10512 {
10513 	struct hal_data_8723a *pHalData = GET_HAL_DATA(padapter);
10514 	u8 H2C_Parameter[3] = {0};
10515 
10516 	if (bBalanceOn) {
10517 		H2C_Parameter[2] = 1;
10518 		H2C_Parameter[1] = ms1;
10519 		H2C_Parameter[0] = ms0;
10520 		pHalData->bt_coexist.bFWCoexistAllOff = false;
10521 	} else {
10522 		H2C_Parameter[2] = 0;
10523 		H2C_Parameter[1] = 0;
10524 		H2C_Parameter[0] = 0;
10525 	}
10526 	pHalData->bt_coexist.bBalanceOn = bBalanceOn;
10527 
10528 	RTPRINT(FBT, BT_TRACE, ("[DM][BT], Balance =[%s:%dms:%dms], write 0xc = 0x%x\n",
10529 		bBalanceOn?"ON":"OFF", ms0, ms1,
10530 		H2C_Parameter[0]<<16|H2C_Parameter[1]<<8|H2C_Parameter[2]));
10531 
10532 	FillH2CCmd(padapter, 0xc, 3, H2C_Parameter);
10533 }
10534 
BTDM_AGCTable(struct rtw_adapter * padapter,u8 type)10535 void BTDM_AGCTable(struct rtw_adapter *padapter, u8 type)
10536 {
10537 	struct hal_data_8723a *pHalData = GET_HAL_DATA(padapter);
10538 	if (type == BT_AGCTABLE_OFF) {
10539 		RTPRINT(FBT, BT_TRACE, ("[BT]AGCTable Off!\n"));
10540 		rtl8723au_write32(padapter, 0xc78, 0x641c0001);
10541 		rtl8723au_write32(padapter, 0xc78, 0x631d0001);
10542 		rtl8723au_write32(padapter, 0xc78, 0x621e0001);
10543 		rtl8723au_write32(padapter, 0xc78, 0x611f0001);
10544 		rtl8723au_write32(padapter, 0xc78, 0x60200001);
10545 
10546 		PHY_SetRFReg(padapter, PathA, RF_RX_AGC_HP, bRFRegOffsetMask, 0x32000);
10547 		PHY_SetRFReg(padapter, PathA, RF_RX_AGC_HP, bRFRegOffsetMask, 0x71000);
10548 		PHY_SetRFReg(padapter, PathA, RF_RX_AGC_HP, bRFRegOffsetMask, 0xb0000);
10549 		PHY_SetRFReg(padapter, PathA, RF_RX_AGC_HP, bRFRegOffsetMask, 0xfc000);
10550 		PHY_SetRFReg(padapter, PathA, RF_RX_G1, bRFRegOffsetMask, 0x30355);
10551 
10552 		pHalData->bt_coexist.b8723aAgcTableOn = false;
10553 	} else if (type == BT_AGCTABLE_ON) {
10554 		RTPRINT(FBT, BT_TRACE, ("[BT]AGCTable On!\n"));
10555 		rtl8723au_write32(padapter, 0xc78, 0x4e1c0001);
10556 		rtl8723au_write32(padapter, 0xc78, 0x4d1d0001);
10557 		rtl8723au_write32(padapter, 0xc78, 0x4c1e0001);
10558 		rtl8723au_write32(padapter, 0xc78, 0x4b1f0001);
10559 		rtl8723au_write32(padapter, 0xc78, 0x4a200001);
10560 
10561 		PHY_SetRFReg(padapter, PathA, RF_RX_AGC_HP, bRFRegOffsetMask, 0xdc000);
10562 		PHY_SetRFReg(padapter, PathA, RF_RX_AGC_HP, bRFRegOffsetMask, 0x90000);
10563 		PHY_SetRFReg(padapter, PathA, RF_RX_AGC_HP, bRFRegOffsetMask, 0x51000);
10564 		PHY_SetRFReg(padapter, PathA, RF_RX_AGC_HP, bRFRegOffsetMask, 0x12000);
10565 		PHY_SetRFReg(padapter, PathA, RF_RX_G1, bRFRegOffsetMask, 0x00355);
10566 
10567 		pHalData->bt_coexist.b8723aAgcTableOn = true;
10568 
10569 		pHalData->bt_coexist.bSWCoexistAllOff = false;
10570 	}
10571 }
10572 
BTDM_BBBackOffLevel(struct rtw_adapter * padapter,u8 type)10573 void BTDM_BBBackOffLevel(struct rtw_adapter *padapter, u8 type)
10574 {
10575 	struct hal_data_8723a *pHalData = GET_HAL_DATA(padapter);
10576 
10577 	if (type == BT_BB_BACKOFF_OFF) {
10578 		RTPRINT(FBT, BT_TRACE, ("[BT]BBBackOffLevel Off!\n"));
10579 		rtl8723au_write32(padapter, 0xc04, 0x3a05611);
10580 	} else if (type == BT_BB_BACKOFF_ON) {
10581 		RTPRINT(FBT, BT_TRACE, ("[BT]BBBackOffLevel On!\n"));
10582 		rtl8723au_write32(padapter, 0xc04, 0x3a07611);
10583 		pHalData->bt_coexist.bSWCoexistAllOff = false;
10584 	}
10585 }
10586 
BTDM_FWCoexAllOff(struct rtw_adapter * padapter)10587 void BTDM_FWCoexAllOff(struct rtw_adapter *padapter)
10588 {
10589 	struct hal_data_8723a *pHalData = GET_HAL_DATA(padapter);
10590 
10591 	RTPRINT(FBT, BT_TRACE, ("BTDM_FWCoexAllOff()\n"));
10592 	if (pHalData->bt_coexist.bFWCoexistAllOff)
10593 		return;
10594 	RTPRINT(FBT, BT_TRACE, ("BTDM_FWCoexAllOff(), real Do\n"));
10595 
10596 	BTDM_FWCoexAllOff8723A(padapter);
10597 
10598 	pHalData->bt_coexist.bFWCoexistAllOff = true;
10599 }
10600 
BTDM_SWCoexAllOff(struct rtw_adapter * padapter)10601 void BTDM_SWCoexAllOff(struct rtw_adapter *padapter)
10602 {
10603 	struct hal_data_8723a *pHalData = GET_HAL_DATA(padapter);
10604 
10605 	RTPRINT(FBT, BT_TRACE, ("BTDM_SWCoexAllOff()\n"));
10606 	if (pHalData->bt_coexist.bSWCoexistAllOff)
10607 		return;
10608 	RTPRINT(FBT, BT_TRACE, ("BTDM_SWCoexAllOff(), real Do\n"));
10609 	BTDM_SWCoexAllOff8723A(padapter);
10610 
10611 	pHalData->bt_coexist.bSWCoexistAllOff = true;
10612 }
10613 
BTDM_HWCoexAllOff(struct rtw_adapter * padapter)10614 void BTDM_HWCoexAllOff(struct rtw_adapter *padapter)
10615 {
10616 	struct hal_data_8723a *pHalData = GET_HAL_DATA(padapter);
10617 
10618 	RTPRINT(FBT, BT_TRACE, ("BTDM_HWCoexAllOff()\n"));
10619 	if (pHalData->bt_coexist.bHWCoexistAllOff)
10620 		return;
10621 	RTPRINT(FBT, BT_TRACE, ("BTDM_HWCoexAllOff(), real Do\n"));
10622 
10623 	BTDM_HWCoexAllOff8723A(padapter);
10624 
10625 	pHalData->bt_coexist.bHWCoexistAllOff = true;
10626 }
10627 
BTDM_CoexAllOff(struct rtw_adapter * padapter)10628 void BTDM_CoexAllOff(struct rtw_adapter *padapter)
10629 {
10630 	BTDM_FWCoexAllOff(padapter);
10631 	BTDM_SWCoexAllOff(padapter);
10632 	BTDM_HWCoexAllOff(padapter);
10633 }
10634 
rtl8723a_BT_disable_coexist(struct rtw_adapter * padapter)10635 void rtl8723a_BT_disable_coexist(struct rtw_adapter *padapter)
10636 {
10637 	struct pwrctrl_priv *ppwrctrl = &padapter->pwrctrlpriv;
10638 
10639 	if (!rtl8723a_BT_coexist(padapter))
10640 		return;
10641 
10642 	/*  8723 1Ant doesn't need to turn off bt coexist mechanism. */
10643 	if (rtl8723a_BT_using_antenna_1(padapter))
10644 		return;
10645 
10646 	/*  Before enter IPS, turn off FW BT Co-exist mechanism */
10647 	if (ppwrctrl->reg_rfoff == rf_on) {
10648 		RTPRINT(FBT, BT_TRACE, ("[BT][DM], Before enter IPS, turn off all Coexist DM\n"));
10649 		btdm_ResetFWCoexState(padapter);
10650 		BTDM_CoexAllOff(padapter);
10651 		BTDM_SetAntenna(padapter, BTDM_ANT_BT);
10652 	}
10653 }
10654 
BTDM_SignalCompensation(struct rtw_adapter * padapter,u8 * rssi_wifi,u8 * rssi_bt)10655 void BTDM_SignalCompensation(struct rtw_adapter *padapter, u8 *rssi_wifi, u8 *rssi_bt)
10656 {
10657 	BTDM_8723ASignalCompensation(padapter, rssi_wifi, rssi_bt);
10658 }
10659 
rtl8723a_BT_do_coexist(struct rtw_adapter * padapter)10660 void rtl8723a_BT_do_coexist(struct rtw_adapter *padapter)
10661 {
10662 	struct hal_data_8723a *pHalData = GET_HAL_DATA(padapter);
10663 
10664 	if (!rtl8723a_BT_coexist(padapter)) {
10665 		RTPRINT(FBT, BT_TRACE, ("[DM][BT], BT not exists!!\n"));
10666 		return;
10667 	}
10668 
10669 	if (!pHalData->bt_coexist.bInitlized) {
10670 		RTPRINT(FBT, BT_TRACE, ("[DM][BT], btdm_InitBtCoexistDM()\n"));
10671 		btdm_InitBtCoexistDM(padapter);
10672 	}
10673 
10674 	RTPRINT(FBT, BT_TRACE, ("\n\n[DM][BT], BTDM start!!\n"));
10675 
10676 	BTDM_PWDBMonitor(padapter);
10677 
10678 	RTPRINT(FBT, BT_TRACE, ("[DM][BT], HW type is 8723\n"));
10679 	BTDM_BTCoexist8723A(padapter);
10680 	RTPRINT(FBT, BT_TRACE, ("[DM][BT], BTDM end!!\n\n"));
10681 }
10682 
BTDM_UpdateCoexState(struct rtw_adapter * padapter)10683 void BTDM_UpdateCoexState(struct rtw_adapter *padapter)
10684 {
10685 	struct hal_data_8723a *pHalData = GET_HAL_DATA(padapter);
10686 
10687 	if (!BTDM_IsSameCoexistState(padapter)) {
10688 		RTPRINT(FBT, BT_TRACE, ("[BTCoex], Coexist State[bitMap] change from 0x%"i64fmt"x to 0x%"i64fmt"x,  changeBits = 0x%"i64fmt"x\n",
10689 			pHalData->bt_coexist.PreviousState,
10690 			pHalData->bt_coexist.CurrentState,
10691 			(pHalData->bt_coexist.PreviousState^pHalData->bt_coexist.CurrentState)));
10692 		pHalData->bt_coexist.PreviousState = pHalData->bt_coexist.CurrentState;
10693 	}
10694 }
10695 
BTDM_IsSameCoexistState(struct rtw_adapter * padapter)10696 u8 BTDM_IsSameCoexistState(struct rtw_adapter *padapter)
10697 {
10698 	struct hal_data_8723a *pHalData = GET_HAL_DATA(padapter);
10699 
10700 	if (pHalData->bt_coexist.PreviousState == pHalData->bt_coexist.CurrentState) {
10701 		return true;
10702 	} else {
10703 		RTPRINT(FBT, BT_TRACE, ("[DM][BT], Coexist state changed!!\n"));
10704 		return false;
10705 	}
10706 }
10707 
BTDM_PWDBMonitor(struct rtw_adapter * padapter)10708 void BTDM_PWDBMonitor(struct rtw_adapter *padapter)
10709 {
10710 	struct bt_30info *pBTInfo = GET_BT_INFO(GetDefaultAdapter(padapter));
10711 	struct bt_mgnt *pBtMgnt = &pBTInfo->BtMgnt;
10712 	struct hal_data_8723a *pHalData = GET_HAL_DATA(padapter);
10713 	u8 H2C_Parameter[3] = {0};
10714 	s32 tmpBTEntryMaxPWDB = 0, tmpBTEntryMinPWDB = 0xff;
10715 	u8 i;
10716 
10717 	if (pBtMgnt->BtOperationOn) {
10718 		for (i = 0; i < MAX_BT_ASOC_ENTRY_NUM; i++) {
10719 			if (pBTInfo->BtAsocEntry[i].bUsed) {
10720 				if (pBTInfo->BtAsocEntry[i].UndecoratedSmoothedPWDB < tmpBTEntryMinPWDB)
10721 					tmpBTEntryMinPWDB = pBTInfo->BtAsocEntry[i].UndecoratedSmoothedPWDB;
10722 				if (pBTInfo->BtAsocEntry[i].UndecoratedSmoothedPWDB > tmpBTEntryMaxPWDB)
10723 					tmpBTEntryMaxPWDB = pBTInfo->BtAsocEntry[i].UndecoratedSmoothedPWDB;
10724 				/*  Report every BT connection (HS mode) RSSI to FW */
10725 				H2C_Parameter[2] = (u8)(pBTInfo->BtAsocEntry[i].UndecoratedSmoothedPWDB & 0xFF);
10726 				H2C_Parameter[0] = (MAX_FW_SUPPORT_MACID_NUM-1-i);
10727 				RTPRINT(FDM, DM_BT30, ("RSSI report for BT[%d], H2C_Par = 0x%x\n", i, H2C_Parameter[0]));
10728 				FillH2CCmd(padapter, RSSI_SETTING_EID, 3, H2C_Parameter);
10729 				RTPRINT_ADDR(FDM, (DM_PWDB|DM_BT30), ("BT_Entry Mac :"),
10730 					     pBTInfo->BtAsocEntry[i].BTRemoteMACAddr)
10731 				RTPRINT(FDM, (DM_PWDB|DM_BT30),
10732 					("BT rx pwdb[%d] = 0x%x(%d)\n", i,
10733 					pBTInfo->BtAsocEntry[i].UndecoratedSmoothedPWDB,
10734 					pBTInfo->BtAsocEntry[i].UndecoratedSmoothedPWDB));
10735 			}
10736 		}
10737 		if (tmpBTEntryMaxPWDB != 0) {	/*  If associated entry is found */
10738 			pHalData->dmpriv.BT_EntryMaxUndecoratedSmoothedPWDB = tmpBTEntryMaxPWDB;
10739 			RTPRINT(FDM, (DM_PWDB|DM_BT30), ("BT_EntryMaxPWDB = 0x%x(%d)\n",
10740 				tmpBTEntryMaxPWDB, tmpBTEntryMaxPWDB));
10741 		} else {
10742 			pHalData->dmpriv.BT_EntryMaxUndecoratedSmoothedPWDB = 0;
10743 		}
10744 		if (tmpBTEntryMinPWDB != 0xff) { /*  If associated entry is found */
10745 			pHalData->dmpriv.BT_EntryMinUndecoratedSmoothedPWDB = tmpBTEntryMinPWDB;
10746 			RTPRINT(FDM, (DM_PWDB|DM_BT30), ("BT_EntryMinPWDB = 0x%x(%d)\n",
10747 				tmpBTEntryMinPWDB, tmpBTEntryMinPWDB));
10748 		} else {
10749 			pHalData->dmpriv.BT_EntryMinUndecoratedSmoothedPWDB = 0;
10750 		}
10751 	}
10752 }
10753 
BTDM_IsBTBusy(struct rtw_adapter * padapter)10754 u8 BTDM_IsBTBusy(struct rtw_adapter *padapter)
10755 {
10756 	struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
10757 	struct bt_mgnt *pBtMgnt = &pBTInfo->BtMgnt;
10758 
10759 	if (pBtMgnt->ExtConfig.bBTBusy)
10760 		return true;
10761 	else
10762 		return false;
10763 }
10764 
BTDM_IsWifiBusy(struct rtw_adapter * padapter)10765 u8 BTDM_IsWifiBusy(struct rtw_adapter *padapter)
10766 {
10767 /*PMGNT_INFO		pMgntInfo = &GetDefaultAdapter(padapter)->MgntInfo; */
10768 	struct mlme_priv *pmlmepriv = &GetDefaultAdapter(padapter)->mlmepriv;
10769 	struct bt_30info *pBTInfo = GET_BT_INFO(padapter);
10770 	struct bt_traffic *pBtTraffic = &pBTInfo->BtTraffic;
10771 
10772 	if (pmlmepriv->LinkDetectInfo.bBusyTraffic ||
10773 		pBtTraffic->Bt30TrafficStatistics.bTxBusyTraffic ||
10774 		pBtTraffic->Bt30TrafficStatistics.bRxBusyTraffic)
10775 		return true;
10776 	else
10777 		return false;
10778 }
10779 
BTDM_IsCoexistStateChanged(struct rtw_adapter * padapter)10780 u8 BTDM_IsCoexistStateChanged(struct rtw_adapter *padapter)
10781 {
10782 	struct hal_data_8723a *pHalData = GET_HAL_DATA(padapter);
10783 
10784 	if (pHalData->bt_coexist.PreviousState == pHalData->bt_coexist.CurrentState)
10785 		return false;
10786 	else
10787 		return true;
10788 }
10789 
BTDM_IsWifiUplink(struct rtw_adapter * padapter)10790 u8 BTDM_IsWifiUplink(struct rtw_adapter *padapter)
10791 {
10792 /*PMGNT_INFO		pMgntInfo = &GetDefaultAdapter(padapter)->MgntInfo; */
10793 	struct mlme_priv *pmlmepriv;
10794 	struct bt_30info *pBTInfo;
10795 	struct bt_traffic *pBtTraffic;
10796 
10797 	pmlmepriv = &padapter->mlmepriv;
10798 	pBTInfo = GET_BT_INFO(padapter);
10799 	pBtTraffic = &pBTInfo->BtTraffic;
10800 
10801 	if ((pmlmepriv->LinkDetectInfo.bTxBusyTraffic) ||
10802 		(pBtTraffic->Bt30TrafficStatistics.bTxBusyTraffic))
10803 		return true;
10804 	else
10805 		return false;
10806 }
10807 
BTDM_IsWifiDownlink(struct rtw_adapter * padapter)10808 u8 BTDM_IsWifiDownlink(struct rtw_adapter *padapter)
10809 {
10810 /*PMGNT_INFO		pMgntInfo = &GetDefaultAdapter(padapter)->MgntInfo; */
10811 	struct mlme_priv *pmlmepriv;
10812 	struct bt_30info *pBTInfo;
10813 	struct bt_traffic *pBtTraffic;
10814 
10815 	pmlmepriv = &padapter->mlmepriv;
10816 	pBTInfo = GET_BT_INFO(padapter);
10817 	pBtTraffic = &pBTInfo->BtTraffic;
10818 
10819 	if ((pmlmepriv->LinkDetectInfo.bRxBusyTraffic) ||
10820 		(pBtTraffic->Bt30TrafficStatistics.bRxBusyTraffic))
10821 		return true;
10822 	else
10823 		return false;
10824 }
10825 
BTDM_IsBTHSMode(struct rtw_adapter * padapter)10826 u8 BTDM_IsBTHSMode(struct rtw_adapter *padapter)
10827 {
10828 /*PMGNT_INFO		pMgntInfo = &GetDefaultAdapter(padapter)->MgntInfo; */
10829 	struct hal_data_8723a *pHalData;
10830 	struct bt_mgnt *pBtMgnt;
10831 
10832 	pHalData = GET_HAL_DATA(padapter);
10833 	pBtMgnt = &pHalData->BtInfo.BtMgnt;
10834 
10835 	if (pBtMgnt->BtOperationOn)
10836 		return true;
10837 	else
10838 		return false;
10839 }
10840 
BTDM_IsBTUplink(struct rtw_adapter * padapter)10841 u8 BTDM_IsBTUplink(struct rtw_adapter *padapter)
10842 {
10843 	struct hal_data_8723a *pHalData = GET_HAL_DATA(padapter);
10844 
10845 	if (pHalData->bt_coexist.BT21TrafficStatistics.bTxBusyTraffic)
10846 		return true;
10847 	else
10848 		return false;
10849 }
10850 
BTDM_IsBTDownlink(struct rtw_adapter * padapter)10851 u8 BTDM_IsBTDownlink(struct rtw_adapter *padapter)
10852 {
10853 	struct hal_data_8723a *pHalData = GET_HAL_DATA(padapter);
10854 
10855 	if (pHalData->bt_coexist.BT21TrafficStatistics.bRxBusyTraffic)
10856 		return true;
10857 	else
10858 		return false;
10859 }
10860 
BTDM_AdjustForBtOperation(struct rtw_adapter * padapter)10861 void BTDM_AdjustForBtOperation(struct rtw_adapter *padapter)
10862 {
10863 	RTPRINT(FBT, BT_TRACE, ("[BT][DM], BTDM_AdjustForBtOperation()\n"));
10864 	BTDM_AdjustForBtOperation8723A(padapter);
10865 }
10866 
BTDM_SetBtCoexCurrAntNum(struct rtw_adapter * padapter,u8 antNum)10867 void BTDM_SetBtCoexCurrAntNum(struct rtw_adapter *padapter, u8 antNum)
10868 {
10869 	BTDM_Set8723ABtCoexCurrAntNum(padapter, antNum);
10870 }
10871 
BTDM_ForHalt(struct rtw_adapter * padapter)10872 void BTDM_ForHalt(struct rtw_adapter *padapter)
10873 {
10874 	if (!rtl8723a_BT_coexist(padapter))
10875 		return;
10876 
10877 	BTDM_ForHalt8723A(padapter);
10878 	GET_HAL_DATA(padapter)->bt_coexist.bInitlized = false;
10879 }
10880 
BTDM_WifiScanNotify(struct rtw_adapter * padapter,u8 scanType)10881 void BTDM_WifiScanNotify(struct rtw_adapter *padapter, u8 scanType)
10882 {
10883 	if (!rtl8723a_BT_coexist(padapter))
10884 		return;
10885 
10886 	BTDM_WifiScanNotify8723A(padapter, scanType);
10887 }
10888 
BTDM_WifiAssociateNotify(struct rtw_adapter * padapter,u8 action)10889 void BTDM_WifiAssociateNotify(struct rtw_adapter *padapter, u8 action)
10890 {
10891 	if (!rtl8723a_BT_coexist(padapter))
10892 		return;
10893 
10894 	BTDM_WifiAssociateNotify8723A(padapter, action);
10895 }
10896 
rtl8723a_BT_mediastatus_notify(struct rtw_adapter * padapter,enum rt_media_status mstatus)10897 void rtl8723a_BT_mediastatus_notify(struct rtw_adapter *padapter,
10898 				    enum rt_media_status mstatus)
10899 {
10900 	if (!rtl8723a_BT_coexist(padapter))
10901 		return;
10902 
10903 	BTDM_MediaStatusNotify8723A(padapter, mstatus);
10904 }
10905 
rtl8723a_BT_specialpacket_notify(struct rtw_adapter * padapter)10906 void rtl8723a_BT_specialpacket_notify(struct rtw_adapter *padapter)
10907 {
10908 	if (!rtl8723a_BT_coexist(padapter))
10909 		return;
10910 
10911 	BTDM_ForDhcp8723A(padapter);
10912 }
10913 
BTDM_ResetActionProfileState(struct rtw_adapter * padapter)10914 void BTDM_ResetActionProfileState(struct rtw_adapter *padapter)
10915 {
10916 	struct hal_data_8723a *pHalData = GET_HAL_DATA(padapter);
10917 
10918 	pHalData->bt_coexist.CurrentState &= ~\
10919 		(BT_COEX_STATE_PROFILE_HID|BT_COEX_STATE_PROFILE_A2DP|
10920 		BT_COEX_STATE_PROFILE_PAN|BT_COEX_STATE_PROFILE_SCO);
10921 }
10922 
BTDM_IsActionSCO(struct rtw_adapter * padapter)10923 u8 BTDM_IsActionSCO(struct rtw_adapter *padapter)
10924 {
10925 	struct hal_data_8723a *pHalData;
10926 	struct bt_30info *pBTInfo;
10927 	struct bt_mgnt *pBtMgnt;
10928 	struct bt_dgb *pBtDbg;
10929 	u8 bRet;
10930 
10931 	pHalData = GET_HAL_DATA(padapter);
10932 	pBTInfo = GET_BT_INFO(padapter);
10933 	pBtMgnt = &pBTInfo->BtMgnt;
10934 	pBtDbg = &pBTInfo->BtDbg;
10935 	bRet = false;
10936 
10937 	if (pBtDbg->dbgCtrl) {
10938 		if (pBtDbg->dbgProfile == BT_DBG_PROFILE_SCO) {
10939 			pHalData->bt_coexist.CurrentState |= BT_COEX_STATE_PROFILE_SCO;
10940 			bRet = true;
10941 		}
10942 	} else {
10943 		if (pBtMgnt->ExtConfig.NumberOfSCO > 0) {
10944 			pHalData->bt_coexist.CurrentState |= BT_COEX_STATE_PROFILE_SCO;
10945 			bRet = true;
10946 		}
10947 	}
10948 	return bRet;
10949 }
10950 
BTDM_IsActionHID(struct rtw_adapter * padapter)10951 u8 BTDM_IsActionHID(struct rtw_adapter *padapter)
10952 {
10953 	struct bt_30info *pBTInfo;
10954 	struct hal_data_8723a *pHalData;
10955 	struct bt_mgnt *pBtMgnt;
10956 	struct bt_dgb *pBtDbg;
10957 	u8 bRet;
10958 
10959 	pHalData = GET_HAL_DATA(padapter);
10960 	pBTInfo = GET_BT_INFO(padapter);
10961 	pBtMgnt = &pBTInfo->BtMgnt;
10962 	pBtDbg = &pBTInfo->BtDbg;
10963 	bRet = false;
10964 
10965 	if (pBtDbg->dbgCtrl) {
10966 		if (pBtDbg->dbgProfile == BT_DBG_PROFILE_HID) {
10967 			pHalData->bt_coexist.CurrentState |= BT_COEX_STATE_PROFILE_HID;
10968 			bRet = true;
10969 		}
10970 	} else {
10971 		if (BTHCI_CheckProfileExist(padapter, BT_PROFILE_HID) &&
10972 		    pBtMgnt->ExtConfig.NumberOfHandle == 1) {
10973 			pHalData->bt_coexist.CurrentState |= BT_COEX_STATE_PROFILE_HID;
10974 			bRet = true;
10975 		}
10976 	}
10977 	return bRet;
10978 }
10979 
BTDM_IsActionA2DP(struct rtw_adapter * padapter)10980 u8 BTDM_IsActionA2DP(struct rtw_adapter *padapter)
10981 {
10982 	struct hal_data_8723a *pHalData;
10983 	struct bt_30info *pBTInfo;
10984 	struct bt_mgnt *pBtMgnt;
10985 	struct bt_dgb *pBtDbg;
10986 	u8 bRet;
10987 
10988 	pHalData = GET_HAL_DATA(padapter);
10989 	pBTInfo = GET_BT_INFO(padapter);
10990 	pBtMgnt = &pBTInfo->BtMgnt;
10991 	pBtDbg = &pBTInfo->BtDbg;
10992 	bRet = false;
10993 
10994 	if (pBtDbg->dbgCtrl) {
10995 		if (pBtDbg->dbgProfile == BT_DBG_PROFILE_A2DP) {
10996 			pHalData->bt_coexist.CurrentState |= BT_COEX_STATE_PROFILE_A2DP;
10997 			bRet = true;
10998 		}
10999 	} else {
11000 		if (BTHCI_CheckProfileExist(padapter, BT_PROFILE_A2DP) &&
11001 		    pBtMgnt->ExtConfig.NumberOfHandle == 1) {
11002 			pHalData->bt_coexist.CurrentState |= BT_COEX_STATE_PROFILE_A2DP;
11003 			bRet = true;
11004 		}
11005 	}
11006 	return bRet;
11007 }
11008 
BTDM_IsActionPAN(struct rtw_adapter * padapter)11009 u8 BTDM_IsActionPAN(struct rtw_adapter *padapter)
11010 {
11011 	struct hal_data_8723a *pHalData;
11012 	struct bt_30info *pBTInfo;
11013 	struct bt_mgnt *pBtMgnt;
11014 	struct bt_dgb *pBtDbg;
11015 	u8 bRet;
11016 
11017 	pHalData = GET_HAL_DATA(padapter);
11018 	pBTInfo = GET_BT_INFO(padapter);
11019 	pBtMgnt = &pBTInfo->BtMgnt;
11020 	pBtDbg = &pBTInfo->BtDbg;
11021 	bRet = false;
11022 
11023 	if (pBtDbg->dbgCtrl) {
11024 		if (pBtDbg->dbgProfile == BT_DBG_PROFILE_PAN) {
11025 			pHalData->bt_coexist.CurrentState |= BT_COEX_STATE_PROFILE_PAN;
11026 			bRet = true;
11027 		}
11028 	} else {
11029 		if (BTHCI_CheckProfileExist(padapter, BT_PROFILE_PAN) &&
11030 		    pBtMgnt->ExtConfig.NumberOfHandle == 1) {
11031 			pHalData->bt_coexist.CurrentState |= BT_COEX_STATE_PROFILE_PAN;
11032 			bRet = true;
11033 		}
11034 	}
11035 	return bRet;
11036 }
11037 
BTDM_IsActionHIDA2DP(struct rtw_adapter * padapter)11038 u8 BTDM_IsActionHIDA2DP(struct rtw_adapter *padapter)
11039 {
11040 	struct hal_data_8723a *pHalData;
11041 	struct bt_30info *pBTInfo;
11042 	struct bt_mgnt *pBtMgnt;
11043 	struct bt_dgb *pBtDbg;
11044 	u8 bRet;
11045 
11046 	pHalData = GET_HAL_DATA(padapter);
11047 	pBTInfo = GET_BT_INFO(padapter);
11048 	pBtMgnt = &pBTInfo->BtMgnt;
11049 	pBtDbg = &pBTInfo->BtDbg;
11050 	bRet = false;
11051 
11052 	if (pBtDbg->dbgCtrl) {
11053 		if (pBtDbg->dbgProfile == BT_DBG_PROFILE_HID_A2DP) {
11054 			pHalData->bt_coexist.CurrentState |= (BT_COEX_STATE_PROFILE_HID|BT_COEX_STATE_PROFILE_A2DP);
11055 			bRet = true;
11056 		}
11057 	} else {
11058 		if (BTHCI_CheckProfileExist(padapter, BT_PROFILE_HID) &&
11059 		    BTHCI_CheckProfileExist(padapter, BT_PROFILE_A2DP)) {
11060 			pHalData->bt_coexist.CurrentState |= (BT_COEX_STATE_PROFILE_HID|BT_COEX_STATE_PROFILE_A2DP);
11061 			bRet = true;
11062 		}
11063 	}
11064 	return bRet;
11065 }
11066 
BTDM_IsActionHIDPAN(struct rtw_adapter * padapter)11067 u8 BTDM_IsActionHIDPAN(struct rtw_adapter *padapter)
11068 {
11069 	struct hal_data_8723a *pHalData;
11070 	struct bt_30info *pBTInfo;
11071 	struct bt_dgb *pBtDbg;
11072 	u8 bRet;
11073 
11074 	pHalData = GET_HAL_DATA(padapter);
11075 	pBTInfo = GET_BT_INFO(padapter);
11076 	pBtDbg = &pBTInfo->BtDbg;
11077 	bRet = false;
11078 
11079 	if (pBtDbg->dbgCtrl) {
11080 		if (pBtDbg->dbgProfile == BT_DBG_PROFILE_HID_PAN) {
11081 			pHalData->bt_coexist.CurrentState |= (BT_COEX_STATE_PROFILE_HID|BT_COEX_STATE_PROFILE_PAN);
11082 			bRet = true;
11083 		}
11084 	} else {
11085 		if (BTHCI_CheckProfileExist(padapter, BT_PROFILE_HID) &&
11086 		    BTHCI_CheckProfileExist(padapter, BT_PROFILE_PAN)) {
11087 			pHalData->bt_coexist.CurrentState |= (BT_COEX_STATE_PROFILE_HID|BT_COEX_STATE_PROFILE_PAN);
11088 			bRet = true;
11089 		}
11090 	}
11091 	return bRet;
11092 }
11093 
BTDM_IsActionPANA2DP(struct rtw_adapter * padapter)11094 u8 BTDM_IsActionPANA2DP(struct rtw_adapter *padapter)
11095 {
11096 	struct hal_data_8723a *pHalData;
11097 	struct bt_30info *pBTInfo;
11098 	struct bt_dgb *pBtDbg;
11099 	u8 bRet;
11100 
11101 	pHalData = GET_HAL_DATA(padapter);
11102 	pBTInfo = GET_BT_INFO(padapter);
11103 	pBtDbg = &pBTInfo->BtDbg;
11104 	bRet = false;
11105 
11106 	if (pBtDbg->dbgCtrl) {
11107 		if (pBtDbg->dbgProfile == BT_DBG_PROFILE_PAN_A2DP) {
11108 			pHalData->bt_coexist.CurrentState |= (BT_COEX_STATE_PROFILE_PAN|BT_COEX_STATE_PROFILE_A2DP);
11109 			bRet = true;
11110 		}
11111 	} else {
11112 		if (BTHCI_CheckProfileExist(padapter, BT_PROFILE_PAN) && BTHCI_CheckProfileExist(padapter, BT_PROFILE_A2DP)) {
11113 			pHalData->bt_coexist.CurrentState |= (BT_COEX_STATE_PROFILE_PAN|BT_COEX_STATE_PROFILE_A2DP);
11114 			bRet = true;
11115 		}
11116 	}
11117 	return bRet;
11118 }
11119 
rtl8723a_BT_enabled(struct rtw_adapter * padapter)11120 bool rtl8723a_BT_enabled(struct rtw_adapter *padapter)
11121 {
11122 	struct hal_data_8723a *pHalData = GET_HAL_DATA(padapter);
11123 
11124 	if (pHalData->bt_coexist.bCurBtDisabled)
11125 		return false;
11126 	else
11127 		return true;
11128 }
11129 
11130 /*  ===== End of sync from SD7 driver HAL/BTCoexist/HalBtCoexist.c ===== */
11131 
11132 /*  ===== Below this line is sync from SD7 driver HAL/HalBT.c ===== */
11133 
11134 /*  */
11135 /*local function */
11136 /*  */
11137 
halbt_InitHwConfig8723A(struct rtw_adapter * padapter)11138 static void halbt_InitHwConfig8723A(struct rtw_adapter *padapter)
11139 {
11140 }
11141 
11142 /*  */
11143 /*extern function */
11144 /*  */
HALBT_GetPGAntNum(struct rtw_adapter * padapter)11145 u8 HALBT_GetPGAntNum(struct rtw_adapter *padapter)
11146 {
11147 	struct hal_data_8723a *pHalData = GET_HAL_DATA(padapter);
11148 
11149 	return pHalData->bt_coexist.BT_Ant_Num;
11150 }
11151 
HALBT_SetKey(struct rtw_adapter * padapter,u8 EntryNum)11152 void HALBT_SetKey(struct rtw_adapter *padapter, u8 EntryNum)
11153 {
11154 	struct bt_30info *pBTinfo;
11155 	struct bt_asoc_entry *pBtAssocEntry;
11156 	u16				usConfig = 0;
11157 
11158 	pBTinfo = GET_BT_INFO(padapter);
11159 	pBtAssocEntry = &pBTinfo->BtAsocEntry[EntryNum];
11160 
11161 	pBtAssocEntry->HwCAMIndex = BT_HWCAM_STAR + EntryNum;
11162 
11163 	usConfig = CAM_VALID | (CAM_AES << 2);
11164 	rtl8723a_cam_write(padapter, pBtAssocEntry->HwCAMIndex, usConfig,
11165 			   pBtAssocEntry->BTRemoteMACAddr,
11166 			   pBtAssocEntry->PTK + TKIP_ENC_KEY_POS);
11167 }
11168 
HALBT_RemoveKey(struct rtw_adapter * padapter,u8 EntryNum)11169 void HALBT_RemoveKey(struct rtw_adapter *padapter, u8 EntryNum)
11170 {
11171 	struct bt_30info *pBTinfo;
11172 	struct bt_asoc_entry *pBtAssocEntry;
11173 
11174 	pBTinfo = GET_BT_INFO(padapter);
11175 	pBtAssocEntry = &pBTinfo->BtAsocEntry[EntryNum];
11176 
11177 	if (pBTinfo->BtAsocEntry[EntryNum].HwCAMIndex != 0) {
11178 		/*  ToDo : add New HALBT_RemoveKey function !! */
11179 		if (pBtAssocEntry->HwCAMIndex >= BT_HWCAM_STAR &&
11180 		    pBtAssocEntry->HwCAMIndex < HALF_CAM_ENTRY)
11181 			rtl8723a_cam_empty_entry(padapter,
11182 						 pBtAssocEntry->HwCAMIndex);
11183 		pBTinfo->BtAsocEntry[EntryNum].HwCAMIndex = 0;
11184 	}
11185 }
11186 
rtl8723a_BT_init_hal_vars(struct rtw_adapter * padapter)11187 void rtl8723a_BT_init_hal_vars(struct rtw_adapter *padapter)
11188 {
11189 	struct hal_data_8723a *pHalData;
11190 
11191 	pHalData = GET_HAL_DATA(padapter);
11192 
11193 	pHalData->bt_coexist.BluetoothCoexist = pHalData->EEPROMBluetoothCoexist;
11194 	pHalData->bt_coexist.BT_Ant_Num = pHalData->EEPROMBluetoothAntNum;
11195 	pHalData->bt_coexist.BT_CoexistType = pHalData->EEPROMBluetoothType;
11196 	pHalData->bt_coexist.BT_Ant_isolation = pHalData->EEPROMBluetoothAntIsolation;
11197 	pHalData->bt_coexist.bt_radiosharedtype = pHalData->EEPROMBluetoothRadioShared;
11198 
11199 	RT_TRACE(_module_hal_init_c_, _drv_info_,
11200 		 "BT Coexistance = 0x%x\n", rtl8723a_BT_coexist(padapter));
11201 
11202 	if (rtl8723a_BT_coexist(padapter)) {
11203 		if (pHalData->bt_coexist.BT_Ant_Num == Ant_x2) {
11204 			BTDM_SetBtCoexCurrAntNum(padapter, 2);
11205 			RT_TRACE(_module_hal_init_c_, _drv_info_,
11206 				 "BlueTooth BT_Ant_Num = Antx2\n");
11207 		} else if (pHalData->bt_coexist.BT_Ant_Num == Ant_x1) {
11208 			BTDM_SetBtCoexCurrAntNum(padapter, 1);
11209 			RT_TRACE(_module_hal_init_c_, _drv_info_,
11210 				 "BlueTooth BT_Ant_Num = Antx1\n");
11211 		}
11212 		pHalData->bt_coexist.bBTBusyTraffic = false;
11213 		pHalData->bt_coexist.bBTTrafficModeSet = false;
11214 		pHalData->bt_coexist.bBTNonTrafficModeSet = false;
11215 		pHalData->bt_coexist.CurrentState = 0;
11216 		pHalData->bt_coexist.PreviousState = 0;
11217 
11218 		RT_TRACE(_module_hal_init_c_, _drv_info_,
11219 			 "bt_radiosharedType = 0x%x\n",
11220 			 pHalData->bt_coexist.bt_radiosharedtype);
11221 	}
11222 }
11223 
rtl8723a_BT_coexist(struct rtw_adapter * padapter)11224 bool rtl8723a_BT_coexist(struct rtw_adapter *padapter)
11225 {
11226 	struct hal_data_8723a *pHalData = GET_HAL_DATA(padapter);
11227 
11228 	if (pHalData->bt_coexist.BluetoothCoexist)
11229 		return true;
11230 	else
11231 		return false;
11232 }
11233 
HALBT_BTChipType(struct rtw_adapter * padapter)11234 u8 HALBT_BTChipType(struct rtw_adapter *padapter)
11235 {
11236 	struct hal_data_8723a *pHalData = GET_HAL_DATA(padapter);
11237 
11238 	return pHalData->bt_coexist.BT_CoexistType;
11239 }
11240 
rtl8723a_BT_init_hwconfig(struct rtw_adapter * padapter)11241 void rtl8723a_BT_init_hwconfig(struct rtw_adapter *padapter)
11242 {
11243 	halbt_InitHwConfig8723A(padapter);
11244 	rtl8723a_BT_do_coexist(padapter);
11245 }
11246 
HALBT_SetRtsCtsNoLenLimit(struct rtw_adapter * padapter)11247 void HALBT_SetRtsCtsNoLenLimit(struct rtw_adapter *padapter)
11248 {
11249 }
11250 
11251 /*  ===== End of sync from SD7 driver HAL/HalBT.c ===== */
11252 
rtl8723a_dual_antenna_detection(struct rtw_adapter * padapter)11253 void rtl8723a_dual_antenna_detection(struct rtw_adapter *padapter)
11254 {
11255 	struct hal_data_8723a *pHalData;
11256 	struct dm_odm_t *pDM_Odm;
11257 	struct sw_ant_sw *pDM_SWAT_Table;
11258 	u8 i;
11259 
11260 	pHalData = GET_HAL_DATA(padapter);
11261 	pDM_Odm = &pHalData->odmpriv;
11262 	pDM_SWAT_Table = &pDM_Odm->DM_SWAT_Table;
11263 
11264 	/*  */
11265 	/*  <Roger_Notes> RTL8723A Single and Dual antenna dynamic detection
11266 	    mechanism when RF power state is on. */
11267 	/*  We should take power tracking, IQK, LCK, RCK RF read/write
11268 	    operation into consideration. */
11269 	/*  2011.12.15. */
11270 	/*  */
11271 	if (!pHalData->bAntennaDetected) {
11272 		u8 btAntNum = BT_GetPGAntNum(padapter);
11273 
11274 		/*  Set default antenna B status */
11275 		if (btAntNum == Ant_x2)
11276 			pDM_SWAT_Table->ANTB_ON = true;
11277 		else if (btAntNum == Ant_x1)
11278 			pDM_SWAT_Table->ANTB_ON = false;
11279 		else
11280 			pDM_SWAT_Table->ANTB_ON = true;
11281 
11282 		if (pHalData->CustomerID != RT_CID_TOSHIBA) {
11283 			for (i = 0; i < MAX_ANTENNA_DETECTION_CNT; i++) {
11284 				if (ODM_SingleDualAntennaDetection
11285 				    (&pHalData->odmpriv, ANTTESTALL) == true)
11286 					break;
11287 			}
11288 
11289 			/*  Set default antenna number for BT coexistence */
11290 			if (btAntNum == Ant_x2)
11291 				BT_SetBtCoexCurrAntNum(padapter,
11292 						       pDM_SWAT_Table->
11293 						       ANTB_ON ? 2 : 1);
11294 		}
11295 		pHalData->bAntennaDetected = true;
11296 	}
11297 }
11298