1
2
3
4
5
6
7
8#include "Mp_Precomp.h"
9
10
11static struct coex_dm_8723b_1ant GLCoexDm8723b1Ant;
12static struct coex_dm_8723b_1ant *pCoexDm = &GLCoexDm8723b1Ant;
13static struct coex_sta_8723b_1ant GLCoexSta8723b1Ant;
14static struct coex_sta_8723b_1ant *pCoexSta = &GLCoexSta8723b1Ant;
15
16
17
18static u8 halbtc8723b1ant_BtRssiState(
19 u8 levelNum, u8 rssiThresh, u8 rssiThresh1
20)
21{
22 s32 btRssi = 0;
23 u8 btRssiState = pCoexSta->preBtRssiState;
24
25 btRssi = pCoexSta->btRssi;
26
27 if (levelNum == 2) {
28 if (
29 (pCoexSta->preBtRssiState == BTC_RSSI_STATE_LOW) ||
30 (pCoexSta->preBtRssiState == BTC_RSSI_STATE_STAY_LOW)
31 ) {
32 if (btRssi >= (rssiThresh + BTC_RSSI_COEX_THRESH_TOL_8723B_1ANT))
33
34 btRssiState = BTC_RSSI_STATE_HIGH;
35 else
36 btRssiState = BTC_RSSI_STATE_STAY_LOW;
37 } else {
38 if (btRssi < rssiThresh)
39 btRssiState = BTC_RSSI_STATE_LOW;
40 else
41 btRssiState = BTC_RSSI_STATE_STAY_HIGH;
42 }
43 } else if (levelNum == 3) {
44 if (rssiThresh > rssiThresh1)
45 return pCoexSta->preBtRssiState;
46
47 if (
48 (pCoexSta->preBtRssiState == BTC_RSSI_STATE_LOW) ||
49 (pCoexSta->preBtRssiState == BTC_RSSI_STATE_STAY_LOW)
50 ) {
51 if (btRssi >= (rssiThresh + BTC_RSSI_COEX_THRESH_TOL_8723B_1ANT))
52 btRssiState = BTC_RSSI_STATE_MEDIUM;
53 else
54 btRssiState = BTC_RSSI_STATE_STAY_LOW;
55 } else if (
56 (pCoexSta->preBtRssiState == BTC_RSSI_STATE_MEDIUM) ||
57 (pCoexSta->preBtRssiState == BTC_RSSI_STATE_STAY_MEDIUM)
58 ) {
59 if (btRssi >= (rssiThresh1 + BTC_RSSI_COEX_THRESH_TOL_8723B_1ANT))
60 btRssiState = BTC_RSSI_STATE_HIGH;
61 else if (btRssi < rssiThresh)
62 btRssiState = BTC_RSSI_STATE_LOW;
63 else
64 btRssiState = BTC_RSSI_STATE_STAY_MEDIUM;
65 } else {
66 if (btRssi < rssiThresh1)
67 btRssiState = BTC_RSSI_STATE_MEDIUM;
68 else
69 btRssiState = BTC_RSSI_STATE_STAY_HIGH;
70 }
71 }
72
73 pCoexSta->preBtRssiState = btRssiState;
74
75 return btRssiState;
76}
77
78static void halbtc8723b1ant_UpdateRaMask(
79 struct btc_coexist *pBtCoexist, bool bForceExec, u32 disRateMask
80)
81{
82 pCoexDm->curRaMask = disRateMask;
83
84 if (bForceExec || (pCoexDm->preRaMask != pCoexDm->curRaMask))
85 pBtCoexist->fBtcSet(
86 pBtCoexist,
87 BTC_SET_ACT_UPDATE_RAMASK,
88 &pCoexDm->curRaMask
89 );
90 pCoexDm->preRaMask = pCoexDm->curRaMask;
91}
92
93static void halbtc8723b1ant_AutoRateFallbackRetry(
94 struct btc_coexist *pBtCoexist, bool bForceExec, u8 type
95)
96{
97 bool bWifiUnderBMode = false;
98
99 pCoexDm->curArfrType = type;
100
101 if (bForceExec || (pCoexDm->preArfrType != pCoexDm->curArfrType)) {
102 switch (pCoexDm->curArfrType) {
103 case 0:
104 pBtCoexist->fBtcWrite4Byte(
105 pBtCoexist, 0x430, pCoexDm->backupArfrCnt1
106 );
107 pBtCoexist->fBtcWrite4Byte(
108 pBtCoexist, 0x434, pCoexDm->backupArfrCnt2
109 );
110 break;
111 case 1:
112 pBtCoexist->fBtcGet(
113 pBtCoexist, BTC_GET_BL_WIFI_UNDER_B_MODE, &bWifiUnderBMode
114 );
115 if (bWifiUnderBMode) {
116 pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0x430, 0x0);
117 pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0x434, 0x01010101);
118 } else {
119 pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0x430, 0x0);
120 pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0x434, 0x04030201);
121 }
122 break;
123 default:
124 break;
125 }
126 }
127
128 pCoexDm->preArfrType = pCoexDm->curArfrType;
129}
130
131static void halbtc8723b1ant_RetryLimit(
132 struct btc_coexist *pBtCoexist, bool bForceExec, u8 type
133)
134{
135 pCoexDm->curRetryLimitType = type;
136
137 if (
138 bForceExec ||
139 (pCoexDm->preRetryLimitType != pCoexDm->curRetryLimitType)
140 ) {
141 switch (pCoexDm->curRetryLimitType) {
142 case 0:
143 pBtCoexist->fBtcWrite2Byte(
144 pBtCoexist, 0x42a, pCoexDm->backupRetryLimit
145 );
146 break;
147 case 1:
148 pBtCoexist->fBtcWrite2Byte(pBtCoexist, 0x42a, 0x0808);
149 break;
150 default:
151 break;
152 }
153 }
154
155 pCoexDm->preRetryLimitType = pCoexDm->curRetryLimitType;
156}
157
158static void halbtc8723b1ant_AmpduMaxTime(
159 struct btc_coexist *pBtCoexist, bool bForceExec, u8 type
160)
161{
162 pCoexDm->curAmpduTimeType = type;
163
164 if (
165 bForceExec || (pCoexDm->preAmpduTimeType != pCoexDm->curAmpduTimeType)
166 ) {
167 switch (pCoexDm->curAmpduTimeType) {
168 case 0:
169 pBtCoexist->fBtcWrite1Byte(
170 pBtCoexist, 0x456, pCoexDm->backupAmpduMaxTime
171 );
172 break;
173 case 1:
174 pBtCoexist->fBtcWrite1Byte(pBtCoexist, 0x456, 0x38);
175 break;
176 default:
177 break;
178 }
179 }
180
181 pCoexDm->preAmpduTimeType = pCoexDm->curAmpduTimeType;
182}
183
184static void halbtc8723b1ant_LimitedTx(
185 struct btc_coexist *pBtCoexist,
186 bool bForceExec,
187 u8 raMaskType,
188 u8 arfrType,
189 u8 retryLimitType,
190 u8 ampduTimeType
191)
192{
193 switch (raMaskType) {
194 case 0:
195 halbtc8723b1ant_UpdateRaMask(pBtCoexist, bForceExec, 0x0);
196 break;
197 case 1:
198 halbtc8723b1ant_UpdateRaMask(pBtCoexist, bForceExec, 0x00000003);
199 break;
200 case 2:
201 halbtc8723b1ant_UpdateRaMask(pBtCoexist, bForceExec, 0x0001f1f7);
202 break;
203 default:
204 break;
205 }
206
207 halbtc8723b1ant_AutoRateFallbackRetry(pBtCoexist, bForceExec, arfrType);
208 halbtc8723b1ant_RetryLimit(pBtCoexist, bForceExec, retryLimitType);
209 halbtc8723b1ant_AmpduMaxTime(pBtCoexist, bForceExec, ampduTimeType);
210}
211
212static void halbtc8723b1ant_LimitedRx(
213 struct btc_coexist *pBtCoexist,
214 bool bForceExec,
215 bool bRejApAggPkt,
216 bool bBtCtrlAggBufSize,
217 u8 aggBufSize
218)
219{
220 bool bRejectRxAgg = bRejApAggPkt;
221 bool bBtCtrlRxAggSize = bBtCtrlAggBufSize;
222 u8 rxAggSize = aggBufSize;
223
224
225
226
227 pBtCoexist->fBtcSet(
228 pBtCoexist, BTC_SET_BL_TO_REJ_AP_AGG_PKT, &bRejectRxAgg
229 );
230
231 pBtCoexist->fBtcSet(
232 pBtCoexist, BTC_SET_BL_BT_CTRL_AGG_SIZE, &bBtCtrlRxAggSize
233 );
234
235 pBtCoexist->fBtcSet(pBtCoexist, BTC_SET_U1_AGG_BUF_SIZE, &rxAggSize);
236
237 pBtCoexist->fBtcSet(pBtCoexist, BTC_SET_ACT_AGGREGATE_CTRL, NULL);
238
239
240}
241
242static void halbtc8723b1ant_QueryBtInfo(struct btc_coexist *pBtCoexist)
243{
244 u8 H2C_Parameter[1] = {0};
245
246 pCoexSta->bC2hBtInfoReqSent = true;
247
248 H2C_Parameter[0] |= BIT0;
249
250 pBtCoexist->fBtcFillH2c(pBtCoexist, 0x61, 1, H2C_Parameter);
251}
252
253static void halbtc8723b1ant_MonitorBtCtr(struct btc_coexist *pBtCoexist)
254{
255 u32 regHPTxRx, regLPTxRx, u4Tmp;
256 u32 regHPTx = 0, regHPRx = 0, regLPTx = 0, regLPRx = 0;
257 static u8 NumOfBtCounterChk;
258
259
260
261
262 if (pCoexSta->bUnderIps) {
263 pCoexSta->highPriorityTx = 65535;
264 pCoexSta->highPriorityRx = 65535;
265 pCoexSta->lowPriorityTx = 65535;
266 pCoexSta->lowPriorityRx = 65535;
267 return;
268 }
269
270 regHPTxRx = 0x770;
271 regLPTxRx = 0x774;
272
273 u4Tmp = pBtCoexist->fBtcRead4Byte(pBtCoexist, regHPTxRx);
274 regHPTx = u4Tmp & bMaskLWord;
275 regHPRx = (u4Tmp & bMaskHWord) >> 16;
276
277 u4Tmp = pBtCoexist->fBtcRead4Byte(pBtCoexist, regLPTxRx);
278 regLPTx = u4Tmp & bMaskLWord;
279 regLPRx = (u4Tmp & bMaskHWord) >> 16;
280
281 pCoexSta->highPriorityTx = regHPTx;
282 pCoexSta->highPriorityRx = regHPRx;
283 pCoexSta->lowPriorityTx = regLPTx;
284 pCoexSta->lowPriorityRx = regLPRx;
285
286 if ((pCoexSta->lowPriorityTx >= 1050) && (!pCoexSta->bC2hBtInquiryPage))
287 pCoexSta->popEventCnt++;
288
289
290 pBtCoexist->fBtcWrite1Byte(pBtCoexist, 0x76e, 0xc);
291
292 if ((regHPTx == 0) && (regHPRx == 0) && (regLPTx == 0) && (regLPRx == 0)) {
293 NumOfBtCounterChk++;
294 if (NumOfBtCounterChk >= 3) {
295 halbtc8723b1ant_QueryBtInfo(pBtCoexist);
296 NumOfBtCounterChk = 0;
297 }
298 }
299}
300
301
302static void halbtc8723b1ant_MonitorWiFiCtr(struct btc_coexist *pBtCoexist)
303{
304 s32 wifiRssi = 0;
305 bool bWifiBusy = false, bWifiUnderBMode = false;
306 static u8 nCCKLockCounter;
307
308 pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_WIFI_BUSY, &bWifiBusy);
309 pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_S4_WIFI_RSSI, &wifiRssi);
310 pBtCoexist->fBtcGet(
311 pBtCoexist, BTC_GET_BL_WIFI_UNDER_B_MODE, &bWifiUnderBMode
312 );
313
314 if (pCoexSta->bUnderIps) {
315 pCoexSta->nCRCOK_CCK = 0;
316 pCoexSta->nCRCOK_11g = 0;
317 pCoexSta->nCRCOK_11n = 0;
318 pCoexSta->nCRCOK_11nAgg = 0;
319
320 pCoexSta->nCRCErr_CCK = 0;
321 pCoexSta->nCRCErr_11g = 0;
322 pCoexSta->nCRCErr_11n = 0;
323 pCoexSta->nCRCErr_11nAgg = 0;
324 } else {
325 pCoexSta->nCRCOK_CCK = pBtCoexist->fBtcRead4Byte(pBtCoexist, 0xf88);
326 pCoexSta->nCRCOK_11g = pBtCoexist->fBtcRead2Byte(pBtCoexist, 0xf94);
327 pCoexSta->nCRCOK_11n = pBtCoexist->fBtcRead2Byte(pBtCoexist, 0xf90);
328 pCoexSta->nCRCOK_11nAgg = pBtCoexist->fBtcRead2Byte(pBtCoexist, 0xfb8);
329
330 pCoexSta->nCRCErr_CCK = pBtCoexist->fBtcRead4Byte(pBtCoexist, 0xf84);
331 pCoexSta->nCRCErr_11g = pBtCoexist->fBtcRead2Byte(pBtCoexist, 0xf96);
332 pCoexSta->nCRCErr_11n = pBtCoexist->fBtcRead2Byte(pBtCoexist, 0xf92);
333 pCoexSta->nCRCErr_11nAgg = pBtCoexist->fBtcRead2Byte(pBtCoexist, 0xfba);
334 }
335
336
337
338 pBtCoexist->fBtcWrite1ByteBitMask(pBtCoexist, 0xf16, 0x1, 0x1);
339 pBtCoexist->fBtcWrite1ByteBitMask(pBtCoexist, 0xf16, 0x1, 0x0);
340
341 if (bWifiBusy && (wifiRssi >= 30) && !bWifiUnderBMode) {
342 if (
343 (pCoexDm->btStatus == BT_8723B_1ANT_BT_STATUS_ACL_BUSY) ||
344 (pCoexDm->btStatus == BT_8723B_1ANT_BT_STATUS_ACL_SCO_BUSY) ||
345 (pCoexDm->btStatus == BT_8723B_1ANT_BT_STATUS_SCO_BUSY)
346 ) {
347 if (
348 pCoexSta->nCRCOK_CCK > (
349 pCoexSta->nCRCOK_11g +
350 pCoexSta->nCRCOK_11n +
351 pCoexSta->nCRCOK_11nAgg
352 )
353 ) {
354 if (nCCKLockCounter < 5)
355 nCCKLockCounter++;
356 } else {
357 if (nCCKLockCounter > 0)
358 nCCKLockCounter--;
359 }
360
361 } else {
362 if (nCCKLockCounter > 0)
363 nCCKLockCounter--;
364 }
365 } else {
366 if (nCCKLockCounter > 0)
367 nCCKLockCounter--;
368 }
369
370 if (!pCoexSta->bPreCCKLock) {
371
372 if (nCCKLockCounter >= 5)
373 pCoexSta->bCCKLock = true;
374 else
375 pCoexSta->bCCKLock = false;
376 } else {
377 if (nCCKLockCounter == 0)
378 pCoexSta->bCCKLock = false;
379 else
380 pCoexSta->bCCKLock = true;
381 }
382
383 pCoexSta->bPreCCKLock = pCoexSta->bCCKLock;
384
385
386}
387
388static bool halbtc8723b1ant_IsWifiStatusChanged(struct btc_coexist *pBtCoexist)
389{
390 static bool bPreWifiBusy, bPreUnder4way, bPreBtHsOn;
391 bool bWifiBusy = false, bUnder4way = false, bBtHsOn = false;
392 bool bWifiConnected = false;
393
394 pBtCoexist->fBtcGet(
395 pBtCoexist, BTC_GET_BL_WIFI_CONNECTED, &bWifiConnected
396 );
397 pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_WIFI_BUSY, &bWifiBusy);
398 pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_HS_OPERATION, &bBtHsOn);
399 pBtCoexist->fBtcGet(
400 pBtCoexist, BTC_GET_BL_WIFI_4_WAY_PROGRESS, &bUnder4way
401 );
402
403 if (bWifiConnected) {
404 if (bWifiBusy != bPreWifiBusy) {
405 bPreWifiBusy = bWifiBusy;
406 return true;
407 }
408
409 if (bUnder4way != bPreUnder4way) {
410 bPreUnder4way = bUnder4way;
411 return true;
412 }
413
414 if (bBtHsOn != bPreBtHsOn) {
415 bPreBtHsOn = bBtHsOn;
416 return true;
417 }
418 }
419
420 return false;
421}
422
423static void halbtc8723b1ant_UpdateBtLinkInfo(struct btc_coexist *pBtCoexist)
424{
425 struct btc_bt_link_info *pBtLinkInfo = &pBtCoexist->btLinkInfo;
426 bool bBtHsOn = false;
427
428 pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_HS_OPERATION, &bBtHsOn);
429
430 pBtLinkInfo->bBtLinkExist = pCoexSta->bBtLinkExist;
431 pBtLinkInfo->bScoExist = pCoexSta->bScoExist;
432 pBtLinkInfo->bA2dpExist = pCoexSta->bA2dpExist;
433 pBtLinkInfo->bPanExist = pCoexSta->bPanExist;
434 pBtLinkInfo->bHidExist = pCoexSta->bHidExist;
435
436
437 if (bBtHsOn) {
438 pBtLinkInfo->bPanExist = true;
439 pBtLinkInfo->bBtLinkExist = true;
440 }
441
442
443 if (
444 pBtLinkInfo->bScoExist &&
445 !pBtLinkInfo->bA2dpExist &&
446 !pBtLinkInfo->bPanExist &&
447 !pBtLinkInfo->bHidExist
448 )
449 pBtLinkInfo->bScoOnly = true;
450 else
451 pBtLinkInfo->bScoOnly = false;
452
453
454 if (
455 !pBtLinkInfo->bScoExist &&
456 pBtLinkInfo->bA2dpExist &&
457 !pBtLinkInfo->bPanExist &&
458 !pBtLinkInfo->bHidExist
459 )
460 pBtLinkInfo->bA2dpOnly = true;
461 else
462 pBtLinkInfo->bA2dpOnly = false;
463
464
465 if (
466 !pBtLinkInfo->bScoExist &&
467 !pBtLinkInfo->bA2dpExist &&
468 pBtLinkInfo->bPanExist &&
469 !pBtLinkInfo->bHidExist
470 )
471 pBtLinkInfo->bPanOnly = true;
472 else
473 pBtLinkInfo->bPanOnly = false;
474
475
476 if (
477 !pBtLinkInfo->bScoExist &&
478 !pBtLinkInfo->bA2dpExist &&
479 !pBtLinkInfo->bPanExist &&
480 pBtLinkInfo->bHidExist
481 )
482 pBtLinkInfo->bHidOnly = true;
483 else
484 pBtLinkInfo->bHidOnly = false;
485}
486
487static u8 halbtc8723b1ant_ActionAlgorithm(struct btc_coexist *pBtCoexist)
488{
489 struct btc_bt_link_info *pBtLinkInfo = &pBtCoexist->btLinkInfo;
490 bool bBtHsOn = false;
491 u8 algorithm = BT_8723B_1ANT_COEX_ALGO_UNDEFINED;
492 u8 numOfDiffProfile = 0;
493
494 pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_HS_OPERATION, &bBtHsOn);
495
496 if (!pBtLinkInfo->bBtLinkExist)
497 return algorithm;
498
499 if (pBtLinkInfo->bScoExist)
500 numOfDiffProfile++;
501 if (pBtLinkInfo->bHidExist)
502 numOfDiffProfile++;
503 if (pBtLinkInfo->bPanExist)
504 numOfDiffProfile++;
505 if (pBtLinkInfo->bA2dpExist)
506 numOfDiffProfile++;
507
508 if (numOfDiffProfile == 1) {
509 if (pBtLinkInfo->bScoExist) {
510 algorithm = BT_8723B_1ANT_COEX_ALGO_SCO;
511 } else {
512 if (pBtLinkInfo->bHidExist) {
513 algorithm = BT_8723B_1ANT_COEX_ALGO_HID;
514 } else if (pBtLinkInfo->bA2dpExist) {
515 algorithm = BT_8723B_1ANT_COEX_ALGO_A2DP;
516 } else if (pBtLinkInfo->bPanExist) {
517 if (bBtHsOn)
518 algorithm = BT_8723B_1ANT_COEX_ALGO_PANHS;
519 else
520 algorithm = BT_8723B_1ANT_COEX_ALGO_PANEDR;
521 }
522 }
523 } else if (numOfDiffProfile == 2) {
524 if (pBtLinkInfo->bScoExist) {
525 if (pBtLinkInfo->bHidExist) {
526 algorithm = BT_8723B_1ANT_COEX_ALGO_HID;
527 } else if (pBtLinkInfo->bA2dpExist) {
528 algorithm = BT_8723B_1ANT_COEX_ALGO_SCO;
529 } else if (pBtLinkInfo->bPanExist) {
530 if (bBtHsOn)
531 algorithm = BT_8723B_1ANT_COEX_ALGO_SCO;
532 else
533 algorithm = BT_8723B_1ANT_COEX_ALGO_PANEDR_HID;
534 }
535 } else {
536 if (pBtLinkInfo->bHidExist && pBtLinkInfo->bA2dpExist) {
537 algorithm = BT_8723B_1ANT_COEX_ALGO_HID_A2DP;
538 } else if (pBtLinkInfo->bHidExist && pBtLinkInfo->bPanExist) {
539 if (bBtHsOn)
540 algorithm = BT_8723B_1ANT_COEX_ALGO_HID_A2DP;
541 else
542 algorithm = BT_8723B_1ANT_COEX_ALGO_PANEDR_HID;
543 } else if (pBtLinkInfo->bPanExist && pBtLinkInfo->bA2dpExist) {
544 if (bBtHsOn)
545 algorithm = BT_8723B_1ANT_COEX_ALGO_A2DP_PANHS;
546 else
547 algorithm = BT_8723B_1ANT_COEX_ALGO_PANEDR_A2DP;
548 }
549 }
550 } else if (numOfDiffProfile == 3) {
551 if (pBtLinkInfo->bScoExist) {
552 if (pBtLinkInfo->bHidExist && pBtLinkInfo->bA2dpExist) {
553 algorithm = BT_8723B_1ANT_COEX_ALGO_HID;
554 } else if (
555 pBtLinkInfo->bHidExist && pBtLinkInfo->bPanExist
556 ) {
557 if (bBtHsOn)
558 algorithm = BT_8723B_1ANT_COEX_ALGO_HID_A2DP;
559 else
560 algorithm = BT_8723B_1ANT_COEX_ALGO_PANEDR_HID;
561 } else if (pBtLinkInfo->bPanExist && pBtLinkInfo->bA2dpExist) {
562 if (bBtHsOn)
563 algorithm = BT_8723B_1ANT_COEX_ALGO_SCO;
564 else
565 algorithm = BT_8723B_1ANT_COEX_ALGO_PANEDR_HID;
566 }
567 } else {
568 if (
569 pBtLinkInfo->bHidExist &&
570 pBtLinkInfo->bPanExist &&
571 pBtLinkInfo->bA2dpExist
572 ) {
573 if (bBtHsOn)
574 algorithm = BT_8723B_1ANT_COEX_ALGO_HID_A2DP;
575 else
576 algorithm = BT_8723B_1ANT_COEX_ALGO_HID_A2DP_PANEDR;
577 }
578 }
579 } else if (numOfDiffProfile >= 3) {
580 if (pBtLinkInfo->bScoExist) {
581 if (
582 pBtLinkInfo->bHidExist &&
583 pBtLinkInfo->bPanExist &&
584 pBtLinkInfo->bA2dpExist
585 ) {
586 if (!bBtHsOn)
587 algorithm = BT_8723B_1ANT_COEX_ALGO_PANEDR_HID;
588
589 }
590 }
591 }
592
593 return algorithm;
594}
595
596static void halbtc8723b1ant_SetSwPenaltyTxRateAdaptive(
597 struct btc_coexist *pBtCoexist, bool bLowPenaltyRa
598)
599{
600 u8 H2C_Parameter[6] = {0};
601
602 H2C_Parameter[0] = 0x6;
603
604 if (bLowPenaltyRa) {
605 H2C_Parameter[1] |= BIT0;
606 H2C_Parameter[2] = 0x00;
607 H2C_Parameter[3] = 0xf7;
608 H2C_Parameter[4] = 0xf8;
609 H2C_Parameter[5] = 0xf9;
610 }
611
612 pBtCoexist->fBtcFillH2c(pBtCoexist, 0x69, 6, H2C_Parameter);
613}
614
615static void halbtc8723b1ant_LowPenaltyRa(
616 struct btc_coexist *pBtCoexist, bool bForceExec, bool bLowPenaltyRa
617)
618{
619 pCoexDm->bCurLowPenaltyRa = bLowPenaltyRa;
620
621 if (!bForceExec) {
622 if (pCoexDm->bPreLowPenaltyRa == pCoexDm->bCurLowPenaltyRa)
623 return;
624 }
625 halbtc8723b1ant_SetSwPenaltyTxRateAdaptive(
626 pBtCoexist, pCoexDm->bCurLowPenaltyRa
627 );
628
629 pCoexDm->bPreLowPenaltyRa = pCoexDm->bCurLowPenaltyRa;
630}
631
632static void halbtc8723b1ant_SetCoexTable(
633 struct btc_coexist *pBtCoexist,
634 u32 val0x6c0,
635 u32 val0x6c4,
636 u32 val0x6c8,
637 u8 val0x6cc
638)
639{
640 pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0x6c0, val0x6c0);
641
642 pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0x6c4, val0x6c4);
643
644 pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0x6c8, val0x6c8);
645
646 pBtCoexist->fBtcWrite1Byte(pBtCoexist, 0x6cc, val0x6cc);
647}
648
649static void halbtc8723b1ant_CoexTable(
650 struct btc_coexist *pBtCoexist,
651 bool bForceExec,
652 u32 val0x6c0,
653 u32 val0x6c4,
654 u32 val0x6c8,
655 u8 val0x6cc
656)
657{
658 pCoexDm->curVal0x6c0 = val0x6c0;
659 pCoexDm->curVal0x6c4 = val0x6c4;
660 pCoexDm->curVal0x6c8 = val0x6c8;
661 pCoexDm->curVal0x6cc = val0x6cc;
662
663 if (!bForceExec) {
664 if (
665 (pCoexDm->preVal0x6c0 == pCoexDm->curVal0x6c0) &&
666 (pCoexDm->preVal0x6c4 == pCoexDm->curVal0x6c4) &&
667 (pCoexDm->preVal0x6c8 == pCoexDm->curVal0x6c8) &&
668 (pCoexDm->preVal0x6cc == pCoexDm->curVal0x6cc)
669 )
670 return;
671 }
672
673 halbtc8723b1ant_SetCoexTable(
674 pBtCoexist, val0x6c0, val0x6c4, val0x6c8, val0x6cc
675 );
676
677 pCoexDm->preVal0x6c0 = pCoexDm->curVal0x6c0;
678 pCoexDm->preVal0x6c4 = pCoexDm->curVal0x6c4;
679 pCoexDm->preVal0x6c8 = pCoexDm->curVal0x6c8;
680 pCoexDm->preVal0x6cc = pCoexDm->curVal0x6cc;
681}
682
683static void halbtc8723b1ant_CoexTableWithType(
684 struct btc_coexist *pBtCoexist, bool bForceExec, u8 type
685)
686{
687 pCoexSta->nCoexTableType = type;
688
689 switch (type) {
690 case 0:
691 halbtc8723b1ant_CoexTable(
692 pBtCoexist, bForceExec, 0x55555555, 0x55555555, 0xffffff, 0x3
693 );
694 break;
695 case 1:
696 halbtc8723b1ant_CoexTable(
697 pBtCoexist, bForceExec, 0x55555555, 0x5a5a5a5a, 0xffffff, 0x3
698 );
699 break;
700 case 2:
701 halbtc8723b1ant_CoexTable(
702 pBtCoexist, bForceExec, 0x5a5a5a5a, 0x5a5a5a5a, 0xffffff, 0x3
703 );
704 break;
705 case 3:
706 halbtc8723b1ant_CoexTable(
707 pBtCoexist, bForceExec, 0xaaaa5555, 0xaaaa5a5a, 0xffffff, 0x3
708 );
709 break;
710 case 4:
711 halbtc8723b1ant_CoexTable(
712 pBtCoexist, bForceExec, 0x55555555, 0xaaaa5a5a, 0xffffff, 0x3
713 );
714 break;
715 case 5:
716 halbtc8723b1ant_CoexTable(
717 pBtCoexist, bForceExec, 0x5a5a5a5a, 0xaaaa5a5a, 0xffffff, 0x3
718 );
719 break;
720 case 6:
721 halbtc8723b1ant_CoexTable(
722 pBtCoexist, bForceExec, 0x55555555, 0xaaaaaaaa, 0xffffff, 0x3
723 );
724 break;
725 case 7:
726 halbtc8723b1ant_CoexTable(
727 pBtCoexist, bForceExec, 0xaaaaaaaa, 0xaaaaaaaa, 0xffffff, 0x3
728 );
729 break;
730 default:
731 break;
732 }
733}
734
735static void halbtc8723b1ant_SetFwIgnoreWlanAct(
736 struct btc_coexist *pBtCoexist, bool bEnable
737)
738{
739 u8 H2C_Parameter[1] = {0};
740
741 if (bEnable)
742 H2C_Parameter[0] |= BIT0;
743
744 pBtCoexist->fBtcFillH2c(pBtCoexist, 0x63, 1, H2C_Parameter);
745}
746
747static void halbtc8723b1ant_IgnoreWlanAct(
748 struct btc_coexist *pBtCoexist, bool bForceExec, bool bEnable
749)
750{
751 pCoexDm->bCurIgnoreWlanAct = bEnable;
752
753 if (!bForceExec) {
754 if (pCoexDm->bPreIgnoreWlanAct == pCoexDm->bCurIgnoreWlanAct)
755 return;
756 }
757 halbtc8723b1ant_SetFwIgnoreWlanAct(pBtCoexist, bEnable);
758
759 pCoexDm->bPreIgnoreWlanAct = pCoexDm->bCurIgnoreWlanAct;
760}
761
762static void halbtc8723b1ant_SetLpsRpwm(
763 struct btc_coexist *pBtCoexist, u8 lpsVal, u8 rpwmVal
764)
765{
766 u8 lps = lpsVal;
767 u8 rpwm = rpwmVal;
768
769 pBtCoexist->fBtcSet(pBtCoexist, BTC_SET_U1_LPS_VAL, &lps);
770 pBtCoexist->fBtcSet(pBtCoexist, BTC_SET_U1_RPWM_VAL, &rpwm);
771}
772
773static void halbtc8723b1ant_LpsRpwm(
774 struct btc_coexist *pBtCoexist, bool bForceExec, u8 lpsVal, u8 rpwmVal
775)
776{
777 pCoexDm->curLps = lpsVal;
778 pCoexDm->curRpwm = rpwmVal;
779
780 if (!bForceExec) {
781 if (
782 (pCoexDm->preLps == pCoexDm->curLps) &&
783 (pCoexDm->preRpwm == pCoexDm->curRpwm)
784 ) {
785 return;
786 }
787 }
788 halbtc8723b1ant_SetLpsRpwm(pBtCoexist, lpsVal, rpwmVal);
789
790 pCoexDm->preLps = pCoexDm->curLps;
791 pCoexDm->preRpwm = pCoexDm->curRpwm;
792}
793
794static void halbtc8723b1ant_SwMechanism(
795 struct btc_coexist *pBtCoexist, bool bLowPenaltyRA
796)
797{
798 halbtc8723b1ant_LowPenaltyRa(pBtCoexist, NORMAL_EXEC, bLowPenaltyRA);
799}
800
801static void halbtc8723b1ant_SetAntPath(
802 struct btc_coexist *pBtCoexist, u8 antPosType, bool bInitHwCfg, bool bWifiOff
803)
804{
805 struct btc_board_info *pBoardInfo = &pBtCoexist->boardInfo;
806 u32 fwVer = 0, u4Tmp = 0, cntBtCalChk = 0;
807 bool bPgExtSwitch = false;
808 bool bUseExtSwitch = false;
809 bool bIsInMpMode = false;
810 u8 H2C_Parameter[2] = {0}, u1Tmp = 0;
811
812 pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_EXT_SWITCH, &bPgExtSwitch);
813 pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_U4_WIFI_FW_VER, &fwVer);
814
815 if ((fwVer > 0 && fwVer < 0xc0000) || bPgExtSwitch)
816 bUseExtSwitch = true;
817
818 if (bInitHwCfg) {
819 pBtCoexist->fBtcSetRfReg(pBtCoexist, BTC_RF_A, 0x1, 0xfffff, 0x780);
820 pBtCoexist->fBtcSetBtReg(pBtCoexist, BTC_BT_REG_RF, 0x3c, 0x15);
821
822 if (fwVer >= 0x180000) {
823
824 H2C_Parameter[0] = 1;
825 pBtCoexist->fBtcFillH2c(pBtCoexist, 0x6E, 1, H2C_Parameter);
826 } else
827 pBtCoexist->fBtcWrite1Byte(pBtCoexist, 0x765, 0x18);
828
829
830 pBtCoexist->fBtcWrite1Byte(pBtCoexist, 0x76e, 0x4);
831
832 pBtCoexist->fBtcWrite1ByteBitMask(pBtCoexist, 0x67, 0x20, 0x1);
833
834 pBtCoexist->fBtcWrite1ByteBitMask(pBtCoexist, 0x39, 0x8, 0x1);
835 pBtCoexist->fBtcWrite1Byte(pBtCoexist, 0x974, 0xff);
836 pBtCoexist->fBtcWrite1ByteBitMask(pBtCoexist, 0x944, 0x3, 0x3);
837 pBtCoexist->fBtcWrite1Byte(pBtCoexist, 0x930, 0x77);
838 } else if (bWifiOff) {
839 if (fwVer >= 0x180000) {
840
841 H2C_Parameter[0] = 1;
842 pBtCoexist->fBtcFillH2c(pBtCoexist, 0x6E, 1, H2C_Parameter);
843 } else
844 pBtCoexist->fBtcWrite1Byte(pBtCoexist, 0x765, 0x18);
845
846
847 pBtCoexist->fBtcWrite1Byte(pBtCoexist, 0x76e, 0x4);
848
849 pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_WIFI_IS_IN_MP_MODE, &bIsInMpMode);
850 if (!bIsInMpMode)
851 pBtCoexist->fBtcWrite1ByteBitMask(pBtCoexist, 0x67, 0x20, 0x0);
852 else
853 pBtCoexist->fBtcWrite1ByteBitMask(pBtCoexist, 0x67, 0x20, 0x1);
854
855
856 u4Tmp = pBtCoexist->fBtcRead4Byte(pBtCoexist, 0x4c);
857 u4Tmp &= ~BIT23;
858 u4Tmp &= ~BIT24;
859 pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0x4c, u4Tmp);
860 } else {
861
862 if (fwVer >= 0x180000) {
863 if (pBtCoexist->fBtcRead1Byte(pBtCoexist, 0x765) != 0) {
864 H2C_Parameter[0] = 0;
865 pBtCoexist->fBtcFillH2c(pBtCoexist, 0x6E, 1, H2C_Parameter);
866 }
867 } else {
868
869 while (cntBtCalChk <= 20) {
870 u1Tmp = pBtCoexist->fBtcRead1Byte(pBtCoexist, 0x49d);
871 cntBtCalChk++;
872
873 if (u1Tmp & BIT0)
874 mdelay(50);
875 else
876 break;
877 }
878
879
880 pBtCoexist->fBtcWrite1Byte(pBtCoexist, 0x765, 0x0);
881 }
882
883 if (pBtCoexist->fBtcRead1Byte(pBtCoexist, 0x76e) != 0xc)
884
885 pBtCoexist->fBtcWrite1Byte(pBtCoexist, 0x76e, 0xc);
886 }
887
888 if (bUseExtSwitch) {
889 if (bInitHwCfg) {
890
891 u4Tmp = pBtCoexist->fBtcRead4Byte(pBtCoexist, 0x4c);
892 u4Tmp &= ~BIT23;
893 u4Tmp |= BIT24;
894 pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0x4c, u4Tmp);
895
896 pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0x948, 0x0);
897
898 if (pBoardInfo->btdmAntPos == BTC_ANTENNA_AT_MAIN_PORT) {
899
900 H2C_Parameter[0] = 0;
901 H2C_Parameter[1] = 1;
902 pBtCoexist->fBtcFillH2c(pBtCoexist, 0x65, 2, H2C_Parameter);
903 } else {
904
905 H2C_Parameter[0] = 1;
906 H2C_Parameter[1] = 1;
907 pBtCoexist->fBtcFillH2c(pBtCoexist, 0x65, 2, H2C_Parameter);
908 }
909 }
910
911
912
913 switch (antPosType) {
914 case BTC_ANT_PATH_WIFI:
915 if (pBoardInfo->btdmAntPos == BTC_ANTENNA_AT_MAIN_PORT)
916 pBtCoexist->fBtcWrite1ByteBitMask(pBtCoexist, 0x92c, 0x3, 0x1);
917 else
918 pBtCoexist->fBtcWrite1ByteBitMask(pBtCoexist, 0x92c, 0x3, 0x2);
919 break;
920 case BTC_ANT_PATH_BT:
921 if (pBoardInfo->btdmAntPos == BTC_ANTENNA_AT_MAIN_PORT)
922 pBtCoexist->fBtcWrite1ByteBitMask(pBtCoexist, 0x92c, 0x3, 0x2);
923 else
924 pBtCoexist->fBtcWrite1ByteBitMask(pBtCoexist, 0x92c, 0x3, 0x1);
925 break;
926 default:
927 case BTC_ANT_PATH_PTA:
928 if (pBoardInfo->btdmAntPos == BTC_ANTENNA_AT_MAIN_PORT)
929 pBtCoexist->fBtcWrite1ByteBitMask(pBtCoexist, 0x92c, 0x3, 0x1);
930 else
931 pBtCoexist->fBtcWrite1ByteBitMask(pBtCoexist, 0x92c, 0x3, 0x2);
932 break;
933 }
934
935 } else {
936 if (bInitHwCfg) {
937
938 u4Tmp = pBtCoexist->fBtcRead4Byte(pBtCoexist, 0x4c);
939 u4Tmp |= BIT23;
940 u4Tmp &= ~BIT24;
941 pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0x4c, u4Tmp);
942
943
944 pBtCoexist->fBtcWrite1ByteBitMask(pBtCoexist, 0x64, 0x1, 0x0);
945
946 if (pBoardInfo->btdmAntPos == BTC_ANTENNA_AT_MAIN_PORT) {
947
948
949 H2C_Parameter[0] = 0;
950 H2C_Parameter[1] = 0;
951 pBtCoexist->fBtcFillH2c(pBtCoexist, 0x65, 2, H2C_Parameter);
952 } else {
953
954
955 H2C_Parameter[0] = 1;
956 H2C_Parameter[1] = 0;
957 pBtCoexist->fBtcFillH2c(pBtCoexist, 0x65, 2, H2C_Parameter);
958 }
959 }
960
961
962
963 switch (antPosType) {
964 case BTC_ANT_PATH_WIFI:
965 if (pBoardInfo->btdmAntPos == BTC_ANTENNA_AT_MAIN_PORT)
966 pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0x948, 0x0);
967 else
968 pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0x948, 0x280);
969 break;
970 case BTC_ANT_PATH_BT:
971 if (pBoardInfo->btdmAntPos == BTC_ANTENNA_AT_MAIN_PORT)
972 pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0x948, 0x280);
973 else
974 pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0x948, 0x0);
975 break;
976 default:
977 case BTC_ANT_PATH_PTA:
978 if (pBoardInfo->btdmAntPos == BTC_ANTENNA_AT_MAIN_PORT)
979 pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0x948, 0x200);
980 else
981 pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0x948, 0x80);
982 break;
983 }
984 }
985}
986
987static void halbtc8723b1ant_SetFwPstdma(
988 struct btc_coexist *pBtCoexist, u8 byte1, u8 byte2, u8 byte3, u8 byte4, u8 byte5
989)
990{
991 u8 H2C_Parameter[5] = {0};
992 u8 realByte1 = byte1, realByte5 = byte5;
993 bool bApEnable = false;
994
995 pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_WIFI_AP_MODE_ENABLE, &bApEnable);
996
997 if (bApEnable) {
998 if (byte1 & BIT4 && !(byte1 & BIT5)) {
999 realByte1 &= ~BIT4;
1000 realByte1 |= BIT5;
1001
1002 realByte5 |= BIT5;
1003 realByte5 &= ~BIT6;
1004 }
1005 }
1006
1007 H2C_Parameter[0] = realByte1;
1008 H2C_Parameter[1] = byte2;
1009 H2C_Parameter[2] = byte3;
1010 H2C_Parameter[3] = byte4;
1011 H2C_Parameter[4] = realByte5;
1012
1013 pCoexDm->psTdmaPara[0] = realByte1;
1014 pCoexDm->psTdmaPara[1] = byte2;
1015 pCoexDm->psTdmaPara[2] = byte3;
1016 pCoexDm->psTdmaPara[3] = byte4;
1017 pCoexDm->psTdmaPara[4] = realByte5;
1018
1019 pBtCoexist->fBtcFillH2c(pBtCoexist, 0x60, 5, H2C_Parameter);
1020}
1021
1022
1023static void halbtc8723b1ant_PsTdma(
1024 struct btc_coexist *pBtCoexist, bool bForceExec, bool bTurnOn, u8 type
1025)
1026{
1027 struct btc_bt_link_info *pBtLinkInfo = &pBtCoexist->btLinkInfo;
1028 bool bWifiBusy = false;
1029 u8 rssiAdjustVal = 0;
1030 u8 psTdmaByte4Val = 0x50, psTdmaByte0Val = 0x51, psTdmaByte3Val = 0x10;
1031 s8 nWiFiDurationAdjust = 0x0;
1032
1033
1034 pCoexDm->bCurPsTdmaOn = bTurnOn;
1035 pCoexDm->curPsTdma = type;
1036
1037 pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_WIFI_BUSY, &bWifiBusy);
1038
1039 if (!bForceExec) {
1040 if (
1041 (pCoexDm->bPrePsTdmaOn == pCoexDm->bCurPsTdmaOn) &&
1042 (pCoexDm->prePsTdma == pCoexDm->curPsTdma)
1043 )
1044 return;
1045 }
1046
1047 if (pCoexSta->nScanAPNum <= 5)
1048 nWiFiDurationAdjust = 5;
1049 else if (pCoexSta->nScanAPNum >= 40)
1050 nWiFiDurationAdjust = -15;
1051 else if (pCoexSta->nScanAPNum >= 20)
1052 nWiFiDurationAdjust = -10;
1053
1054 if (!pCoexSta->bForceLpsOn) {
1055 psTdmaByte0Val = 0x61;
1056 psTdmaByte3Val = 0x11;
1057 psTdmaByte4Val = 0x10;
1058 }
1059
1060
1061 if (bTurnOn) {
1062 if (pBtLinkInfo->bSlaveRole)
1063 psTdmaByte4Val = psTdmaByte4Val | 0x1;
1064
1065
1066 switch (type) {
1067 default:
1068 halbtc8723b1ant_SetFwPstdma(
1069 pBtCoexist, 0x51, 0x1a, 0x1a, 0x0, psTdmaByte4Val
1070 );
1071 break;
1072 case 1:
1073 halbtc8723b1ant_SetFwPstdma(
1074 pBtCoexist,
1075 psTdmaByte0Val,
1076 0x3a + nWiFiDurationAdjust,
1077 0x03,
1078 psTdmaByte3Val,
1079 psTdmaByte4Val
1080 );
1081 break;
1082 case 2:
1083 halbtc8723b1ant_SetFwPstdma(
1084 pBtCoexist,
1085 psTdmaByte0Val,
1086 0x2d + nWiFiDurationAdjust,
1087 0x03,
1088 psTdmaByte3Val,
1089 psTdmaByte4Val
1090 );
1091 break;
1092 case 3:
1093 halbtc8723b1ant_SetFwPstdma(
1094 pBtCoexist, 0x51, 0x1d, 0x1d, 0x0, 0x10
1095 );
1096 break;
1097 case 4:
1098 halbtc8723b1ant_SetFwPstdma(
1099 pBtCoexist, 0x93, 0x15, 0x3, 0x14, 0x0
1100 );
1101 break;
1102 case 5:
1103 halbtc8723b1ant_SetFwPstdma(
1104 pBtCoexist, 0x61, 0x15, 0x3, 0x11, 0x10
1105 );
1106 break;
1107 case 6:
1108 halbtc8723b1ant_SetFwPstdma(
1109 pBtCoexist, 0x61, 0x20, 0x3, 0x11, 0x11
1110 );
1111 break;
1112 case 7:
1113 halbtc8723b1ant_SetFwPstdma(pBtCoexist, 0x13, 0xc, 0x5, 0x0, 0x0);
1114 break;
1115 case 8:
1116 halbtc8723b1ant_SetFwPstdma(
1117 pBtCoexist, 0x93, 0x25, 0x3, 0x10, 0x0
1118 );
1119 break;
1120 case 9:
1121 halbtc8723b1ant_SetFwPstdma(
1122 pBtCoexist,
1123 psTdmaByte0Val,
1124 0x21,
1125 0x3,
1126 psTdmaByte3Val,
1127 psTdmaByte4Val
1128 );
1129 break;
1130 case 10:
1131 halbtc8723b1ant_SetFwPstdma(pBtCoexist, 0x13, 0xa, 0xa, 0x0, 0x40);
1132 break;
1133 case 11:
1134 halbtc8723b1ant_SetFwPstdma(
1135 pBtCoexist,
1136 psTdmaByte0Val,
1137 0x21,
1138 0x03,
1139 psTdmaByte3Val,
1140 psTdmaByte4Val
1141 );
1142 break;
1143 case 12:
1144 halbtc8723b1ant_SetFwPstdma(
1145 pBtCoexist, 0x51, 0x0a, 0x0a, 0x0, 0x50
1146 );
1147 break;
1148 case 13:
1149 halbtc8723b1ant_SetFwPstdma(
1150 pBtCoexist, 0x51, 0x12, 0x12, 0x0, 0x10
1151 );
1152 break;
1153 case 14:
1154 halbtc8723b1ant_SetFwPstdma(
1155 pBtCoexist, 0x51, 0x21, 0x3, 0x10, psTdmaByte4Val
1156 );
1157 break;
1158 case 15:
1159 halbtc8723b1ant_SetFwPstdma(
1160 pBtCoexist, 0x13, 0xa, 0x3, 0x8, 0x0
1161 );
1162 break;
1163 case 16:
1164 halbtc8723b1ant_SetFwPstdma(
1165 pBtCoexist, 0x93, 0x15, 0x3, 0x10, 0x0
1166 );
1167 break;
1168 case 18:
1169 halbtc8723b1ant_SetFwPstdma(
1170 pBtCoexist, 0x93, 0x25, 0x3, 0x10, 0x0
1171 );
1172 break;
1173 case 20:
1174 halbtc8723b1ant_SetFwPstdma(
1175 pBtCoexist, 0x61, 0x3f, 0x03, 0x11, 0x10
1176
1177 );
1178 break;
1179 case 21:
1180 halbtc8723b1ant_SetFwPstdma(
1181 pBtCoexist, 0x61, 0x25, 0x03, 0x11, 0x11
1182 );
1183 break;
1184 case 22:
1185 halbtc8723b1ant_SetFwPstdma(
1186 pBtCoexist, 0x61, 0x25, 0x03, 0x11, 0x10
1187 );
1188 break;
1189 case 23:
1190 halbtc8723b1ant_SetFwPstdma(
1191 pBtCoexist, 0xe3, 0x25, 0x3, 0x31, 0x18
1192 );
1193 break;
1194 case 24:
1195 halbtc8723b1ant_SetFwPstdma(
1196 pBtCoexist, 0xe3, 0x15, 0x3, 0x31, 0x18
1197 );
1198 break;
1199 case 25:
1200 halbtc8723b1ant_SetFwPstdma(
1201 pBtCoexist, 0xe3, 0xa, 0x3, 0x31, 0x18
1202 );
1203 break;
1204 case 26:
1205 halbtc8723b1ant_SetFwPstdma(
1206 pBtCoexist, 0xe3, 0xa, 0x3, 0x31, 0x18
1207 );
1208 break;
1209 case 27:
1210 halbtc8723b1ant_SetFwPstdma(
1211 pBtCoexist, 0xe3, 0x25, 0x3, 0x31, 0x98
1212 );
1213 break;
1214 case 28:
1215 halbtc8723b1ant_SetFwPstdma(
1216 pBtCoexist, 0x69, 0x25, 0x3, 0x31, 0x0
1217 );
1218 break;
1219 case 29:
1220 halbtc8723b1ant_SetFwPstdma(
1221 pBtCoexist, 0xab, 0x1a, 0x1a, 0x1, 0x10
1222 );
1223 break;
1224 case 30:
1225 halbtc8723b1ant_SetFwPstdma(
1226 pBtCoexist, 0x51, 0x30, 0x3, 0x10, 0x10
1227 );
1228 break;
1229 case 31:
1230 halbtc8723b1ant_SetFwPstdma(
1231 pBtCoexist, 0xd3, 0x1a, 0x1a, 0x0, 0x58
1232 );
1233 break;
1234 case 32:
1235 halbtc8723b1ant_SetFwPstdma(
1236 pBtCoexist, 0x61, 0x35, 0x3, 0x11, 0x11
1237 );
1238 break;
1239 case 33:
1240 halbtc8723b1ant_SetFwPstdma(
1241 pBtCoexist, 0xa3, 0x25, 0x3, 0x30, 0x90
1242 );
1243 break;
1244 case 34:
1245 halbtc8723b1ant_SetFwPstdma(
1246 pBtCoexist, 0x53, 0x1a, 0x1a, 0x0, 0x10
1247 );
1248 break;
1249 case 35:
1250 halbtc8723b1ant_SetFwPstdma(
1251 pBtCoexist, 0x63, 0x1a, 0x1a, 0x0, 0x10
1252 );
1253 break;
1254 case 36:
1255 halbtc8723b1ant_SetFwPstdma(
1256 pBtCoexist, 0xd3, 0x12, 0x3, 0x14, 0x50
1257 );
1258 break;
1259 case 40:
1260
1261 halbtc8723b1ant_SetFwPstdma(
1262 pBtCoexist, 0x23, 0x18, 0x00, 0x10, 0x24
1263 );
1264 break;
1265 }
1266 } else {
1267
1268
1269 switch (type) {
1270 case 8:
1271 halbtc8723b1ant_SetFwPstdma(pBtCoexist, 0x8, 0x0, 0x0, 0x0, 0x0);
1272 halbtc8723b1ant_SetAntPath(
1273 pBtCoexist, BTC_ANT_PATH_PTA, false, false
1274 );
1275 break;
1276 case 0:
1277 default:
1278 halbtc8723b1ant_SetFwPstdma(pBtCoexist, 0x0, 0x0, 0x0, 0x0, 0x0);
1279 halbtc8723b1ant_SetAntPath(
1280 pBtCoexist, BTC_ANT_PATH_BT, false, false
1281 );
1282 break;
1283 case 9:
1284 halbtc8723b1ant_SetFwPstdma(pBtCoexist, 0x0, 0x0, 0x0, 0x0, 0x0);
1285 halbtc8723b1ant_SetAntPath(
1286 pBtCoexist, BTC_ANT_PATH_WIFI, false, false
1287 );
1288 break;
1289 }
1290 }
1291
1292 rssiAdjustVal = 0;
1293 pBtCoexist->fBtcSet(
1294 pBtCoexist, BTC_SET_U1_RSSI_ADJ_VAL_FOR_1ANT_COEX_TYPE, &rssiAdjustVal
1295 );
1296
1297
1298 pCoexDm->bPrePsTdmaOn = pCoexDm->bCurPsTdmaOn;
1299 pCoexDm->prePsTdma = pCoexDm->curPsTdma;
1300}
1301
1302static bool halbtc8723b1ant_IsCommonAction(struct btc_coexist *pBtCoexist)
1303{
1304 bool bCommon = false, bWifiConnected = false, bWifiBusy = false;
1305
1306 pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_WIFI_CONNECTED, &bWifiConnected);
1307 pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_WIFI_BUSY, &bWifiBusy);
1308
1309 if (
1310 !bWifiConnected &&
1311 pCoexDm->btStatus == BT_8723B_1ANT_BT_STATUS_NON_CONNECTED_IDLE
1312 ) {
1313
1314
1315 bCommon = true;
1316 } else if (
1317 bWifiConnected &&
1318 (pCoexDm->btStatus == BT_8723B_1ANT_BT_STATUS_NON_CONNECTED_IDLE)
1319 ) {
1320
1321
1322 bCommon = true;
1323 } else if (
1324 !bWifiConnected &&
1325 (pCoexDm->btStatus == BT_8723B_1ANT_BT_STATUS_CONNECTED_IDLE)
1326 ) {
1327
1328
1329 bCommon = true;
1330 } else if (
1331 bWifiConnected &&
1332 (pCoexDm->btStatus == BT_8723B_1ANT_BT_STATUS_CONNECTED_IDLE)
1333 ) {
1334
1335
1336 bCommon = true;
1337 } else if (
1338 !bWifiConnected &&
1339 (pCoexDm->btStatus != BT_8723B_1ANT_BT_STATUS_CONNECTED_IDLE)
1340 ) {
1341
1342
1343 bCommon = true;
1344 } else {
1345 bCommon = false;
1346 }
1347
1348 return bCommon;
1349}
1350
1351
1352static void halbtc8723b1ant_TdmaDurationAdjustForAcl(
1353 struct btc_coexist *pBtCoexist, u8 wifiStatus
1354)
1355{
1356 static s32 up, dn, m, n, WaitCount;
1357 s32 result;
1358 u8 retryCount = 0, btInfoExt;
1359
1360 if (
1361 (wifiStatus == BT_8723B_1ANT_WIFI_STATUS_NON_CONNECTED_ASSO_AUTH_SCAN) ||
1362 (wifiStatus == BT_8723B_1ANT_WIFI_STATUS_CONNECTED_SCAN) ||
1363 (wifiStatus == BT_8723B_1ANT_WIFI_STATUS_CONNECTED_SPECIAL_PKT)
1364 ) {
1365 if (
1366 pCoexDm->curPsTdma != 1 &&
1367 pCoexDm->curPsTdma != 2 &&
1368 pCoexDm->curPsTdma != 3 &&
1369 pCoexDm->curPsTdma != 9
1370 ) {
1371 halbtc8723b1ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 9);
1372 pCoexDm->psTdmaDuAdjType = 9;
1373
1374 up = 0;
1375 dn = 0;
1376 m = 1;
1377 n = 3;
1378 result = 0;
1379 WaitCount = 0;
1380 }
1381 return;
1382 }
1383
1384 if (!pCoexDm->bAutoTdmaAdjust) {
1385 pCoexDm->bAutoTdmaAdjust = true;
1386
1387 halbtc8723b1ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 2);
1388 pCoexDm->psTdmaDuAdjType = 2;
1389
1390 up = 0;
1391 dn = 0;
1392 m = 1;
1393 n = 3;
1394 result = 0;
1395 WaitCount = 0;
1396 } else {
1397
1398 retryCount = pCoexSta->btRetryCnt;
1399 btInfoExt = pCoexSta->btInfoExt;
1400
1401 if (pCoexSta->lowPriorityTx > 1050 || pCoexSta->lowPriorityRx > 1250)
1402 retryCount++;
1403
1404 result = 0;
1405 WaitCount++;
1406
1407 if (retryCount == 0) {
1408 up++;
1409 dn--;
1410
1411 if (dn <= 0)
1412 dn = 0;
1413
1414 if (up >= n) {
1415 WaitCount = 0;
1416 n = 3;
1417 up = 0;
1418 dn = 0;
1419 result = 1;
1420 }
1421 } else if (retryCount <= 3) {
1422 up--;
1423 dn++;
1424
1425 if (up <= 0)
1426 up = 0;
1427
1428 if (dn == 2) {
1429 if (WaitCount <= 2)
1430 m++;
1431 else
1432 m = 1;
1433
1434 if (m >= 20)
1435 m = 20;
1436
1437 n = 3 * m;
1438 up = 0;
1439 dn = 0;
1440 WaitCount = 0;
1441 result = -1;
1442 }
1443 } else {
1444 if (WaitCount == 1)
1445 m++;
1446 else
1447 m = 1;
1448
1449 if (m >= 20)
1450 m = 20;
1451
1452 n = 3 * m;
1453 up = 0;
1454 dn = 0;
1455 WaitCount = 0;
1456 result = -1;
1457 }
1458
1459 if (result == -1) {
1460 if (
1461 BT_INFO_8723B_1ANT_A2DP_BASIC_RATE(btInfoExt) &&
1462 ((pCoexDm->curPsTdma == 1) || (pCoexDm->curPsTdma == 2))
1463 ) {
1464 halbtc8723b1ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 9);
1465 pCoexDm->psTdmaDuAdjType = 9;
1466 } else if (pCoexDm->curPsTdma == 1) {
1467 halbtc8723b1ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 2);
1468 pCoexDm->psTdmaDuAdjType = 2;
1469 } else if (pCoexDm->curPsTdma == 2) {
1470 halbtc8723b1ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 9);
1471 pCoexDm->psTdmaDuAdjType = 9;
1472 } else if (pCoexDm->curPsTdma == 9) {
1473 halbtc8723b1ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 11);
1474 pCoexDm->psTdmaDuAdjType = 11;
1475 }
1476 } else if (result == 1) {
1477 if (
1478 BT_INFO_8723B_1ANT_A2DP_BASIC_RATE(btInfoExt) &&
1479 ((pCoexDm->curPsTdma == 1) || (pCoexDm->curPsTdma == 2))
1480 ) {
1481 halbtc8723b1ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 9);
1482 pCoexDm->psTdmaDuAdjType = 9;
1483 } else if (pCoexDm->curPsTdma == 11) {
1484 halbtc8723b1ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 9);
1485 pCoexDm->psTdmaDuAdjType = 9;
1486 } else if (pCoexDm->curPsTdma == 9) {
1487 halbtc8723b1ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 2);
1488 pCoexDm->psTdmaDuAdjType = 2;
1489 } else if (pCoexDm->curPsTdma == 2) {
1490 halbtc8723b1ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 1);
1491 pCoexDm->psTdmaDuAdjType = 1;
1492 }
1493 }
1494
1495 if (
1496 pCoexDm->curPsTdma != 1 &&
1497 pCoexDm->curPsTdma != 2 &&
1498 pCoexDm->curPsTdma != 9 &&
1499 pCoexDm->curPsTdma != 11
1500 )
1501 halbtc8723b1ant_PsTdma(
1502 pBtCoexist, NORMAL_EXEC, true, pCoexDm->psTdmaDuAdjType
1503 );
1504 }
1505}
1506
1507static void halbtc8723b1ant_PsTdmaCheckForPowerSaveState(
1508 struct btc_coexist *pBtCoexist, bool bNewPsState
1509)
1510{
1511 u8 lpsMode = 0x0;
1512
1513 pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_U1_LPS_MODE, &lpsMode);
1514
1515 if (lpsMode) {
1516 if (bNewPsState) {
1517
1518 } else
1519 halbtc8723b1ant_PsTdma(pBtCoexist, NORMAL_EXEC, false, 0);
1520 } else {
1521 if (bNewPsState)
1522 halbtc8723b1ant_PsTdma(pBtCoexist, NORMAL_EXEC, false, 0);
1523 else {
1524
1525 }
1526 }
1527}
1528
1529static void halbtc8723b1ant_PowerSaveState(
1530 struct btc_coexist *pBtCoexist, u8 psType, u8 lpsVal, u8 rpwmVal
1531)
1532{
1533 bool bLowPwrDisable = false;
1534
1535 switch (psType) {
1536 case BTC_PS_WIFI_NATIVE:
1537
1538 bLowPwrDisable = false;
1539 pBtCoexist->fBtcSet(
1540 pBtCoexist, BTC_SET_ACT_DISABLE_LOW_POWER, &bLowPwrDisable
1541 );
1542 pBtCoexist->fBtcSet(pBtCoexist, BTC_SET_ACT_NORMAL_LPS, NULL);
1543 pCoexSta->bForceLpsOn = false;
1544 break;
1545 case BTC_PS_LPS_ON:
1546 halbtc8723b1ant_PsTdmaCheckForPowerSaveState(pBtCoexist, true);
1547 halbtc8723b1ant_LpsRpwm(pBtCoexist, NORMAL_EXEC, lpsVal, rpwmVal);
1548
1549 bLowPwrDisable = true;
1550 pBtCoexist->fBtcSet(
1551 pBtCoexist, BTC_SET_ACT_DISABLE_LOW_POWER, &bLowPwrDisable
1552 );
1553
1554 pBtCoexist->fBtcSet(pBtCoexist, BTC_SET_ACT_ENTER_LPS, NULL);
1555 pCoexSta->bForceLpsOn = true;
1556 break;
1557 case BTC_PS_LPS_OFF:
1558 halbtc8723b1ant_PsTdmaCheckForPowerSaveState(pBtCoexist, false);
1559 pBtCoexist->fBtcSet(pBtCoexist, BTC_SET_ACT_LEAVE_LPS, NULL);
1560 pCoexSta->bForceLpsOn = false;
1561 break;
1562 default:
1563 break;
1564 }
1565}
1566
1567
1568
1569
1570
1571
1572
1573
1574
1575
1576
1577
1578static void halbtc8723b1ant_ActionWifiMultiPort(struct btc_coexist *pBtCoexist)
1579{
1580 halbtc8723b1ant_PowerSaveState(pBtCoexist, BTC_PS_WIFI_NATIVE, 0x0, 0x0);
1581
1582 halbtc8723b1ant_PsTdma(pBtCoexist, NORMAL_EXEC, false, 8);
1583 halbtc8723b1ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 2);
1584}
1585
1586static void halbtc8723b1ant_ActionHs(struct btc_coexist *pBtCoexist)
1587{
1588 halbtc8723b1ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 5);
1589 halbtc8723b1ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 2);
1590}
1591
1592static void halbtc8723b1ant_ActionBtInquiry(struct btc_coexist *pBtCoexist)
1593{
1594 struct btc_bt_link_info *pBtLinkInfo = &pBtCoexist->btLinkInfo;
1595 bool bWifiConnected = false;
1596 bool bApEnable = false;
1597 bool bWifiBusy = false;
1598 bool bBtBusy = false;
1599
1600 pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_WIFI_AP_MODE_ENABLE, &bApEnable);
1601 pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_WIFI_CONNECTED, &bWifiConnected);
1602 pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_WIFI_BUSY, &bWifiBusy);
1603 pBtCoexist->fBtcSet(pBtCoexist, BTC_SET_BL_BT_TRAFFIC_BUSY, &bBtBusy);
1604
1605 if (!bWifiConnected && !pCoexSta->bWiFiIsHighPriTask) {
1606 halbtc8723b1ant_PowerSaveState(pBtCoexist, BTC_PS_WIFI_NATIVE, 0x0, 0x0);
1607 halbtc8723b1ant_PsTdma(pBtCoexist, NORMAL_EXEC, false, 8);
1608
1609 halbtc8723b1ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 0);
1610 } else if (
1611 pBtLinkInfo->bScoExist ||
1612 pBtLinkInfo->bHidExist ||
1613 pBtLinkInfo->bA2dpExist
1614 ) {
1615
1616 halbtc8723b1ant_PowerSaveState(pBtCoexist, BTC_PS_WIFI_NATIVE, 0x0, 0x0);
1617 halbtc8723b1ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 32);
1618
1619 halbtc8723b1ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 4);
1620 } else if (pBtLinkInfo->bPanExist || bWifiBusy) {
1621 halbtc8723b1ant_PowerSaveState(pBtCoexist, BTC_PS_WIFI_NATIVE, 0x0, 0x0);
1622 halbtc8723b1ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 20);
1623
1624 halbtc8723b1ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 4);
1625 } else {
1626 halbtc8723b1ant_PowerSaveState(pBtCoexist, BTC_PS_WIFI_NATIVE, 0x0, 0x0);
1627 halbtc8723b1ant_PsTdma(pBtCoexist, NORMAL_EXEC, false, 8);
1628
1629 halbtc8723b1ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 7);
1630 }
1631}
1632
1633static void halbtc8723b1ant_ActionBtScoHidOnlyBusy(
1634 struct btc_coexist *pBtCoexist, u8 wifiStatus
1635)
1636{
1637 struct btc_bt_link_info *pBtLinkInfo = &pBtCoexist->btLinkInfo;
1638 bool bWifiConnected = false;
1639
1640 pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_WIFI_CONNECTED, &bWifiConnected);
1641
1642
1643
1644 if (pBtLinkInfo->bScoExist) {
1645 halbtc8723b1ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 5);
1646 halbtc8723b1ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 5);
1647 } else {
1648 halbtc8723b1ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 6);
1649 halbtc8723b1ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 5);
1650 }
1651}
1652
1653static void halbtc8723b1ant_ActionWifiConnectedBtAclBusy(
1654 struct btc_coexist *pBtCoexist, u8 wifiStatus
1655)
1656{
1657 struct btc_bt_link_info *pBtLinkInfo = &pBtCoexist->btLinkInfo;
1658
1659 halbtc8723b1ant_BtRssiState(2, 28, 0);
1660
1661 if ((pCoexSta->lowPriorityRx >= 1000) && (pCoexSta->lowPriorityRx != 65535))
1662 pBtLinkInfo->bSlaveRole = true;
1663 else
1664 pBtLinkInfo->bSlaveRole = false;
1665
1666 if (pBtLinkInfo->bHidOnly) {
1667 halbtc8723b1ant_ActionBtScoHidOnlyBusy(pBtCoexist, wifiStatus);
1668 pCoexDm->bAutoTdmaAdjust = false;
1669 return;
1670 } else if (pBtLinkInfo->bA2dpOnly) {
1671 if (wifiStatus == BT_8723B_1ANT_WIFI_STATUS_CONNECTED_IDLE) {
1672 halbtc8723b1ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 32);
1673 halbtc8723b1ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 4);
1674 pCoexDm->bAutoTdmaAdjust = false;
1675 } else {
1676 halbtc8723b1ant_TdmaDurationAdjustForAcl(pBtCoexist, wifiStatus);
1677 halbtc8723b1ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 4);
1678 pCoexDm->bAutoTdmaAdjust = true;
1679 }
1680 } else if (pBtLinkInfo->bHidExist && pBtLinkInfo->bA2dpExist) {
1681 halbtc8723b1ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 14);
1682 pCoexDm->bAutoTdmaAdjust = false;
1683
1684 halbtc8723b1ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 4);
1685 } else if (
1686 pBtLinkInfo->bPanOnly ||
1687 (pBtLinkInfo->bHidExist && pBtLinkInfo->bPanExist)
1688 ) {
1689 halbtc8723b1ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 3);
1690 halbtc8723b1ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 4);
1691 pCoexDm->bAutoTdmaAdjust = false;
1692 } else if (
1693 (pBtLinkInfo->bA2dpExist && pBtLinkInfo->bPanExist) ||
1694 (pBtLinkInfo->bHidExist && pBtLinkInfo->bA2dpExist && pBtLinkInfo->bPanExist)
1695 ) {
1696 halbtc8723b1ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 13);
1697 halbtc8723b1ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 4);
1698 pCoexDm->bAutoTdmaAdjust = false;
1699 } else {
1700
1701 halbtc8723b1ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 32);
1702 halbtc8723b1ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 4);
1703 pCoexDm->bAutoTdmaAdjust = false;
1704 }
1705}
1706
1707static void halbtc8723b1ant_ActionWifiNotConnected(struct btc_coexist *pBtCoexist)
1708{
1709
1710 halbtc8723b1ant_PowerSaveState(pBtCoexist, BTC_PS_WIFI_NATIVE, 0x0, 0x0);
1711
1712
1713 halbtc8723b1ant_PsTdma(pBtCoexist, FORCE_EXEC, false, 8);
1714 halbtc8723b1ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 0);
1715}
1716
1717static void halbtc8723b1ant_ActionWifiNotConnectedScan(
1718 struct btc_coexist *pBtCoexist
1719)
1720{
1721 struct btc_bt_link_info *pBtLinkInfo = &pBtCoexist->btLinkInfo;
1722
1723 halbtc8723b1ant_PowerSaveState(pBtCoexist, BTC_PS_WIFI_NATIVE, 0x0, 0x0);
1724
1725
1726 if (pCoexDm->btStatus == BT_8723B_1ANT_BT_STATUS_ACL_BUSY) {
1727 if (pBtLinkInfo->bA2dpExist) {
1728 halbtc8723b1ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 32);
1729 halbtc8723b1ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 4);
1730 } else if (pBtLinkInfo->bA2dpExist && pBtLinkInfo->bPanExist) {
1731 halbtc8723b1ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 22);
1732 halbtc8723b1ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 4);
1733 } else {
1734 halbtc8723b1ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 20);
1735 halbtc8723b1ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 4);
1736 }
1737 } else if (
1738 (pCoexDm->btStatus == BT_8723B_1ANT_BT_STATUS_SCO_BUSY) ||
1739 (pCoexDm->btStatus == BT_8723B_1ANT_BT_STATUS_ACL_SCO_BUSY)
1740 ) {
1741 halbtc8723b1ant_ActionBtScoHidOnlyBusy(
1742 pBtCoexist, BT_8723B_1ANT_WIFI_STATUS_CONNECTED_SCAN
1743 );
1744 } else {
1745
1746 halbtc8723b1ant_PsTdma(pBtCoexist, NORMAL_EXEC, false, 8);
1747 halbtc8723b1ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 2);
1748 }
1749}
1750
1751static void halbtc8723b1ant_ActionWifiNotConnectedAssoAuth(
1752 struct btc_coexist *pBtCoexist
1753)
1754{
1755 struct btc_bt_link_info *pBtLinkInfo = &pBtCoexist->btLinkInfo;
1756
1757 halbtc8723b1ant_PowerSaveState(pBtCoexist, BTC_PS_WIFI_NATIVE, 0x0, 0x0);
1758
1759
1760 if (
1761 (pBtLinkInfo->bScoExist) ||
1762 (pBtLinkInfo->bHidExist) ||
1763 (pBtLinkInfo->bA2dpExist)
1764 ) {
1765 halbtc8723b1ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 32);
1766 halbtc8723b1ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 4);
1767 } else if (pBtLinkInfo->bPanExist) {
1768 halbtc8723b1ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 20);
1769 halbtc8723b1ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 4);
1770 } else {
1771 halbtc8723b1ant_PsTdma(pBtCoexist, NORMAL_EXEC, false, 8);
1772 halbtc8723b1ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 2);
1773 }
1774}
1775
1776static void halbtc8723b1ant_ActionWifiConnectedScan(struct btc_coexist *pBtCoexist)
1777{
1778 struct btc_bt_link_info *pBtLinkInfo = &pBtCoexist->btLinkInfo;
1779
1780 halbtc8723b1ant_PowerSaveState(pBtCoexist, BTC_PS_WIFI_NATIVE, 0x0, 0x0);
1781
1782
1783 if (pCoexDm->btStatus == BT_8723B_1ANT_BT_STATUS_ACL_BUSY) {
1784 if (pBtLinkInfo->bA2dpExist) {
1785 halbtc8723b1ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 32);
1786 halbtc8723b1ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 4);
1787 } else if (pBtLinkInfo->bA2dpExist && pBtLinkInfo->bPanExist) {
1788 halbtc8723b1ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 22);
1789 halbtc8723b1ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 4);
1790 } else {
1791 halbtc8723b1ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 20);
1792 halbtc8723b1ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 4);
1793 }
1794 } else if (
1795 (pCoexDm->btStatus == BT_8723B_1ANT_BT_STATUS_SCO_BUSY) ||
1796 (pCoexDm->btStatus == BT_8723B_1ANT_BT_STATUS_ACL_SCO_BUSY)
1797 ) {
1798 halbtc8723b1ant_ActionBtScoHidOnlyBusy(
1799 pBtCoexist, BT_8723B_1ANT_WIFI_STATUS_CONNECTED_SCAN
1800 );
1801 } else {
1802
1803 halbtc8723b1ant_PsTdma(pBtCoexist, NORMAL_EXEC, false, 8);
1804 halbtc8723b1ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 2);
1805 }
1806}
1807
1808static void halbtc8723b1ant_ActionWifiConnectedSpecialPacket(
1809 struct btc_coexist *pBtCoexist
1810)
1811{
1812 struct btc_bt_link_info *pBtLinkInfo = &pBtCoexist->btLinkInfo;
1813
1814 halbtc8723b1ant_PowerSaveState(pBtCoexist, BTC_PS_WIFI_NATIVE, 0x0, 0x0);
1815
1816
1817 if (
1818 (pBtLinkInfo->bScoExist) ||
1819 (pBtLinkInfo->bHidExist) ||
1820 (pBtLinkInfo->bA2dpExist)
1821 ) {
1822 halbtc8723b1ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 32);
1823 halbtc8723b1ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 4);
1824 } else if (pBtLinkInfo->bPanExist) {
1825 halbtc8723b1ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 20);
1826 halbtc8723b1ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 4);
1827 } else {
1828 halbtc8723b1ant_PsTdma(pBtCoexist, NORMAL_EXEC, false, 8);
1829 halbtc8723b1ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 2);
1830 }
1831}
1832
1833static void halbtc8723b1ant_ActionWifiConnected(struct btc_coexist *pBtCoexist)
1834{
1835 bool bWifiBusy = false;
1836 bool bScan = false, bLink = false, bRoam = false;
1837 bool bUnder4way = false, bApEnable = false;
1838
1839 pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_WIFI_4_WAY_PROGRESS, &bUnder4way);
1840 if (bUnder4way) {
1841 halbtc8723b1ant_ActionWifiConnectedSpecialPacket(pBtCoexist);
1842 return;
1843 }
1844
1845 pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_WIFI_SCAN, &bScan);
1846 pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_WIFI_LINK, &bLink);
1847 pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_WIFI_ROAM, &bRoam);
1848 if (bScan || bLink || bRoam) {
1849 if (bScan)
1850 halbtc8723b1ant_ActionWifiConnectedScan(pBtCoexist);
1851 else
1852 halbtc8723b1ant_ActionWifiConnectedSpecialPacket(pBtCoexist);
1853 return;
1854 }
1855
1856 pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_WIFI_AP_MODE_ENABLE, &bApEnable);
1857 pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_WIFI_BUSY, &bWifiBusy);
1858
1859
1860 if (
1861 !bApEnable &&
1862 pCoexDm->btStatus == BT_8723B_1ANT_BT_STATUS_ACL_BUSY &&
1863 !pBtCoexist->btLinkInfo.bHidOnly
1864 ) {
1865 if (pBtCoexist->btLinkInfo.bA2dpOnly) {
1866 if (!bWifiBusy)
1867 halbtc8723b1ant_PowerSaveState(
1868 pBtCoexist, BTC_PS_WIFI_NATIVE, 0x0, 0x0
1869 );
1870 else {
1871 if (pCoexSta->nScanAPNum >= BT_8723B_1ANT_WIFI_NOISY_THRESH)
1872 halbtc8723b1ant_PowerSaveState(
1873 pBtCoexist, BTC_PS_WIFI_NATIVE, 0x0, 0x0
1874 );
1875 else
1876 halbtc8723b1ant_PowerSaveState(
1877 pBtCoexist, BTC_PS_LPS_ON, 0x50, 0x4
1878 );
1879 }
1880 } else if (
1881 (!pCoexSta->bPanExist) &&
1882 (!pCoexSta->bA2dpExist) &&
1883 (!pCoexSta->bHidExist)
1884 )
1885 halbtc8723b1ant_PowerSaveState(pBtCoexist, BTC_PS_WIFI_NATIVE, 0x0, 0x0);
1886 else
1887 halbtc8723b1ant_PowerSaveState(pBtCoexist, BTC_PS_LPS_ON, 0x50, 0x4);
1888 } else
1889 halbtc8723b1ant_PowerSaveState(pBtCoexist, BTC_PS_WIFI_NATIVE, 0x0, 0x0);
1890
1891
1892 if (!bWifiBusy) {
1893 if (pCoexDm->btStatus == BT_8723B_1ANT_BT_STATUS_ACL_BUSY) {
1894 halbtc8723b1ant_ActionWifiConnectedBtAclBusy(
1895 pBtCoexist,
1896 BT_8723B_1ANT_WIFI_STATUS_CONNECTED_IDLE
1897 );
1898 } else if (
1899 (pCoexDm->btStatus == BT_8723B_1ANT_BT_STATUS_SCO_BUSY) ||
1900 (pCoexDm->btStatus == BT_8723B_1ANT_BT_STATUS_ACL_SCO_BUSY)
1901 ) {
1902 halbtc8723b1ant_ActionBtScoHidOnlyBusy(pBtCoexist,
1903 BT_8723B_1ANT_WIFI_STATUS_CONNECTED_IDLE);
1904 } else {
1905 halbtc8723b1ant_PsTdma(pBtCoexist, NORMAL_EXEC, false, 8);
1906
1907 if ((pCoexSta->highPriorityTx) + (pCoexSta->highPriorityRx) <= 60)
1908 halbtc8723b1ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 2);
1909 else
1910 halbtc8723b1ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 7);
1911 }
1912 } else {
1913 if (pCoexDm->btStatus == BT_8723B_1ANT_BT_STATUS_ACL_BUSY) {
1914 halbtc8723b1ant_ActionWifiConnectedBtAclBusy(
1915 pBtCoexist,
1916 BT_8723B_1ANT_WIFI_STATUS_CONNECTED_BUSY
1917 );
1918 } else if (
1919 (pCoexDm->btStatus == BT_8723B_1ANT_BT_STATUS_SCO_BUSY) ||
1920 (pCoexDm->btStatus == BT_8723B_1ANT_BT_STATUS_ACL_SCO_BUSY)
1921 ) {
1922 halbtc8723b1ant_ActionBtScoHidOnlyBusy(
1923 pBtCoexist,
1924 BT_8723B_1ANT_WIFI_STATUS_CONNECTED_BUSY
1925 );
1926 } else {
1927 halbtc8723b1ant_PsTdma(pBtCoexist, NORMAL_EXEC, false, 8);
1928
1929 if ((pCoexSta->highPriorityTx) + (pCoexSta->highPriorityRx) <= 60)
1930 halbtc8723b1ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 2);
1931 else
1932 halbtc8723b1ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 7);
1933 }
1934 }
1935}
1936
1937static void halbtc8723b1ant_RunSwCoexistMechanism(struct btc_coexist *pBtCoexist)
1938{
1939 u8 algorithm = 0;
1940
1941 algorithm = halbtc8723b1ant_ActionAlgorithm(pBtCoexist);
1942 pCoexDm->curAlgorithm = algorithm;
1943
1944 if (halbtc8723b1ant_IsCommonAction(pBtCoexist)) {
1945
1946 } else {
1947 switch (pCoexDm->curAlgorithm) {
1948 case BT_8723B_1ANT_COEX_ALGO_SCO:
1949
1950 break;
1951 case BT_8723B_1ANT_COEX_ALGO_HID:
1952
1953 break;
1954 case BT_8723B_1ANT_COEX_ALGO_A2DP:
1955
1956 break;
1957 case BT_8723B_1ANT_COEX_ALGO_A2DP_PANHS:
1958
1959 break;
1960 case BT_8723B_1ANT_COEX_ALGO_PANEDR:
1961
1962 break;
1963 case BT_8723B_1ANT_COEX_ALGO_PANHS:
1964
1965 break;
1966 case BT_8723B_1ANT_COEX_ALGO_PANEDR_A2DP:
1967
1968 break;
1969 case BT_8723B_1ANT_COEX_ALGO_PANEDR_HID:
1970
1971 break;
1972 case BT_8723B_1ANT_COEX_ALGO_HID_A2DP_PANEDR:
1973
1974 break;
1975 case BT_8723B_1ANT_COEX_ALGO_HID_A2DP:
1976
1977 break;
1978 default:
1979 break;
1980 }
1981 pCoexDm->preAlgorithm = pCoexDm->curAlgorithm;
1982 }
1983}
1984
1985static void halbtc8723b1ant_RunCoexistMechanism(struct btc_coexist *pBtCoexist)
1986{
1987 struct btc_bt_link_info *pBtLinkInfo = &pBtCoexist->btLinkInfo;
1988 bool bWifiConnected = false, bBtHsOn = false;
1989 bool bIncreaseScanDevNum = false;
1990 bool bBtCtrlAggBufSize = false;
1991 u8 aggBufSize = 5;
1992 u32 wifiLinkStatus = 0;
1993 u32 numOfWifiLink = 0;
1994
1995 if (pBtCoexist->bManualControl)
1996 return;
1997
1998 if (pBtCoexist->bStopCoexDm)
1999 return;
2000
2001 if (pCoexSta->bUnderIps)
2002 return;
2003
2004 if (
2005 (pCoexDm->btStatus == BT_8723B_1ANT_BT_STATUS_ACL_BUSY) ||
2006 (pCoexDm->btStatus == BT_8723B_1ANT_BT_STATUS_SCO_BUSY) ||
2007 (pCoexDm->btStatus == BT_8723B_1ANT_BT_STATUS_ACL_SCO_BUSY)
2008 ){
2009 bIncreaseScanDevNum = true;
2010 }
2011
2012 pBtCoexist->fBtcSet(
2013 pBtCoexist,
2014 BTC_SET_BL_INC_SCAN_DEV_NUM,
2015 &bIncreaseScanDevNum
2016 );
2017 pBtCoexist->fBtcGet(
2018 pBtCoexist,
2019 BTC_GET_BL_WIFI_CONNECTED,
2020 &bWifiConnected
2021 );
2022
2023 pBtCoexist->fBtcGet(
2024 pBtCoexist,
2025 BTC_GET_U4_WIFI_LINK_STATUS,
2026 &wifiLinkStatus
2027 );
2028 numOfWifiLink = wifiLinkStatus >> 16;
2029
2030 if ((numOfWifiLink >= 2) || (wifiLinkStatus & WIFI_P2P_GO_CONNECTED)) {
2031 halbtc8723b1ant_LimitedTx(pBtCoexist, NORMAL_EXEC, 0, 0, 0, 0);
2032 halbtc8723b1ant_LimitedRx(pBtCoexist, NORMAL_EXEC, false, bBtCtrlAggBufSize, aggBufSize);
2033
2034 if ((pBtLinkInfo->bA2dpExist) && (pCoexSta->bC2hBtInquiryPage))
2035 halbtc8723b1ant_ActionBtInquiry(pBtCoexist);
2036 else
2037 halbtc8723b1ant_ActionWifiMultiPort(pBtCoexist);
2038
2039 return;
2040 }
2041
2042 if ((pBtLinkInfo->bBtLinkExist) && (bWifiConnected)) {
2043 halbtc8723b1ant_LimitedTx(pBtCoexist, NORMAL_EXEC, 1, 1, 0, 1);
2044
2045 if (pBtLinkInfo->bScoExist)
2046 halbtc8723b1ant_LimitedRx(pBtCoexist, NORMAL_EXEC, false, true, 0x5);
2047 else
2048 halbtc8723b1ant_LimitedRx(pBtCoexist, NORMAL_EXEC, false, true, 0x8);
2049
2050 halbtc8723b1ant_SwMechanism(pBtCoexist, true);
2051 halbtc8723b1ant_RunSwCoexistMechanism(pBtCoexist);
2052 } else {
2053 halbtc8723b1ant_LimitedTx(pBtCoexist, NORMAL_EXEC, 0, 0, 0, 0);
2054
2055 halbtc8723b1ant_LimitedRx(pBtCoexist, NORMAL_EXEC, false, false, 0x5);
2056
2057 halbtc8723b1ant_SwMechanism(pBtCoexist, false);
2058 halbtc8723b1ant_RunSwCoexistMechanism(pBtCoexist);
2059 }
2060
2061 pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_HS_OPERATION, &bBtHsOn);
2062 if (pCoexSta->bC2hBtInquiryPage) {
2063 halbtc8723b1ant_ActionBtInquiry(pBtCoexist);
2064 return;
2065 } else if (bBtHsOn) {
2066 halbtc8723b1ant_ActionHs(pBtCoexist);
2067 return;
2068 }
2069
2070
2071 if (!bWifiConnected) {
2072 bool bScan = false, bLink = false, bRoam = false;
2073
2074 pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_WIFI_SCAN, &bScan);
2075 pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_WIFI_LINK, &bLink);
2076 pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_WIFI_ROAM, &bRoam);
2077
2078 if (bScan || bLink || bRoam) {
2079 if (bScan)
2080 halbtc8723b1ant_ActionWifiNotConnectedScan(pBtCoexist);
2081 else
2082 halbtc8723b1ant_ActionWifiNotConnectedAssoAuth(pBtCoexist);
2083 } else
2084 halbtc8723b1ant_ActionWifiNotConnected(pBtCoexist);
2085 } else
2086 halbtc8723b1ant_ActionWifiConnected(pBtCoexist);
2087}
2088
2089static void halbtc8723b1ant_InitCoexDm(struct btc_coexist *pBtCoexist)
2090{
2091
2092
2093
2094 halbtc8723b1ant_SwMechanism(pBtCoexist, false);
2095
2096
2097 halbtc8723b1ant_CoexTableWithType(pBtCoexist, FORCE_EXEC, 0);
2098
2099 pCoexSta->popEventCnt = 0;
2100}
2101
2102static void halbtc8723b1ant_InitHwConfig(
2103 struct btc_coexist *pBtCoexist,
2104 bool bBackUp,
2105 bool bWifiOnly
2106)
2107{
2108 pBtCoexist->fBtcWrite1ByteBitMask(pBtCoexist, 0x550, 0x8, 0x1);
2109
2110
2111 pBtCoexist->fBtcWrite1Byte(pBtCoexist, 0x790, 0x5);
2112
2113
2114 pBtCoexist->fBtcWrite1Byte(pBtCoexist, 0x778, 0x1);
2115 pBtCoexist->fBtcWrite1ByteBitMask(pBtCoexist, 0x40, 0x20, 0x1);
2116
2117
2118 if (bWifiOnly) {
2119 halbtc8723b1ant_SetAntPath(pBtCoexist, BTC_ANT_PATH_WIFI, true, false);
2120 halbtc8723b1ant_PsTdma(pBtCoexist, FORCE_EXEC, false, 9);
2121 } else
2122 halbtc8723b1ant_SetAntPath(pBtCoexist, BTC_ANT_PATH_BT, true, false);
2123
2124
2125 halbtc8723b1ant_CoexTableWithType(pBtCoexist, FORCE_EXEC, 0);
2126
2127 pBtCoexist->fBtcRead4Byte(pBtCoexist, 0x948);
2128 pBtCoexist->fBtcRead1Byte(pBtCoexist, 0x765);
2129 pBtCoexist->fBtcRead1Byte(pBtCoexist, 0x67);
2130}
2131
2132
2133
2134
2135
2136
2137
2138void EXhalbtc8723b1ant_PowerOnSetting(struct btc_coexist *pBtCoexist)
2139{
2140 struct btc_board_info *pBoardInfo = &pBtCoexist->boardInfo;
2141 u8 u1Tmp = 0x0;
2142 u16 u2Tmp = 0x0;
2143
2144 pBtCoexist->fBtcWrite1Byte(pBtCoexist, 0x67, 0x20);
2145
2146
2147 u2Tmp = pBtCoexist->fBtcRead2Byte(pBtCoexist, 0x2);
2148 pBtCoexist->fBtcWrite2Byte(pBtCoexist, 0x2, u2Tmp | BIT0 | BIT1);
2149
2150
2151 pBtCoexist->fBtcWrite1Byte(pBtCoexist, 0x765, 0x18);
2152
2153 pBtCoexist->fBtcWrite1Byte(pBtCoexist, 0x76e, 0x4);
2154
2155
2156
2157
2158
2159
2160
2161
2162 if (pBtCoexist->chipInterface == BTC_INTF_USB) {
2163
2164 pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0x948, 0x0);
2165
2166 u1Tmp |= 0x1;
2167 pBtCoexist->fBtcWriteLocalReg1Byte(pBtCoexist, 0xfe08, u1Tmp);
2168
2169 pBoardInfo->btdmAntPos = BTC_ANTENNA_AT_AUX_PORT;
2170 } else {
2171
2172 if (pBoardInfo->singleAntPath == 0) {
2173
2174 pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0x948, 0x280);
2175 pBoardInfo->btdmAntPos = BTC_ANTENNA_AT_MAIN_PORT;
2176 } else if (pBoardInfo->singleAntPath == 1) {
2177
2178 pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0x948, 0x0);
2179 u1Tmp |= 0x1;
2180 pBoardInfo->btdmAntPos = BTC_ANTENNA_AT_AUX_PORT;
2181 }
2182
2183 if (pBtCoexist->chipInterface == BTC_INTF_PCI)
2184 pBtCoexist->fBtcWriteLocalReg1Byte(pBtCoexist, 0x384, u1Tmp);
2185 else if (pBtCoexist->chipInterface == BTC_INTF_SDIO)
2186 pBtCoexist->fBtcWriteLocalReg1Byte(pBtCoexist, 0x60, u1Tmp);
2187 }
2188}
2189
2190void EXhalbtc8723b1ant_InitHwConfig(struct btc_coexist *pBtCoexist, bool bWifiOnly)
2191{
2192 halbtc8723b1ant_InitHwConfig(pBtCoexist, true, bWifiOnly);
2193}
2194
2195void EXhalbtc8723b1ant_InitCoexDm(struct btc_coexist *pBtCoexist)
2196{
2197 pBtCoexist->bStopCoexDm = false;
2198
2199 halbtc8723b1ant_InitCoexDm(pBtCoexist);
2200
2201 halbtc8723b1ant_QueryBtInfo(pBtCoexist);
2202}
2203
2204void EXhalbtc8723b1ant_IpsNotify(struct btc_coexist *pBtCoexist, u8 type)
2205{
2206 if (pBtCoexist->bManualControl || pBtCoexist->bStopCoexDm)
2207 return;
2208
2209 if (type == BTC_IPS_ENTER) {
2210 pCoexSta->bUnderIps = true;
2211
2212 halbtc8723b1ant_PsTdma(pBtCoexist, NORMAL_EXEC, false, 0);
2213 halbtc8723b1ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 0);
2214 halbtc8723b1ant_SetAntPath(pBtCoexist, BTC_ANT_PATH_BT, false, true);
2215 } else if (type == BTC_IPS_LEAVE) {
2216 pCoexSta->bUnderIps = false;
2217
2218 halbtc8723b1ant_InitHwConfig(pBtCoexist, false, false);
2219 halbtc8723b1ant_InitCoexDm(pBtCoexist);
2220 halbtc8723b1ant_QueryBtInfo(pBtCoexist);
2221 }
2222}
2223
2224void EXhalbtc8723b1ant_LpsNotify(struct btc_coexist *pBtCoexist, u8 type)
2225{
2226 if (pBtCoexist->bManualControl || pBtCoexist->bStopCoexDm)
2227 return;
2228
2229 if (type == BTC_LPS_ENABLE)
2230 pCoexSta->bUnderLps = true;
2231 else if (type == BTC_LPS_DISABLE)
2232 pCoexSta->bUnderLps = false;
2233}
2234
2235void EXhalbtc8723b1ant_ScanNotify(struct btc_coexist *pBtCoexist, u8 type)
2236{
2237 bool bWifiConnected = false, bBtHsOn = false;
2238 u32 wifiLinkStatus = 0;
2239 u32 numOfWifiLink = 0;
2240 bool bBtCtrlAggBufSize = false;
2241 u8 aggBufSize = 5;
2242
2243 if (pBtCoexist->bManualControl || pBtCoexist->bStopCoexDm)
2244 return;
2245
2246 if (type == BTC_SCAN_START) {
2247 pCoexSta->bWiFiIsHighPriTask = true;
2248
2249 halbtc8723b1ant_PsTdma(pBtCoexist, FORCE_EXEC, false, 8);
2250 pBtCoexist->fBtcRead4Byte(pBtCoexist, 0x948);
2251 pBtCoexist->fBtcRead1Byte(pBtCoexist, 0x765);
2252 pBtCoexist->fBtcRead1Byte(pBtCoexist, 0x67);
2253 } else {
2254 pCoexSta->bWiFiIsHighPriTask = false;
2255
2256 pBtCoexist->fBtcGet(
2257 pBtCoexist, BTC_GET_U1_AP_NUM, &pCoexSta->nScanAPNum
2258 );
2259 }
2260
2261 if (pBtCoexist->btInfo.bBtDisabled)
2262 return;
2263
2264 pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_HS_OPERATION, &bBtHsOn);
2265 pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_WIFI_CONNECTED, &bWifiConnected);
2266
2267 halbtc8723b1ant_QueryBtInfo(pBtCoexist);
2268
2269 pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_U4_WIFI_LINK_STATUS, &wifiLinkStatus);
2270 numOfWifiLink = wifiLinkStatus >> 16;
2271
2272 if (numOfWifiLink >= 2) {
2273 halbtc8723b1ant_LimitedTx(pBtCoexist, NORMAL_EXEC, 0, 0, 0, 0);
2274 halbtc8723b1ant_LimitedRx(
2275 pBtCoexist, NORMAL_EXEC, false, bBtCtrlAggBufSize, aggBufSize
2276 );
2277 halbtc8723b1ant_ActionWifiMultiPort(pBtCoexist);
2278 return;
2279 }
2280
2281 if (pCoexSta->bC2hBtInquiryPage) {
2282 halbtc8723b1ant_ActionBtInquiry(pBtCoexist);
2283 return;
2284 } else if (bBtHsOn) {
2285 halbtc8723b1ant_ActionHs(pBtCoexist);
2286 return;
2287 }
2288
2289 if (type == BTC_SCAN_START) {
2290 if (!bWifiConnected)
2291 halbtc8723b1ant_ActionWifiNotConnectedScan(pBtCoexist);
2292 else
2293 halbtc8723b1ant_ActionWifiConnectedScan(pBtCoexist);
2294 } else if (type == BTC_SCAN_FINISH) {
2295 if (!bWifiConnected)
2296 halbtc8723b1ant_ActionWifiNotConnected(pBtCoexist);
2297 else
2298 halbtc8723b1ant_ActionWifiConnected(pBtCoexist);
2299 }
2300}
2301
2302void EXhalbtc8723b1ant_ConnectNotify(struct btc_coexist *pBtCoexist, u8 type)
2303{
2304 bool bWifiConnected = false, bBtHsOn = false;
2305 u32 wifiLinkStatus = 0;
2306 u32 numOfWifiLink = 0;
2307 bool bBtCtrlAggBufSize = false;
2308 u8 aggBufSize = 5;
2309
2310 if (
2311 pBtCoexist->bManualControl ||
2312 pBtCoexist->bStopCoexDm ||
2313 pBtCoexist->btInfo.bBtDisabled
2314 )
2315 return;
2316
2317 if (type == BTC_ASSOCIATE_START) {
2318 pCoexSta->bWiFiIsHighPriTask = true;
2319 pCoexDm->nArpCnt = 0;
2320 } else {
2321 pCoexSta->bWiFiIsHighPriTask = false;
2322
2323 }
2324
2325 pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_U4_WIFI_LINK_STATUS, &wifiLinkStatus);
2326 numOfWifiLink = wifiLinkStatus >> 16;
2327 if (numOfWifiLink >= 2) {
2328 halbtc8723b1ant_LimitedTx(pBtCoexist, NORMAL_EXEC, 0, 0, 0, 0);
2329 halbtc8723b1ant_LimitedRx(pBtCoexist, NORMAL_EXEC, false, bBtCtrlAggBufSize, aggBufSize);
2330 halbtc8723b1ant_ActionWifiMultiPort(pBtCoexist);
2331 return;
2332 }
2333
2334 pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_HS_OPERATION, &bBtHsOn);
2335 if (pCoexSta->bC2hBtInquiryPage) {
2336 halbtc8723b1ant_ActionBtInquiry(pBtCoexist);
2337 return;
2338 } else if (bBtHsOn) {
2339 halbtc8723b1ant_ActionHs(pBtCoexist);
2340 return;
2341 }
2342
2343 if (type == BTC_ASSOCIATE_START) {
2344 halbtc8723b1ant_ActionWifiNotConnectedAssoAuth(pBtCoexist);
2345 } else if (type == BTC_ASSOCIATE_FINISH) {
2346 pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_WIFI_CONNECTED, &bWifiConnected);
2347 if (!bWifiConnected)
2348 halbtc8723b1ant_ActionWifiNotConnected(pBtCoexist);
2349 else
2350 halbtc8723b1ant_ActionWifiConnected(pBtCoexist);
2351 }
2352}
2353
2354void EXhalbtc8723b1ant_MediaStatusNotify(struct btc_coexist *pBtCoexist, u8 type)
2355{
2356 u8 H2C_Parameter[3] = {0};
2357 u32 wifiBw;
2358 u8 wifiCentralChnl;
2359 bool bWifiUnderBMode = false;
2360
2361 if (
2362 pBtCoexist->bManualControl ||
2363 pBtCoexist->bStopCoexDm ||
2364 pBtCoexist->btInfo.bBtDisabled
2365 )
2366 return;
2367
2368 if (type == BTC_MEDIA_CONNECT) {
2369 pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_WIFI_UNDER_B_MODE, &bWifiUnderBMode);
2370
2371
2372 if (bWifiUnderBMode) {
2373 pBtCoexist->fBtcWrite1Byte(pBtCoexist, 0x6cd, 0x00);
2374 pBtCoexist->fBtcWrite1Byte(pBtCoexist, 0x6cf, 0x00);
2375 } else {
2376 pBtCoexist->fBtcWrite1Byte(pBtCoexist, 0x6cd, 0x10);
2377 pBtCoexist->fBtcWrite1Byte(pBtCoexist, 0x6cf, 0x10);
2378 }
2379
2380 pCoexDm->backupArfrCnt1 = pBtCoexist->fBtcRead4Byte(pBtCoexist, 0x430);
2381 pCoexDm->backupArfrCnt2 = pBtCoexist->fBtcRead4Byte(pBtCoexist, 0x434);
2382 pCoexDm->backupRetryLimit = pBtCoexist->fBtcRead2Byte(pBtCoexist, 0x42a);
2383 pCoexDm->backupAmpduMaxTime = pBtCoexist->fBtcRead1Byte(pBtCoexist, 0x456);
2384 } else {
2385 pCoexDm->nArpCnt = 0;
2386
2387 pBtCoexist->fBtcWrite1Byte(pBtCoexist, 0x6cd, 0x0);
2388 pBtCoexist->fBtcWrite1Byte(pBtCoexist, 0x6cf, 0x0);
2389 }
2390
2391
2392 pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_U1_WIFI_CENTRAL_CHNL, &wifiCentralChnl);
2393 if ((type == BTC_MEDIA_CONNECT) && (wifiCentralChnl <= 14)) {
2394
2395 H2C_Parameter[0] = 0x0;
2396 H2C_Parameter[1] = wifiCentralChnl;
2397 pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_U4_WIFI_BW, &wifiBw);
2398
2399 if (wifiBw == BTC_WIFI_BW_HT40)
2400 H2C_Parameter[2] = 0x30;
2401 else
2402 H2C_Parameter[2] = 0x20;
2403 }
2404
2405 pCoexDm->wifiChnlInfo[0] = H2C_Parameter[0];
2406 pCoexDm->wifiChnlInfo[1] = H2C_Parameter[1];
2407 pCoexDm->wifiChnlInfo[2] = H2C_Parameter[2];
2408
2409 pBtCoexist->fBtcFillH2c(pBtCoexist, 0x66, 3, H2C_Parameter);
2410}
2411
2412void EXhalbtc8723b1ant_SpecialPacketNotify(struct btc_coexist *pBtCoexist, u8 type)
2413{
2414 bool bBtHsOn = false;
2415 u32 wifiLinkStatus = 0;
2416 u32 numOfWifiLink = 0;
2417 bool bBtCtrlAggBufSize = false;
2418 u8 aggBufSize = 5;
2419
2420 if (
2421 pBtCoexist->bManualControl ||
2422 pBtCoexist->bStopCoexDm ||
2423 pBtCoexist->btInfo.bBtDisabled
2424 )
2425 return;
2426
2427 if (
2428 type == BTC_PACKET_DHCP ||
2429 type == BTC_PACKET_EAPOL ||
2430 type == BTC_PACKET_ARP
2431 ) {
2432 if (type == BTC_PACKET_ARP) {
2433 pCoexDm->nArpCnt++;
2434
2435 if (pCoexDm->nArpCnt >= 10)
2436 pCoexSta->bWiFiIsHighPriTask = false;
2437 else
2438 pCoexSta->bWiFiIsHighPriTask = true;
2439 } else {
2440 pCoexSta->bWiFiIsHighPriTask = true;
2441 }
2442 } else {
2443 pCoexSta->bWiFiIsHighPriTask = false;
2444 }
2445
2446 pCoexSta->specialPktPeriodCnt = 0;
2447
2448 pBtCoexist->fBtcGet(
2449 pBtCoexist, BTC_GET_U4_WIFI_LINK_STATUS, &wifiLinkStatus
2450 );
2451 numOfWifiLink = wifiLinkStatus >> 16;
2452
2453 if (numOfWifiLink >= 2) {
2454 halbtc8723b1ant_LimitedTx(pBtCoexist, NORMAL_EXEC, 0, 0, 0, 0);
2455 halbtc8723b1ant_LimitedRx(
2456 pBtCoexist, NORMAL_EXEC, false, bBtCtrlAggBufSize, aggBufSize
2457 );
2458 halbtc8723b1ant_ActionWifiMultiPort(pBtCoexist);
2459 return;
2460 }
2461
2462 pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_HS_OPERATION, &bBtHsOn);
2463 if (pCoexSta->bC2hBtInquiryPage) {
2464 halbtc8723b1ant_ActionBtInquiry(pBtCoexist);
2465 return;
2466 } else if (bBtHsOn) {
2467 halbtc8723b1ant_ActionHs(pBtCoexist);
2468 return;
2469 }
2470
2471 if (
2472 type == BTC_PACKET_DHCP ||
2473 type == BTC_PACKET_EAPOL ||
2474 ((type == BTC_PACKET_ARP) && (pCoexSta->bWiFiIsHighPriTask))
2475 )
2476 halbtc8723b1ant_ActionWifiConnectedSpecialPacket(pBtCoexist);
2477}
2478
2479void EXhalbtc8723b1ant_BtInfoNotify(
2480 struct btc_coexist *pBtCoexist, u8 *tmpBuf, u8 length
2481)
2482{
2483 u8 btInfo = 0;
2484 u8 i, rspSource = 0;
2485 bool bWifiConnected = false;
2486 bool bBtBusy = false;
2487
2488 pCoexSta->bC2hBtInfoReqSent = false;
2489
2490 rspSource = tmpBuf[0] & 0xf;
2491 if (rspSource >= BT_INFO_SRC_8723B_1ANT_MAX)
2492 rspSource = BT_INFO_SRC_8723B_1ANT_WIFI_FW;
2493 pCoexSta->btInfoC2hCnt[rspSource]++;
2494
2495 for (i = 0; i < length; i++) {
2496 pCoexSta->btInfoC2h[rspSource][i] = tmpBuf[i];
2497 if (i == 1)
2498 btInfo = tmpBuf[i];
2499 }
2500
2501 if (rspSource != BT_INFO_SRC_8723B_1ANT_WIFI_FW) {
2502 pCoexSta->btRetryCnt = pCoexSta->btInfoC2h[rspSource][2] & 0xf;
2503
2504 if (pCoexSta->btRetryCnt >= 1)
2505 pCoexSta->popEventCnt++;
2506
2507 if (pCoexSta->btInfoC2h[rspSource][2] & 0x20)
2508 pCoexSta->bC2hBtPage = true;
2509 else
2510 pCoexSta->bC2hBtPage = false;
2511
2512 pCoexSta->btRssi = pCoexSta->btInfoC2h[rspSource][3] * 2 - 90;
2513
2514
2515 pCoexSta->btInfoExt = pCoexSta->btInfoC2h[rspSource][4];
2516
2517 pCoexSta->bBtTxRxMask = (pCoexSta->btInfoC2h[rspSource][2] & 0x40);
2518 pBtCoexist->fBtcSet(pBtCoexist, BTC_SET_BL_BT_TX_RX_MASK, &pCoexSta->bBtTxRxMask);
2519
2520 if (!pCoexSta->bBtTxRxMask) {
2521
2522 pBtCoexist->fBtcSetBtReg(pBtCoexist, BTC_BT_REG_RF, 0x3c, 0x15);
2523 }
2524
2525
2526
2527 if (pCoexSta->btInfoExt & BIT1) {
2528 pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_WIFI_CONNECTED, &bWifiConnected);
2529 if (bWifiConnected)
2530 EXhalbtc8723b1ant_MediaStatusNotify(pBtCoexist, BTC_MEDIA_CONNECT);
2531 else
2532 EXhalbtc8723b1ant_MediaStatusNotify(pBtCoexist, BTC_MEDIA_DISCONNECT);
2533 }
2534
2535 if (pCoexSta->btInfoExt & BIT3) {
2536 if (!pBtCoexist->bManualControl && !pBtCoexist->bStopCoexDm)
2537 halbtc8723b1ant_IgnoreWlanAct(pBtCoexist, FORCE_EXEC, false);
2538 } else {
2539
2540 }
2541 }
2542
2543
2544 if (btInfo & BT_INFO_8723B_1ANT_B_INQ_PAGE)
2545 pCoexSta->bC2hBtInquiryPage = true;
2546 else
2547 pCoexSta->bC2hBtInquiryPage = false;
2548
2549
2550 if (!(btInfo & BT_INFO_8723B_1ANT_B_CONNECTION)) {
2551 pCoexSta->bBtLinkExist = false;
2552 pCoexSta->bPanExist = false;
2553 pCoexSta->bA2dpExist = false;
2554 pCoexSta->bHidExist = false;
2555 pCoexSta->bScoExist = false;
2556 } else {
2557 pCoexSta->bBtLinkExist = true;
2558 if (btInfo & BT_INFO_8723B_1ANT_B_FTP)
2559 pCoexSta->bPanExist = true;
2560 else
2561 pCoexSta->bPanExist = false;
2562
2563 if (btInfo & BT_INFO_8723B_1ANT_B_A2DP)
2564 pCoexSta->bA2dpExist = true;
2565 else
2566 pCoexSta->bA2dpExist = false;
2567
2568 if (btInfo & BT_INFO_8723B_1ANT_B_HID)
2569 pCoexSta->bHidExist = true;
2570 else
2571 pCoexSta->bHidExist = false;
2572
2573 if (btInfo & BT_INFO_8723B_1ANT_B_SCO_ESCO)
2574 pCoexSta->bScoExist = true;
2575 else
2576 pCoexSta->bScoExist = false;
2577 }
2578
2579 halbtc8723b1ant_UpdateBtLinkInfo(pBtCoexist);
2580
2581 btInfo = btInfo & 0x1f;
2582
2583 if (!(btInfo & BT_INFO_8723B_1ANT_B_CONNECTION)) {
2584 pCoexDm->btStatus = BT_8723B_1ANT_BT_STATUS_NON_CONNECTED_IDLE;
2585 } else if (btInfo == BT_INFO_8723B_1ANT_B_CONNECTION) {
2586
2587 pCoexDm->btStatus = BT_8723B_1ANT_BT_STATUS_CONNECTED_IDLE;
2588 } else if (
2589 (btInfo & BT_INFO_8723B_1ANT_B_SCO_ESCO) ||
2590 (btInfo & BT_INFO_8723B_1ANT_B_SCO_BUSY)
2591 ) {
2592 pCoexDm->btStatus = BT_8723B_1ANT_BT_STATUS_SCO_BUSY;
2593 } else if (btInfo & BT_INFO_8723B_1ANT_B_ACL_BUSY) {
2594 if (pCoexDm->btStatus != BT_8723B_1ANT_BT_STATUS_ACL_BUSY)
2595 pCoexDm->bAutoTdmaAdjust = false;
2596
2597 pCoexDm->btStatus = BT_8723B_1ANT_BT_STATUS_ACL_BUSY;
2598 } else {
2599 pCoexDm->btStatus = BT_8723B_1ANT_BT_STATUS_MAX;
2600 }
2601
2602 if (
2603 (pCoexDm->btStatus == BT_8723B_1ANT_BT_STATUS_ACL_BUSY) ||
2604 (pCoexDm->btStatus == BT_8723B_1ANT_BT_STATUS_SCO_BUSY) ||
2605 (pCoexDm->btStatus == BT_8723B_1ANT_BT_STATUS_ACL_SCO_BUSY)
2606 )
2607 bBtBusy = true;
2608 else
2609 bBtBusy = false;
2610 pBtCoexist->fBtcSet(pBtCoexist, BTC_SET_BL_BT_TRAFFIC_BUSY, &bBtBusy);
2611
2612 halbtc8723b1ant_RunCoexistMechanism(pBtCoexist);
2613}
2614
2615void EXhalbtc8723b1ant_HaltNotify(struct btc_coexist *pBtCoexist)
2616{
2617 halbtc8723b1ant_PowerSaveState(pBtCoexist, BTC_PS_WIFI_NATIVE, 0x0, 0x0);
2618 halbtc8723b1ant_PsTdma(pBtCoexist, FORCE_EXEC, false, 0);
2619 halbtc8723b1ant_SetAntPath(pBtCoexist, BTC_ANT_PATH_BT, false, true);
2620
2621 halbtc8723b1ant_IgnoreWlanAct(pBtCoexist, FORCE_EXEC, true);
2622
2623 EXhalbtc8723b1ant_MediaStatusNotify(pBtCoexist, BTC_MEDIA_DISCONNECT);
2624
2625 pBtCoexist->bStopCoexDm = true;
2626}
2627
2628void EXhalbtc8723b1ant_PnpNotify(struct btc_coexist *pBtCoexist, u8 pnpState)
2629{
2630 if (pnpState == BTC_WIFI_PNP_SLEEP) {
2631 halbtc8723b1ant_PowerSaveState(pBtCoexist, BTC_PS_WIFI_NATIVE, 0x0, 0x0);
2632 halbtc8723b1ant_PsTdma(pBtCoexist, NORMAL_EXEC, false, 0);
2633 halbtc8723b1ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 2);
2634 halbtc8723b1ant_SetAntPath(pBtCoexist, BTC_ANT_PATH_BT, false, true);
2635
2636 pBtCoexist->bStopCoexDm = true;
2637 } else if (pnpState == BTC_WIFI_PNP_WAKE_UP) {
2638 pBtCoexist->bStopCoexDm = false;
2639 halbtc8723b1ant_InitHwConfig(pBtCoexist, false, false);
2640 halbtc8723b1ant_InitCoexDm(pBtCoexist);
2641 halbtc8723b1ant_QueryBtInfo(pBtCoexist);
2642 }
2643}
2644
2645void EXhalbtc8723b1ant_Periodical(struct btc_coexist *pBtCoexist)
2646{
2647 static u8 disVerInfoCnt;
2648 u32 fwVer = 0, btPatchVer = 0;
2649
2650 if (disVerInfoCnt <= 5) {
2651 disVerInfoCnt += 1;
2652 pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_U4_BT_PATCH_VER, &btPatchVer);
2653 pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_U4_WIFI_FW_VER, &fwVer);
2654 }
2655
2656 halbtc8723b1ant_MonitorBtCtr(pBtCoexist);
2657 halbtc8723b1ant_MonitorWiFiCtr(pBtCoexist);
2658
2659 if (
2660 halbtc8723b1ant_IsWifiStatusChanged(pBtCoexist) ||
2661 pCoexDm->bAutoTdmaAdjust
2662 )
2663 halbtc8723b1ant_RunCoexistMechanism(pBtCoexist);
2664
2665 pCoexSta->specialPktPeriodCnt++;
2666}
2667
