projects / deliverable / linux.git / blob
? search:


cf15f80836badfd625e63e7a3d241686a6f0fb9a
[deliverable/linux.git] / drivers / staging / rtl8723au / hal / rtl8723a_bt-coexist.c
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
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
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
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
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
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
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
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
193 static u8 bthci_GetLocalChannel(struct rtw_adapter *padapter)
194 {
195 return padapter->mlmeextpriv.cur_channel;
196 }
197
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
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 */
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
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
429 static u8 bthci_DiscardTxPackets(struct rtw_adapter *padapter, u16 LLH)
430 {
431 return false;
432 }
433
434 static u8
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
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
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
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
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
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
626 static void bthci_ResponderStartToScan(struct rtw_adapter *padapter)
627 {
628 }
629
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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 */
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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 */
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 */
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
4809 void BTHCI_EventParse(struct rtw_adapter *padapter, void *pEvntData, u32 dataLen)
4810 {
4811 }
4812
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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 */
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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_ */
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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) */
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
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) */
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
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 */
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 */
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
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) */
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
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
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_ */
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
8522 static void BTDM_2AntHwCoexAllOff8723A(struct rtw_adapter *padapter)
8523 {
8524 btdm_2AntCoexTable(padapter, 0x55555555, 0xffff, 0x3);
8525 }
8526
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
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
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
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
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
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 */
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
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_ */
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
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
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
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
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
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
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
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
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
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
9296 static void BTDM_AdjustForBtOperation8723A(struct rtw_adapter *padapter)
9297 {
9298 /* BTDM_2AntAdjustForBtOperation8723(padapter); */
9299 }
9300
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
9773 static void BTDM_SetAntenna(struct rtw_adapter *padapter, u8 who)
9774 {
9775 }
9776
9777 void
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
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
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 */
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
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 /* */
10039 void BTDM_CheckAntSelMode(struct rtw_adapter *padapter)
10040 {
10041 }
10042
10043 void BTDM_FwC2hBtRssi(struct rtw_adapter *padapter, u8 *tmpBuf)
10044 {
10045 BTDM_FwC2hBtRssi8723A(padapter, tmpBuf);
10046 }
10047
10048 void BTDM_DisplayBtCoexInfo(struct rtw_adapter *padapter)
10049 {
10050 BTDM_Display8723ABtCoexInfo(padapter);
10051 }
10052
10053 void BTDM_RejectAPAggregatedPacket(struct rtw_adapter *padapter, u8 bReject)
10054 {
10055 }
10056
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
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
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
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
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 */
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
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
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
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
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
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
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
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
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
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
10628 void BTDM_CoexAllOff(struct rtw_adapter *padapter)
10629 {
10630 BTDM_FWCoexAllOff(padapter);
10631 BTDM_SWCoexAllOff(padapter);
10632 BTDM_HWCoexAllOff(padapter);
10633 }
10634
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
10867 void BTDM_SetBtCoexCurrAntNum(struct rtw_adapter *padapter, u8 antNum)
10868 {
10869 BTDM_Set8723ABtCoexCurrAntNum(padapter, antNum);
10870 }
10871
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
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
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
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
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
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
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
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
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
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
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
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
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
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
11138 static void halbt_InitHwConfig8723A(struct rtw_adapter *padapter)
11139 {
11140 }
11141
11142 /* */
11143 /*extern function */
11144 /* */
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
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
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
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
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
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
11241 void rtl8723a_BT_init_hwconfig(struct rtw_adapter *padapter)
11242 {
11243 halbt_InitHwConfig8723A(padapter);
11244 rtl8723a_BT_do_coexist(padapter);
11245 }
11246
11247 void HALBT_SetRtsCtsNoLenLimit(struct rtw_adapter *padapter)
11248 {
11249 }
11250
11251 /* ===== End of sync from SD7 driver HAL/HalBT.c ===== */
11252
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 }
Linux kernel - Deliverables
This page took 0.281646 seconds and 4 git commands to generate.