1 /******************************************************************************
2 *
3 * Copyright(c) 2016 - 2017 Realtek Corporation.
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
16 #include "mp_precomp.h"
17
18 #if (BT_SUPPORT == 1 && COEX_SUPPORT == 1)
19
20 #if (RTL8822B_SUPPORT == 1)
21 static u8 *trace_buf = &gl_btc_trace_buf[0];
22
23 static const char *const glbt_info_src_8822b_1ant[] = {
24 "BT Info[wifi fw]",
25 "BT Info[bt rsp]",
26 "BT Info[bt auto report]",
27 "BT Info[bt iqk]",
28 "BT Info[bt scbd]"
29 };
30
31 u32 glcoex_ver_date_8822b_1ant = 20190625;
32 u32 glcoex_ver_8822b_1ant = 0x72;
33 u32 glcoex_ver_btdesired_8822b_1ant = 0x6c;
34
35 #if 0
36 static
37 u8 halbtc8822b1ant_bt_rssi_state(struct btc_coexist *btc,
38 u8 *ppre_bt_rssi_state, u8 level_num,
39 u8 rssi_thresh, u8 rssi_thresh1)
40 {
41 struct coex_sta_8822b_1ant *coex_sta = &btc->coex_sta_8822b_1ant;
42 s32 bt_rssi = 0;
43 u8 bt_rssi_state = *ppre_bt_rssi_state;
44
45 bt_rssi = coex_sta->bt_rssi;
46
47 if (level_num == 2) {
48 if ((*ppre_bt_rssi_state == BTC_RSSI_STATE_LOW) ||
49 (*ppre_bt_rssi_state == BTC_RSSI_STATE_STAY_LOW)) {
50 if (bt_rssi >= (rssi_thresh +
51 BTC_RSSI_COEX_THRESH_TOL_8822B_1ANT))
52 bt_rssi_state = BTC_RSSI_STATE_HIGH;
53 else
54 bt_rssi_state = BTC_RSSI_STATE_STAY_LOW;
55 } else {
56 if (bt_rssi < rssi_thresh)
57 bt_rssi_state = BTC_RSSI_STATE_LOW;
58 else
59 bt_rssi_state = BTC_RSSI_STATE_STAY_HIGH;
60 }
61 } else if (level_num == 3) {
62 if (rssi_thresh > rssi_thresh1) {
63 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
64 "[BTCoex], BT Rssi thresh error!!\n");
65 BTC_TRACE(trace_buf);
66 return *ppre_bt_rssi_state;
67 }
68
69 if ((*ppre_bt_rssi_state == BTC_RSSI_STATE_LOW) ||
70 (*ppre_bt_rssi_state == BTC_RSSI_STATE_STAY_LOW)) {
71 if (bt_rssi >= (rssi_thresh +
72 BTC_RSSI_COEX_THRESH_TOL_8822B_1ANT))
73 bt_rssi_state = BTC_RSSI_STATE_MEDIUM;
74 else
75 bt_rssi_state = BTC_RSSI_STATE_STAY_LOW;
76 } else if ((*ppre_bt_rssi_state == BTC_RSSI_STATE_MEDIUM) ||
77 (*ppre_bt_rssi_state == BTC_RSSI_STATE_STAY_MEDIUM)) {
78 if (bt_rssi >= (rssi_thresh1 +
79 BTC_RSSI_COEX_THRESH_TOL_8822B_1ANT))
80 bt_rssi_state = BTC_RSSI_STATE_HIGH;
81 else if (bt_rssi < rssi_thresh)
82 bt_rssi_state = BTC_RSSI_STATE_LOW;
83 else
84 bt_rssi_state = BTC_RSSI_STATE_STAY_MEDIUM;
85 } else {
86 if (bt_rssi < rssi_thresh1)
87 bt_rssi_state = BTC_RSSI_STATE_MEDIUM;
88 else
89 bt_rssi_state = BTC_RSSI_STATE_STAY_HIGH;
90 }
91 }
92
93 *ppre_bt_rssi_state = bt_rssi_state;
94
95 return bt_rssi_state;
96 }
97 #endif
98
halbtc8822b1ant_wifi_rssi_state(struct btc_coexist * btc,u8 * pprewifi_rssi_state,u8 level_num,u8 rssi_thresh,u8 rssi_thresh1)99 static u8 halbtc8822b1ant_wifi_rssi_state(struct btc_coexist *btc,
100 u8 *pprewifi_rssi_state, u8 level_num,
101 u8 rssi_thresh, u8 rssi_thresh1)
102 {
103 s32 wifi_rssi = 0;
104 u8 wifi_rssi_state = *pprewifi_rssi_state;
105
106 btc->btc_get(btc, BTC_GET_S4_WIFI_RSSI, &wifi_rssi);
107
108 if (level_num == 2) {
109 if ((*pprewifi_rssi_state == BTC_RSSI_STATE_LOW) ||
110 (*pprewifi_rssi_state == BTC_RSSI_STATE_STAY_LOW)) {
111 if (wifi_rssi >= (rssi_thresh +
112 BTC_RSSI_COEX_THRESH_TOL_8822B_1ANT))
113 wifi_rssi_state = BTC_RSSI_STATE_HIGH;
114 else
115 wifi_rssi_state = BTC_RSSI_STATE_STAY_LOW;
116 } else {
117 if (wifi_rssi < rssi_thresh)
118 wifi_rssi_state = BTC_RSSI_STATE_LOW;
119 else
120 wifi_rssi_state = BTC_RSSI_STATE_STAY_HIGH;
121 }
122 } else if (level_num == 3) {
123 if (rssi_thresh > rssi_thresh1) {
124 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
125 "[BTCoex], wifi RSSI thresh error!!\n");
126 BTC_TRACE(trace_buf);
127 return *pprewifi_rssi_state;
128 }
129
130 if ((*pprewifi_rssi_state == BTC_RSSI_STATE_LOW) ||
131 (*pprewifi_rssi_state == BTC_RSSI_STATE_STAY_LOW)) {
132 if (wifi_rssi >= (rssi_thresh +
133 BTC_RSSI_COEX_THRESH_TOL_8822B_1ANT))
134 wifi_rssi_state = BTC_RSSI_STATE_MEDIUM;
135 else
136 wifi_rssi_state = BTC_RSSI_STATE_STAY_LOW;
137 } else if ((*pprewifi_rssi_state == BTC_RSSI_STATE_MEDIUM) ||
138 (*pprewifi_rssi_state ==
139 BTC_RSSI_STATE_STAY_MEDIUM)) {
140 if (wifi_rssi >= (rssi_thresh1 +
141 BTC_RSSI_COEX_THRESH_TOL_8822B_1ANT))
142 wifi_rssi_state = BTC_RSSI_STATE_HIGH;
143 else if (wifi_rssi < rssi_thresh)
144 wifi_rssi_state = BTC_RSSI_STATE_LOW;
145 else
146 wifi_rssi_state = BTC_RSSI_STATE_STAY_MEDIUM;
147 } else {
148 if (wifi_rssi < rssi_thresh1)
149 wifi_rssi_state = BTC_RSSI_STATE_MEDIUM;
150 else
151 wifi_rssi_state = BTC_RSSI_STATE_STAY_HIGH;
152 }
153 }
154
155 *pprewifi_rssi_state = wifi_rssi_state;
156
157 return wifi_rssi_state;
158 }
159
160 static void
halbtc8822b1ant_limited_tx(struct btc_coexist * btc,boolean force_exec,boolean tx_limit_en,boolean ampdu_limit_en)161 halbtc8822b1ant_limited_tx(struct btc_coexist *btc, boolean force_exec,
162 boolean tx_limit_en, boolean ampdu_limit_en)
163 {
164 struct coex_sta_8822b_1ant *coex_sta = &btc->coex_sta_8822b_1ant;
165 struct wifi_link_info_8822b_1ant *wifi_link_info_ext =
166 &btc->wifi_link_info_8822b_1ant;
167 boolean wifi_under_b_mode = FALSE;
168
169 /* Force Max Tx retry limit = 8*/
170 if (!coex_sta->wl_tx_limit_en) {
171 coex_sta->wl_0x430_backup = btc->btc_read_4byte(btc, 0x430);
172 coex_sta->wl_0x434_backup = btc->btc_read_4byte(btc, 0x434);
173 coex_sta->wl_0x42a_backup = btc->btc_read_2byte(btc, 0x42a);
174 }
175
176 if (!coex_sta->wl_ampdu_limit_en)
177 coex_sta->wl_0x455_backup = btc->btc_read_1byte(btc, 0x455);
178
179 if (!force_exec && tx_limit_en == coex_sta->wl_tx_limit_en &&
180 ampdu_limit_en == coex_sta->wl_ampdu_limit_en)
181 return;
182
183 coex_sta->wl_tx_limit_en = tx_limit_en;
184 coex_sta->wl_ampdu_limit_en = ampdu_limit_en;
185
186 if (tx_limit_en) {
187 /* Set BT polluted packet on for Tx rate adaptive not
188 * including Tx retry break by PTA, 0x45c[19] =1
189 * Set queue life time to avoid can't reach tx retry limit
190 * if tx is always break by GNT_BT.
191 */
192 btc->btc_write_1byte_bitmask(btc, 0x45e, 0x8, 0x1);
193 btc->btc_write_1byte_bitmask(btc, 0x426, 0xf, 0xf);
194
195 /* Max Tx retry limit = 8*/
196 btc->btc_write_2byte(btc, 0x42a, 0x0808);
197
198 btc->btc_get(btc, BTC_GET_BL_WIFI_UNDER_B_MODE,
199 &wifi_under_b_mode);
200
201 /* Auto rate fallback step within 8 retry*/
202 if (wifi_under_b_mode) {
203 btc->btc_write_4byte(btc, 0x430, 0x1000000);
204 btc->btc_write_4byte(btc, 0x434, 0x1010101);
205 } else {
206 btc->btc_write_4byte(btc, 0x430, 0x1000000);
207 btc->btc_write_4byte(btc, 0x434, 0x4030201);
208 }
209 } else {
210 /* Set BT polluted packet on for Tx rate adaptive not
211 *including Tx retry break by PTA, 0x45c[19] =1
212 */
213 btc->btc_write_1byte_bitmask(btc, 0x45e, 0x8, 0x0);
214
215 /* Set queue life time to avoid can't reach tx retry limit
216 * if tx is always break by GNT_BT.
217 */
218 btc->btc_write_1byte_bitmask(btc, 0x426, 0xf, 0x0);
219
220 /* Recovery Max Tx retry limit*/
221 btc->btc_write_2byte(btc, 0x42a, coex_sta->wl_0x42a_backup);
222 btc->btc_write_4byte(btc, 0x430, coex_sta->wl_0x430_backup);
223 btc->btc_write_4byte(btc, 0x434, coex_sta->wl_0x434_backup);
224 }
225
226 if (ampdu_limit_en)
227 btc->btc_write_1byte(btc, 0x455, 0x20);
228 else
229 btc->btc_write_1byte(btc, 0x455, coex_sta->wl_0x455_backup);
230 }
231
232 static void
halbtc8822b1ant_limited_rx(struct btc_coexist * btc,boolean force_exec,boolean rej_ap_agg_pkt,boolean bt_ctrl_agg_buf_size,u8 agg_buf_size)233 halbtc8822b1ant_limited_rx(struct btc_coexist *btc, boolean force_exec,
234 boolean rej_ap_agg_pkt, boolean bt_ctrl_agg_buf_size,
235 u8 agg_buf_size)
236 {
237 #if 0
238 struct coex_sta_8822b_1ant *coex_sta = &btc->coex_sta_8822b_1ant;
239 boolean reject_rx_agg = rej_ap_agg_pkt;
240 boolean bt_ctrl_rx_agg_size = bt_ctrl_agg_buf_size;
241 u8 rx_agg_size = agg_buf_size;
242
243 if (!force_exec &&
244 bt_ctrl_agg_buf_size == coex_sta->wl_rxagg_limit_en &&
245 agg_buf_size == coex_sta->wl_rxagg_size)
246 return;
247
248 coex_sta->wl_rxagg_limit_en = bt_ctrl_agg_buf_size;
249 coex_sta->wl_rxagg_size = agg_buf_size;
250
251 /*btc->btc_set(btc, BTC_SET_BL_TO_REJ_AP_AGG_PKT, &reject_rx_agg);*/
252 /* decide BT control aggregation buf size or not */
253 btc->btc_set(btc, BTC_SET_BL_BT_CTRL_AGG_SIZE, &bt_ctrl_rx_agg_size);
254 /* aggregation buf size, only work when BT control Rx aggregation size*/
255 btc->btc_set(btc, BTC_SET_U1_AGG_BUF_SIZE, &rx_agg_size);
256 /* real update aggregation setting */
257 btc->btc_set(btc, BTC_SET_ACT_AGGREGATE_CTRL, NULL);
258 #endif
259 }
260
261 static void
halbtc8822b1ant_ccklock_action(struct btc_coexist * btc)262 halbtc8822b1ant_ccklock_action(struct btc_coexist *btc)
263 {
264 struct coex_sta_8822b_1ant *coex_sta = &btc->coex_sta_8822b_1ant;
265 u8 h2c_parameter[2] = {0};
266 static u8 cnt;
267
268 if (coex_sta->tdma_timer_base == 3) {
269 if (!coex_sta->is_no_wl_5ms_extend) {
270 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
271 "[BTCoex], set h2c 0x69 opcode 12 to turn off 5ms WL slot extend!!\n");
272 BTC_TRACE(trace_buf);
273
274 h2c_parameter[0] = 0xc;
275 h2c_parameter[1] = 0x1;
276 btc->btc_fill_h2c(btc, 0x69, 2, h2c_parameter);
277 coex_sta->is_no_wl_5ms_extend = TRUE;
278 cnt = 0;
279 }
280 return;
281 }
282
283 if (!coex_sta->is_no_wl_5ms_extend && coex_sta->force_lps_ctrl &&
284 !coex_sta->cck_lock_ever) {
285 if (coex_sta->wl_fw_dbg_info[7] <= 5)
286 cnt++;
287 else
288 cnt = 0;
289
290 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
291 "[BTCoex], 5ms WL slot extend cnt = %d!!\n", cnt);
292 BTC_TRACE(trace_buf);
293
294 if (cnt == 7) {
295 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
296 "[BTCoex], set h2c 0x69 opcode 12 to turn off 5ms WL slot extend!!\n");
297 BTC_TRACE(trace_buf);
298
299 h2c_parameter[0] = 0xc;
300 h2c_parameter[1] = 0x1;
301 btc->btc_fill_h2c(btc, 0x69, 2, h2c_parameter);
302 coex_sta->is_no_wl_5ms_extend = TRUE;
303 cnt = 0;
304 }
305 } else if (coex_sta->is_no_wl_5ms_extend && coex_sta->cck_lock) {
306 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
307 "[BTCoex], set h2c 0x69 opcode 12 to turn on 5ms WL slot extend!!\n");
308 BTC_TRACE(trace_buf);
309
310 h2c_parameter[0] = 0xc;
311 h2c_parameter[1] = 0x0;
312 btc->btc_fill_h2c(btc, 0x69, 2, h2c_parameter);
313 coex_sta->is_no_wl_5ms_extend = FALSE;
314 }
315 }
316
317 static void
halbtc8822b1ant_ccklock_detect(struct btc_coexist * btc)318 halbtc8822b1ant_ccklock_detect(struct btc_coexist *btc)
319 {
320 struct coex_sta_8822b_1ant *coex_sta = &btc->coex_sta_8822b_1ant;
321 struct coex_dm_8822b_1ant *coex_dm = &btc->coex_dm_8822b_1ant;
322 struct btc_wifi_link_info_ext *link_info_ext = &btc->wifi_link_info_ext;
323 boolean is_cck_lock_rate = FALSE;
324
325 if (coex_dm->bt_status == BTC_BTSTATUS_INQ_PAGE ||
326 coex_sta->is_setup_link) {
327 coex_sta->cck_lock = FALSE;
328 return;
329 }
330
331 if (coex_sta->wl_rx_rate <= BTC_CCK_2 ||
332 coex_sta->wl_rts_rx_rate <= BTC_CCK_2)
333 is_cck_lock_rate = TRUE;
334
335 if (link_info_ext->is_connected && coex_sta->gl_wifi_busy &&
336 (coex_dm->bt_status == BT_8822B_1ANT_BSTATUS_ACL_BUSY ||
337 coex_dm->bt_status == BT_8822B_1ANT_BSTATUS_ACL_SCO_BUSY ||
338 coex_dm->bt_status == BT_8822B_1ANT_BSTATUS_SCO_BUSY)) {
339 if (is_cck_lock_rate) {
340 coex_sta->cck_lock = TRUE;
341
342 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
343 "[BTCoex], cck locking...\n");
344 BTC_TRACE(trace_buf);
345 } else {
346 coex_sta->cck_lock = FALSE;
347
348 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
349 "[BTCoex], cck unlock...\n");
350 BTC_TRACE(trace_buf);
351 }
352 } else {
353 coex_sta->cck_lock = FALSE;
354 }
355 }
356
357 static void
halbtc8822b1ant_set_tdma_timer_base(struct btc_coexist * btc,u8 type)358 halbtc8822b1ant_set_tdma_timer_base(struct btc_coexist *btc, u8 type)
359 {
360 struct coex_sta_8822b_1ant *coex_sta = &btc->coex_sta_8822b_1ant;
361 u16 tbtt_interval = 100;
362 u8 h2c_para[2] = {0xb, 0x1};
363
364 btc->btc_get(btc, BTC_GET_U2_BEACON_PERIOD, &tbtt_interval);
365
366 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
367 "[BTCoex], tbtt_interval = %d\n", tbtt_interval);
368 BTC_TRACE(trace_buf);
369
370 /* Add for JIRA coex-256 */
371 if (type == 3) { /* 4-slot */
372 if (coex_sta->tdma_timer_base == 3)
373 return;
374
375 h2c_para[1] = 0xc1; /* 4-slot */
376 coex_sta->tdma_timer_base = 3;
377 } else if (tbtt_interval < 80 && tbtt_interval > 0) {
378 if (coex_sta->tdma_timer_base == 2)
379 return;
380 h2c_para[1] = (100 / tbtt_interval);
381
382 if (100 % tbtt_interval != 0)
383 h2c_para[1] = h2c_para[1] + 1;
384
385 h2c_para[1] = h2c_para[1] & 0x3f;
386 coex_sta->tdma_timer_base = 2;
387 } else if (tbtt_interval >= 180) {
388 if (coex_sta->tdma_timer_base == 1)
389 return;
390 h2c_para[1] = (tbtt_interval / 100);
391
392 if (tbtt_interval % 100 <= 80)
393 h2c_para[1] = h2c_para[1] - 1;
394
395 h2c_para[1] = h2c_para[1] & 0x3f;
396 h2c_para[1] = h2c_para[1] | 0x80;
397 coex_sta->tdma_timer_base = 1;
398 } else {
399 if (coex_sta->tdma_timer_base == 0)
400 return;
401 h2c_para[1] = 0x1;
402 coex_sta->tdma_timer_base = 0;
403 }
404
405 btc->btc_fill_h2c(btc, 0x69, 2, h2c_para);
406
407 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
408 "[BTCoex], %s() h2c_0x69 = 0x%x\n", __func__, h2c_para[1]);
409 BTC_TRACE(trace_buf);
410
411 /* no 5ms_wl_slot_extend for 4-slot mode */
412 if (coex_sta->tdma_timer_base == 3)
413 halbtc8822b1ant_ccklock_action(btc);
414 }
415
halbtc8822b1ant_low_penalty_ra(struct btc_coexist * btc,boolean force_exec,boolean low_penalty_ra,u8 thres)416 static void halbtc8822b1ant_low_penalty_ra(struct btc_coexist *btc,
417 boolean force_exec,
418 boolean low_penalty_ra,
419 u8 thres)
420 {
421 struct coex_dm_8822b_1ant *coex_dm = &btc->coex_dm_8822b_1ant;
422 static u8 cur_thres;
423
424 if (!force_exec) {
425 if (low_penalty_ra == coex_dm->cur_low_penalty_ra &&
426 thres == cur_thres)
427 return;
428 }
429
430 if (low_penalty_ra)
431 btc->btc_phydm_modify_RA_PCR_threshold(btc, 0, thres);
432 else
433 btc->btc_phydm_modify_RA_PCR_threshold(btc, 0, 0);
434
435 coex_dm->cur_low_penalty_ra = low_penalty_ra;
436 cur_thres = thres;
437 }
438
halbtc8822b1ant_write_scbd(struct btc_coexist * btc,u16 bitpos,boolean state)439 static void halbtc8822b1ant_write_scbd(struct btc_coexist *btc, u16 bitpos,
440 boolean state)
441 {
442 struct coex_sta_8822b_1ant *coex_sta = &btc->coex_sta_8822b_1ant;
443 static u16 originalval = 0x8002, preval;
444
445 if (state)
446 originalval = originalval | bitpos;
447 else
448 originalval = originalval & (~bitpos);
449
450 coex_sta->score_board_WB = originalval;
451
452 if (originalval != preval) {
453 preval = originalval;
454 btc->btc_write_2byte(btc, 0xaa, originalval);
455 } else {
456 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
457 "[BTCoex], %s: return for nochange\n", __func__);
458 BTC_TRACE(trace_buf);
459 }
460 }
461
halbtc8822b1ant_read_scbd(struct btc_coexist * btc,u16 * score_board_val)462 static void halbtc8822b1ant_read_scbd(struct btc_coexist *btc,
463 u16 *score_board_val)
464 {
465 *score_board_val = (btc->btc_read_2byte(btc, 0xaa)) & 0x7fff;
466 }
467
halbtc8822b1ant_query_bt_info(struct btc_coexist * btc)468 static void halbtc8822b1ant_query_bt_info(struct btc_coexist *btc)
469 {
470 struct coex_sta_8822b_1ant *coex_sta = &btc->coex_sta_8822b_1ant;
471 u8 h2c_parameter[1] = {0};
472
473 if (coex_sta->bt_disabled) {
474 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
475 "[BTCoex], No query BT info because BT is disabled!\n");
476 BTC_TRACE(trace_buf);
477 return;
478 }
479
480 h2c_parameter[0] |= BIT(0); /* trigger */
481
482 btc->btc_fill_h2c(btc, 0x61, 1, h2c_parameter);
483
484 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
485 "[BTCoex], WL query BT info!!\n");
486 BTC_TRACE(trace_buf);
487 }
488
halbtc8822b1ant_enable_gnt_to_gpio(struct btc_coexist * btc,boolean isenable)489 static void halbtc8822b1ant_enable_gnt_to_gpio(struct btc_coexist *btc,
490 boolean isenable)
491 {
492 static u8 bit_val[5] = {0, 0, 0, 0, 0};
493 static boolean state;
494
495 if (!btc->dbg_mode)
496 return;
497
498 if (state == isenable)
499 return;
500
501 state = isenable;
502
503 if (isenable) {
504 /* enable GNT_WL, GNT_BT to GPIO for debug */
505 btc->btc_write_1byte_bitmask(btc, 0x73, 0x8, 0x1);
506
507 /* store original value */
508 bit_val[0] = (btc->btc_read_1byte(btc, 0x66) & BIT(4)) >> 4;
509 bit_val[1] = (btc->btc_read_1byte(btc, 0x67) & BIT(0));
510 bit_val[2] = (btc->btc_read_1byte(btc, 0x42) & BIT(3)) >> 3;
511 bit_val[3] = (btc->btc_read_1byte(btc, 0x65) & BIT(7)) >> 7;
512 bit_val[4] = (btc->btc_read_1byte(btc, 0x72) & BIT(2)) >> 2;
513
514 /* switch GPIO Mux */
515 btc->btc_write_1byte_bitmask(btc, 0x66, BIT(4), 0x0);
516 btc->btc_write_1byte_bitmask(btc, 0x67, BIT(0), 0x0);
517 btc->btc_write_1byte_bitmask(btc, 0x42, BIT(3), 0x0);
518 btc->btc_write_1byte_bitmask(btc, 0x65, BIT(7), 0x0);
519 btc->btc_write_1byte_bitmask(btc, 0x72, BIT(2), 0x0);
520 } else {
521 btc->btc_write_1byte_bitmask(btc, 0x73, 0x8, 0x0);
522
523 /* Restore original value */
524 /* switch GPIO Mux */
525 btc->btc_write_1byte_bitmask(btc, 0x66, BIT(4), bit_val[0]);
526 btc->btc_write_1byte_bitmask(btc, 0x67, BIT(0), bit_val[1]);
527 btc->btc_write_1byte_bitmask(btc, 0x42, BIT(3), bit_val[2]);
528 btc->btc_write_1byte_bitmask(btc, 0x65, BIT(7), bit_val[3]);
529 btc->btc_write_1byte_bitmask(btc, 0x72, BIT(2), bit_val[4]);
530 }
531 }
532
halbtc8822b1ant_monitor_bt_ctr(struct btc_coexist * btc)533 static void halbtc8822b1ant_monitor_bt_ctr(struct btc_coexist *btc)
534 {
535 struct coex_sta_8822b_1ant *coex_sta = &btc->coex_sta_8822b_1ant;
536 u32 reg_hp_txrx, reg_lp_txrx, u32tmp;
537 u32 reg_hp_tx = 0, reg_hp_rx = 0, reg_lp_tx = 0, reg_lp_rx = 0;
538 static u8 num_of_bt_counter_chk, cnt_autoslot_hang;
539 struct btc_bt_link_info *bt_link_info = &btc->bt_link_info;
540
541 reg_hp_txrx = 0x770;
542 reg_lp_txrx = 0x774;
543
544 u32tmp = btc->btc_read_4byte(btc, reg_hp_txrx);
545 reg_hp_tx = u32tmp & MASKLWORD;
546 reg_hp_rx = (u32tmp & MASKHWORD) >> 16;
547
548 u32tmp = btc->btc_read_4byte(btc, reg_lp_txrx);
549 reg_lp_tx = u32tmp & MASKLWORD;
550 reg_lp_rx = (u32tmp & MASKHWORD) >> 16;
551
552 coex_sta->high_priority_tx = reg_hp_tx;
553 coex_sta->high_priority_rx = reg_hp_rx;
554 coex_sta->low_priority_tx = reg_lp_tx;
555 coex_sta->low_priority_rx = reg_lp_rx;
556
557 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
558 "[BTCoex], Hi-Pri Rx/Tx: %d/%d, Lo-Pri Rx/Tx: %d/%d\n",
559 reg_hp_rx, reg_hp_tx, reg_lp_rx, reg_lp_tx);
560 BTC_TRACE(trace_buf);
561
562 /* reset counter */
563 btc->btc_write_1byte(btc, 0x76e, 0xc);
564
565 if (coex_sta->low_priority_tx > 1150 &&
566 !coex_sta->c2h_bt_inquiry_page)
567 coex_sta->pop_event_cnt++;
568 }
569
halbtc8822b1ant_monitor_wifi_ctr(struct btc_coexist * btc)570 static void halbtc8822b1ant_monitor_wifi_ctr(struct btc_coexist *btc)
571 {
572 struct coex_sta_8822b_1ant *coex_sta = &btc->coex_sta_8822b_1ant;
573 struct coex_dm_8822b_1ant *coex_dm = &btc->coex_dm_8822b_1ant;
574 boolean wifi_busy = FALSE, wifi_scan = FALSE;
575 static u8 wl_noisy_count0, wl_noisy_count1 = 3, wl_noisy_count2;
576 u32 cnt_cck;
577 static u8 cnt_ccklocking;
578 u8 h2c_parameter[1] = {0};
579 struct btc_bt_link_info *bt_link_info = &btc->bt_link_info;
580
581 btc->btc_get(btc, BTC_GET_BL_WIFI_BUSY, &wifi_busy);
582 btc->btc_get(btc, BTC_GET_BL_WIFI_SCAN, &wifi_scan);
583
584 coex_sta->crc_ok_cck =
585 btc->btc_phydm_query_PHY_counter(btc, PHYDM_INFO_CRC32_OK_CCK);
586 coex_sta->crc_ok_11g =
587 btc->btc_phydm_query_PHY_counter(btc, PHYDM_INFO_CRC32_OK_LEGACY);
588 coex_sta->crc_ok_11n =
589 btc->btc_phydm_query_PHY_counter(btc, PHYDM_INFO_CRC32_OK_HT);
590 coex_sta->crc_ok_11n_vht =
591 btc->btc_phydm_query_PHY_counter(btc, PHYDM_INFO_CRC32_OK_VHT);
592
593 coex_sta->crc_err_cck =
594 btc->btc_phydm_query_PHY_counter(btc, PHYDM_INFO_CRC32_ERROR_CCK);
595 coex_sta->crc_err_11g =
596 btc->btc_phydm_query_PHY_counter(btc, PHYDM_INFO_CRC32_ERROR_LEGACY);
597 coex_sta->crc_err_11n =
598 btc->btc_phydm_query_PHY_counter(btc, PHYDM_INFO_CRC32_ERROR_HT);
599 coex_sta->crc_err_11n_vht =
600 btc->btc_phydm_query_PHY_counter(btc, PHYDM_INFO_CRC32_ERROR_VHT);
601
602 /* CCK lock identification */
603 if (coex_sta->cck_lock)
604 cnt_ccklocking++;
605 else if (cnt_ccklocking != 0)
606 cnt_ccklocking--;
607
608 if (cnt_ccklocking >= 3) {
609 cnt_ccklocking = 3;
610 coex_sta->cck_lock_ever = TRUE;
611 }
612
613 /* WiFi environment noisy identification */
614 cnt_cck = coex_sta->crc_ok_cck + coex_sta->crc_err_cck;
615
616 if (!wifi_busy && !coex_sta->cck_lock) {
617 if (cnt_cck > 250) {
618 if (wl_noisy_count2 < 3)
619 wl_noisy_count2++;
620
621 if (wl_noisy_count2 == 3) {
622 wl_noisy_count0 = 0;
623 wl_noisy_count1 = 0;
624 }
625
626 } else if (cnt_cck < 100) {
627 if (wl_noisy_count0 < 3)
628 wl_noisy_count0++;
629
630 if (wl_noisy_count0 == 3) {
631 wl_noisy_count1 = 0;
632 wl_noisy_count2 = 0;
633 }
634
635 } else {
636 if (wl_noisy_count1 < 3)
637 wl_noisy_count1++;
638
639 if (wl_noisy_count1 == 3) {
640 wl_noisy_count0 = 0;
641 wl_noisy_count2 = 0;
642 }
643 }
644
645 if (wl_noisy_count2 == 3)
646 coex_sta->wl_noisy_level = 2;
647 else if (wl_noisy_count1 == 3)
648 coex_sta->wl_noisy_level = 1;
649 else
650 coex_sta->wl_noisy_level = 0;
651 }
652 }
653
654 static void
halbtc8822b1ant_monitor_bt_enable(struct btc_coexist * btc)655 halbtc8822b1ant_monitor_bt_enable(struct btc_coexist *btc)
656 {
657 struct coex_sta_8822b_1ant *coex_sta = &btc->coex_sta_8822b_1ant;
658 static u32 bt_disable_cnt;
659 boolean bt_active = TRUE, bt_disabled = FALSE;
660 u16 u16tmp;
661 u8 lna_lvl = 1;
662
663 /* Read BT on/off status from scoreboard[1],
664 * enable this only if BT patch support this feature
665 */
666 halbtc8822b1ant_read_scbd(btc, &u16tmp);
667
668 bt_active = u16tmp & BIT(1);
669
670 if (bt_active) {
671 bt_disable_cnt = 0;
672 bt_disabled = FALSE;
673 btc->btc_set(btc, BTC_SET_BL_BT_DISABLE, &bt_disabled);
674 } else {
675 bt_disable_cnt++;
676 if (bt_disable_cnt >= 2) {
677 bt_disabled = TRUE;
678 bt_disable_cnt = 2;
679 }
680
681 btc->btc_set(btc, BTC_SET_BL_BT_DISABLE, &bt_disabled);
682 }
683
684 if (coex_sta->bt_disabled != bt_disabled) {
685 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
686 "[BTCoex], BT is from %s to %s!!\n",
687 (coex_sta->bt_disabled ? "disabled" : "enabled"),
688 (bt_disabled ? "disabled" : "enabled"));
689 BTC_TRACE(trace_buf);
690 coex_sta->bt_disabled = bt_disabled;
691
692 /*for win10 BT disable->enable trigger wifi scan issue */
693 if (!coex_sta->bt_disabled) {
694 coex_sta->is_bt_reenable = TRUE;
695 coex_sta->cnt_bt_reenable = 15;
696 btc->btc_set(btc, BTC_SET_BL_BT_LNA_CONSTRAIN_LEVEL,
697 &lna_lvl);
698 } else {
699 coex_sta->is_bt_reenable = FALSE;
700 coex_sta->cnt_bt_reenable = 0;
701 }
702 }
703 }
704
705 static boolean
halbtc8822b1ant_moniter_wifibt_status(struct btc_coexist * btc)706 halbtc8822b1ant_moniter_wifibt_status(struct btc_coexist *btc)
707 {
708 struct coex_sta_8822b_1ant *coex_sta = &btc->coex_sta_8822b_1ant;
709 struct wifi_link_info_8822b_1ant *wifi_link_info_ext =
710 &btc->wifi_link_info_8822b_1ant;
711 static boolean pre_wifi_busy, pre_under_4way,
712 pre_rf4ce_enabled,
713 pre_bt_off, pre_bt_slave,
714 pre_wifi_under_lps, pre_bt_setup_link,
715 pre_bt_acl_busy;
716 static u8 pre_hid_busy_num, pre_wl_noisy_level;
717 boolean wifi_busy = FALSE, under_4way = FALSE, rf4ce_enabled = FALSE;
718 boolean wifi_connected = FALSE;
719 struct btc_bt_link_info *bt_link_info = &btc->bt_link_info;
720 static u8 cnt_wifi_busytoidle;
721 u32 num_of_wifi_link = 0, wifi_link_mode = 0;
722 static u32 pre_num_of_wifi_link, pre_wifi_link_mode;
723 boolean miracast_plus_bt = FALSE;
724 u8 lna_lvl = 1;
725
726 btc->btc_get(btc, BTC_GET_BL_WIFI_CONNECTED, &wifi_connected);
727 btc->btc_get(btc, BTC_GET_BL_WIFI_BUSY, &wifi_busy);
728 btc->btc_get(btc, BTC_GET_BL_WIFI_4_WAY_PROGRESS, &under_4way);
729
730 if (wifi_busy) {
731 coex_sta->gl_wifi_busy = TRUE;
732 cnt_wifi_busytoidle = 6;
733 } else {
734 if (coex_sta->gl_wifi_busy && cnt_wifi_busytoidle > 0)
735 cnt_wifi_busytoidle--;
736 else if (cnt_wifi_busytoidle == 0)
737 coex_sta->gl_wifi_busy = FALSE;
738 }
739
740 if (coex_sta->bt_disabled != pre_bt_off) {
741 pre_bt_off = coex_sta->bt_disabled;
742
743 if (coex_sta->bt_disabled)
744 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
745 "[BTCoex], BT is disabled !!\n");
746 else
747 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
748 "[BTCoex], BT is enabled !!\n");
749
750 BTC_TRACE(trace_buf);
751
752 coex_sta->bt_coex_supported_feature = 0;
753 coex_sta->bt_coex_supported_version = 0;
754 coex_sta->bt_ble_scan_type = 0;
755 coex_sta->bt_ble_scan_para[0] = 0;
756 coex_sta->bt_ble_scan_para[1] = 0;
757 coex_sta->bt_ble_scan_para[2] = 0;
758 coex_sta->bt_reg_vendor_ac = 0xffff;
759 coex_sta->bt_reg_vendor_ae = 0xffff;
760 coex_sta->bt_a2dp_vendor_id = 0;
761 coex_sta->bt_a2dp_device_name = 0;
762 btc->bt_info.bt_get_fw_ver = 0;
763 return TRUE;
764 }
765
766 num_of_wifi_link = wifi_link_info_ext->num_of_active_port;
767
768 if (num_of_wifi_link != pre_num_of_wifi_link) {
769 pre_num_of_wifi_link = num_of_wifi_link;
770
771 if (wifi_link_info_ext->is_p2p_connected) {
772 if (bt_link_info->bt_link_exist)
773 miracast_plus_bt = TRUE;
774 else
775 miracast_plus_bt = FALSE;
776
777 btc->btc_set(btc, BTC_SET_BL_MIRACAST_PLUS_BT,
778 &miracast_plus_bt);
779 }
780
781 return TRUE;
782 }
783
784 wifi_link_mode = btc->wifi_link_info.link_mode;
785 if (wifi_link_mode != pre_wifi_link_mode) {
786 pre_wifi_link_mode = wifi_link_mode;
787 return TRUE;
788 }
789
790 btc->btc_get(btc, BTC_GET_BL_RF4CE_CONNECTED, &rf4ce_enabled);
791
792 if (rf4ce_enabled != pre_rf4ce_enabled) {
793 pre_rf4ce_enabled = rf4ce_enabled;
794
795 if (rf4ce_enabled)
796 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
797 "[BTCoex], rf4ce is enabled !!\n");
798 else
799 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
800 "[BTCoex], rf4ce is disabled !!\n");
801
802 BTC_TRACE(trace_buf);
803
804 return TRUE;
805 }
806
807 if (wifi_connected) {
808 if (wifi_busy != pre_wifi_busy) {
809 pre_wifi_busy = wifi_busy;
810 return TRUE;
811 }
812 if (under_4way != pre_under_4way) {
813 pre_under_4way = under_4way;
814 return TRUE;
815 }
816 if (coex_sta->wl_noisy_level != pre_wl_noisy_level) {
817 pre_wl_noisy_level = coex_sta->wl_noisy_level;
818 return TRUE;
819 }
820 if (coex_sta->under_lps != pre_wifi_under_lps) {
821 pre_wifi_under_lps = coex_sta->under_lps;
822 if (coex_sta->under_lps)
823 return TRUE;
824 }
825 }
826
827 if (!coex_sta->bt_disabled) {
828 if (coex_sta->acl_busy != pre_bt_acl_busy) {
829 pre_bt_acl_busy = coex_sta->acl_busy;
830 return TRUE;
831 }
832
833 if (coex_sta->hid_busy_num != pre_hid_busy_num) {
834 pre_hid_busy_num = coex_sta->hid_busy_num;
835 return TRUE;
836 }
837
838 if (bt_link_info->slave_role != pre_bt_slave) {
839 pre_bt_slave = bt_link_info->slave_role;
840 return TRUE;
841 }
842
843 if (pre_bt_setup_link != coex_sta->is_setup_link) {
844 pre_bt_setup_link = coex_sta->is_setup_link;
845 return TRUE;
846 }
847 }
848
849 return FALSE;
850 }
851
halbtc8822b1ant_update_wifi_link_info(struct btc_coexist * btc,u8 reason)852 static void halbtc8822b1ant_update_wifi_link_info(struct btc_coexist *btc,
853 u8 reason)
854 {
855 struct coex_sta_8822b_1ant *coex_sta = &btc->coex_sta_8822b_1ant;
856 struct wifi_link_info_8822b_1ant *wifi_link_info_ext =
857 &btc->wifi_link_info_8822b_1ant;
858 struct btc_wifi_link_info wifi_link_info;
859 struct coex_dm_8822b_1ant *coex_dm = &btc->coex_dm_8822b_1ant;
860 u8 wifi_central_chnl = 0, num_of_wifi_link = 0;
861 boolean isunder5G = FALSE, ismcc25g = FALSE, isp2pconnected = FALSE;
862 u32 wifi_link_status = 0;
863
864 btc->btc_get(btc, BTC_GET_BL_WIFI_CONNECTED,
865 &wifi_link_info_ext->is_connected);
866
867 btc->btc_get(btc, BTC_GET_U4_WIFI_LINK_STATUS, &wifi_link_status);
868 wifi_link_info_ext->port_connect_status = wifi_link_status & 0xffff;
869
870 btc->btc_get(btc, BTC_GET_BL_WIFI_LINK_INFO, &wifi_link_info);
871 btc->wifi_link_info = wifi_link_info;
872
873 btc->btc_get(btc, BTC_GET_U1_WIFI_CENTRAL_CHNL, &wifi_central_chnl);
874 coex_sta->wl_center_channel = wifi_central_chnl;
875
876 /* Check scan/connect/special-pkt action first */
877 switch (reason) {
878 case BT_8822B_1ANT_RSN_5GSCANSTART:
879 case BT_8822B_1ANT_RSN_5GSWITCHBAND:
880 case BT_8822B_1ANT_RSN_5GCONSTART:
881
882 isunder5G = TRUE;
883 break;
884 case BT_8822B_1ANT_RSN_2GSCANSTART:
885 case BT_8822B_1ANT_RSN_2GSWITCHBAND:
886 case BT_8822B_1ANT_RSN_2GCONSTART:
887
888 isunder5G = FALSE;
889 break;
890 case BT_8822B_1ANT_RSN_2GCONFINISH:
891 case BT_8822B_1ANT_RSN_5GCONFINISH:
892 case BT_8822B_1ANT_RSN_2GMEDIA:
893 case BT_8822B_1ANT_RSN_5GMEDIA:
894 case BT_8822B_1ANT_RSN_BTINFO:
895 case BT_8822B_1ANT_RSN_PERIODICAL:
896 case BT_8822B_1ANT_RSN_2GSPECIALPKT:
897 case BT_8822B_1ANT_RSN_5GSPECIALPKT:
898 default:
899 switch (wifi_link_info.link_mode) {
900 case BTC_LINK_5G_MCC_GO_STA:
901 case BTC_LINK_5G_MCC_GC_STA:
902 case BTC_LINK_5G_SCC_GO_STA:
903 case BTC_LINK_5G_SCC_GC_STA:
904
905 isunder5G = TRUE;
906 break;
907 case BTC_LINK_2G_MCC_GO_STA:
908 case BTC_LINK_2G_MCC_GC_STA:
909 case BTC_LINK_2G_SCC_GO_STA:
910 case BTC_LINK_2G_SCC_GC_STA:
911
912 isunder5G = FALSE;
913 break;
914 case BTC_LINK_25G_MCC_GO_STA:
915 case BTC_LINK_25G_MCC_GC_STA:
916
917 isunder5G = FALSE;
918 ismcc25g = TRUE;
919 break;
920 case BTC_LINK_ONLY_STA:
921 if (wifi_link_info.sta_center_channel > 14)
922 isunder5G = TRUE;
923 else
924 isunder5G = FALSE;
925 break;
926 case BTC_LINK_ONLY_GO:
927 case BTC_LINK_ONLY_GC:
928 case BTC_LINK_ONLY_AP:
929 default:
930 if (wifi_link_info.p2p_center_channel > 14)
931 isunder5G = TRUE;
932 else
933 isunder5G = FALSE;
934
935 break;
936 }
937 break;
938 }
939
940 wifi_link_info_ext->is_all_under_5g = isunder5G;
941 wifi_link_info_ext->is_mcc_25g = ismcc25g;
942
943 if (wifi_link_status & WIFI_STA_CONNECTED)
944 num_of_wifi_link++;
945
946 if (wifi_link_status & WIFI_AP_CONNECTED)
947 num_of_wifi_link++;
948
949 if (wifi_link_status & WIFI_P2P_GO_CONNECTED) {
950 num_of_wifi_link++;
951 isp2pconnected = TRUE;
952 }
953
954 if (wifi_link_status & WIFI_P2P_GC_CONNECTED) {
955 num_of_wifi_link++;
956 isp2pconnected = TRUE;
957 }
958
959 wifi_link_info_ext->num_of_active_port = num_of_wifi_link;
960 wifi_link_info_ext->is_p2p_connected = isp2pconnected;
961
962 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
963 "[BTCoex], wifi_link_info: link_mode=%d, STA_Ch=%d, P2P_Ch=%d, AnyClient_Join_Go=%d !\n",
964 btc->wifi_link_info.link_mode,
965 btc->wifi_link_info.sta_center_channel,
966 btc->wifi_link_info.p2p_center_channel,
967 btc->wifi_link_info.bany_client_join_go);
968 BTC_TRACE(trace_buf);
969
970 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
971 "[BTCoex], wifi_link_info: center_ch=%d, is_all_under_5g=%d, is_mcc_25g=%d!\n",
972 coex_sta->wl_center_channel,
973 wifi_link_info_ext->is_all_under_5g,
974 wifi_link_info_ext->is_mcc_25g);
975 BTC_TRACE(trace_buf);
976
977 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
978 "[BTCoex], wifi_link_info: port_connect_status=0x%x, active_port_cnt=%d, P2P_Connect=%d!\n",
979 wifi_link_info_ext->port_connect_status,
980 wifi_link_info_ext->num_of_active_port,
981 wifi_link_info_ext->is_p2p_connected);
982 BTC_TRACE(trace_buf);
983
984 switch (reason) {
985 case BT_8822B_1ANT_RSN_2GSCANSTART:
986 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
987 "[BTCoex], Update reason = %s\n", "2GSCANSTART");
988 break;
989 case BT_8822B_1ANT_RSN_5GSCANSTART:
990 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
991 "[BTCoex], Update reason = %s\n", "5GSCANSTART");
992 break;
993 case BT_8822B_1ANT_RSN_SCANFINISH:
994 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
995 "[BTCoex], Update reason = %s\n", "SCANFINISH");
996 break;
997 case BT_8822B_1ANT_RSN_2GSWITCHBAND:
998 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
999 "[BTCoex], Update reason = %s\n", "2GSWITCHBAND");
1000 break;
1001 case BT_8822B_1ANT_RSN_5GSWITCHBAND:
1002 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
1003 "[BTCoex], Update reason = %s\n", "5GSWITCHBAND");
1004 break;
1005 case BT_8822B_1ANT_RSN_2GCONSTART:
1006 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
1007 "[BTCoex], Update reason = %s\n", "2GCONNECTSTART");
1008 break;
1009 case BT_8822B_1ANT_RSN_5GCONSTART:
1010 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
1011 "[BTCoex], Update reason = %s\n", "5GCONNECTSTART");
1012 break;
1013 case BT_8822B_1ANT_RSN_2GCONFINISH:
1014 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
1015 "[BTCoex], Update reason = %s\n",
1016 "2GCONNECTFINISH");
1017 break;
1018 case BT_8822B_1ANT_RSN_5GCONFINISH:
1019 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
1020 "[BTCoex], Update reason = %s\n",
1021 "5GCONNECTFINISH");
1022 break;
1023 case BT_8822B_1ANT_RSN_2GMEDIA:
1024 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
1025 "[BTCoex], Update reason = %s\n", "2GMEDIASTATUS");
1026 break;
1027 case BT_8822B_1ANT_RSN_5GMEDIA:
1028 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
1029 "[BTCoex], Update reason = %s\n", "5GMEDIASTATUS");
1030 break;
1031 case BT_8822B_1ANT_RSN_MEDIADISCON:
1032 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
1033 "[BTCoex], Update reason = %s\n",
1034 "MEDIADISCONNECT");
1035 break;
1036 case BT_8822B_1ANT_RSN_2GSPECIALPKT:
1037 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
1038 "[BTCoex], Update reason = %s\n", "2GSPECIALPKT");
1039 break;
1040 case BT_8822B_1ANT_RSN_5GSPECIALPKT:
1041 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
1042 "[BTCoex], Update reason = %s\n", "5GSPECIALPKT");
1043 break;
1044 case BT_8822B_1ANT_RSN_BTINFO:
1045 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
1046 "[BTCoex], Update reason = %s\n", "BTINFO");
1047 break;
1048 case BT_8822B_1ANT_RSN_PERIODICAL:
1049 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
1050 "[BTCoex], Update reason = %s\n", "PERIODICAL");
1051 break;
1052 case BT_8822B_1ANT_RSN_PNP:
1053 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
1054 "[BTCoex], Update reason = %s\n", "PNPNotify");
1055 break;
1056 case BT_8822B_1ANT_RSN_LPS:
1057 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
1058 "[BTCoex], Update reason = %s\n", "LPSNotify");
1059 break;
1060 default:
1061 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
1062 "[BTCoex], Update reason = %s\n", "UNKNOWN");
1063 break;
1064 }
1065
1066 BTC_TRACE(trace_buf);
1067
1068 if (btc->manual_control || btc->stop_coex_dm)
1069 return;
1070
1071 if (wifi_link_info_ext->is_all_under_5g || num_of_wifi_link == 0 ||
1072 coex_dm->bt_status == BT_8822B_1ANT_BSTATUS_NCON_IDLE) {
1073 halbtc8822b1ant_low_penalty_ra(btc, NM_EXCU, FALSE, 0);
1074 halbtc8822b1ant_limited_tx(btc, NM_EXCU, FALSE, FALSE);
1075 halbtc8822b1ant_limited_rx(btc, NM_EXCU, FALSE, TRUE, 64);
1076 } else if (wifi_link_info_ext->num_of_active_port > 1) {
1077 halbtc8822b1ant_low_penalty_ra(btc, NM_EXCU, TRUE, 30);
1078 halbtc8822b1ant_limited_tx(btc, NM_EXCU, FALSE, TRUE);
1079 halbtc8822b1ant_limited_rx(btc, NM_EXCU, FALSE, TRUE, 16);
1080 } else {
1081 halbtc8822b1ant_low_penalty_ra(btc, NM_EXCU, TRUE, 15);
1082
1083 if (coex_sta->hid_exist || coex_sta->hid_pair_cnt > 0 ||
1084 coex_sta->sco_exist) {
1085 halbtc8822b1ant_limited_tx(btc, NM_EXCU, TRUE, TRUE);
1086 halbtc8822b1ant_limited_rx(btc, NM_EXCU, FALSE, TRUE,
1087 16);
1088 } else {
1089 halbtc8822b1ant_limited_tx(btc, NM_EXCU, TRUE, FALSE);
1090 halbtc8822b1ant_limited_rx(btc, NM_EXCU, FALSE, TRUE,
1091 64);
1092 }
1093 }
1094
1095 /* coex-276 P2P-Go beacon request can't release issue
1096 * Only PCIe can set 0x454[6] = 1 to solve this issue,
1097 * WL SDIO/USB interface need driver support.
1098 */
1099 if (btc->chip_interface == BTC_INTF_PCI &&
1100 wifi_link_info.link_mode == BTC_LINK_ONLY_GO)
1101 btc->btc_write_1byte_bitmask(btc, 0x454, BIT(6), 0x1);
1102 else
1103 btc->btc_write_1byte_bitmask(btc, 0x454, BIT(6), 0x0);
1104 }
1105
halbtc8822b1ant_update_bt_link_info(struct btc_coexist * btc)1106 static void halbtc8822b1ant_update_bt_link_info(struct btc_coexist *btc)
1107 {
1108 struct coex_sta_8822b_1ant *coex_sta = &btc->coex_sta_8822b_1ant;
1109 struct coex_dm_8822b_1ant *coex_dm = &btc->coex_dm_8822b_1ant;
1110 struct btc_bt_link_info *bt_link_info = &btc->bt_link_info;
1111 boolean bt_busy = FALSE, increase_scan_dev_num = FALSE;
1112 u32 val = 0;
1113 static u8 pre_num_of_profile, cur_num_of_profile, cnt, ble_cnt;
1114
1115 if (++ble_cnt >= 3)
1116 ble_cnt = 0;
1117
1118 if (coex_sta->is_ble_scan_en && ble_cnt == 0) {
1119 u32 *p = NULL;
1120 u8 scantype;
1121
1122 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
1123 "[BTCoex], BT ext info bit4 check, query BLE Scan type!!\n");
1124 BTC_TRACE(trace_buf);
1125 coex_sta->bt_ble_scan_type =
1126 btc->btc_get_ble_scan_type_from_bt(btc);
1127
1128 if ((coex_sta->bt_ble_scan_type & 0x1) == 0x1) {
1129 p = &coex_sta->bt_ble_scan_para[0];
1130 scantype = 0x1;
1131 }
1132
1133 if ((coex_sta->bt_ble_scan_type & 0x2) == 0x2) {
1134 p = &coex_sta->bt_ble_scan_para[1];
1135 scantype = 0x2;
1136 }
1137
1138 if ((coex_sta->bt_ble_scan_type & 0x4) == 0x4) {
1139 p = &coex_sta->bt_ble_scan_para[2];
1140 scantype = 0x4;
1141 }
1142
1143 if (p)
1144 *p = btc->btc_get_ble_scan_para_from_bt(btc, scantype);
1145 }
1146
1147 coex_sta->num_of_profile = 0;
1148
1149 /* set link exist status */
1150 if (!(coex_sta->bt_info_lb2 & BT_INFO_8822B_1ANT_B_CONNECTION)) {
1151 coex_sta->bt_link_exist = FALSE;
1152 coex_sta->pan_exist = FALSE;
1153 coex_sta->a2dp_exist = FALSE;
1154 coex_sta->hid_exist = FALSE;
1155 coex_sta->sco_exist = FALSE;
1156 coex_sta->msft_mr_exist = FALSE;
1157 } else { /* connection exists */
1158 coex_sta->bt_link_exist = TRUE;
1159 if (coex_sta->bt_info_lb2 & BT_INFO_8822B_1ANT_B_FTP) {
1160 coex_sta->pan_exist = TRUE;
1161 coex_sta->num_of_profile++;
1162 } else {
1163 coex_sta->pan_exist = FALSE;
1164 }
1165
1166 if (coex_sta->bt_info_lb2 & BT_INFO_8822B_1ANT_B_A2DP) {
1167 coex_sta->a2dp_exist = TRUE;
1168 coex_sta->num_of_profile++;
1169 } else {
1170 coex_sta->a2dp_exist = FALSE;
1171 }
1172
1173 if (coex_sta->bt_info_lb2 & BT_INFO_8822B_1ANT_B_HID) {
1174 coex_sta->hid_exist = TRUE;
1175 coex_sta->num_of_profile++;
1176 } else {
1177 coex_sta->hid_exist = FALSE;
1178 }
1179
1180 if (coex_sta->bt_info_lb2 & BT_INFO_8822B_1ANT_B_SCO_ESCO) {
1181 coex_sta->sco_exist = TRUE;
1182 coex_sta->num_of_profile++;
1183 } else {
1184 coex_sta->sco_exist = FALSE;
1185 }
1186
1187 if (coex_sta->hid_busy_num == 0 &&
1188 coex_sta->hid_pair_cnt > 0 &&
1189 coex_sta->low_priority_tx > 1000 &&
1190 coex_sta->low_priority_rx > 1000 &&
1191 !coex_sta->c2h_bt_inquiry_page)
1192 coex_sta->msft_mr_exist = TRUE;
1193 else
1194 coex_sta->msft_mr_exist = FALSE;
1195 }
1196
1197 bt_link_info->bt_link_exist = coex_sta->bt_link_exist;
1198 bt_link_info->sco_exist = coex_sta->sco_exist;
1199 bt_link_info->a2dp_exist = coex_sta->a2dp_exist;
1200 bt_link_info->pan_exist = coex_sta->pan_exist;
1201 bt_link_info->hid_exist = coex_sta->hid_exist;
1202 bt_link_info->acl_busy = coex_sta->acl_busy;
1203
1204 /* check if Sco only */
1205 if (bt_link_info->sco_exist && !bt_link_info->a2dp_exist &&
1206 !bt_link_info->pan_exist && !bt_link_info->hid_exist)
1207 bt_link_info->sco_only = TRUE;
1208 else
1209 bt_link_info->sco_only = FALSE;
1210
1211 /* check if A2dp only */
1212 if (!bt_link_info->sco_exist && bt_link_info->a2dp_exist &&
1213 !bt_link_info->pan_exist && !bt_link_info->hid_exist)
1214 bt_link_info->a2dp_only = TRUE;
1215 else
1216 bt_link_info->a2dp_only = FALSE;
1217
1218 /* check if Pan only */
1219 if (!bt_link_info->sco_exist && !bt_link_info->a2dp_exist &&
1220 bt_link_info->pan_exist && !bt_link_info->hid_exist)
1221 bt_link_info->pan_only = TRUE;
1222 else
1223 bt_link_info->pan_only = FALSE;
1224
1225 /* check if Hid only */
1226 if (!bt_link_info->sco_exist && !bt_link_info->a2dp_exist &&
1227 !bt_link_info->pan_exist && bt_link_info->hid_exist)
1228 bt_link_info->hid_only = TRUE;
1229 else
1230 bt_link_info->hid_only = FALSE;
1231
1232 if (coex_sta->bt_info_lb2 & BT_INFO_8822B_1ANT_B_INQ_PAGE) {
1233 coex_dm->bt_status = BT_8822B_1ANT_BSTATUS_INQ_PAGE;
1234 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
1235 "[BTCoex], BtInfoNotify(), BT Inq/page!!!\n");
1236 } else if (!(coex_sta->bt_info_lb2 & BT_INFO_8822B_1ANT_B_CONNECTION)) {
1237 coex_dm->bt_status = BT_8822B_1ANT_BSTATUS_NCON_IDLE;
1238 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
1239 "[BTCoex], BtInfoNotify(), BT Non-Connected idle!!!\n");
1240 } else if (coex_sta->bt_info_lb2 == BT_INFO_8822B_1ANT_B_CONNECTION) {
1241 /* connection exists but no busy */
1242
1243 if (coex_sta->msft_mr_exist) {
1244 coex_dm->bt_status = BT_8822B_1ANT_BSTATUS_ACL_BUSY;
1245 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
1246 "[BTCoex], BtInfoNotify(), BT ACL busy!!\n");
1247 } else {
1248 coex_dm->bt_status =
1249 BT_8822B_1ANT_BSTATUS_CON_IDLE;
1250 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
1251 "[BTCoex], BtInfoNotify(), BT Connected-idle!!!\n");
1252 }
1253 } else if (((coex_sta->bt_info_lb2 & BT_INFO_8822B_1ANT_B_SCO_ESCO) ||
1254 (coex_sta->bt_info_lb2 & BT_INFO_8822B_1ANT_B_SCO_BUSY)) &&
1255 (coex_sta->bt_info_lb2 & BT_INFO_8822B_1ANT_B_ACL_BUSY)) {
1256 coex_dm->bt_status = BT_8822B_1ANT_BSTATUS_ACL_SCO_BUSY;
1257 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
1258 "[BTCoex], BtInfoNotify(), BT ACL SCO busy!!!\n");
1259 } else if ((coex_sta->bt_info_lb2 & BT_INFO_8822B_1ANT_B_SCO_ESCO) ||
1260 (coex_sta->bt_info_lb2 & BT_INFO_8822B_1ANT_B_SCO_BUSY)) {
1261 coex_dm->bt_status = BT_8822B_1ANT_BSTATUS_SCO_BUSY;
1262 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
1263 "[BTCoex], BtInfoNotify(), BT SCO busy!!!\n");
1264 } else if (coex_sta->bt_info_lb2 & BT_INFO_8822B_1ANT_B_ACL_BUSY) {
1265 coex_dm->bt_status = BT_8822B_1ANT_BSTATUS_ACL_BUSY;
1266 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
1267 "[BTCoex], BtInfoNotify(), BT ACL busy!!!\n");
1268 } else {
1269 coex_dm->bt_status = BT_8822B_1ANT_BSTATUS_MAX;
1270 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
1271 "[BTCoex], BtInfoNotify(), BT Non-Defined state!!!\n");
1272 }
1273
1274 BTC_TRACE(trace_buf);
1275
1276 if (coex_dm->bt_status == BT_8822B_1ANT_BSTATUS_ACL_BUSY ||
1277 coex_dm->bt_status == BT_8822B_1ANT_BSTATUS_SCO_BUSY ||
1278 coex_dm->bt_status == BT_8822B_1ANT_BSTATUS_ACL_SCO_BUSY) {
1279 bt_busy = TRUE;
1280 increase_scan_dev_num = TRUE;
1281 } else {
1282 bt_busy = FALSE;
1283 increase_scan_dev_num = FALSE;
1284 }
1285
1286 btc->btc_set(btc, BTC_SET_BL_BT_TRAFFIC_BUSY, &bt_busy);
1287 btc->btc_set(btc, BTC_SET_BL_INC_SCAN_DEV_NUM, &increase_scan_dev_num);
1288
1289 cur_num_of_profile = coex_sta->num_of_profile;
1290
1291 if (cur_num_of_profile != pre_num_of_profile)
1292 cnt = 2;
1293
1294 if (bt_link_info->a2dp_exist && cnt > 0) {
1295 cnt--;
1296 if (coex_sta->bt_a2dp_vendor_id == 0 &&
1297 coex_sta->bt_a2dp_device_name == 0) {
1298 btc->btc_get(btc, BTC_GET_U4_BT_DEVICE_INFO, &val);
1299
1300 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
1301 "[BTCoex], BtInfoNotify(), get BT DEVICE_INFO = %x\n",
1302 val);
1303 BTC_TRACE(trace_buf);
1304
1305 coex_sta->bt_a2dp_vendor_id = (u8)(val & 0xff);
1306 coex_sta->bt_a2dp_device_name = (val & 0xffffff00) >> 8;
1307
1308 btc->btc_get(btc, BTC_GET_U4_BT_A2DP_FLUSH_VAL, &val);
1309 coex_sta->bt_a2dp_flush_time = val;
1310 }
1311 } else if (!bt_link_info->a2dp_exist) {
1312 coex_sta->bt_a2dp_vendor_id = 0;
1313 coex_sta->bt_a2dp_device_name = 0;
1314 coex_sta->bt_a2dp_flush_time = 0;
1315 }
1316
1317 pre_num_of_profile = coex_sta->num_of_profile;
1318 }
1319
1320 static void
halbtc8822b1ant_update_wifi_ch_info(struct btc_coexist * btc,u8 type)1321 halbtc8822b1ant_update_wifi_ch_info(struct btc_coexist *btc, u8 type)
1322 {
1323 struct coex_sta_8822b_1ant *coex_sta = &btc->coex_sta_8822b_1ant;
1324 struct coex_dm_8822b_1ant *coex_dm = &btc->coex_dm_8822b_1ant;
1325 struct wifi_link_info_8822b_1ant *wifi_link_info_ext =
1326 &btc->wifi_link_info_8822b_1ant;
1327 u8 h2c_parameter[3] = {0}, i;
1328 u32 wifi_bw;
1329 u8 wl_ch = 0;
1330 u8 wl_5g_ch[] = {120, 124, 128, 132, 136, 140, 144, 149, 153, 157,
1331 118, 126, 134, 142, 151, 159, 122, 138, 155};
1332 u8 bt_skip_ch[] = {2, 8, 17, 26, 34, 42, 51, 62, 71, 77,
1333 2, 12, 29, 46, 66, 76, 10, 37, 68};
1334 u8 bt_skip_span[] = {4, 8, 8, 10, 8, 10, 8, 8, 10, 4,
1335 4, 16, 16, 16, 16, 4, 20, 34, 20};
1336
1337 if (btc->manual_control)
1338 return;
1339
1340 btc->btc_get(btc, BTC_GET_U4_WIFI_BW, &wifi_bw);
1341
1342 if (btc->stop_coex_dm || btc->wl_rf_state_off) {
1343 wl_ch = 0;
1344 } else if (type != BTC_MEDIA_DISCONNECT ||
1345 (type == BTC_MEDIA_DISCONNECT &&
1346 wifi_link_info_ext->num_of_active_port > 0)) {
1347 if (wifi_link_info_ext->num_of_active_port == 1) {
1348 if (wifi_link_info_ext->is_p2p_connected)
1349 wl_ch = btc->wifi_link_info.p2p_center_channel;
1350 else
1351 wl_ch = btc->wifi_link_info.sta_center_channel;
1352 } else { /* port > 2 */
1353 if (btc->wifi_link_info.p2p_center_channel > 14 &&
1354 btc->wifi_link_info.sta_center_channel > 14)
1355 wl_ch = btc->wifi_link_info.p2p_center_channel;
1356 else if (btc->wifi_link_info.p2p_center_channel <= 14)
1357 wl_ch = btc->wifi_link_info.p2p_center_channel;
1358 else if (btc->wifi_link_info.sta_center_channel <= 14)
1359 wl_ch = btc->wifi_link_info.sta_center_channel;
1360 }
1361 }
1362
1363 if (wl_ch > 0) {
1364 if (wl_ch <= 14) {
1365 /* no AFH notify for shared-antenna */
1366 h2c_parameter[0] = 0x0;
1367 h2c_parameter[1] = 0x0;
1368 h2c_parameter[2] = 0x0;
1369 #if 0
1370 h2c_parameter[0] = 0x1;
1371 h2c_parameter[1] = wl_ch;
1372
1373 if (wifi_bw == BTC_WIFI_BW_HT40)
1374 h2c_parameter[2] = 0x36;
1375 else
1376 h2c_parameter[2] = 0x24;
1377 #endif
1378 } else { /* for 5G */
1379 for (i = 0; i < ARRAY_SIZE(wl_5g_ch); i++) {
1380 if (wl_ch == wl_5g_ch[i]) {
1381 h2c_parameter[0] = 0x3;
1382 h2c_parameter[1] = bt_skip_ch[i];
1383 h2c_parameter[2] = bt_skip_span[i];
1384 break;
1385 }
1386 }
1387 }
1388 }
1389
1390 coex_dm->wifi_chnl_info[0] = h2c_parameter[0];
1391 coex_dm->wifi_chnl_info[1] = h2c_parameter[1];
1392 coex_dm->wifi_chnl_info[2] = h2c_parameter[2];
1393
1394 btc->btc_fill_h2c(btc, 0x66, 3, h2c_parameter);
1395
1396 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
1397 "[BTCoex], para[0:2] = 0x%x 0x%x 0x%x\n", h2c_parameter[0],
1398 h2c_parameter[1], h2c_parameter[2]);
1399 BTC_TRACE(trace_buf);
1400 }
1401
halbtc8822b1ant_set_wl_tx_power(struct btc_coexist * btc,boolean force_exec,u8 wl_pwr_lvl)1402 static void halbtc8822b1ant_set_wl_tx_power(struct btc_coexist *btc,
1403 boolean force_exec, u8 wl_pwr_lvl)
1404 {
1405 struct coex_dm_8822b_1ant *coex_dm = &btc->coex_dm_8822b_1ant;
1406
1407 if (!force_exec) {
1408 if (wl_pwr_lvl == coex_dm->cur_wl_pwr_lvl)
1409 return;
1410 }
1411
1412 btc->btc_write_1byte_bitmask(btc, 0xc5b, 0xff, wl_pwr_lvl);
1413 btc->btc_write_1byte_bitmask(btc, 0xe5b, 0xff, wl_pwr_lvl);
1414
1415 coex_dm->cur_wl_pwr_lvl = wl_pwr_lvl;
1416 }
1417
halbtc8822b1ant_set_bt_tx_power(struct btc_coexist * btc,boolean force_exec,u8 bt_pwr_lvl)1418 static void halbtc8822b1ant_set_bt_tx_power(struct btc_coexist *btc,
1419 boolean force_exec, u8 bt_pwr_lvl)
1420 {
1421 struct coex_dm_8822b_1ant *coex_dm = &btc->coex_dm_8822b_1ant;
1422 u8 h2c_parameter[1] = {0};
1423
1424 if (!force_exec) {
1425 if (bt_pwr_lvl == coex_dm->cur_bt_pwr_lvl)
1426 return;
1427 }
1428
1429 h2c_parameter[0] = 0 - bt_pwr_lvl;
1430
1431 btc->btc_fill_h2c(btc, 0x62, 1, h2c_parameter);
1432
1433 coex_dm->cur_bt_pwr_lvl = bt_pwr_lvl;
1434 }
1435
halbtc8822b1ant_set_wl_rx_gain(struct btc_coexist * btc,boolean force_exec,boolean agc_table_en)1436 static void halbtc8822b1ant_set_wl_rx_gain(struct btc_coexist *btc,
1437 boolean force_exec,
1438 boolean agc_table_en)
1439 {
1440 struct coex_dm_8822b_1ant *coex_dm = &btc->coex_dm_8822b_1ant;
1441 u8 i;
1442
1443 /*20180228--58~-110:use from line 5 to line 8 , others :line 5*/
1444 u32 rx_gain_value_en[] = {
1445 0xff000003, 0xf4120003, 0xf5100003, 0xf60e0003, 0xf70c0003,
1446 0xf80a0003, 0xf3140003, 0xf2160003, 0xf1180003, 0xf01a0003,
1447 0xef1c0003, 0xee1e0003, 0xed200003, 0xec220003, 0xeb240003,
1448 0xea260003, 0xe9280003, 0xe82a0003, 0xe72c0003, 0xe62e0003,
1449 0xe5300003, 0xc8320003, 0xc7340003, 0xab360003, 0x8d380003,
1450 0x8c3a0003, 0x8b3c0003, 0x8a3e0003, 0x6e400003, 0x6d420003,
1451 0x6c440003, 0x6b460003, 0x6a480003, 0x694a0003, 0x684c0003,
1452 0x674e0003, 0x66500003, 0x65520003, 0x64540003, 0x64560003,
1453 0x007e0403};
1454
1455 u32 rx_gain_value_dis[] = {
1456 0xff000003, 0xf4120003, 0xf5100003, 0xf60e0003, 0xf70c0003,
1457 0xf80a0003, 0xf3140003, 0xf2160003, 0xf1180003, 0xf01a0003,
1458 0xef1c0003, 0xee1e0003, 0xed200003, 0xec220003, 0xeb240003,
1459 0xea260003, 0xe9280003, 0xe82a0003, 0xe72c0003, 0xe62e0003,
1460 0xe5300003, 0xc8320003, 0xc7340003, 0xc6360003, 0xc5380003,
1461 0xc43a0003, 0xc33c0003, 0xc23e0003, 0xc1400003, 0xc0420003,
1462 0xa5440003, 0xa4460003, 0xa3480003, 0xa24a0003, 0xa14c0003,
1463 0x834e0003, 0x82500003, 0x81520003, 0x80540003, 0x65560003,
1464 0x007e0403};
1465
1466 if (!force_exec) {
1467 if (agc_table_en == coex_dm->cur_agc_table_en)
1468 return;
1469 }
1470
1471 if (agc_table_en) {
1472 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
1473 "[BTCoex], BB Agc Table On!\n");
1474 BTC_TRACE(trace_buf);
1475
1476 for (i = 0; i < ARRAY_SIZE(rx_gain_value_en); i++)
1477 btc->btc_write_4byte(btc, 0x81c, rx_gain_value_en[i]);
1478 } else {
1479 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
1480 "[BTCoex], BB Agc Table Off!\n");
1481 BTC_TRACE(trace_buf);
1482
1483 for (i = 0; i < ARRAY_SIZE(rx_gain_value_dis); i++)
1484 btc->btc_write_4byte(btc, 0x81c, rx_gain_value_dis[i]);
1485 }
1486
1487 coex_dm->cur_agc_table_en = agc_table_en;
1488 }
1489
halbtc8822b1ant_set_bt_rx_gain(struct btc_coexist * btc,boolean force_exec,boolean rx_gain_en)1490 static void halbtc8822b1ant_set_bt_rx_gain(struct btc_coexist *btc,
1491 boolean force_exec,
1492 boolean rx_gain_en)
1493 {
1494 /* use scoreboard[4] to notify BT Rx gain table change */
1495 halbtc8822b1ant_write_scbd(btc, BT_8822B_1ANT_SCBD_RXGAIN, rx_gain_en);
1496 }
1497
1498 static u32
halbtc8822b1ant_wait_indirect_reg_ready(struct btc_coexist * btc)1499 halbtc8822b1ant_wait_indirect_reg_ready(struct btc_coexist *btc)
1500 {
1501 u32 delay_count = 0;
1502
1503 /* wait for ready bit before access 0x1700 */
1504 while (1) {
1505 if ((btc->btc_read_1byte(btc, 0x1703) & BIT(5)) == 0) {
1506 delay_ms(10);
1507 if (++delay_count >= 10)
1508 break;
1509 } else {
1510 break;
1511 }
1512 }
1513
1514 return delay_count;
1515 }
1516
1517 static
halbtc8822b1ant_read_indirect_reg(struct btc_coexist * btc,u16 reg_addr)1518 u32 halbtc8822b1ant_read_indirect_reg(struct btc_coexist *btc, u16 reg_addr)
1519 {
1520 u32 delay_count = 0;
1521
1522 /* wait for ready bit before access 0x1700 */
1523 halbtc8822b1ant_wait_indirect_reg_ready(btc);
1524
1525 btc->btc_write_4byte(btc, 0x1700, 0x800F0000 | reg_addr);
1526 return btc->btc_read_4byte(btc, 0x1708); /* get read data */
1527 }
1528
1529 static
halbtc8822b1ant_write_indirect_reg(struct btc_coexist * btc,u16 reg_addr,u32 bit_mask,u32 reg_value)1530 void halbtc8822b1ant_write_indirect_reg(struct btc_coexist *btc, u16 reg_addr,
1531 u32 bit_mask, u32 reg_value)
1532 {
1533 u32 val, i = 0, bitpos = 0, delay_count = 0;
1534
1535 if (bit_mask == 0x0)
1536 return;
1537
1538 if (bit_mask == 0xffffffff) {
1539 /* wait for ready bit before access 0x1700/0x1704 */
1540 halbtc8822b1ant_wait_indirect_reg_ready(btc);
1541
1542 /* put write data */
1543 btc->btc_write_4byte(btc, 0x1704, reg_value);
1544 btc->btc_write_4byte(btc, 0x1700, 0xc00F0000 | reg_addr);
1545 } else {
1546 for (i = 0; i <= 31; i++) {
1547 if (((bit_mask >> i) & 0x1) == 0x1) {
1548 bitpos = i;
1549 break;
1550 }
1551 }
1552
1553 /* read back register value before write */
1554 val = halbtc8822b1ant_read_indirect_reg(btc, reg_addr);
1555 val = (val & (~bit_mask)) | (reg_value << bitpos);
1556
1557 /* wait for ready bit before access 0x1700/0x1704 */
1558 halbtc8822b1ant_wait_indirect_reg_ready(btc);
1559
1560 btc->btc_write_4byte(btc, 0x1704, val); /* put write data */
1561 btc->btc_write_4byte(btc, 0x1700, 0xc00F0000 | reg_addr);
1562 }
1563 }
1564
1565 static
halbtc8822b1ant_ltecoex_enable(struct btc_coexist * btc,boolean enable)1566 void halbtc8822b1ant_ltecoex_enable(struct btc_coexist *btc, boolean enable)
1567 {
1568 u8 val;
1569
1570 val = (enable) ? 1 : 0;
1571 /* 0x38[7] */
1572 halbtc8822b1ant_write_indirect_reg(btc, 0x38, BIT(7), val);
1573 }
1574
1575 static
hallbtc8822b1ant_ltecoex_table(struct btc_coexist * btc,u8 table_type,u16 table_val)1576 void hallbtc8822b1ant_ltecoex_table(struct btc_coexist *btc,
1577 u8 table_type, u16 table_val)
1578 {
1579 u16 reg_addr = 0x0000;
1580
1581 switch (table_type) {
1582 case BT_8822B_1ANT_CTT_WL_VS_LTE:
1583 reg_addr = 0xa0;
1584 break;
1585 case BT_8822B_1ANT_CTT_BT_VS_LTE:
1586 reg_addr = 0xa4;
1587 break;
1588 }
1589
1590 if (reg_addr == 0x0000)
1591 return;
1592
1593 /* 0xa0[15:0] or 0xa4[15:0] */
1594 halbtc8822b1ant_write_indirect_reg(btc, reg_addr, 0xffff, table_val);
1595 }
1596
1597 static
halbtc8822b1ant_coex_ctrl_owner(struct btc_coexist * btc,boolean wifi_control)1598 void halbtc8822b1ant_coex_ctrl_owner(struct btc_coexist *btc,
1599 boolean wifi_control)
1600 {
1601 u8 val;
1602
1603 val = (wifi_control) ? 1 : 0;
1604 /* 0x70[26] */
1605 btc->btc_write_1byte_bitmask(btc, 0x73, BIT(2), val);
1606 }
1607
1608 static void
halbtc8822b1ant_set_gnt_bt(struct btc_coexist * btc,u8 state)1609 halbtc8822b1ant_set_gnt_bt(struct btc_coexist *btc, u8 state)
1610 {
1611 switch (state) {
1612 case BTC_GNT_SET_SW_LOW:
1613 halbtc8822b1ant_write_indirect_reg(btc, 0x38, 0xc000, 0x1);
1614 halbtc8822b1ant_write_indirect_reg(btc, 0x38, 0x0c00, 0x1);
1615 break;
1616 case BTC_GNT_SET_SW_HIGH:
1617 halbtc8822b1ant_write_indirect_reg(btc, 0x38, 0xc000, 0x3);
1618 halbtc8822b1ant_write_indirect_reg(btc, 0x38, 0x0c00, 0x3);
1619 break;
1620 case BTC_GNT_SET_HW_PTA:
1621 default:
1622 halbtc8822b1ant_write_indirect_reg(btc, 0x38, 0xc000, 0x0);
1623 halbtc8822b1ant_write_indirect_reg(btc, 0x38, 0x0c00, 0x0);
1624 break;
1625 }
1626 }
1627
1628 static void
halbtc8822b1ant_set_gnt_wl(struct btc_coexist * btc,u8 state)1629 halbtc8822b1ant_set_gnt_wl(struct btc_coexist *btc, u8 state)
1630 {
1631 switch (state) {
1632 case BTC_GNT_SET_SW_LOW:
1633 halbtc8822b1ant_write_indirect_reg(btc, 0x38, 0x3000, 0x1);
1634 halbtc8822b1ant_write_indirect_reg(btc, 0x38, 0x0300, 0x1);
1635 break;
1636 case BTC_GNT_SET_SW_HIGH:
1637 halbtc8822b1ant_write_indirect_reg(btc, 0x38, 0x3000, 0x3);
1638 halbtc8822b1ant_write_indirect_reg(btc, 0x38, 0x0300, 0x3);
1639 break;
1640 case BTC_GNT_SET_HW_PTA:
1641 default:
1642 halbtc8822b1ant_write_indirect_reg(btc, 0x38, 0x3000, 0x0);
1643 halbtc8822b1ant_write_indirect_reg(btc, 0x38, 0x0300, 0x0);
1644 break;
1645 }
1646 }
1647
halbtc8822b1ant_mimo_ps(struct btc_coexist * btc,boolean force_exec,u8 state)1648 static void halbtc8822b1ant_mimo_ps(struct btc_coexist *btc,
1649 boolean force_exec, u8 state)
1650 {
1651 static u8 pre_state;
1652
1653 if (!force_exec) {
1654 if (state == pre_state)
1655 return;
1656 }
1657
1658 pre_state = state;
1659
1660 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
1661 "[BTCoex], %s(), state = %d\n", __func__, state);
1662 BTC_TRACE(trace_buf);
1663
1664 btc->btc_set(btc, BTC_SET_MIMO_PS_MODE, &state);
1665 }
1666
halbtc8822b1ant_set_table(struct btc_coexist * btc,boolean force_exec,u32 val0x6c0,u32 val0x6c4,u32 val0x6c8,u8 val0x6cc)1667 static void halbtc8822b1ant_set_table(struct btc_coexist *btc,
1668 boolean force_exec, u32 val0x6c0,
1669 u32 val0x6c4, u32 val0x6c8, u8 val0x6cc)
1670 {
1671 struct coex_sta_8822b_1ant *coex_sta = &btc->coex_sta_8822b_1ant;
1672 struct coex_dm_8822b_1ant *coex_dm = &btc->coex_dm_8822b_1ant;
1673
1674 if (!force_exec && !coex_sta->wl_slot_toggle_change) {
1675 if (val0x6c0 == coex_dm->cur_val0x6c0 &&
1676 val0x6c4 == coex_dm->cur_val0x6c4 &&
1677 val0x6c8 == coex_dm->cur_val0x6c8 &&
1678 val0x6cc == coex_dm->cur_val0x6cc)
1679 return;
1680 }
1681
1682 btc->btc_write_4byte(btc, 0x6c0, val0x6c0);
1683 btc->btc_write_4byte(btc, 0x6c4, val0x6c4);
1684 btc->btc_write_4byte(btc, 0x6c8, val0x6c8);
1685 btc->btc_write_1byte(btc, 0x6cc, val0x6cc);
1686
1687 coex_dm->cur_val0x6c0 = val0x6c0;
1688 coex_dm->cur_val0x6c4 = val0x6c4;
1689 coex_dm->cur_val0x6c8 = val0x6c8;
1690 coex_dm->cur_val0x6cc = val0x6cc;
1691 }
1692
1693 static
halbtc8822b1ant_table(struct btc_coexist * btc,boolean force_exec,u8 type)1694 void halbtc8822b1ant_table(struct btc_coexist *btc, boolean force_exec, u8 type)
1695 {
1696 struct coex_sta_8822b_1ant *coex_sta = &btc->coex_sta_8822b_1ant;
1697 u32 break_table;
1698 u8 select_table;
1699
1700 coex_sta->coex_table_type = type;
1701
1702 if (coex_sta->concurrent_rx_mode_on) {
1703 /* set WL hi-pri can break BT */
1704 break_table = 0xf0ffffff;
1705 /* set Tx response = Hi-Pri (ex: Transmitting ACK,BA,CTS) */
1706 select_table = 0x1b;
1707 } else {
1708 break_table = 0xffffff;
1709 select_table = 0x13;
1710 }
1711
1712 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
1713 "[BTCoex], ********** Table-%d **********\n",
1714 coex_sta->coex_table_type);
1715 BTC_TRACE(trace_buf);
1716
1717 switch (type) {
1718 case 0:
1719 halbtc8822b1ant_set_table(btc, force_exec, 0x55555555,
1720 0x55555555, break_table,
1721 select_table);
1722 break;
1723 case 1:
1724 halbtc8822b1ant_set_table(btc, force_exec, 0x66555555,
1725 0x5a5a5a5a, break_table,
1726 select_table);
1727 break;
1728 case 2:
1729 halbtc8822b1ant_set_table(btc, force_exec, 0x66555555,
1730 0xaaaaaaaa, break_table,
1731 select_table);
1732 break;
1733 case 3:
1734 halbtc8822b1ant_set_table(btc, force_exec, 0x66555555,
1735 0x6a5a5aaa, break_table,
1736 select_table);
1737 break;
1738 case 4:
1739 halbtc8822b1ant_set_table(btc, force_exec, 0x66555555,
1740 0x5a5a5a5a, break_table,
1741 select_table);
1742 break;
1743 case 5:
1744 halbtc8822b1ant_set_table(btc, force_exec, 0x6a5a5a5a,
1745 0x5a5a5a5a, break_table,
1746 select_table);
1747 break;
1748 case 6:
1749 halbtc8822b1ant_set_table(btc, force_exec, 0x6a5a56aa,
1750 0x6a5a56aa, break_table,
1751 select_table);
1752 break;
1753 case 7:
1754 halbtc8822b1ant_set_table(btc, force_exec, 0x66555555,
1755 0xaaaa5aaa, break_table,
1756 select_table);
1757 break;
1758 case 8:
1759 halbtc8822b1ant_set_table(btc, force_exec, 0xffffffff,
1760 0xffffffff, break_table,
1761 select_table);
1762 break;
1763 case 9:
1764 halbtc8822b1ant_set_table(btc, force_exec, 0x66555555,
1765 0xaaaaaaaa, break_table,
1766 select_table);
1767 break;
1768 case 10:
1769 halbtc8822b1ant_set_table(btc, force_exec, 0xaaaaaaaa,
1770 0xaaaaaaaa, break_table,
1771 select_table);
1772 break;
1773 case 11:
1774 halbtc8822b1ant_set_table(btc, force_exec, 0x66555555,
1775 0x6a5a5a5a, break_table,
1776 select_table);
1777 break;
1778 case 12:
1779 halbtc8822b1ant_set_table(btc, force_exec, 0xffff55ff,
1780 0xaaaaaaaa, break_table,
1781 select_table);
1782 break;
1783 case 13:
1784 halbtc8822b1ant_set_table(btc, force_exec, 0xaa5555aa,
1785 0xaaaa5aaa, break_table,
1786 select_table);
1787 break;
1788 case 14:
1789 halbtc8822b1ant_set_table(btc, force_exec, 0x6a5a5aaa,
1790 0x6a5a5aaa, break_table,
1791 select_table);
1792 break;
1793 case 15:
1794 halbtc8822b1ant_set_table(btc, force_exec, 0xffff55ff,
1795 0x6afa5afa, break_table,
1796 select_table);
1797 break;
1798 case 16:
1799 halbtc8822b1ant_set_table(btc, force_exec, 0x55555555,
1800 0x5a5a5a5a, break_table,
1801 select_table);
1802 break;
1803 case 17:
1804 halbtc8822b1ant_set_table(btc, force_exec, 0x55555555,
1805 0xaaaaaaaa, break_table,
1806 select_table);
1807 break;
1808 case 18:
1809 halbtc8822b1ant_set_table(btc, force_exec, 0x66555555,
1810 0x66555555, break_table,
1811 select_table);
1812 break;
1813 case 19:
1814 halbtc8822b1ant_set_table(btc, force_exec, 0x66555555,
1815 0xaaaa5aaa, break_table,
1816 select_table);
1817 break;
1818 case 20:
1819 halbtc8822b1ant_set_table(btc, force_exec, 0x6a5a5a5a,
1820 0x6a5a5a5a, break_table,
1821 select_table);
1822 break;
1823 case 21:
1824 halbtc8822b1ant_set_table(btc, force_exec, 0x66555555,
1825 0x6a5a6a5a, break_table,
1826 select_table);
1827 break;
1828 case 22:
1829 halbtc8822b1ant_set_table(btc, force_exec, 0xaaffffaa,
1830 0xfafafafa, break_table,
1831 select_table);
1832 break;
1833 case 23:
1834 halbtc8822b1ant_set_table(btc, force_exec, 0xffff55ff,
1835 0xfafafafa, break_table,
1836 select_table);
1837 break;
1838 case 24:
1839 halbtc8822b1ant_set_table(btc, force_exec, 0x66555555,
1840 0xfafafafa, break_table,
1841 select_table);
1842 break;
1843 case 25:
1844 halbtc8822b1ant_set_table(btc, force_exec, 0xffffffff,
1845 0x5a5a5a5a, break_table,
1846 select_table);
1847 break;
1848 case 26:
1849 halbtc8822b1ant_set_table(btc, force_exec, 0xffffffff,
1850 0x55555555, break_table,
1851 select_table);
1852 break;
1853 default:
1854 break;
1855 }
1856 }
1857
1858 static void
halbtc8822b1ant_wltoggle_table(IN struct btc_coexist * btc,IN boolean force_exec,IN u8 interval,IN u8 val0x6c4_b0,IN u8 val0x6c4_b1,IN u8 val0x6c4_b2,IN u8 val0x6c4_b3)1859 halbtc8822b1ant_wltoggle_table(IN struct btc_coexist *btc,
1860 IN boolean force_exec, IN u8 interval,
1861 IN u8 val0x6c4_b0, IN u8 val0x6c4_b1,
1862 IN u8 val0x6c4_b2, IN u8 val0x6c4_b3)
1863 {
1864 static u8 pre_h2c_parameter[6] = {0};
1865 u8 cur_h2c_parameter[6] = {0};
1866 u8 i, match_cnt = 0;
1867
1868 cur_h2c_parameter[0] = 0x7; /* op_code, 0x7= wlan toggle slot*/
1869
1870 cur_h2c_parameter[1] = interval;
1871 cur_h2c_parameter[2] = val0x6c4_b0;
1872 cur_h2c_parameter[3] = val0x6c4_b1;
1873 cur_h2c_parameter[4] = val0x6c4_b2;
1874 cur_h2c_parameter[5] = val0x6c4_b3;
1875 #if 0
1876 if (!force_exec) {
1877 for (i = 1; i <= 5; i++) {
1878 if (cur_h2c_parameter[i] != pre_h2c_parameter[i])
1879 break;
1880
1881 match_cnt++;
1882 }
1883
1884 if (match_cnt == 5)
1885 return;
1886 }
1887 #endif
1888 for (i = 1; i <= 5; i++)
1889 pre_h2c_parameter[i] = cur_h2c_parameter[i];
1890
1891 btc->btc_fill_h2c(btc, 0x69, 6, cur_h2c_parameter);
1892 }
1893
halbtc8822b1ant_ignore_wlan_act(struct btc_coexist * btc,boolean force_exec,boolean enable)1894 static void halbtc8822b1ant_ignore_wlan_act(struct btc_coexist *btc,
1895 boolean force_exec,
1896 boolean enable)
1897 {
1898 struct coex_dm_8822b_1ant *coex_dm = &btc->coex_dm_8822b_1ant;
1899
1900 u8 h2c_parameter[1] = {0};
1901
1902 if (btc->manual_control || btc->stop_coex_dm)
1903 return;
1904
1905 if (!force_exec) {
1906 if (enable == coex_dm->cur_ignore_wlan_act)
1907 return;
1908 }
1909
1910 if (enable)
1911 h2c_parameter[0] |= BIT(0); /* function enable */
1912
1913 btc->btc_fill_h2c(btc, 0x63, 1, h2c_parameter);
1914
1915 coex_dm->cur_ignore_wlan_act = enable;
1916 }
1917
halbtc8822b1ant_lps_rpwm(struct btc_coexist * btc,boolean force_exec,u8 lps_val,u8 rpwm_val)1918 static void halbtc8822b1ant_lps_rpwm(struct btc_coexist *btc,
1919 boolean force_exec, u8 lps_val,
1920 u8 rpwm_val)
1921 {
1922 struct coex_dm_8822b_1ant *coex_dm = &btc->coex_dm_8822b_1ant;
1923
1924 if (!force_exec) {
1925 if (lps_val == coex_dm->cur_lps &&
1926 rpwm_val == coex_dm->cur_rpwm)
1927 return;
1928 }
1929
1930 btc->btc_set(btc, BTC_SET_U1_LPS_VAL, &lps_val);
1931 btc->btc_set(btc, BTC_SET_U1_RPWM_VAL, &rpwm_val);
1932
1933 coex_dm->cur_lps = lps_val;
1934 coex_dm->cur_rpwm = rpwm_val;
1935 }
1936
1937 #if 0
1938 static void halbtc8822b1ant_multiport_tdma(struct btc_coexist *btc,
1939 u8 multi_port_mode)
1940 {
1941 struct struct btc_multi_port_tdma_info multiport_tdma_para;
1942 static u8 pre_state = BTC_MULTI_PORT_TDMA_MODE_NONE;
1943
1944 if (multi_port_mode == pre_state)
1945 return;
1946
1947 multiport_tdma_para.btc_multi_port_tdma_mode = multi_port_mode;
1948
1949 switch (multi_port_mode) {
1950 case BTC_MULTI_PORT_TDMA_MODE_NONE:
1951 multiport_tdma_para.start_time_from_bcn = 0;
1952 multiport_tdma_para.bt_time = 0;
1953 break;
1954 case BTC_MULTI_PORT_TDMA_MODE_2G_SCC_GO:
1955 multiport_tdma_para.start_time_from_bcn = 65;
1956 multiport_tdma_para.bt_time = 35;
1957 break;
1958 case BTC_MULTI_PORT_TDMA_MODE_2G_P2P_GO:
1959 multiport_tdma_para.start_time_from_bcn = 55;
1960 multiport_tdma_para.bt_time = 45;
1961 break;
1962 }
1963
1964 btc->btc_set(btc, BTC_SET_WIFI_BT_COEX_MODE, &multiport_tdma_para);
1965
1966 pre_state = multi_port_mode;
1967 }
1968 #endif
1969
1970 static void
halbtc8822b1ant_tdma_check(struct btc_coexist * btc,boolean new_ps_state)1971 halbtc8822b1ant_tdma_check(struct btc_coexist *btc, boolean new_ps_state)
1972 {
1973 u8 lps_mode = 0x0;
1974 u8 h2c_parameter[5] = {0x8, 0, 0, 0, 0};
1975
1976 btc->btc_get(btc, BTC_GET_U1_LPS_MODE, &lps_mode);
1977
1978 if (lps_mode) { /* already under LPS state */
1979 if (new_ps_state) {
1980 /* keep state under LPS, do nothing. */
1981 } else {
1982 /* will leave LPS state, turn off psTdma first */
1983 btc->btc_fill_h2c(btc, 0x60, 5, h2c_parameter);
1984 }
1985 } else { /* NO PS state */
1986 if (new_ps_state) {
1987 /* will enter LPS state, turn off psTdma first */
1988 btc->btc_fill_h2c(btc, 0x60, 5, h2c_parameter);
1989 } else {
1990 /* keep state under NO PS state, do nothing. */
1991 }
1992 }
1993 }
1994
1995 static boolean
halbtc8822b1ant_power_save_state(struct btc_coexist * btc,u8 ps_type,u8 lps_val,u8 rpwm_val)1996 halbtc8822b1ant_power_save_state(struct btc_coexist *btc,
1997 u8 ps_type, u8 lps_val, u8 rpwm_val)
1998 {
1999 struct coex_sta_8822b_1ant *coex_sta = &btc->coex_sta_8822b_1ant;
2000 boolean low_pwr_dis = FALSE, result = TRUE;
2001
2002 switch (ps_type) {
2003 case BTC_PS_WIFI_NATIVE:
2004 /* recover to original 32k low power setting */
2005 coex_sta->force_lps_ctrl = FALSE;
2006 low_pwr_dis = FALSE;
2007 /* recover to original 32k low power setting */
2008
2009 btc->btc_set(btc, BTC_SET_ACT_PRE_NORMAL_LPS, NULL);
2010 break;
2011 case BTC_PS_LPS_ON:
2012
2013 coex_sta->force_lps_ctrl = TRUE;
2014 halbtc8822b1ant_tdma_check(btc, TRUE);
2015 halbtc8822b1ant_lps_rpwm(btc, NM_EXCU, lps_val, rpwm_val);
2016 /* when coex force to enter LPS, do not enter 32k low power. */
2017 low_pwr_dis = TRUE;
2018 btc->btc_set(btc, BTC_SET_ACT_DISABLE_LOW_POWER, &low_pwr_dis);
2019 /* power save must executed before psTdma. */
2020 btc->btc_set(btc, BTC_SET_ACT_ENTER_LPS, NULL);
2021
2022 break;
2023 case BTC_PS_LPS_OFF:
2024
2025 coex_sta->force_lps_ctrl = TRUE;
2026 halbtc8822b1ant_tdma_check(btc, FALSE);
2027 result = btc->btc_set(btc, BTC_SET_ACT_LEAVE_LPS, NULL);
2028
2029 break;
2030 default:
2031 break;
2032 }
2033
2034 return result;
2035 }
2036
2037 static
halbtc8822b1ant_set_tdma(struct btc_coexist * btc,u8 byte1,u8 byte2,u8 byte3,u8 byte4,u8 byte5)2038 void halbtc8822b1ant_set_tdma(struct btc_coexist *btc, u8 byte1,
2039 u8 byte2, u8 byte3, u8 byte4, u8 byte5)
2040 {
2041 struct coex_sta_8822b_1ant *coex_sta = &btc->coex_sta_8822b_1ant;
2042 struct coex_dm_8822b_1ant *coex_dm = &btc->coex_dm_8822b_1ant;
2043 u8 h2c_parameter[5] = {0};
2044 u8 real_byte1 = byte1, real_byte5 = byte5;
2045 boolean ap_enable = FALSE, result = FALSE;
2046 struct btc_bt_link_info *bt_link_info = &btc->bt_link_info;
2047 u8 ps_type = BTC_PS_WIFI_NATIVE;
2048
2049 if (byte5 & BIT(2))
2050 coex_sta->is_tdma_btautoslot = TRUE;
2051 else
2052 coex_sta->is_tdma_btautoslot = FALSE;
2053
2054 if (btc->wifi_link_info.link_mode == BTC_LINK_ONLY_GO &&
2055 btc->wifi_link_info.bhotspot &&
2056 btc->wifi_link_info.bany_client_join_go)
2057 ap_enable = TRUE;
2058
2059 if ((ap_enable) && (byte1 & BIT(4) && !(byte1 & BIT(5)))) {
2060 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2061 "[BTCoex], %s == FW for 1Ant AP mode\n", __func__);
2062 BTC_TRACE(trace_buf);
2063
2064 real_byte1 &= ~BIT(4);
2065 real_byte1 |= BIT(5);
2066
2067 real_byte5 |= BIT(5);
2068 real_byte5 &= ~BIT(6);
2069
2070 ps_type = BTC_PS_WIFI_NATIVE;
2071 halbtc8822b1ant_power_save_state(btc, ps_type, 0x0, 0x0);
2072
2073 } else if (byte1 & BIT(4) && !(byte1 & BIT(5))) {
2074 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2075 "[BTCoex], %s == Force LPS (byte1 = 0x%x)\n",
2076 __func__, byte1);
2077 BTC_TRACE(trace_buf);
2078
2079 ps_type = BTC_PS_LPS_OFF;
2080 if (!halbtc8822b1ant_power_save_state(btc, ps_type, 0x50, 0x4))
2081 result = TRUE;
2082 } else {
2083 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2084 "[BTCoex], %s == native power save (byte1 = 0x%x)\n",
2085 __func__, byte1);
2086 BTC_TRACE(trace_buf);
2087
2088 ps_type = BTC_PS_WIFI_NATIVE;
2089 halbtc8822b1ant_power_save_state(btc, ps_type, 0x0, 0x0);
2090 }
2091
2092 coex_sta->is_set_ps_state_fail = result;
2093
2094 if (!coex_sta->is_set_ps_state_fail) {
2095 h2c_parameter[0] = real_byte1;
2096 h2c_parameter[1] = byte2;
2097 h2c_parameter[2] = byte3;
2098 h2c_parameter[3] = byte4;
2099 h2c_parameter[4] = real_byte5;
2100
2101 coex_dm->ps_tdma_para[0] = real_byte1;
2102 coex_dm->ps_tdma_para[1] = byte2;
2103 coex_dm->ps_tdma_para[2] = byte3;
2104 coex_dm->ps_tdma_para[3] = byte4;
2105 coex_dm->ps_tdma_para[4] = real_byte5;
2106
2107 btc->btc_fill_h2c(btc, 0x60, 5, h2c_parameter);
2108
2109 if (real_byte1 & BIT(2)) {
2110 coex_sta->wl_slot_toggle = TRUE;
2111 coex_sta->wl_slot_toggle_change = FALSE;
2112 } else {
2113 if (coex_sta->wl_slot_toggle)
2114 coex_sta->wl_slot_toggle_change = TRUE;
2115 else
2116 coex_sta->wl_slot_toggle_change = FALSE;
2117 coex_sta->wl_slot_toggle = FALSE;
2118 }
2119 } else {
2120 coex_sta->cnt_set_ps_state_fail++;
2121 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2122 "[BTCoex], %s == Force Leave LPS Fail (cnt = %d)\n",
2123 __func__, coex_sta->cnt_set_ps_state_fail);
2124 BTC_TRACE(trace_buf);
2125 }
2126
2127 if (ps_type == BTC_PS_WIFI_NATIVE)
2128 btc->btc_set(btc, BTC_SET_ACT_POST_NORMAL_LPS, NULL);
2129 }
2130
2131 static void
halbtc8822b1ant_tdma(struct btc_coexist * btc,boolean force_exec,boolean turn_on,u32 tcase)2132 halbtc8822b1ant_tdma(struct btc_coexist *btc, boolean force_exec,
2133 boolean turn_on, u32 tcase)
2134 {
2135 struct coex_sta_8822b_1ant *coex_sta = &btc->coex_sta_8822b_1ant;
2136 struct coex_dm_8822b_1ant *coex_dm = &btc->coex_dm_8822b_1ant;
2137 struct btc_bt_link_info *bt_link_info = &btc->bt_link_info;
2138 boolean wifi_busy = FALSE;
2139 static u8 tdma_byte4_modify, pre_tdma_byte4_modify;
2140 static boolean pre_wifi_busy;
2141 u8 type;
2142
2143 btc->btc_set_atomic(btc, &coex_dm->setting_tdma, TRUE);
2144
2145 /* tcase: bit0~7 --> tdma case index
2146 * bit8 --> for 4-slot (50ms) mode
2147 */
2148 if (tcase & BIT(8))/* 4-slot (50ms) mode */
2149 halbtc8822b1ant_set_tdma_timer_base(btc, 3);
2150 else
2151 halbtc8822b1ant_set_tdma_timer_base(btc, 0);
2152
2153 type = (u8)tcase & 0xff;
2154
2155 btc->btc_get(btc, BTC_GET_BL_WIFI_BUSY, &wifi_busy);
2156
2157 if (wifi_busy != pre_wifi_busy) {
2158 force_exec = TRUE;
2159 pre_wifi_busy = wifi_busy;
2160 }
2161
2162 #if 0
2163 /* 0x778 = 0x1 at wifi slot (no blocking BT Low-Pri pkts) */
2164 if (bt_link_info->slave_role)
2165 tdma_byte4_modify = 0x1;
2166 else
2167 tdma_byte4_modify = 0x0;
2168
2169 if (pre_tdma_byte4_modify != tdma_byte4_modify) {
2170 force_exec = TRUE;
2171 pre_tdma_byte4_modify = tdma_byte4_modify;
2172 }
2173 #endif
2174
2175 if (!force_exec &&
2176 (turn_on == coex_dm->cur_ps_tdma_on &&
2177 type == coex_dm->cur_ps_tdma)) {
2178 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2179 "[BTCoex], Skip TDMA because no change TDMA(%s, %d)\n",
2180 (coex_dm->cur_ps_tdma_on ? "on" : "off"),
2181 coex_dm->cur_ps_tdma);
2182 BTC_TRACE(trace_buf);
2183
2184 btc->btc_set_atomic(btc, &coex_dm->setting_tdma, FALSE);
2185 return;
2186 }
2187
2188 if (turn_on) {
2189 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2190 "[BTCoex], ********** TDMA(on, %d) **********\n",
2191 type);
2192 BTC_TRACE(trace_buf);
2193
2194 halbtc8822b1ant_write_scbd(btc, BT_8822B_1ANT_SCBD_TDMA, TRUE);
2195
2196 /* enable TBTT nterrupt */
2197 btc->btc_write_1byte_bitmask(btc, 0x550, 0x8, 0x1);
2198
2199 switch (type) {
2200 default:
2201 halbtc8822b1ant_set_tdma(btc, 0x61, 0x35, 0x03, 0x11,
2202 0x11);
2203 break;
2204 case 1: /* not use */
2205 halbtc8822b1ant_set_tdma(btc, 0x61, 0x3a, 0x03, 0x11,
2206 0x10);
2207 break;
2208 case 3:
2209 halbtc8822b1ant_set_tdma(btc, 0x51, 0x35, 0x03, 0x10,
2210 0x50);
2211 break;
2212 case 4:
2213 halbtc8822b1ant_set_tdma(btc, 0x51, 0x21, 0x03, 0x10,
2214 0x50);
2215 break;
2216 case 5:
2217 halbtc8822b1ant_set_tdma(btc, 0x61, 0x15, 0x3, 0x11,
2218 0x11);
2219 break;
2220 case 6:
2221 halbtc8822b1ant_set_tdma(btc, 0x61, 0x20, 0x3, 0x11,
2222 0x10);
2223 break;
2224 case 7:
2225 halbtc8822b1ant_set_tdma(btc, 0x51, 0x08, 0x03, 0x10,
2226 0x54);
2227 break;
2228 case 8: /* not use */
2229 halbtc8822b1ant_set_tdma(btc, 0x51, 0x08, 0x03, 0x10,
2230 0x50);
2231 break;
2232 case 10:
2233 halbtc8822b1ant_set_tdma(btc, 0x51, 0x08, 0x07, 0x10,
2234 0x55);
2235 break;
2236 case 11:
2237 halbtc8822b1ant_set_tdma(btc, 0x61, 0x25, 0x03, 0x11,
2238 0x11);
2239 break;
2240 case 12:
2241 halbtc8822b1ant_set_tdma(btc, 0x51, 0x30, 0x03, 0x10,
2242 0x50);
2243 break;
2244 case 13:
2245 halbtc8822b1ant_set_tdma(btc, 0x51, 0x08, 0x07, 0x10,
2246 0x54);
2247 break;
2248 case 14:
2249 halbtc8822b1ant_set_tdma(btc, 0x51, 0x15, 0x03, 0x10,
2250 0x50);
2251 break;
2252 case 15:
2253 halbtc8822b1ant_set_tdma(btc, 0x51, 0x20, 0x03, 0x10,
2254 0x10);
2255 break;
2256 case 17:
2257 halbtc8822b1ant_set_tdma(btc, 0x61, 0x08, 0x03, 0x11,
2258 0x14);
2259 break;
2260 case 18:
2261 halbtc8822b1ant_set_tdma(btc, 0x51, 0x30, 0x03, 0x10,
2262 0x50);
2263 break;
2264 case 20: /* not use */
2265 halbtc8822b1ant_set_tdma(btc, 0x61, 0x30, 0x03, 0x11,
2266 0x10);
2267 break;
2268 case 21:
2269 halbtc8822b1ant_set_tdma(btc, 0x61, 0x30, 0x03, 0x11,
2270 0x10);
2271 break;
2272 case 22:
2273 halbtc8822b1ant_set_tdma(btc, 0x61, 0x25, 0x03, 0x11,
2274 0x10);
2275 break;
2276 case 23:
2277 halbtc8822b1ant_set_tdma(btc, 0x61, 0x10, 0x03, 0x11,
2278 0x10);
2279 break;
2280 case 25:
2281 halbtc8822b1ant_set_tdma(btc, 0x51, 0x3a, 0x3, 0x11,
2282 0x50);
2283 break;
2284 case 26:
2285 halbtc8822b1ant_set_tdma(btc, 0x51, 0x08, 0x03, 0x10,
2286 0x55);
2287 break;
2288 case 27:
2289 halbtc8822b1ant_set_tdma(btc, 0x61, 0x08, 0x03, 0x11,
2290 0x15);
2291 break;
2292 case 32:
2293 halbtc8822b1ant_set_tdma(btc, 0x61, 0x35, 0x3, 0x11,
2294 0x11);
2295 break;
2296 case 33:
2297 halbtc8822b1ant_set_tdma(btc, 0x61, 0x35, 0x03, 0x11,
2298 0x10);
2299 break;
2300 case 34:
2301 halbtc8822b1ant_set_tdma(btc, 0x61, 0x45, 0x03, 0x11,
2302 0x10);
2303 break;
2304 case 36:
2305 halbtc8822b1ant_set_tdma(btc, 0x61, 0x50, 0x03, 0x11,
2306 0x10);
2307 break;
2308 case 37:
2309 halbtc8822b1ant_set_tdma(btc, 0x61, 0x3a, 0x03, 0x11,
2310 0x11);
2311 break;
2312 case 38:
2313 halbtc8822b1ant_set_tdma(btc, 0x65, 0x10, 0x03, 0x11,
2314 0x11);
2315 break;
2316 case 39:
2317 halbtc8822b1ant_set_tdma(btc, 0x55, 0x08, 0x3, 0x10,
2318 0x54);
2319 break;
2320 case 50:
2321 halbtc8822b1ant_set_tdma(btc, 0x51, 0x4a, 0x3, 0x10,
2322 0x50);
2323 break;
2324 case 51:
2325 halbtc8822b1ant_set_tdma(btc, 0x51, 0x08, 0x3, 0x30,
2326 0x54);
2327 break;
2328 case 105:
2329 halbtc8822b1ant_set_tdma(btc, 0x51, 0x3f, 0x3, 0x10,
2330 0x50);
2331 break;
2332 }
2333 } else {
2334 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2335 "[BTCoex], ********** TDMA(off, %d) **********\n",
2336 type);
2337 BTC_TRACE(trace_buf);
2338
2339 halbtc8822b1ant_write_scbd(btc, BT_8822B_1ANT_SCBD_TDMA, FALSE);
2340
2341 switch (type) {
2342 case 0:
2343 default: /* Software control, Antenna at BT side */
2344 halbtc8822b1ant_set_tdma(btc, 0x0, 0x0, 0x0, 0x0, 0x0);
2345 break;
2346 case 8: /* PTA Control */
2347 halbtc8822b1ant_set_tdma(btc, 0x8, 0x0, 0x0, 0x0, 0x0);
2348 break;
2349 }
2350 }
2351
2352 if (!coex_sta->is_set_ps_state_fail) {
2353 /* update pre state */
2354 coex_dm->cur_ps_tdma_on = turn_on;
2355 coex_dm->cur_ps_tdma = type;
2356 }
2357
2358 btc->btc_set_atomic(btc, &coex_dm->setting_tdma, FALSE);
2359 }
2360
2361 /* rf4 type by efuse, and for ant at main aux inverse use,
2362 * because is 2x2, and control types are the same, does not need
2363 */
halbtc8822b1ant_set_rfe_type(struct btc_coexist * btc)2364 static void halbtc8822b1ant_set_rfe_type(struct btc_coexist *btc)
2365 {
2366 struct rfe_type_8822b_1ant *rfe_type = &btc->rfe_type_8822b_1ant;
2367 struct btc_board_info *board_info = &btc->board_info;
2368
2369 /* Ext switch buffer mux */
2370 btc->btc_write_1byte(btc, 0x974, 0xff);
2371 btc->btc_write_1byte_bitmask(btc, 0x1991, 0x3, 0x0);
2372 btc->btc_write_1byte_bitmask(btc, 0xcbe, 0x8, 0x0);
2373
2374 /* the following setup should be got from Efuse in the future */
2375 rfe_type->rfe_module_type = board_info->rfe_type;
2376
2377 rfe_type->ext_switch_polarity = 0;
2378
2379 if (rfe_type->rfe_module_type == 0x12 ||
2380 rfe_type->rfe_module_type == 0x15 ||
2381 rfe_type->rfe_module_type == 0x16)
2382 rfe_type->ext_switch_exist = FALSE;
2383 else
2384 rfe_type->ext_switch_exist = TRUE;
2385
2386 rfe_type->ext_switch_type = BT_8822B_1ANT_SWITCH_USE_SPDT;
2387 }
2388
2389 /*anttenna control by bb mac bt antdiv pta to write 0x4c 0xcb4,0xcbd*/
2390
2391 static
hallbtc8822b1ant_set_ant_switch(struct btc_coexist * btc,boolean force_exec,u8 ctrl_type,u8 pos_type)2392 void hallbtc8822b1ant_set_ant_switch(struct btc_coexist *btc,
2393 boolean force_exec, u8 ctrl_type,
2394 u8 pos_type)
2395 {
2396 struct coex_dm_8822b_1ant *coex_dm = &btc->coex_dm_8822b_1ant;
2397 struct rfe_type_8822b_1ant *rfe_type = &btc->rfe_type_8822b_1ant;
2398 boolean polarity_inverse;
2399 u8 val = 0;
2400
2401 if (!rfe_type->ext_switch_exist)
2402 return;
2403
2404 if (!force_exec) {
2405 if (((ctrl_type << 8) + pos_type) == coex_dm->cur_switch_status)
2406 return;
2407 }
2408
2409 coex_dm->cur_switch_status = (ctrl_type << 8) + pos_type;
2410
2411 /* swap control polarity if use different switch control polarity*/
2412 /* Normal switch polarity for SPDT,
2413 * 0xcbd[1:0] = 2b'01 => Ant to BTG, WLA
2414 * 0xcbd[1:0] = 2b'10 => Ant to WLG
2415 */
2416 polarity_inverse = (rfe_type->ext_switch_polarity == 1);
2417
2418 if (rfe_type->ext_switch_type == BT_8822B_1ANT_SWITCH_USE_SPDT) {
2419 switch (ctrl_type) {
2420 default:
2421 case BT_8822B_1ANT_CTRL_BY_BBSW:
2422 /* 0x4c[23] = 0 */
2423 btc->btc_write_1byte_bitmask(btc, 0x4e, 0x80, 0x0);
2424 /* 0x4c[24] = 1 */
2425 btc->btc_write_1byte_bitmask(btc, 0x4f, 0x01, 0x1);
2426 /* BB SW, DPDT use RFE_ctrl8 and RFE_ctrl9 as ctrl pin*/
2427 btc->btc_write_1byte_bitmask(btc, 0xcb4, 0xff, 0x77);
2428
2429 /* 0xcbd[1:0] = 2b'01 for no switch_polarity_inverse,
2430 * ANTSWB =1, ANTSW =0
2431 */
2432 if (pos_type == BT_8822B_1ANT_TO_S0WLG_S1BT) {
2433 if (rfe_type->rfe_module_type != 0x4 &&
2434 rfe_type->rfe_module_type != 0x2)
2435 val = 0x3;
2436 else
2437 val = (!polarity_inverse ? 0x2 : 0x1);
2438 } else if (pos_type == BT_8822B_1ANT_TO_WLG) {
2439 val = (!polarity_inverse ? 0x2 : 0x1);
2440 } else {
2441 val = (!polarity_inverse ? 0x1 : 0x2);
2442 }
2443 btc->btc_write_1byte_bitmask(btc, 0xcbd, 0x3, val);
2444 break;
2445 case BT_8822B_1ANT_CTRL_BY_PTA:
2446 /* 0x4c[23] = 0 */
2447 btc->btc_write_1byte_bitmask(btc, 0x4e, 0x80, 0x0);
2448 /* 0x4c[24] = 1 */
2449 btc->btc_write_1byte_bitmask(btc, 0x4f, 0x01, 0x1);
2450 /* PTA, DPDT use RFE_ctrl8 and RFE_ctrl9 as ctrl pin */
2451 btc->btc_write_1byte_bitmask(btc, 0xcb4, 0xff, 0x66);
2452
2453 /* 0xcbd[1:0] = 2b'10 for no switch_polarity_inverse,
2454 * ANTSWB =1, ANTSW =0 @ GNT_BT=1
2455 */
2456 val = (!polarity_inverse ? 0x2 : 0x1);
2457 btc->btc_write_1byte_bitmask(btc, 0xcbd, 0x3, val);
2458 break;
2459 case BT_8822B_1ANT_CTRL_BY_ANTDIV:
2460 /* 0x4c[23] = 0 */
2461 btc->btc_write_1byte_bitmask(btc, 0x4e, 0x80, 0x0);
2462 /* 0x4c[24] = 1 */
2463 btc->btc_write_1byte_bitmask(btc, 0x4f, 0x01, 0x1);
2464 btc->btc_write_1byte_bitmask(btc, 0xcb4, 0xff, 0x88);
2465
2466 /* no regval_0xcbd setup required, because
2467 * antenna switch control value by antenna diversity
2468 */
2469 break;
2470 case BT_8822B_1ANT_CTRL_BY_MAC:
2471 /* 0x4c[23] = 1 */
2472 btc->btc_write_1byte_bitmask(btc, 0x4e, 0x80, 0x1);
2473
2474 /* 0x64[0] = 1b'0 for no switch_polarity_inverse,
2475 * DPDT_SEL_N =1, DPDT_SEL_P =0
2476 */
2477 val = (!polarity_inverse ? 0x0 : 0x1);
2478 btc->btc_write_1byte_bitmask(btc, 0x64, 0x1, val);
2479 break;
2480 case BT_8822B_1ANT_CTRL_BY_FW:
2481 /* 0x4c[23] = 0 */
2482 btc->btc_write_1byte_bitmask(btc, 0x4e, 0x80, 0x0);
2483 /* 0x4c[24] = 1 */
2484 btc->btc_write_1byte_bitmask(btc, 0x4f, 0x01, 0x1);
2485 break;
2486 case BT_8822B_1ANT_CTRL_BY_BT:
2487 /* 0x4c[23] = 0 */
2488 btc->btc_write_1byte_bitmask(btc, 0x4e, 0x80, 0x0);
2489 /* 0x4c[24] = 0 */
2490 btc->btc_write_1byte_bitmask(btc, 0x4f, 0x01, 0x0);
2491
2492 /* no setup required, because antenna switch control
2493 * value by BT vendor 0xac[1:0]
2494 */
2495 break;
2496 }
2497 }
2498 }
2499
2500 static
halbtc8822b1ant_set_ant_path(struct btc_coexist * btc,u8 ant_pos_type,boolean force_exec,u8 phase)2501 void halbtc8822b1ant_set_ant_path(struct btc_coexist *btc,
2502 u8 ant_pos_type, boolean force_exec,
2503 u8 phase)
2504 {
2505 struct coex_sta_8822b_1ant *coex_sta = &btc->coex_sta_8822b_1ant;
2506 struct coex_dm_8822b_1ant *coex_dm = &btc->coex_dm_8822b_1ant;
2507 u32 u32tmp1 = 0, u32tmp2 = 0;
2508 u8 u8tmp = 0, ctrl_type, pos_type;
2509
2510 if (!force_exec) {
2511 if (coex_dm->cur_ant_pos_type == ((ant_pos_type << 8) + phase))
2512 return;
2513 }
2514
2515 coex_dm->cur_ant_pos_type = (ant_pos_type << 8) + phase;
2516
2517 coex_sta->is_2g_freerun =
2518 ((phase == BT_8822B_1ANT_PHASE_2G_FREERUN) ? TRUE : FALSE);
2519
2520 if (btc->dbg_mode) {
2521 u32tmp1 = btc->btc_read_4byte(btc, 0xcbc);
2522 u32tmp2 = btc->btc_read_4byte(btc, 0xcb4);
2523 u8tmp = btc->btc_read_1byte(btc, 0x73);
2524
2525 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2526 "[BTCoex], (Before Ant Setup) 0xcb4 = 0x%x, 0xcbc = 0x%x, 0x73 = 0x%x\n",
2527 u32tmp1, u32tmp2, u8tmp);
2528 BTC_TRACE(trace_buf);
2529 }
2530
2531 switch (phase) {
2532 case BT_8822B_1ANT_PHASE_POWERON:
2533 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2534 "[BTCoex], set_ant_path - 1ANT_PHASE_COEX_POWERON\n");
2535 BTC_TRACE(trace_buf);
2536
2537 /* set Path control owner to BT at power-on step */
2538 halbtc8822b1ant_coex_ctrl_owner(btc, BT_8822B_1ANT_PCO_BTSIDE);
2539
2540 if (ant_pos_type == BTC_ANT_PATH_AUTO)
2541 ant_pos_type = BTC_ANT_PATH_BT;
2542
2543 coex_sta->run_time_state = FALSE;
2544 break;
2545 case BT_8822B_1ANT_PHASE_INIT:
2546 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2547 "[BTCoex], set_ant_path - 1ANT_PHASE_COEX_INIT\n");
2548 BTC_TRACE(trace_buf);
2549
2550 halbtc8822b1ant_ltecoex_enable(btc, 0x0);
2551
2552 hallbtc8822b1ant_ltecoex_table(btc, BT_8822B_1ANT_CTT_WL_VS_LTE,
2553 0xffff);
2554
2555 hallbtc8822b1ant_ltecoex_table(btc, BT_8822B_1ANT_CTT_BT_VS_LTE,
2556 0xffff);
2557
2558 /* set GNT_BT to SW high */
2559 halbtc8822b1ant_set_gnt_bt(btc, BTC_GNT_SET_SW_HIGH);
2560
2561 /* set GNT_WL to SW low */
2562 halbtc8822b1ant_set_gnt_wl(btc, BTC_GNT_SET_SW_LOW);
2563
2564 /* set Path control owner to WL at initial step */
2565 halbtc8822b1ant_coex_ctrl_owner(btc, BT_8822B_1ANT_PCO_WLSIDE);
2566
2567 coex_sta->run_time_state = FALSE;
2568
2569 if (ant_pos_type == BTC_ANT_PATH_AUTO)
2570 ant_pos_type = BTC_ANT_PATH_BT;
2571
2572 break;
2573 case BT_8822B_1ANT_PHASE_WONLY:
2574 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2575 "[BTCoex], set_ant_path - 1ANT_PHASE_WLANONLY_INIT\n");
2576 BTC_TRACE(trace_buf);
2577
2578 halbtc8822b1ant_ltecoex_enable(btc, 0x0);
2579
2580 hallbtc8822b1ant_ltecoex_table(btc, BT_8822B_1ANT_CTT_WL_VS_LTE,
2581 0xffff);
2582
2583 hallbtc8822b1ant_ltecoex_table(btc, BT_8822B_1ANT_CTT_BT_VS_LTE,
2584 0xffff);
2585
2586 /* set GNT_BT to SW Low */
2587 halbtc8822b1ant_set_gnt_bt(btc, BTC_GNT_SET_SW_LOW);
2588
2589 /* Set GNT_WL to SW high */
2590 halbtc8822b1ant_set_gnt_wl(btc, BTC_GNT_SET_SW_HIGH);
2591
2592 /* set Path control owner to WL at initial step */
2593 halbtc8822b1ant_coex_ctrl_owner(btc, BT_8822B_1ANT_PCO_WLSIDE);
2594
2595 coex_sta->run_time_state = FALSE;
2596
2597 if (ant_pos_type == BTC_ANT_PATH_AUTO)
2598 ant_pos_type = BTC_ANT_PATH_WIFI;
2599 break;
2600 case BT_8822B_1ANT_PHASE_WOFF:
2601 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2602 "[BTCoex], set_ant_path - 1ANT_PHASE_WLAN_OFF\n");
2603 BTC_TRACE(trace_buf);
2604
2605 /* Disable LTE Coex Function in WiFi side */
2606 halbtc8822b1ant_ltecoex_enable(btc, 0x0);
2607
2608 /* set Path control owner to BT */
2609 halbtc8822b1ant_coex_ctrl_owner(btc, BT_8822B_1ANT_PCO_BTSIDE);
2610
2611 coex_sta->run_time_state = FALSE;
2612 break;
2613 case BT_8822B_1ANT_PHASE_2G:
2614 case BT_8822B_1ANT_PHASE_2G_FREERUN:
2615 case BT_8822B_1ANT_PHASE_2G_WLBT:
2616 case BT_8822B_1ANT_PHASE_2G_WL:
2617 case BT_8822B_1ANT_PHASE_2G_BT:
2618 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2619 "[BTCoex], set_ant_path - 1ANT_PHASE_2G_RUNTIME\n");
2620 BTC_TRACE(trace_buf);
2621
2622 if (phase == BT_8822B_1ANT_PHASE_2G_FREERUN) {
2623 /* set GNT_BT to SW Hi */
2624 halbtc8822b1ant_set_gnt_bt(btc, BTC_GNT_SET_SW_HIGH);
2625
2626 /* Set GNT_WL to SW Hi */
2627 halbtc8822b1ant_set_gnt_wl(btc, BTC_GNT_SET_SW_HIGH);
2628 } else {
2629 /* set GNT_BT to PTA */
2630 halbtc8822b1ant_set_gnt_bt(btc, BTC_GNT_SET_HW_PTA);
2631
2632 /* Set GNT_WL to PTA */
2633 halbtc8822b1ant_set_gnt_wl(btc, BTC_GNT_SET_HW_PTA);
2634 }
2635
2636 /* set Path control owner to WL at runtime step */
2637 halbtc8822b1ant_coex_ctrl_owner(btc, BT_8822B_1ANT_PCO_WLSIDE);
2638
2639 coex_sta->run_time_state = TRUE;
2640
2641 if (phase == BT_8822B_1ANT_PHASE_2G_WL)
2642 ant_pos_type = BTC_ANT_PATH_WIFI;
2643 else if (phase == BT_8822B_1ANT_PHASE_2G_BT)
2644 ant_pos_type = BTC_ANT_PATH_BT;
2645 else
2646 ant_pos_type = BTC_ANT_PATH_PTA;
2647 break;
2648 case BT_8822B_1ANT_PHASE_5G:
2649 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2650 "[BTCoex], set_ant_path - %d\n", phase);
2651 BTC_TRACE(trace_buf);
2652
2653 /* set GNT_BT to SW Hi */
2654 halbtc8822b1ant_set_gnt_bt(btc, BTC_GNT_SET_HW_PTA);
2655
2656 /* Set GNT_WL to SW Hi */
2657 halbtc8822b1ant_set_gnt_wl(btc, BTC_GNT_SET_SW_HIGH);
2658
2659 /* set Path control owner to WL at runtime step */
2660 halbtc8822b1ant_coex_ctrl_owner(btc, BT_8822B_1ANT_PCO_WLSIDE);
2661
2662 coex_sta->run_time_state = TRUE;
2663
2664 if (ant_pos_type == BTC_ANT_PATH_AUTO)
2665 ant_pos_type = BTC_ANT_PATH_WIFI5G;
2666 break;
2667 case BT_8822B_1ANT_PHASE_BTMP:
2668 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2669 "[BTCoex], set_ant_path - 1ANT_PHASE_BTMPMODE\n");
2670 BTC_TRACE(trace_buf);
2671
2672 /* Disable LTE Coex Function in WiFi side */
2673 halbtc8822b1ant_ltecoex_enable(btc, 0x0);
2674
2675 /* set GNT_BT to SW Hi */
2676 halbtc8822b1ant_set_gnt_bt(btc, BTC_GNT_SET_SW_HIGH);
2677
2678 /* Set GNT_WL to SW Lo */
2679 halbtc8822b1ant_set_gnt_wl(btc, BTC_GNT_SET_SW_LOW);
2680
2681 /* set Path control owner to WL */
2682 halbtc8822b1ant_coex_ctrl_owner(btc, BT_8822B_1ANT_PCO_WLSIDE);
2683
2684 coex_sta->run_time_state = FALSE;
2685
2686 /* Set Ext Ant Switch to BT side at BT MP mode */
2687 if (ant_pos_type == BTC_ANT_PATH_AUTO)
2688 ant_pos_type = BTC_ANT_PATH_BT;
2689 break;
2690 case BT_8822B_1ANT_PHASE_MCC:
2691 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2692 "[BTCoex], set_ant_path - 1ANT_PHASE_MCC_DUALBAND_RUNTIME\n");
2693 BTC_TRACE(trace_buf);
2694
2695 /* set GNT_BT to PTA */
2696 halbtc8822b1ant_set_gnt_bt(btc, BTC_GNT_SET_HW_PTA);
2697
2698 /* Set GNT_WL to PTA */
2699 halbtc8822b1ant_set_gnt_wl(btc, BTC_GNT_SET_HW_PTA);
2700
2701 /* set Path control owner to WL at runtime step */
2702 halbtc8822b1ant_coex_ctrl_owner(btc, BT_8822B_1ANT_PCO_WLSIDE);
2703
2704 coex_sta->run_time_state = TRUE;
2705
2706 if (ant_pos_type == BTC_ANT_PATH_AUTO)
2707 ant_pos_type = BTC_ANT_PATH_PTA;
2708 break;
2709 }
2710
2711 if (phase == BT_8822B_1ANT_PHASE_WOFF) {
2712 /* Set Ext Ant Switch to BT control at wifi off step */
2713 ctrl_type = BT_8822B_1ANT_CTRL_BY_BT;
2714 pos_type = BT_8822B_1ANT_TO_NOCARE;
2715 } else if (phase == BT_8822B_1ANT_PHASE_MCC) {
2716 ctrl_type = BT_8822B_1ANT_CTRL_BY_FW;
2717 pos_type = BT_8822B_1ANT_TO_NOCARE;
2718 } else {
2719 switch (ant_pos_type) {
2720 case BTC_ANT_PATH_WIFI:
2721 ctrl_type = BT_8822B_1ANT_CTRL_BY_BBSW;
2722 pos_type = BT_8822B_1ANT_TO_WLG;
2723 break;
2724 case BTC_ANT_PATH_WIFI5G:
2725 ctrl_type = BT_8822B_1ANT_CTRL_BY_BBSW;
2726 pos_type = BT_8822B_1ANT_TO_WLA;
2727 break;
2728 case BTC_ANT_PATH_BT:
2729 ctrl_type = BT_8822B_1ANT_CTRL_BY_BBSW;
2730 pos_type = BT_8822B_1ANT_TO_BT;
2731 break;
2732 default:
2733 case BTC_ANT_PATH_PTA:
2734 if (phase == BT_8822B_1ANT_PHASE_2G_WLBT ||
2735 phase == BT_8822B_1ANT_PHASE_2G_FREERUN) {
2736 ctrl_type = BT_8822B_1ANT_CTRL_BY_BBSW;
2737 pos_type = BT_8822B_1ANT_TO_S0WLG_S1BT;
2738 } else {
2739 ctrl_type = BT_8822B_1ANT_CTRL_BY_PTA;
2740 pos_type = BT_8822B_1ANT_TO_NOCARE;
2741 }
2742 break;
2743 }
2744 }
2745
2746 hallbtc8822b1ant_set_ant_switch(btc, force_exec, ctrl_type, pos_type);
2747
2748 if (btc->dbg_mode) {
2749 u32tmp1 = btc->btc_read_4byte(btc, 0xcbc);
2750 u32tmp2 = btc->btc_read_4byte(btc, 0xcb4);
2751 u8tmp = btc->btc_read_1byte(btc, 0x73);
2752
2753 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2754 "[BTCoex], (After Ant Setup) 0xcb4 = 0x%x, 0xcbc = 0x%x, 0x73 = 0x%x\n",
2755 u32tmp1, u32tmp2, u8tmp);
2756 BTC_TRACE(trace_buf);
2757 }
2758 }
2759
halbtc8822b1ant_action_algorithm(struct btc_coexist * btc)2760 static u8 halbtc8822b1ant_action_algorithm(struct btc_coexist *btc)
2761 {
2762 struct btc_bt_link_info *bt_link_info = &btc->bt_link_info;
2763 u8 algorithm = BT_8822B_1ANT_COEX_UNDEFINED;
2764 u8 profile_map = 0;
2765
2766 if (bt_link_info->sco_exist)
2767 profile_map = profile_map | BIT(0);
2768
2769 if (bt_link_info->hid_exist)
2770 profile_map = profile_map | BIT(1);
2771
2772 if (bt_link_info->a2dp_exist)
2773 profile_map = profile_map | BIT(2);
2774
2775 if (bt_link_info->pan_exist)
2776 profile_map = profile_map | BIT(3);
2777
2778 switch (profile_map) {
2779 case 0:
2780 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2781 "[BTCoex], No BT link exists!!!\n");
2782 BTC_TRACE(trace_buf);
2783 algorithm = BT_8822B_1ANT_COEX_UNDEFINED;
2784 break;
2785 case 1:
2786 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2787 "[BTCoex], BT Profile = SCO only\n");
2788 BTC_TRACE(trace_buf);
2789 algorithm = BT_8822B_1ANT_COEX_SCO;
2790 break;
2791 case 2:
2792 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2793 "[BTCoex], BT Profile = HID only\n");
2794 BTC_TRACE(trace_buf);
2795 algorithm = BT_8822B_1ANT_COEX_HID;
2796 break;
2797 case 3:
2798 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2799 "[BTCoex], BT Profile = SCO + HID ==> HID\n");
2800 BTC_TRACE(trace_buf);
2801 algorithm = BT_8822B_1ANT_COEX_HID;
2802 break;
2803 case 4:
2804 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2805 "[BTCoex], BT Profile = A2DP only\n");
2806 BTC_TRACE(trace_buf);
2807 algorithm = BT_8822B_1ANT_COEX_A2DP;
2808 break;
2809 case 5:
2810 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2811 "[BTCoex], BT Profile = SCO + A2DP ==> HID + A2DP\n");
2812 BTC_TRACE(trace_buf);
2813 algorithm = BT_8822B_1ANT_COEX_HID_A2DP;
2814 break;
2815 case 6:
2816 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2817 "[BTCoex], BT Profile = HID + A2DP\n");
2818 BTC_TRACE(trace_buf);
2819 algorithm = BT_8822B_1ANT_COEX_HID_A2DP;
2820 break;
2821 case 7:
2822 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2823 "[BTCoex], BT Profile = SCO + HID + A2DP ==> HID + A2DP\n");
2824 BTC_TRACE(trace_buf);
2825 algorithm = BT_8822B_1ANT_COEX_HID_A2DP;
2826 break;
2827 case 8:
2828 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2829 "[BTCoex], BT Profile = PAN(EDR) only\n");
2830 BTC_TRACE(trace_buf);
2831 algorithm = BT_8822B_1ANT_COEX_PAN;
2832 break;
2833 case 9:
2834 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2835 "[BTCoex], BT Profile = SCO + PAN(EDR) ==> HID + PAN(EDR)\n");
2836 BTC_TRACE(trace_buf);
2837 algorithm = BT_8822B_1ANT_COEX_PAN_HID;
2838 break;
2839 case 10:
2840 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2841 "[BTCoex], BT Profile = HID + PAN(EDR)\n");
2842 BTC_TRACE(trace_buf);
2843 algorithm = BT_8822B_1ANT_COEX_PAN_HID;
2844 break;
2845 case 11:
2846 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2847 "[BTCoex], BT Profile = SCO + HID + PAN(EDR) ==> HID + PAN(EDR)\n");
2848 BTC_TRACE(trace_buf);
2849 algorithm = BT_8822B_1ANT_COEX_PAN_HID;
2850 break;
2851 case 12:
2852 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2853 "[BTCoex], BT Profile = A2DP + PAN(EDR)\n");
2854 BTC_TRACE(trace_buf);
2855 algorithm = BT_8822B_1ANT_COEX_PAN_A2DP;
2856 break;
2857 case 13:
2858 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2859 "[BTCoex], BT Profile = SCO + A2DP + PAN(EDR) ==> A2DP + PAN(EDR)\n");
2860 BTC_TRACE(trace_buf);
2861 algorithm = BT_8822B_1ANT_COEX_PAN_A2DP;
2862 break;
2863 case 14:
2864 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2865 "[BTCoex], BT Profile = HID + A2DP + PAN(EDR) ==> A2DP + PAN(EDR)\n");
2866 BTC_TRACE(trace_buf);
2867 algorithm = BT_8822B_1ANT_COEX_PAN_A2DP;
2868 break;
2869 case 15:
2870 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2871 "[BTCoex], BT Profile = SCO + HID + A2DP + PAN(EDR) ==> A2DP + PAN(EDR)\n");
2872 BTC_TRACE(trace_buf);
2873 algorithm = BT_8822B_1ANT_COEX_PAN_A2DP;
2874 break;
2875 }
2876
2877 return algorithm;
2878 }
2879
halbtc8822b1ant_action_coex_all_off(struct btc_coexist * btc)2880 static void halbtc8822b1ant_action_coex_all_off(struct btc_coexist *btc)
2881 {
2882 halbtc8822b1ant_table(btc, NM_EXCU, 0);
2883 halbtc8822b1ant_tdma(btc, NM_EXCU, FALSE, 0);
2884 }
2885
halbtc8822b1ant_action_bt_whql_test(struct btc_coexist * btc)2886 static void halbtc8822b1ant_action_bt_whql_test(struct btc_coexist *btc)
2887 {
2888 halbtc8822b1ant_set_wl_tx_power(btc, NM_EXCU, 0xd8);
2889 halbtc8822b1ant_set_bt_tx_power(btc, NM_EXCU, 0);
2890 halbtc8822b1ant_set_wl_rx_gain(btc, NM_EXCU, FALSE);
2891 halbtc8822b1ant_set_bt_rx_gain(btc, NM_EXCU, FALSE);
2892
2893 halbtc8822b1ant_table(btc, NM_EXCU, 0);
2894 halbtc8822b1ant_tdma(btc, NM_EXCU, FALSE, 8);
2895 }
2896
halbtc8822b1ant_action_bt_relink(struct btc_coexist * btc)2897 static void halbtc8822b1ant_action_bt_relink(struct btc_coexist *btc)
2898 {
2899 struct coex_sta_8822b_1ant *coex_sta = &btc->coex_sta_8822b_1ant;
2900 struct btc_bt_link_info *bt_link_info = &btc->bt_link_info;
2901
2902 if ((!coex_sta->is_bt_multi_link && !bt_link_info->pan_exist) ||
2903 (bt_link_info->a2dp_exist && bt_link_info->hid_exist)) {
2904 halbtc8822b1ant_set_wl_tx_power(btc, NM_EXCU, 0xd8);
2905 halbtc8822b1ant_set_bt_tx_power(btc, NM_EXCU, 0);
2906 halbtc8822b1ant_set_wl_rx_gain(btc, NM_EXCU, FALSE);
2907 halbtc8822b1ant_set_bt_rx_gain(btc, NM_EXCU, FALSE);
2908
2909 halbtc8822b1ant_table(btc, NM_EXCU, 0);
2910 halbtc8822b1ant_tdma(btc, NM_EXCU, FALSE, 8);
2911 }
2912 }
2913
halbtc8822b1ant_action_bt_idle(struct btc_coexist * btc)2914 static void halbtc8822b1ant_action_bt_idle(struct btc_coexist *btc)
2915 {
2916 struct coex_sta_8822b_1ant *coex_sta = &btc->coex_sta_8822b_1ant;
2917 struct coex_dm_8822b_1ant *coex_dm = &btc->coex_dm_8822b_1ant;
2918 boolean wifi_busy = FALSE;
2919 u32 wifi_bw = 1;
2920 static u8 prewifi_rssi_state = BTC_RSSI_STATE_LOW;
2921 u8 wifi_rssi_state;
2922
2923 btc->btc_get(btc, BTC_GET_BL_WIFI_BUSY, &wifi_busy);
2924 btc->btc_get(btc, BTC_GET_U4_WIFI_BW, &wifi_bw);
2925
2926 wifi_rssi_state =
2927 halbtc8822b1ant_wifi_rssi_state(btc, &prewifi_rssi_state, 2,
2928 50, 0);
2929
2930 halbtc8822b1ant_set_wl_tx_power(btc, NM_EXCU, 0xd8);
2931 halbtc8822b1ant_set_bt_tx_power(btc, NM_EXCU, 0);
2932 halbtc8822b1ant_set_wl_rx_gain(btc, NM_EXCU, FALSE);
2933 halbtc8822b1ant_set_bt_rx_gain(btc, NM_EXCU, FALSE);
2934
2935 if (coex_dm->bt_status == BT_8822B_1ANT_BSTATUS_NCON_IDLE &&
2936 BTC_RSSI_HIGH(wifi_rssi_state))
2937 halbtc8822b1ant_set_ant_path(btc, BTC_ANT_PATH_AUTO, NM_EXCU,
2938 BT_8822B_1ANT_PHASE_2G_FREERUN);
2939 else
2940 halbtc8822b1ant_set_ant_path(btc, BTC_ANT_PATH_AUTO, NM_EXCU,
2941 BT_8822B_1ANT_PHASE_2G);
2942
2943 #ifdef PLATFORM_WINDOWS
2944 if (coex_sta->wl_noisy_level > 0) {
2945 halbtc8822b1ant_table(btc, NM_EXCU, 0);
2946 halbtc8822b1ant_tdma(btc, NM_EXCU, FALSE, 8);
2947 return;
2948 }
2949 #endif
2950
2951 if (!wifi_busy) {
2952 halbtc8822b1ant_table(btc, NM_EXCU, 7);
2953 halbtc8822b1ant_tdma(btc, NM_EXCU, TRUE, 32);
2954 } else { /* if wl busy */
2955 if (coex_dm->bt_status == BT_8822B_1ANT_BSTATUS_NCON_IDLE &&
2956 btc->wifi_link_info.link_mode == BTC_LINK_ONLY_STA) {
2957 halbtc8822b1ant_table(btc, NM_EXCU, 2);
2958 halbtc8822b1ant_tdma(btc, NM_EXCU, TRUE, 33);
2959 } else {
2960 halbtc8822b1ant_table(btc, NM_EXCU, 3);
2961 halbtc8822b1ant_tdma(btc, NM_EXCU, TRUE, 33);
2962 }
2963 }
2964 }
2965
halbtc8822b1ant_action_bt_inquiry(struct btc_coexist * btc)2966 static void halbtc8822b1ant_action_bt_inquiry(struct btc_coexist *btc)
2967 {
2968 struct coex_sta_8822b_1ant *coex_sta = &btc->coex_sta_8822b_1ant;
2969 struct btc_bt_link_info *bt_link_info = &btc->bt_link_info;
2970 boolean wifi_connected = FALSE, wifi_busy = FALSE;
2971
2972 halbtc8822b1ant_set_wl_tx_power(btc, NM_EXCU, 0xd8);
2973 halbtc8822b1ant_set_bt_tx_power(btc, NM_EXCU, 0);
2974 halbtc8822b1ant_set_wl_rx_gain(btc, NM_EXCU, FALSE);
2975 halbtc8822b1ant_set_bt_rx_gain(btc, NM_EXCU, FALSE);
2976
2977 btc->btc_get(btc, BTC_GET_BL_WIFI_CONNECTED, &wifi_connected);
2978 btc->btc_get(btc, BTC_GET_BL_WIFI_BUSY, &wifi_busy);
2979
2980 if (coex_sta->is_wifi_linkscan_process ||
2981 coex_sta->wifi_high_pri_task1 || coex_sta->wifi_high_pri_task2) {
2982 if (coex_sta->bt_create_connection) {
2983 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2984 "[BTCoex], bt page + wifi hi-pri task\n");
2985 BTC_TRACE(trace_buf);
2986
2987 halbtc8822b1ant_table(btc, NM_EXCU, 23);
2988
2989 if (bt_link_info->a2dp_exist &&
2990 !bt_link_info->pan_exist) {
2991 halbtc8822b1ant_tdma(btc, NM_EXCU, TRUE, 17);
2992 } else if (coex_sta->wifi_high_pri_task1) {
2993 halbtc8822b1ant_tdma(btc, NM_EXCU, TRUE, 36);
2994 } else {
2995 halbtc8822b1ant_tdma(btc, NM_EXCU, TRUE, 33);
2996 }
2997 } else {
2998 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2999 "[BTCoex], bt inquiry + wifi hi-pri task\n");
3000 BTC_TRACE(trace_buf);
3001
3002 halbtc8822b1ant_table(btc, NM_EXCU, 23);
3003 halbtc8822b1ant_tdma(btc, NM_EXCU, TRUE, 21);
3004 }
3005 } else if (wifi_busy) {
3006 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3007 "[BTCoex], bt inq/page + wifi busy\n");
3008 BTC_TRACE(trace_buf);
3009
3010 halbtc8822b1ant_table(btc, NM_EXCU, 23);
3011 /* for android 6.0 remote name request */
3012 halbtc8822b1ant_tdma(btc, NM_EXCU, TRUE, 23);
3013 } else if (wifi_connected) {
3014 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3015 "[BTCoex], bt inq/page + wifi connected\n");
3016 BTC_TRACE(trace_buf);
3017
3018 halbtc8822b1ant_table(btc, NM_EXCU, 23);
3019 halbtc8822b1ant_tdma(btc, NM_EXCU, TRUE, 23);
3020 } else {
3021 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3022 "[BTCoex], bt inq/page + wifi not-connected\n");
3023 BTC_TRACE(trace_buf);
3024 halbtc8822b1ant_table(btc, NM_EXCU, 0);
3025 halbtc8822b1ant_tdma(btc, NM_EXCU, FALSE, 8);
3026 }
3027 }
3028
3029 static
halbtc8822b1ant_action_bt_sco_hid_busy(struct btc_coexist * btc)3030 void halbtc8822b1ant_action_bt_sco_hid_busy(struct btc_coexist *btc)
3031 {
3032 struct coex_sta_8822b_1ant *coex_sta = &btc->coex_sta_8822b_1ant;
3033 struct btc_bt_link_info *bt_link_info = &btc->bt_link_info;
3034 boolean wifi_busy = FALSE;
3035
3036 halbtc8822b1ant_set_wl_tx_power(btc, NM_EXCU, 0xd8);
3037 halbtc8822b1ant_set_bt_tx_power(btc, NM_EXCU, 0);
3038 halbtc8822b1ant_set_wl_rx_gain(btc, NM_EXCU, FALSE);
3039 halbtc8822b1ant_set_bt_rx_gain(btc, NM_EXCU, FALSE);
3040
3041 btc->btc_get(btc, BTC_GET_BL_WIFI_BUSY, &wifi_busy);
3042
3043 if (!wifi_busy)
3044 wifi_busy = coex_sta->gl_wifi_busy;
3045
3046 if (bt_link_info->sco_exist) {
3047 if (coex_sta->is_bt_multi_link) {
3048 halbtc8822b1ant_table(btc, NM_EXCU, 1);
3049 halbtc8822b1ant_tdma(btc, NM_EXCU, TRUE, 25);
3050 } else {
3051 halbtc8822b1ant_table(btc, NM_EXCU, 1);
3052 halbtc8822b1ant_tdma(btc, NM_EXCU, TRUE, 5);
3053 }
3054 } else if (coex_sta->is_hid_rcu) {
3055 if (coex_sta->wl_noisy_level > 0) {
3056 halbtc8822b1ant_table(btc, NM_EXCU, 16);
3057 halbtc8822b1ant_tdma(btc, NM_EXCU, TRUE, 37);
3058 } else {
3059 halbtc8822b1ant_table(btc, NM_EXCU, 17);
3060 halbtc8822b1ant_tdma(btc, NM_EXCU, TRUE, 6);
3061 }
3062 } else {
3063 if (coex_sta->bt_a2dp_active) {
3064 halbtc8822b1ant_table(btc, NM_EXCU, 1);
3065 halbtc8822b1ant_tdma(btc, NM_EXCU, TRUE, 18);
3066 } else {
3067 if (coex_sta->bt_418_hid_exist && wifi_busy) {
3068 halbtc8822b1ant_table(btc, NM_EXCU, 1);
3069 halbtc8822b1ant_wltoggle_table(btc, NM_EXCU, 1,
3070 0xaa, 0x5a,
3071 0x5a, 0x5a);
3072 /* 4-slot TDMA + WL slot table toggle */
3073 halbtc8822b1ant_tdma(btc, NM_EXCU, TRUE,
3074 38 | BIT(8));
3075 } else {
3076 halbtc8822b1ant_table(btc, NM_EXCU, 1);
3077 halbtc8822b1ant_tdma(btc, NM_EXCU, TRUE, 6);
3078 }
3079 }
3080 }
3081 }
3082
halbtc8822b1ant_action_bt_acl_busy(struct btc_coexist * btc)3083 static void halbtc8822b1ant_action_bt_acl_busy(struct btc_coexist *btc)
3084 {
3085 struct coex_sta_8822b_1ant *coex_sta = &btc->coex_sta_8822b_1ant;
3086 struct btc_bt_link_info *bt_link_info = &btc->bt_link_info;
3087 boolean wifi_busy = FALSE, wifi_turbo = FALSE, ap_enable = FALSE;
3088 static u8 prewifi_rssi_state = BTC_RSSI_STATE_LOW;
3089 static u8 prewifi_rssi_state2 = BTC_RSSI_STATE_LOW;
3090 u32 wifi_bw = 1;
3091 u8 wifi_rssi_state, wifi_rssi_state2, iot_peer = BTC_IOT_PEER_UNKNOWN;
3092
3093 btc->btc_get(btc, BTC_GET_U4_WIFI_BW, &wifi_bw);
3094 btc->btc_get(btc, BTC_GET_BL_WIFI_BUSY, &wifi_busy);
3095 btc->btc_get(btc, BTC_GET_U1_AP_NUM, &coex_sta->scan_ap_num);
3096 btc->btc_get(btc, BTC_GET_U1_IOT_PEER, &iot_peer);
3097 btc->btc_get(btc, BTC_GET_BL_WIFI_AP_MODE_ENABLE, &ap_enable);
3098
3099 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3100 "############# [BTCoex], scan_ap_num = %d, wl_noisy_level = %d\n",
3101 coex_sta->scan_ap_num, coex_sta->wl_noisy_level);
3102 BTC_TRACE(trace_buf);
3103
3104 if (!wifi_busy)
3105 wifi_busy = coex_sta->gl_wifi_busy;
3106
3107 if (wifi_busy && coex_sta->wl_noisy_level == 0)
3108 wifi_turbo = TRUE;
3109
3110 wifi_rssi_state =
3111 halbtc8822b1ant_wifi_rssi_state(btc, &prewifi_rssi_state, 2,
3112 40, 0);
3113
3114 wifi_rssi_state2 =
3115 halbtc8822b1ant_wifi_rssi_state(btc, &prewifi_rssi_state2, 2,
3116 42, 0);
3117
3118 if (btc->board_info.customer_id == RT_CID_LENOVO_CHINA &&
3119 coex_sta->scan_ap_num <= 10 &&
3120 iot_peer == BTC_IOT_PEER_ATHEROS &&
3121 ((bt_link_info->a2dp_only && coex_sta->is_bt_multi_link &&
3122 coex_sta->hid_pair_cnt == 0) ||
3123 (bt_link_info->a2dp_exist && bt_link_info->pan_exist))) {
3124 /* OPP may disappear during CPT_for_WiFi test */
3125 /* for CPT_for_WiFi */
3126
3127 if (BTC_RSSI_LOW(wifi_rssi_state2)) {
3128 halbtc8822b1ant_set_bt_tx_power(btc, NM_EXCU, 20);
3129
3130 if (wifi_busy) {
3131 halbtc8822b1ant_table(btc, NM_EXCU, 22);
3132 halbtc8822b1ant_tdma(btc, NM_EXCU, TRUE, 105);
3133 } else {
3134 halbtc8822b1ant_table(btc, NM_EXCU, 23);
3135 halbtc8822b1ant_tdma(btc, NM_EXCU, TRUE, 13);
3136 }
3137 } else { /* for CPT_for_BT */
3138 halbtc8822b1ant_set_bt_tx_power(btc, NM_EXCU, 0);
3139 halbtc8822b1ant_table(btc, NM_EXCU, 16);
3140 halbtc8822b1ant_tdma(btc, NM_EXCU, TRUE, 8);
3141 }
3142 return;
3143 }
3144
3145 halbtc8822b1ant_set_bt_tx_power(btc, NM_EXCU, 0);
3146
3147 if (bt_link_info->a2dp_exist && coex_sta->is_bt_a2dp_sink) {
3148 if (ap_enable) { /* A2DP Sink */
3149 halbtc8822b1ant_table(btc, NM_EXCU, 0);
3150 halbtc8822b1ant_tdma(btc, NM_EXCU, FALSE, 8);
3151 } else {
3152 halbtc8822b1ant_table(btc, NM_EXCU, 1);
3153 halbtc8822b1ant_tdma(btc, NM_EXCU, TRUE, 4);
3154 }
3155 } else if (bt_link_info->a2dp_only) { /* A2DP */
3156 if (wifi_turbo)
3157 halbtc8822b1ant_table(btc, NM_EXCU, 3);
3158 else /* wifi idle */
3159 halbtc8822b1ant_table(btc, NM_EXCU, 1);
3160
3161 if (coex_sta->connect_ap_period_cnt > 0 || !wifi_busy)
3162 halbtc8822b1ant_tdma(btc, NM_EXCU, TRUE, 26);
3163 else
3164 halbtc8822b1ant_tdma(btc, NM_EXCU, TRUE, 7);
3165 } else if ((bt_link_info->a2dp_exist && bt_link_info->pan_exist) ||
3166 (bt_link_info->hid_exist && bt_link_info->a2dp_exist &&
3167 bt_link_info->pan_exist)) {
3168 /* A2DP+PAN, HID+A2DP+PAN*/
3169 if (bt_link_info->hid_exist)
3170 halbtc8822b1ant_table(btc, NM_EXCU, 1);
3171 else if (wifi_turbo)
3172 halbtc8822b1ant_table(btc, NM_EXCU, 3);
3173 else
3174 halbtc8822b1ant_table(btc, NM_EXCU, 4);
3175
3176 if (wifi_busy)
3177 halbtc8822b1ant_tdma(btc, NM_EXCU, TRUE, 13);
3178 else
3179 halbtc8822b1ant_tdma(btc, NM_EXCU, TRUE, 14);
3180 } else if (bt_link_info->hid_exist && coex_sta->is_hid_rcu &&
3181 bt_link_info->a2dp_exist) { /* RCU + A2DP */
3182 halbtc8822b1ant_table(btc, NM_EXCU, 16);
3183
3184 if (coex_sta->connect_ap_period_cnt > 0 || !wifi_busy)
3185 halbtc8822b1ant_tdma(btc, NM_EXCU, TRUE, 26);
3186 else
3187 halbtc8822b1ant_tdma(btc, NM_EXCU, TRUE, 7);
3188 } else if (bt_link_info->hid_exist &&
3189 bt_link_info->a2dp_exist) { /* HID + A2DP */
3190 halbtc8822b1ant_table(btc, FC_EXCU, 1);
3191
3192 if (coex_sta->connect_ap_period_cnt > 0 || !wifi_busy) {
3193 halbtc8822b1ant_tdma(btc, NM_EXCU, TRUE, 26);
3194 } else if (coex_sta->bt_418_hid_exist && wifi_busy) {
3195 halbtc8822b1ant_wltoggle_table(btc, NM_EXCU, 3,
3196 0xaa, 0x5a, 0x5a, 0x5a);
3197 halbtc8822b1ant_tdma(btc, NM_EXCU, TRUE, 39 | BIT(8));
3198 } else {
3199 halbtc8822b1ant_tdma(btc, NM_EXCU, TRUE, 7);
3200 }
3201 /* PAN, HID+PAN */
3202 } else if ((bt_link_info->pan_only) ||
3203 (bt_link_info->hid_exist && bt_link_info->pan_exist)) {
3204 if (bt_link_info->hid_exist)
3205 halbtc8822b1ant_table(btc, NM_EXCU, 1);
3206 else if (wifi_turbo)
3207 halbtc8822b1ant_table(btc, NM_EXCU, 3);
3208 else
3209 halbtc8822b1ant_table(btc, NM_EXCU, 4);
3210
3211 if (!wifi_busy)
3212 halbtc8822b1ant_tdma(btc, NM_EXCU, TRUE, 4);
3213 else
3214 halbtc8822b1ant_tdma(btc, NM_EXCU, TRUE, 3);
3215 } else {
3216 /* BT no-profile busy (0x9) */
3217 halbtc8822b1ant_table(btc, NM_EXCU, 4);
3218 halbtc8822b1ant_tdma(btc, NM_EXCU, TRUE, 33);
3219 }
3220 }
3221
halbtc8822b1ant_action_bt_mr(struct btc_coexist * btc)3222 static void halbtc8822b1ant_action_bt_mr(struct btc_coexist *btc)
3223 {
3224 struct wifi_link_info_8822b_1ant *wifi_link_info_ext =
3225 &btc->wifi_link_info_8822b_1ant;
3226
3227 if (!wifi_link_info_ext->is_all_under_5g) {
3228 halbtc8822b1ant_set_ant_path(btc, BTC_ANT_PATH_AUTO, NM_EXCU,
3229 BT_8822B_1ANT_PHASE_2G_FREERUN);
3230
3231 halbtc8822b1ant_table(btc, NM_EXCU, 8);
3232 halbtc8822b1ant_tdma(btc, NM_EXCU, FALSE, 8);
3233
3234 /* Enter MIMO Power Save, 0:enable */
3235 halbtc8822b1ant_mimo_ps(btc, NM_EXCU, 0);
3236 } else {
3237 halbtc8822b1ant_set_ant_path(btc, BTC_ANT_PATH_AUTO, NM_EXCU,
3238 BT_8822B_1ANT_PHASE_5G);
3239
3240 halbtc8822b1ant_table(btc, NM_EXCU, 0);
3241 halbtc8822b1ant_tdma(btc, NM_EXCU, FALSE, 8);
3242
3243 /* No MIMO Power Save, 3:disable */
3244 halbtc8822b1ant_mimo_ps(btc, NM_EXCU, 3);
3245 }
3246 }
3247
halbtc8822b1ant_action_rf4ce(struct btc_coexist * btc)3248 static void halbtc8822b1ant_action_rf4ce(struct btc_coexist *btc)
3249 {
3250 halbtc8822b1ant_set_wl_tx_power(btc, NM_EXCU, 0xd8);
3251 halbtc8822b1ant_set_bt_tx_power(btc, NM_EXCU, 0);
3252 halbtc8822b1ant_set_wl_rx_gain(btc, NM_EXCU, FALSE);
3253 halbtc8822b1ant_set_bt_rx_gain(btc, NM_EXCU, FALSE);
3254
3255 halbtc8822b1ant_table(btc, NM_EXCU, 1);
3256 halbtc8822b1ant_tdma(btc, NM_EXCU, TRUE, 50);
3257 }
3258
halbtc8822b1ant_action_wifi_under5g(struct btc_coexist * btc)3259 static void halbtc8822b1ant_action_wifi_under5g(struct btc_coexist *btc)
3260 {
3261 halbtc8822b1ant_set_wl_tx_power(btc, NM_EXCU, 0xd8);
3262 halbtc8822b1ant_set_bt_tx_power(btc, NM_EXCU, 0);
3263 halbtc8822b1ant_set_wl_rx_gain(btc, NM_EXCU, FALSE);
3264 halbtc8822b1ant_set_bt_rx_gain(btc, NM_EXCU, FALSE);
3265
3266 halbtc8822b1ant_set_ant_path(btc, BTC_ANT_PATH_AUTO, FC_EXCU,
3267 BT_8822B_1ANT_PHASE_5G);
3268
3269 halbtc8822b1ant_table(btc, NM_EXCU, 0);
3270 halbtc8822b1ant_tdma(btc, NM_EXCU, FALSE, 8);
3271 }
3272
halbtc8822b1ant_action_wifi_only(struct btc_coexist * btc)3273 static void halbtc8822b1ant_action_wifi_only(struct btc_coexist *btc)
3274 {
3275 boolean rf4ce_enabled = FALSE, wifi_connected = FALSE;
3276
3277 halbtc8822b1ant_set_wl_tx_power(btc, NM_EXCU, 0xd8);
3278 halbtc8822b1ant_set_bt_tx_power(btc, NM_EXCU, 0);
3279 halbtc8822b1ant_set_wl_rx_gain(btc, NM_EXCU, FALSE);
3280 halbtc8822b1ant_set_bt_rx_gain(btc, NM_EXCU, FALSE);
3281
3282 btc->btc_get(btc, BTC_GET_BL_RF4CE_CONNECTED, &rf4ce_enabled);
3283 btc->btc_get(btc, BTC_GET_BL_WIFI_CONNECTED, &wifi_connected);
3284
3285 if ((rf4ce_enabled) && (wifi_connected)) {
3286 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3287 "[BTCoex], ********** (wlan only -- rf4ce enable ) **********\n");
3288 BTC_TRACE(trace_buf);
3289 halbtc8822b1ant_action_rf4ce(btc);
3290 } else {
3291 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3292 "[BTCoex], ********** (wlan only -- under 2g ) **********\n");
3293 BTC_TRACE(trace_buf);
3294
3295 halbtc8822b1ant_table(btc, FC_EXCU, 0);
3296 halbtc8822b1ant_tdma(btc, FC_EXCU, FALSE, 8);
3297 }
3298 }
3299
3300 static void
halbtc8822b1ant_action_wifi_native_lps(struct btc_coexist * btc)3301 halbtc8822b1ant_action_wifi_native_lps(struct btc_coexist *btc)
3302 {
3303 struct wifi_link_info_8822b_1ant *wifi_link_info_ext =
3304 &btc->wifi_link_info_8822b_1ant;
3305 struct btc_bt_link_info *bt_link_info = &btc->bt_link_info;
3306
3307 if (wifi_link_info_ext->is_all_under_5g)
3308 return;
3309
3310 halbtc8822b1ant_set_wl_tx_power(btc, NM_EXCU, 0xd8);
3311 halbtc8822b1ant_set_bt_tx_power(btc, NM_EXCU, 0);
3312 halbtc8822b1ant_set_wl_rx_gain(btc, NM_EXCU, FALSE);
3313 halbtc8822b1ant_set_bt_rx_gain(btc, NM_EXCU, FALSE);
3314
3315 halbtc8822b1ant_table(btc, NM_EXCU, 21);
3316 halbtc8822b1ant_tdma(btc, NM_EXCU, FALSE, 8);
3317 }
3318
halbtc8822b1ant_action_wifi_linkscan(struct btc_coexist * btc)3319 static void halbtc8822b1ant_action_wifi_linkscan(struct btc_coexist *btc)
3320 {
3321 struct btc_bt_link_info *bt_link_info = &btc->bt_link_info;
3322
3323 halbtc8822b1ant_set_wl_tx_power(btc, NM_EXCU, 0xd8);
3324 halbtc8822b1ant_set_bt_tx_power(btc, NM_EXCU, 0);
3325 halbtc8822b1ant_set_wl_rx_gain(btc, NM_EXCU, FALSE);
3326 halbtc8822b1ant_set_bt_rx_gain(btc, NM_EXCU, FALSE);
3327
3328 if (bt_link_info->pan_exist) {
3329 halbtc8822b1ant_table(btc, NM_EXCU, 1);
3330 halbtc8822b1ant_tdma(btc, NM_EXCU, TRUE, 22);
3331 } else if (bt_link_info->a2dp_exist) {
3332 halbtc8822b1ant_table(btc, NM_EXCU, 1);
3333 halbtc8822b1ant_tdma(btc, NM_EXCU, TRUE, 27);
3334 } else {
3335 halbtc8822b1ant_table(btc, NM_EXCU, 1);
3336 halbtc8822b1ant_tdma(btc, NM_EXCU, TRUE, 21);
3337 }
3338 }
3339
3340 static void
halbtc8822b1ant_action_wifi_not_connected(struct btc_coexist * btc)3341 halbtc8822b1ant_action_wifi_not_connected(struct btc_coexist *btc)
3342 {
3343 halbtc8822b1ant_set_wl_tx_power(btc, NM_EXCU, 0xd8);
3344 halbtc8822b1ant_set_bt_tx_power(btc, NM_EXCU, 0);
3345 halbtc8822b1ant_set_wl_rx_gain(btc, NM_EXCU, FALSE);
3346 halbtc8822b1ant_set_bt_rx_gain(btc, NM_EXCU, FALSE);
3347
3348 /* tdma and coex table */
3349 halbtc8822b1ant_table(btc, NM_EXCU, 0);
3350 halbtc8822b1ant_tdma(btc, FC_EXCU, FALSE, 8);
3351 }
3352
halbtc8822b1ant_action_wifi_connected(struct btc_coexist * btc)3353 static void halbtc8822b1ant_action_wifi_connected(struct btc_coexist *btc)
3354 {
3355 struct btc_bt_link_info *bt_link_info = &btc->bt_link_info;
3356 struct coex_dm_8822b_1ant *coex_dm = &btc->coex_dm_8822b_1ant;
3357 boolean rf4ce_enabled = FALSE;
3358
3359 btc->btc_get(btc, BTC_GET_BL_RF4CE_CONNECTED, &rf4ce_enabled);
3360
3361 coex_dm->cur_algorithm = halbtc8822b1ant_action_algorithm(btc);
3362
3363 if (coex_dm->bt_status == BT_8822B_1ANT_BSTATUS_ACL_BUSY ||
3364 coex_dm->bt_status == BT_8822B_1ANT_BSTATUS_ACL_SCO_BUSY) {
3365 if (bt_link_info->hid_only) /* HID only */
3366 halbtc8822b1ant_action_bt_sco_hid_busy(btc);
3367 else
3368 halbtc8822b1ant_action_bt_acl_busy(btc);
3369
3370 } else if (coex_dm->bt_status == BT_8822B_1ANT_BSTATUS_SCO_BUSY)
3371 halbtc8822b1ant_action_bt_sco_hid_busy(btc);
3372 else if (rf4ce_enabled)
3373 halbtc8822b1ant_action_rf4ce(btc);
3374 else
3375 halbtc8822b1ant_action_bt_idle(btc);
3376 }
3377
3378 static void
halbtc8822b1ant_action_wifi_multiport25g(struct btc_coexist * btc)3379 halbtc8822b1ant_action_wifi_multiport25g(struct btc_coexist *btc)
3380 {
3381 struct coex_sta_8822b_1ant *coex_sta = &btc->coex_sta_8822b_1ant;
3382
3383 halbtc8822b1ant_set_wl_tx_power(btc, NM_EXCU, 0xd8);
3384 halbtc8822b1ant_set_bt_tx_power(btc, NM_EXCU, 0);
3385 halbtc8822b1ant_set_wl_rx_gain(btc, NM_EXCU, FALSE);
3386 halbtc8822b1ant_set_bt_rx_gain(btc, NM_EXCU, FALSE);
3387
3388 halbtc8822b1ant_write_scbd(btc, BT_8822B_1ANT_SCBD_CQDDR, TRUE);
3389
3390 halbtc8822b1ant_set_ant_path(btc, BTC_ANT_PATH_AUTO, NM_EXCU,
3391 BT_8822B_1ANT_PHASE_MCC);
3392
3393 if (coex_sta->is_setup_link || coex_sta->bt_relink_downcount != 0) {
3394 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3395 "[BTCoex], wifi_multiport25g(), BT Relink!!\n");
3396 BTC_TRACE(trace_buf);
3397
3398 halbtc8822b1ant_table(btc, NM_EXCU, 26);
3399 halbtc8822b1ant_tdma(btc, NM_EXCU, FALSE, 8);
3400 } else if (coex_sta->c2h_bt_inquiry_page) {
3401 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3402 "[BTCoex], wifi_multiport25g(), BT Inq-Page!!\n");
3403 BTC_TRACE(trace_buf);
3404
3405 halbtc8822b1ant_table(btc, NM_EXCU, 25);
3406 halbtc8822b1ant_tdma(btc, NM_EXCU, FALSE, 8);
3407 } else {
3408 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3409 "[BTCoex], wifi_multiport25g(), BT idle or busy!!\n");
3410 BTC_TRACE(trace_buf);
3411
3412 halbtc8822b1ant_table(btc, NM_EXCU, 25);
3413 halbtc8822b1ant_tdma(btc, NM_EXCU, FALSE, 8);
3414 }
3415 }
3416
halbtc8822b1ant_action_wifi_scc2g(struct btc_coexist * btc)3417 static void halbtc8822b1ant_action_wifi_scc2g(struct btc_coexist *btc)
3418 {
3419 struct coex_sta_8822b_1ant *coex_sta = &btc->coex_sta_8822b_1ant;
3420
3421 if (coex_sta->num_of_profile == 1) {
3422 if (coex_sta->hid_exist || coex_sta->sco_exist) {
3423 if (coex_sta->bt_a2dp_active) {
3424 halbtc8822b1ant_table(btc, NM_EXCU, 4);
3425 halbtc8822b1ant_tdma(btc, NM_EXCU, TRUE, 50);
3426 } else {
3427 halbtc8822b1ant_table(btc, NM_EXCU, 0);
3428 halbtc8822b1ant_tdma(btc, NM_EXCU, FALSE, 0);
3429 }
3430 } else if (coex_sta->a2dp_exist) {
3431 halbtc8822b1ant_table(btc, NM_EXCU, 11);
3432 halbtc8822b1ant_tdma(btc, NM_EXCU, TRUE, 51);
3433 } else { /* PAN or OPP */
3434 halbtc8822b1ant_table(btc, NM_EXCU, 11);
3435 halbtc8822b1ant_tdma(btc, NM_EXCU, TRUE, 50);
3436 }
3437 } else {
3438 if ((coex_sta->hid_exist || coex_sta->sco_exist) &&
3439 coex_sta->a2dp_exist) {
3440 halbtc8822b1ant_table(btc, NM_EXCU, 1);
3441 halbtc8822b1ant_tdma(btc, NM_EXCU, TRUE, 51);
3442 } else if (coex_sta->pan_exist && coex_sta->a2dp_exist) {
3443 halbtc8822b1ant_table(btc, NM_EXCU, 11);
3444 halbtc8822b1ant_tdma(btc, NM_EXCU, TRUE, 51);
3445 } else { /* hid + pan */
3446 halbtc8822b1ant_table(btc, NM_EXCU, 1);
3447 halbtc8822b1ant_tdma(btc, NM_EXCU, TRUE, 50);
3448 }
3449 }
3450 }
3451
3452 static void
halbtc8822b1ant_action_wifi_multiport2g(struct btc_coexist * btc)3453 halbtc8822b1ant_action_wifi_multiport2g(struct btc_coexist *btc)
3454 {
3455 struct coex_sta_8822b_1ant *coex_sta = &btc->coex_sta_8822b_1ant;
3456 struct btc_bt_link_info *bt_link_info = &btc->bt_link_info;
3457 u32 traffic_dir;
3458 u8 ant_pase;
3459
3460 btc->btc_get(btc, BTC_GET_U4_WIFI_TRAFFIC_DIRECTION, &traffic_dir);
3461
3462 halbtc8822b1ant_set_wl_tx_power(btc, NM_EXCU, 0xd8);
3463 halbtc8822b1ant_set_bt_tx_power(btc, NM_EXCU, 0);
3464 halbtc8822b1ant_set_wl_rx_gain(btc, NM_EXCU, FALSE);
3465 halbtc8822b1ant_set_bt_rx_gain(btc, NM_EXCU, FALSE);
3466
3467 halbtc8822b1ant_write_scbd(btc, BT_8822B_1ANT_SCBD_CQDDR, TRUE);
3468
3469 if (coex_sta->bt_disabled) {
3470 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3471 "[BTCoex], BT is disabled !!!\n");
3472 BTC_TRACE(trace_buf);
3473 halbtc8822b1ant_set_ant_path(btc, BTC_ANT_PATH_AUTO, NM_EXCU,
3474 BT_8822B_1ANT_PHASE_2G);
3475 halbtc8822b1ant_action_wifi_only(btc);
3476 } else if (coex_sta->is_setup_link ||
3477 coex_sta->bt_relink_downcount != 0) {
3478 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3479 "[BTCoex], wifi_multiport2g, BT Relink!!\n");
3480 BTC_TRACE(trace_buf);
3481
3482 halbtc8822b1ant_set_ant_path(btc, BTC_ANT_PATH_AUTO, NM_EXCU,
3483 BT_8822B_1ANT_PHASE_2G_FREERUN);
3484
3485 halbtc8822b1ant_table(btc, NM_EXCU, 8);
3486 halbtc8822b1ant_tdma(btc, NM_EXCU, FALSE, 8);
3487 } else if (coex_sta->c2h_bt_inquiry_page) {
3488 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3489 "[BTCoex], wifi_multiport2g, BT Inq-Page!!\n");
3490 BTC_TRACE(trace_buf);
3491
3492 halbtc8822b1ant_set_ant_path(btc, BTC_ANT_PATH_AUTO, NM_EXCU,
3493 BT_8822B_1ANT_PHASE_2G_FREERUN);
3494
3495 halbtc8822b1ant_table(btc, NM_EXCU, 8);
3496 halbtc8822b1ant_tdma(btc, NM_EXCU, FALSE, 8);
3497 } else if (coex_sta->num_of_profile == 0) {
3498 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3499 "[BTCoex], wifi_multiport2g, BT idle!!\n");
3500 BTC_TRACE(trace_buf);
3501
3502 halbtc8822b1ant_set_ant_path(btc, BTC_ANT_PATH_AUTO, NM_EXCU,
3503 BT_8822B_1ANT_PHASE_2G_FREERUN);
3504
3505 if (btc->chip_interface == BTC_INTF_PCI &&
3506 (btc->wifi_link_info.link_mode == BTC_LINK_ONLY_GO ||
3507 btc->wifi_link_info.link_mode == BTC_LINK_ONLY_GC))
3508 halbtc8822b1ant_table(btc, NM_EXCU, 10);
3509 else
3510 halbtc8822b1ant_table(btc, NM_EXCU, 18);
3511 halbtc8822b1ant_tdma(btc, NM_EXCU, FALSE, 8);
3512 } else if (coex_sta->is_wifi_linkscan_process) {
3513 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3514 "[BTCoex], wifi_multiport2g, WL scan!!\n");
3515 BTC_TRACE(trace_buf);
3516
3517 halbtc8822b1ant_set_ant_path(btc, BTC_ANT_PATH_AUTO, NM_EXCU,
3518 BT_8822B_1ANT_PHASE_2G);
3519 halbtc8822b1ant_action_wifi_linkscan(btc);
3520 } else {
3521 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3522 "[BTCoex], wifi_multiport2g, BT profile!!\n");
3523 BTC_TRACE(trace_buf);
3524
3525 switch (btc->wifi_link_info.link_mode) {
3526 case BTC_LINK_2G_SCC_GC_STA:
3527 case BTC_LINK_2G_SCC_GO_STA:
3528 ant_pase = BT_8822B_1ANT_PHASE_2G;
3529 halbtc8822b1ant_set_ant_path(btc, BTC_ANT_PATH_AUTO,
3530 NM_EXCU, ant_pase);
3531 halbtc8822b1ant_action_wifi_scc2g(btc);
3532 break;
3533 case BTC_LINK_ONLY_GO:
3534 case BTC_LINK_ONLY_GC:
3535 ant_pase = BT_8822B_1ANT_PHASE_2G_FREERUN;
3536 halbtc8822b1ant_set_ant_path(btc, BTC_ANT_PATH_AUTO,
3537 NM_EXCU, ant_pase);
3538 if (btc->chip_interface == BTC_INTF_PCI &&
3539 coex_sta->a2dp_exist && !coex_sta->is_bt_multi_link)
3540 halbtc8822b1ant_table(btc, NM_EXCU, 10);
3541 else
3542 halbtc8822b1ant_table(btc, NM_EXCU, 18);
3543 halbtc8822b1ant_tdma(btc, NM_EXCU, FALSE, 8);
3544 break;
3545 default:
3546 ant_pase = BT_8822B_1ANT_PHASE_2G_FREERUN;
3547 halbtc8822b1ant_set_ant_path(btc, BTC_ANT_PATH_AUTO,
3548 NM_EXCU, ant_pase);
3549 halbtc8822b1ant_table(btc, NM_EXCU, 18);
3550 halbtc8822b1ant_tdma(btc, NM_EXCU, FALSE, 8);
3551 break;
3552 }
3553 }
3554 }
3555
halbtc8822b1ant_run_coex(struct btc_coexist * btc,u8 reason)3556 static void halbtc8822b1ant_run_coex(struct btc_coexist *btc, u8 reason)
3557 {
3558 struct coex_dm_8822b_1ant *coex_dm = &btc->coex_dm_8822b_1ant;
3559 struct coex_sta_8822b_1ant *coex_sta = &btc->coex_sta_8822b_1ant;
3560 struct wifi_link_info_8822b_1ant *wifi_link_info_ext =
3561 &btc->wifi_link_info_8822b_1ant;
3562 boolean wifi_connected = FALSE, wifi_32k = false;
3563 boolean scan = FALSE, link = FALSE, roam = FALSE, under_4way = FALSE;
3564
3565 btc->btc_get(btc, BTC_GET_BL_WIFI_SCAN, &scan);
3566 btc->btc_get(btc, BTC_GET_BL_WIFI_LINK, &link);
3567 btc->btc_get(btc, BTC_GET_BL_WIFI_ROAM, &roam);
3568 btc->btc_get(btc, BTC_GET_BL_WIFI_4_WAY_PROGRESS, &under_4way);
3569 btc->btc_get(btc, BTC_GET_BL_WIFI_CONNECTED, &wifi_connected);
3570 btc->btc_get(btc, BTC_GET_BL_WIFI_LW_PWR_STATE, &wifi_32k);
3571
3572 if (scan || link || roam || under_4way ||
3573 reason == BT_8822B_1ANT_RSN_2GSCANSTART ||
3574 reason == BT_8822B_1ANT_RSN_2GSWITCHBAND ||
3575 reason == BT_8822B_1ANT_RSN_2GCONSTART ||
3576 reason == BT_8822B_1ANT_RSN_2GSPECIALPKT) {
3577 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3578 "[BTCoex], scan = %d, link = %d, roam = %d 4way = %d!!!\n",
3579 scan, link, roam, under_4way);
3580 BTC_TRACE(trace_buf);
3581 coex_sta->is_wifi_linkscan_process = TRUE;
3582 } else {
3583 coex_sta->is_wifi_linkscan_process = FALSE;
3584 }
3585
3586 /* update wifi_link_info_ext variable */
3587 halbtc8822b1ant_update_wifi_link_info(btc, reason);
3588
3589 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3590 "[BTCoex], RunCoexistMechanism()===> reason = %d\n",
3591 reason);
3592 BTC_TRACE(trace_buf);
3593
3594 coex_sta->coex_run_reason = reason;
3595
3596 if (btc->manual_control) {
3597 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3598 "[BTCoex], RunCoexistMechanism(), return for Manual CTRL <===\n");
3599 BTC_TRACE(trace_buf);
3600 return;
3601 }
3602
3603 if (btc->stop_coex_dm) {
3604 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3605 "[BTCoex], RunCoexistMechanism(), return for Stop Coex DM <===\n");
3606 BTC_TRACE(trace_buf);
3607 return;
3608 }
3609
3610 if (coex_sta->under_ips) {
3611 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3612 "[BTCoex], RunCoexistMechanism(), return for wifi is under IPS !!!\n");
3613 BTC_TRACE(trace_buf);
3614 return;
3615 }
3616
3617 if (coex_sta->under_lps && wifi_32k) {
3618 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3619 "[BTCoex], RunCoexistMechanism(), return for wifi is under LPS-32K !!!\n");
3620 BTC_TRACE(trace_buf);
3621 return;
3622 }
3623
3624 if (!coex_sta->run_time_state) {
3625 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3626 "[BTCoex], RunCoexistMechanism(), return for run_time_state = FALSE !!!\n");
3627 BTC_TRACE(trace_buf);
3628 return;
3629 }
3630
3631 if (coex_sta->freeze_coexrun_by_btinfo && !coex_sta->is_setup_link) {
3632 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3633 "[BTCoex], RunCoexistMechanism(), return for freeze_coexrun_by_btinfo\n");
3634 BTC_TRACE(trace_buf);
3635 return;
3636 }
3637
3638 if (coex_sta->msft_mr_exist && wifi_connected) {
3639 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3640 "[BTCoex], RunCoexistMechanism(), microsoft MR!!\n");
3641 BTC_TRACE(trace_buf);
3642
3643 coex_sta->wl_coex_mode = BT_8822B_1ANT_WLINK_BTMR;
3644 halbtc8822b1ant_action_bt_mr(btc);
3645 return;
3646 }
3647
3648 coex_sta->coex_run_cnt++;
3649
3650 /* No MIMO Power Save, 3:disable */
3651 halbtc8822b1ant_mimo_ps(btc, NM_EXCU, 3);
3652
3653 /* Pure-5G Coex Process */
3654 if (wifi_link_info_ext->is_all_under_5g) {
3655 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3656 "[BTCoex], WiFi is under 5G!!!\n");
3657 BTC_TRACE(trace_buf);
3658
3659 coex_sta->wl_coex_mode = BT_8822B_1ANT_WLINK_5G;
3660 halbtc8822b1ant_action_wifi_under5g(btc);
3661 return;
3662 }
3663
3664 if (wifi_link_info_ext->is_mcc_25g) { /* not iclude scan action */
3665
3666 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3667 "[BTCoex], WiFi is under mcc dual-band!!!\n");
3668 BTC_TRACE(trace_buf);
3669
3670 coex_sta->wl_coex_mode = BT_8822B_1ANT_WLINK_25GMPORT;
3671 halbtc8822b1ant_action_wifi_multiport25g(btc);
3672 return;
3673 }
3674
3675 /* if multi-port or P2PGO+Client_Join */
3676 if (wifi_link_info_ext->num_of_active_port > 1 ||
3677 (btc->wifi_link_info.link_mode == BTC_LINK_ONLY_GO &&
3678 !btc->wifi_link_info.bhotspot &&
3679 btc->wifi_link_info.bany_client_join_go) ||
3680 btc->wifi_link_info.link_mode == BTC_LINK_ONLY_GC) {
3681 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3682 "[BTCoex], WiFi is under scc-2g/mcc-2g/p2pGO-only/P2PGC-Only!!!\n");
3683 BTC_TRACE(trace_buf);
3684
3685 if (btc->wifi_link_info.link_mode == BTC_LINK_ONLY_GO)
3686 coex_sta->wl_coex_mode = BT_8822B_1ANT_WLINK_2GGO;
3687 else if (btc->wifi_link_info.link_mode == BTC_LINK_ONLY_GC)
3688 coex_sta->wl_coex_mode = BT_8822B_1ANT_WLINK_2GGC;
3689 else
3690 coex_sta->wl_coex_mode = BT_8822B_1ANT_WLINK_2GMPORT;
3691
3692 halbtc8822b1ant_action_wifi_multiport2g(btc);
3693 return;
3694 }
3695
3696 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3697 "[BTCoex], WiFi is single-port 2G!!!\n");
3698 BTC_TRACE(trace_buf);
3699
3700 coex_sta->wl_coex_mode = BT_8822B_1ANT_WLINK_2G1PORT;
3701
3702 halbtc8822b1ant_write_scbd(btc, BT_8822B_1ANT_SCBD_CQDDR, TRUE);
3703
3704 if (coex_sta->bt_disabled) {
3705 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3706 "[BTCoex], BT is disabled !!!\n");
3707 BTC_TRACE(trace_buf);
3708 halbtc8822b1ant_set_ant_path(btc, BTC_ANT_PATH_AUTO, NM_EXCU,
3709 BT_8822B_1ANT_PHASE_2G);
3710 halbtc8822b1ant_action_wifi_only(btc);
3711 return;
3712 }
3713
3714 if (coex_sta->under_lps && !coex_sta->force_lps_ctrl) {
3715 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3716 "[BTCoex], RunCoexistMechanism(), wifi is under LPS !!!\n");
3717 BTC_TRACE(trace_buf);
3718 halbtc8822b1ant_set_ant_path(btc, BTC_ANT_PATH_AUTO, NM_EXCU,
3719 BT_8822B_1ANT_PHASE_2G);
3720 halbtc8822b1ant_action_wifi_native_lps(btc);
3721 return;
3722 }
3723
3724 if (coex_sta->bt_whck_test) {
3725 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3726 "[BTCoex], BT is under WHCK TEST!!!\n");
3727 BTC_TRACE(trace_buf);
3728 halbtc8822b1ant_set_ant_path(btc, BTC_ANT_PATH_AUTO, NM_EXCU,
3729 BT_8822B_1ANT_PHASE_2G);
3730 halbtc8822b1ant_action_bt_whql_test(btc);
3731 return;
3732 }
3733
3734 if (coex_sta->is_setup_link || coex_sta->bt_relink_downcount != 0) {
3735 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3736 "[BTCoex], BT is re-link !!!\n");
3737 BTC_TRACE(trace_buf);
3738 halbtc8822b1ant_set_ant_path(btc, BTC_ANT_PATH_AUTO, NM_EXCU,
3739 BT_8822B_1ANT_PHASE_2G);
3740 halbtc8822b1ant_action_bt_relink(btc);
3741 return;
3742 }
3743
3744 if (coex_sta->c2h_bt_inquiry_page) {
3745 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3746 "[BTCoex], BT is under inquiry/page !!\n");
3747 BTC_TRACE(trace_buf);
3748 halbtc8822b1ant_set_ant_path(btc, BTC_ANT_PATH_AUTO, NM_EXCU,
3749 BT_8822B_1ANT_PHASE_2G);
3750 halbtc8822b1ant_action_bt_inquiry(btc);
3751 return;
3752 }
3753
3754 if ((coex_dm->bt_status == BT_8822B_1ANT_BSTATUS_NCON_IDLE ||
3755 coex_dm->bt_status == BT_8822B_1ANT_BSTATUS_CON_IDLE) &&
3756 wifi_link_info_ext->is_connected) {
3757 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3758 "############# [BTCoex], BT Is idle\n");
3759 BTC_TRACE(trace_buf);
3760 halbtc8822b1ant_action_bt_idle(btc);
3761 return;
3762 }
3763
3764 if (coex_sta->is_wifi_linkscan_process) {
3765 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3766 "[BTCoex], wifi is under linkscan process!!\n");
3767 BTC_TRACE(trace_buf);
3768 halbtc8822b1ant_set_ant_path(btc, BTC_ANT_PATH_AUTO, NM_EXCU,
3769 BT_8822B_1ANT_PHASE_2G);
3770 halbtc8822b1ant_action_wifi_linkscan(btc);
3771 return;
3772 }
3773
3774 if (wifi_connected) {
3775 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3776 "[BTCoex], wifi is under connected!!\n");
3777 BTC_TRACE(trace_buf);
3778 halbtc8822b1ant_set_ant_path(btc, BTC_ANT_PATH_AUTO, NM_EXCU,
3779 BT_8822B_1ANT_PHASE_2G);
3780 halbtc8822b1ant_action_wifi_connected(btc);
3781 } else {
3782 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3783 "[BTCoex], wifi is under not-connected!!\n");
3784 BTC_TRACE(trace_buf);
3785 halbtc8822b1ant_set_ant_path(btc, BTC_ANT_PATH_AUTO, NM_EXCU,
3786 BT_8822B_1ANT_PHASE_2G);
3787 halbtc8822b1ant_action_wifi_not_connected(btc);
3788 }
3789 }
3790
halbtc8822b1ant_init_coex_var(struct btc_coexist * btc)3791 static void halbtc8822b1ant_init_coex_var(struct btc_coexist *btc)
3792 {
3793 struct coex_sta_8822b_1ant *coex_sta = &btc->coex_sta_8822b_1ant;
3794
3795 /* Reset Coex variable */
3796 btc->btc_set(btc, BTC_SET_RESET_COEX_VAR, NULL);
3797
3798 coex_sta->bt_reg_vendor_ac = 0xffff;
3799 coex_sta->bt_reg_vendor_ae = 0xffff;
3800
3801 coex_sta->isolation_btween_wb = BT_8822B_1ANT_DEFAULT_ISOLATION;
3802 btc->bt_info.bt_get_fw_ver = 0;
3803 }
3804
halbtc8822b1ant_init_coex_dm(struct btc_coexist * btc)3805 static void halbtc8822b1ant_init_coex_dm(struct btc_coexist *btc)
3806 {
3807 }
3808
halbtc8822b1ant_init_hw_config(struct btc_coexist * btc,boolean back_up,boolean wifi_only)3809 static void halbtc8822b1ant_init_hw_config(struct btc_coexist *btc,
3810 boolean back_up, boolean wifi_only)
3811 {
3812 struct coex_sta_8822b_1ant *coex_sta = &btc->coex_sta_8822b_1ant;
3813 struct rfe_type_8822b_1ant *rfe_type = &btc->rfe_type_8822b_1ant;
3814 u8 u8tmp = 0, i = 0;
3815 u32 u32tmp1 = 0, u32tmp2 = 0, u32tmp3 = 0;
3816
3817 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE, "[BTCoex], %s()!\n", __func__);
3818 BTC_TRACE(trace_buf);
3819
3820 #if 0
3821 u32tmp3 = btc->btc_read_4byte(btc, 0xcbc);
3822 u32tmp1 = halbtc8822b1ant_read_indirect_reg(btc, 0x38);
3823 u32tmp2 = halbtc8822b1ant_read_indirect_reg(btc, 0x54);
3824
3825 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3826 "[BTCoex], (Before Init HW config) 0xcbc = 0x%x, 0x38= 0x%x, 0x54= 0x%x\n",
3827 u32tmp3, u32tmp1, u32tmp2);
3828 BTC_TRACE(trace_buf);
3829 #endif
3830
3831 halbtc8822b1ant_init_coex_var(btc);
3832
3833 /* Setup RF front end type */
3834 halbtc8822b1ant_set_rfe_type(btc);
3835
3836 if (rfe_type->rfe_module_type == 2 || rfe_type->rfe_module_type == 4)
3837 halbtc8822b1ant_write_scbd(btc, BT_8822B_1ANT_SCBD_EXTFEM,
3838 TRUE);
3839 else
3840 halbtc8822b1ant_write_scbd(btc, BT_8822B_1ANT_SCBD_EXTFEM,
3841 FALSE);
3842
3843 /* 0xf0[15:12] --> kt_ver */
3844 coex_sta->kt_ver = (btc->btc_read_1byte(btc, 0xf1) & 0xf0) >> 4;
3845
3846 /* enable TBTT nterrupt */
3847 btc->btc_write_1byte_bitmask(btc, 0x550, 0x8, 0x1);
3848
3849 /* BT report packet sample rate */
3850 /* 0x790[5:0]=0x5 */
3851 btc->btc_write_1byte(btc, 0x790, 0x5);
3852
3853 /* Enable BT counter statistics */
3854 btc->btc_write_1byte(btc, 0x778, 0x1);
3855
3856 /* Enable PTA (3-wire function form BT side) */
3857 btc->btc_write_1byte_bitmask(btc, 0x40, 0x20, 0x1);
3858 btc->btc_write_1byte_bitmask(btc, 0x41, 0x02, 0x1);
3859
3860 /* Enable PTA (tx/rx signal form WiFi side) */
3861 btc->btc_write_1byte_bitmask(btc, 0x4c6, 0x30, 0x1);
3862 /*GNT_BT=1 while select both */
3863 btc->btc_write_1byte_bitmask(btc, 0x763, 0x10, 0x1);
3864 /* beacon queue always hi-pri */
3865 btc->btc_write_1byte_bitmask(btc, 0x6cf, BIT(3), 0x1);
3866
3867 halbtc8822b1ant_enable_gnt_to_gpio(btc, TRUE);
3868
3869 /* Antenna config */
3870 if (btc->wl_rf_state_off) {
3871 halbtc8822b1ant_set_ant_path(btc, BTC_ANT_PATH_AUTO, FC_EXCU,
3872 BT_8822B_1ANT_PHASE_WOFF);
3873 halbtc8822b1ant_write_scbd(btc, BT_8822B_1ANT_SCBD_ALL, FALSE);
3874 btc->stop_coex_dm = TRUE;
3875
3876 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3877 "[BTCoex], %s: RF Off\n", __func__);
3878 BTC_TRACE(trace_buf);
3879 } else if (wifi_only) {
3880 coex_sta->concurrent_rx_mode_on = FALSE;
3881 halbtc8822b1ant_set_ant_path(btc, BTC_ANT_PATH_WIFI, FC_EXCU,
3882 BT_8822B_1ANT_PHASE_WONLY);
3883 halbtc8822b1ant_write_scbd(btc, BT_8822B_1ANT_SCBD_ACTIVE |
3884 BT_8822B_1ANT_SCBD_ONOFF,
3885 TRUE);
3886 btc->stop_coex_dm = TRUE;
3887 } else {
3888 coex_sta->concurrent_rx_mode_on = TRUE;
3889 halbtc8822b1ant_set_ant_path(btc, BTC_ANT_PATH_AUTO, FC_EXCU,
3890 BT_8822B_1ANT_PHASE_INIT);
3891 halbtc8822b1ant_write_scbd(btc, BT_8822B_1ANT_SCBD_ACTIVE |
3892 BT_8822B_1ANT_SCBD_ONOFF,
3893 TRUE);
3894 btc->stop_coex_dm = FALSE;
3895 }
3896
3897 /* PTA parameter */
3898 halbtc8822b1ant_table(btc, FC_EXCU, 0);
3899 halbtc8822b1ant_tdma(btc, FC_EXCU, FALSE, 8);
3900
3901 halbtc8822b1ant_query_bt_info(btc);
3902
3903 #if 0
3904 u32tmp3 = btc->btc_read_4byte(btc, 0xcbc);
3905 u32tmp1 = halbtc8822b1ant_read_indirect_reg(btc, 0x38);
3906 u32tmp2 = halbtc8822b1ant_read_indirect_reg(btc, 0x54);
3907
3908 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3909 "[BTCoex], (After Init HW config) 0xcbc = 0x%x, 0x38= 0x%x, 0x54= 0x%x\n",
3910 u32tmp3, u32tmp1, u32tmp2);
3911 BTC_TRACE(trace_buf);
3912 #endif
3913 }
3914
ex_halbtc8822b1ant_power_on_setting(struct btc_coexist * btc)3915 void ex_halbtc8822b1ant_power_on_setting(struct btc_coexist *btc)
3916 {
3917 struct coex_sta_8822b_1ant *coex_sta = &btc->coex_sta_8822b_1ant;
3918 struct btc_board_info *board_info = &btc->board_info;
3919 u8 u8tmp = 0x0;
3920 u16 u16tmp = 0x0;
3921
3922 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3923 "[BTCoex], Execute %s !!\n", __func__);
3924 BTC_TRACE(trace_buf);
3925
3926 btc->stop_coex_dm = TRUE;
3927 btc->wl_rf_state_off = FALSE;
3928
3929 /* enable BB, REG_SYS_FUNC_EN such that we can write 0x948 correctly. */
3930 u16tmp = btc->btc_read_2byte(btc, 0x2);
3931 btc->btc_write_2byte(btc, 0x2, u16tmp | BIT(0) | BIT(1));
3932
3933 /* Setup RF front end type */
3934 halbtc8822b1ant_set_rfe_type(btc);
3935
3936 /* Set Antenna Path to BT side */
3937 halbtc8822b1ant_set_ant_path(btc, BTC_ANT_PATH_AUTO, FC_EXCU,
3938 BT_8822B_1ANT_PHASE_POWERON);
3939
3940 halbtc8822b1ant_table(btc, FC_EXCU, 0);
3941
3942 /* set WLAN_ACT = 0 */
3943 /* btc->btc_write_1byte(btc, 0x76e, 0x4); */
3944
3945 /* SD1 Chunchu red x issue */
3946 btc->btc_write_1byte(btc, 0xff1a, 0x0);
3947
3948 halbtc8822b1ant_enable_gnt_to_gpio(btc, TRUE);
3949
3950 /* S0 or S1 setting and Local register setting
3951 * (By the setting fw can get ant number, S0/S1, ... info)
3952 * Local setting bit define
3953 * BIT0: "0" for no antenna inverse; "1" for antenna inverse
3954 * BIT1: "0" for internal switch; "1" for external switch
3955 * BIT2: "0" for one antenna; "1" for two antenna
3956 * NOTE: here default all internal switch and 1-antenna ==>
3957 * BIT1=0 and BIT2=0
3958 */
3959
3960 u8tmp = 0;
3961 board_info->btdm_ant_pos = BTC_ANTENNA_AT_MAIN_PORT;
3962
3963 if (btc->chip_interface == BTC_INTF_PCI)
3964 btc->btc_write_local_reg_1byte(btc, 0x3e0, u8tmp);
3965 else if (btc->chip_interface == BTC_INTF_USB)
3966 btc->btc_write_local_reg_1byte(btc, 0xfe08, u8tmp);
3967 else if (btc->chip_interface == BTC_INTF_SDIO)
3968 btc->btc_write_local_reg_1byte(btc, 0x60, u8tmp);
3969
3970 #if 0
3971 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3972 "[BTCoex], LTE coex Reg 0x38 (Power-On) = 0x%x\n",
3973 halbtc8822b1ant_read_indirect_reg(btc, 0x38));
3974 BTC_TRACE(trace_buf);
3975
3976 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3977 "[BTCoex], MACReg 0x70/ BBReg 0xcbc (Power-On) = 0x%x/ 0x%x\n",
3978 btc->btc_read_4byte(btc, 0x70),
3979 btc->btc_read_4byte(btc, 0xcbc));
3980 BTC_TRACE(trace_buf);
3981 #endif
3982 }
3983
ex_halbtc8822b1ant_pre_load_firmware(struct btc_coexist * btc)3984 void ex_halbtc8822b1ant_pre_load_firmware(struct btc_coexist *btc) {}
3985
ex_halbtc8822b1ant_init_hw_config(struct btc_coexist * btc,boolean wifi_only)3986 void ex_halbtc8822b1ant_init_hw_config(struct btc_coexist *btc,
3987 boolean wifi_only)
3988 {
3989 halbtc8822b1ant_init_hw_config(btc, TRUE, wifi_only);
3990 }
3991
ex_halbtc8822b1ant_init_coex_dm(struct btc_coexist * btc)3992 void ex_halbtc8822b1ant_init_coex_dm(struct btc_coexist *btc)
3993 {
3994 btc->stop_coex_dm = FALSE;
3995 btc->auto_report = TRUE;
3996 btc->dbg_mode = FALSE;
3997
3998 halbtc8822b1ant_init_coex_dm(btc);
3999 }
4000
ex_halbtc8822b1ant_display_simple_coex_info(struct btc_coexist * btc)4001 void ex_halbtc8822b1ant_display_simple_coex_info(struct btc_coexist *btc)
4002 {
4003 struct coex_sta_8822b_1ant *coex_sta = &btc->coex_sta_8822b_1ant;
4004 struct coex_dm_8822b_1ant *coex_dm = &btc->coex_dm_8822b_1ant;
4005 struct rfe_type_8822b_1ant *rfe_type = &btc->rfe_type_8822b_1ant;
4006 struct btc_board_info *board_info = &btc->board_info;
4007 struct btc_bt_link_info *bt_link_info = &btc->bt_link_info;
4008
4009 u8 *cli_buf = btc->cli_buf;
4010 u32 bt_patch_ver = 0, bt_coex_ver = 0;
4011 static u8 cnt;
4012 u8 * const p = &coex_sta->bt_afh_map[0];
4013
4014 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n _____[BT Coexist info]____");
4015 CL_PRINTF(cli_buf);
4016
4017 if (btc->manual_control) {
4018 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4019 "\r\n __[Under Manual Control]_");
4020 CL_PRINTF(cli_buf);
4021 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4022 "\r\n _________________________");
4023 CL_PRINTF(cli_buf);
4024 }
4025
4026 if (btc->stop_coex_dm) {
4027 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4028 "\r\n ____[Coex is STOPPED]____");
4029 CL_PRINTF(cli_buf);
4030 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4031 "\r\n _________________________");
4032 CL_PRINTF(cli_buf);
4033 }
4034
4035 if (!coex_sta->bt_disabled &&
4036 (coex_sta->bt_coex_supported_version == 0 ||
4037 coex_sta->bt_coex_supported_version == 0xffff) &&
4038 cnt == 0) {
4039 btc->btc_get(btc, BTC_GET_U4_SUPPORTED_FEATURE,
4040 &coex_sta->bt_coex_supported_feature);
4041
4042 btc->btc_get(btc, BTC_GET_U4_SUPPORTED_VERSION,
4043 &coex_sta->bt_coex_supported_version);
4044
4045 coex_sta->bt_reg_vendor_ac = (u16)(btc->btc_get_bt_reg(btc, 3,
4046 0xac) &
4047 0xffff);
4048
4049 coex_sta->bt_reg_vendor_ae = (u16)(btc->btc_get_bt_reg(btc, 3,
4050 0xae) &
4051 0xffff);
4052
4053 btc->btc_get(btc, BTC_GET_U4_BT_PATCH_VER, &bt_patch_ver);
4054 btc->bt_info.bt_get_fw_ver = bt_patch_ver;
4055
4056 if (coex_sta->num_of_profile > 0)
4057 btc->btc_get_bt_afh_map_from_bt(btc, 0, p);
4058 }
4059
4060 if (++cnt >= 3)
4061 cnt = 0;
4062
4063 /* BT coex. info. */
4064 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4065 "\r\n %-35s = %d/ %d/ %s / %d",
4066 "Ant PG Num/ Mech/ Pos/ RFE", board_info->pg_ant_num,
4067 board_info->btdm_ant_num,
4068 (board_info->btdm_ant_pos ==
4069 BTC_ANTENNA_AT_MAIN_PORT ? "Main" : "Aux"),
4070 rfe_type->rfe_module_type);
4071 CL_PRINTF(cli_buf);
4072
4073 bt_coex_ver = ((coex_sta->bt_coex_supported_version & 0xff00) >> 8);
4074
4075 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4076 "\r\n %-35s = %d_%02x/ 0x%02x/ 0x%02x (%s)",
4077 "CoexVer WL/ BT_Desired/ BT_Report",
4078 glcoex_ver_date_8822b_1ant, glcoex_ver_8822b_1ant,
4079 glcoex_ver_btdesired_8822b_1ant, bt_coex_ver,
4080 (bt_coex_ver == 0xff ?
4081 "Unknown" :
4082 (coex_sta->bt_disabled ?
4083 "BT-disable" :
4084 (bt_coex_ver >= glcoex_ver_btdesired_8822b_1ant ?
4085 "Match" :
4086 "Mis-Match"))));
4087 CL_PRINTF(cli_buf);
4088
4089 /* BT Status */
4090 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %s", "BT status",
4091 ((coex_sta->bt_disabled) ?
4092 ("disabled") :
4093 ((coex_sta->c2h_bt_inquiry_page) ?
4094 ("inquiry/page") :
4095 ((BT_8822B_1ANT_BSTATUS_NCON_IDLE ==
4096 coex_dm->bt_status) ?
4097 "non-connected idle" :
4098 ((coex_dm->bt_status ==
4099 BT_8822B_1ANT_BSTATUS_CON_IDLE) ?
4100 "connected-idle" :
4101 "busy")))));
4102 CL_PRINTF(cli_buf);
4103
4104 /* HW Settings */
4105 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d/ %d",
4106 "0x770(Hi-pri rx/tx)", coex_sta->high_priority_rx,
4107 coex_sta->high_priority_tx);
4108 CL_PRINTF(cli_buf);
4109
4110 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d/ %d %s",
4111 "0x774(Lo-pri rx/tx)", coex_sta->low_priority_rx,
4112 coex_sta->low_priority_tx,
4113 (bt_link_info->slave_role ? "(Slave!!)" : " "));
4114 CL_PRINTF(cli_buf);
4115 }
4116
ex_halbtc8822b1ant_display_coex_info(struct btc_coexist * btc)4117 void ex_halbtc8822b1ant_display_coex_info(struct btc_coexist *btc)
4118 {
4119 struct coex_sta_8822b_1ant *coex_sta = &btc->coex_sta_8822b_1ant;
4120 struct coex_dm_8822b_1ant *coex_dm = &btc->coex_dm_8822b_1ant;
4121 struct rfe_type_8822b_1ant *rfe_type = &btc->rfe_type_8822b_1ant;
4122 struct btc_board_info *board_info = &btc->board_info;
4123 struct btc_bt_link_info *bt_link_info = &btc->bt_link_info;
4124
4125 u8 *cli_buf = btc->cli_buf;
4126 u8 u8tmp[4], i, ps_tdma_case = 0;
4127 u16 u16tmp[4];
4128 u32 u32tmp[4];
4129 u32 fa_ofdm, fa_cck, cca_ofdm, cca_cck;
4130 u32 fw_ver = 0, bt_patch_ver = 0, bt_coex_ver = 0;
4131 static u8 pop_report_in_10s;
4132 u32 phyver = 0, val = 0;
4133 boolean lte_coex_on = FALSE, is_bt_reply = FALSE;
4134 static u8 cnt;
4135 u8 * const p = &coex_sta->bt_afh_map[0];
4136
4137 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4138 "\r\n ============[BT Coexist info 8822B]============");
4139 CL_PRINTF(cli_buf);
4140
4141 if (btc->manual_control) {
4142 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4143 "\r\n ============[Under Manual Control]============");
4144 CL_PRINTF(cli_buf);
4145 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4146 "\r\n ==========================================");
4147 CL_PRINTF(cli_buf);
4148 } else if (btc->stop_coex_dm) {
4149 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4150 "\r\n ============[Coex is STOPPED]============");
4151 CL_PRINTF(cli_buf);
4152 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4153 "\r\n ==========================================");
4154 CL_PRINTF(cli_buf);
4155 } else if (!coex_sta->run_time_state) {
4156 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4157 "\r\n ============[Run Time State = False]============");
4158 CL_PRINTF(cli_buf);
4159 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4160 "\r\n ==========================================");
4161 CL_PRINTF(cli_buf);
4162 } else if (coex_sta->freeze_coexrun_by_btinfo) {
4163 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4164 "\r\n ============[freeze_coexrun_by_btinfo]============");
4165 CL_PRINTF(cli_buf);
4166 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4167 "\r\n ==========================================");
4168 CL_PRINTF(cli_buf);
4169 }
4170
4171 if (!coex_sta->bt_disabled && cnt == 0) {
4172 if (coex_sta->bt_coex_supported_version == 0 ||
4173 coex_sta->bt_coex_supported_version == 0xffff) {
4174 btc->btc_get(btc, BTC_GET_U4_SUPPORTED_VERSION,
4175 &coex_sta->bt_coex_supported_version);
4176
4177 if (coex_sta->bt_coex_supported_version > 0 &&
4178 coex_sta->bt_coex_supported_version < 0xffff)
4179 is_bt_reply = TRUE;
4180 } else {
4181 is_bt_reply = TRUE;
4182 }
4183
4184 if (coex_sta->num_of_profile > 0)
4185 btc->btc_get_bt_afh_map_from_bt(btc, 0, p);
4186 }
4187
4188 if (is_bt_reply) {
4189 if (coex_sta->bt_coex_supported_feature == 0)
4190 btc->btc_get(btc, BTC_GET_U4_SUPPORTED_FEATURE,
4191 &coex_sta->bt_coex_supported_feature);
4192
4193 if (coex_sta->bt_reg_vendor_ac == 0xffff) {
4194 val = btc->btc_get_bt_reg(btc, 3, 0xac);
4195 coex_sta->bt_reg_vendor_ac = (u16)(val & 0xffff);
4196 }
4197
4198 if (coex_sta->bt_reg_vendor_ae == 0xffff) {
4199 val = btc->btc_get_bt_reg(btc, 3, 0xae);
4200 coex_sta->bt_reg_vendor_ae = (u16)(val & 0xffff);
4201 }
4202
4203 if (btc->bt_info.bt_get_fw_ver == 0) {
4204 btc->btc_get(btc, BTC_GET_U4_BT_PATCH_VER,
4205 &bt_patch_ver);
4206 btc->bt_info.bt_get_fw_ver = bt_patch_ver;
4207 }
4208 }
4209
4210 if (++cnt >= 3)
4211 cnt = 0;
4212
4213 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d/ %s/ %s / %d",
4214 "Ant PG Num/ Mech/ Pos/ RFE", board_info->pg_ant_num,
4215 (board_info->btdm_ant_num == 1 ? "Shared" : "Non-Shared"),
4216 (board_info->btdm_ant_pos == BTC_ANTENNA_AT_MAIN_PORT ?
4217 "Main" :
4218 "Aux"),
4219 rfe_type->rfe_module_type);
4220 CL_PRINTF(cli_buf);
4221
4222 bt_patch_ver = btc->bt_info.bt_get_fw_ver;
4223 btc->btc_get(btc, BTC_GET_U4_WIFI_FW_VER, &fw_ver);
4224 phyver = btc->btc_get_bt_phydm_version(btc);
4225 bt_coex_ver = ((coex_sta->bt_coex_supported_version & 0xff00) >> 8);
4226
4227 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4228 "\r\n %-35s = %d_%02x/ 0x%02x/ 0x%02x (%s)",
4229 "CoexVer WL/ BT_Desired/ BT_Report",
4230 glcoex_ver_date_8822b_1ant, glcoex_ver_8822b_1ant,
4231 glcoex_ver_btdesired_8822b_1ant, bt_coex_ver,
4232 (bt_coex_ver == 0xff ?
4233 "Unknown" :
4234 (coex_sta->bt_disabled ?
4235 "BT-disable" :
4236 (bt_coex_ver >= glcoex_ver_btdesired_8822b_1ant ?
4237 "Match" :
4238 "Mis-Match"))));
4239 CL_PRINTF(cli_buf);
4240
4241 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = 0x%x/ 0x%x/ v%d/ %c",
4242 "W_FW/ B_FW/ Phy/ Kt", fw_ver, bt_patch_ver, phyver,
4243 coex_sta->kt_ver + 65);
4244 CL_PRINTF(cli_buf);
4245
4246 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4247 "\r\n %-35s = %02x %02x %02x (RF-Ch = %d)", "AFH Map to BT",
4248 coex_dm->wifi_chnl_info[0], coex_dm->wifi_chnl_info[1],
4249 coex_dm->wifi_chnl_info[2], coex_sta->wl_center_channel);
4250 CL_PRINTF(cli_buf);
4251
4252 /* wifi status */
4253 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s",
4254 "============[Wifi Status]============");
4255 CL_PRINTF(cli_buf);
4256 btc->btc_disp_dbg_msg(btc, BTC_DBG_DISP_WIFI_STATUS);
4257
4258 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s",
4259 "============[BT Status]============");
4260 CL_PRINTF(cli_buf);
4261
4262 pop_report_in_10s++;
4263 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %s/ %ddBm/ %d/ %d",
4264 "BT status/ rssi/ retryCnt/ popCnt",
4265 ((coex_sta->bt_disabled) ? ("disabled") :
4266 ((coex_sta->c2h_bt_inquiry_page) ?
4267 ("inquiry-page") :
4268 ((BT_8822B_1ANT_BSTATUS_NCON_IDLE ==
4269 coex_dm->bt_status) ?
4270 "non-connecte-idle" :
4271 ((coex_dm->bt_status ==
4272 BT_8822B_1ANT_BSTATUS_CON_IDLE) ?
4273 "connected-idle" :
4274 "busy")))),
4275 coex_sta->bt_rssi - 100, coex_sta->bt_retry_cnt,
4276 coex_sta->pop_event_cnt);
4277 CL_PRINTF(cli_buf);
4278
4279 if (pop_report_in_10s >= 5) {
4280 coex_sta->pop_event_cnt = 0;
4281 pop_report_in_10s = 0;
4282 }
4283
4284 if (coex_sta->num_of_profile != 0)
4285 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4286 "\r\n %-35s = %s%s%s%s%s%s (multilink = %d)",
4287 "Profiles", ((bt_link_info->a2dp_exist) ?
4288 ((coex_sta->is_bt_a2dp_sink) ?
4289 "A2DP sink," :
4290 "A2DP,") :
4291 ""),
4292 ((bt_link_info->sco_exist) ? "HFP," : ""),
4293 ((bt_link_info->hid_exist) ?
4294 ((coex_sta->is_hid_rcu) ?
4295 "HID(RCU)" :
4296 ((coex_sta->hid_busy_num >= 2) ?
4297 "HID(4/18)," :
4298 "HID(2/18),")) :
4299 ""),
4300 ((bt_link_info->pan_exist) ?
4301 ((coex_sta->is_bt_opp_exist) ? "OPP," :
4302 "PAN,") :
4303 ""),
4304 ((coex_sta->voice_over_HOGP) ? "Voice," : ""),
4305 ((coex_sta->msft_mr_exist) ? "MR" : ""),
4306 coex_sta->is_bt_multi_link);
4307 else
4308 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %s",
4309 "Profiles",
4310 (coex_sta->msft_mr_exist) ? "MR" : "None");
4311
4312 CL_PRINTF(cli_buf);
4313
4314 if (bt_link_info->a2dp_exist) {
4315 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4316 "\r\n %-35s = %s/ %d/ 0x%x/ 0x%x/ %d",
4317 "CQDDR/Bitpool/V_ID/D_name/flush",
4318 ((coex_sta->is_A2DP_3M) ? "On" : "Off"),
4319 coex_sta->a2dp_bit_pool,
4320 coex_sta->bt_a2dp_vendor_id,
4321 coex_sta->bt_a2dp_device_name,
4322 coex_sta->bt_a2dp_flush_time);
4323 CL_PRINTF(cli_buf);
4324 }
4325
4326 if (bt_link_info->hid_exist) {
4327 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d",
4328 "HID PairNum", coex_sta->hid_pair_cnt);
4329 CL_PRINTF(cli_buf);
4330 }
4331
4332 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %s/ %d/ %s/ 0x%x",
4333 "Role/RoleSwCnt/IgnWlact/Feature",
4334 ((bt_link_info->slave_role) ? "Slave" : "Master"),
4335 coex_sta->cnt_role_switch,
4336 ((coex_dm->cur_ignore_wlan_act) ? "Yes" : "No"),
4337 coex_sta->bt_coex_supported_feature);
4338 CL_PRINTF(cli_buf);
4339
4340 if (coex_sta->is_ble_scan_en) {
4341 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4342 "\r\n %-35s = 0x%x/ 0x%x/ 0x%x/ 0x%x",
4343 "BLEScan Type/TV/Init/Ble",
4344 coex_sta->bt_ble_scan_type,
4345 (coex_sta->bt_ble_scan_type & 0x1 ?
4346 coex_sta->bt_ble_scan_para[0] :
4347 0x0),
4348 (coex_sta->bt_ble_scan_type & 0x2 ?
4349 coex_sta->bt_ble_scan_para[1] :
4350 0x0),
4351 (coex_sta->bt_ble_scan_type & 0x4 ?
4352 coex_sta->bt_ble_scan_para[2] :
4353 0x0));
4354 CL_PRINTF(cli_buf);
4355 }
4356
4357 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4358 "\r\n %-35s = %d/ %d/ %d/ %d/ %d %s",
4359 "ReInit/ReLink/IgnWlact/Page/NameReq", coex_sta->cnt_reinit,
4360 coex_sta->cnt_setup_link, coex_sta->cnt_ign_wlan_act,
4361 coex_sta->cnt_page, coex_sta->cnt_remote_name_req,
4362 (coex_sta->is_setup_link ? "(Relink!!)" : ""));
4363 CL_PRINTF(cli_buf);
4364
4365 halbtc8822b1ant_read_scbd(btc, &u16tmp[0]);
4366
4367 if (coex_sta->bt_reg_vendor_ae == 0xffff ||
4368 coex_sta->bt_reg_vendor_ac == 0xffff)
4369 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4370 "\r\n %-35s = x/ x/ 0x%04x",
4371 "0xae[4]/0xac[1:0]/ScBd(B->W)", u16tmp[0]);
4372 else
4373 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4374 "\r\n %-35s = 0x%x/ 0x%x/ 0x%04x",
4375 "0xae[4]/0xac[1:0]/ScBd(B->W)",
4376 (int)((coex_sta->bt_reg_vendor_ae & BIT(4)) >> 4),
4377 coex_sta->bt_reg_vendor_ac & 0x3, u16tmp[0]);
4378 CL_PRINTF(cli_buf);
4379
4380 if (coex_sta->num_of_profile > 0) {
4381 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4382 "\r\n %-35s = %02x%02x%02x%02x %02x%02x%02x%02x %02x%02x",
4383 "AFH MAP", coex_sta->bt_afh_map[0],
4384 coex_sta->bt_afh_map[1], coex_sta->bt_afh_map[2],
4385 coex_sta->bt_afh_map[3], coex_sta->bt_afh_map[4],
4386 coex_sta->bt_afh_map[5], coex_sta->bt_afh_map[6],
4387 coex_sta->bt_afh_map[7], coex_sta->bt_afh_map[8],
4388 coex_sta->bt_afh_map[9]);
4389 CL_PRINTF(cli_buf);
4390 }
4391
4392 for (i = 0; i < BT_8822B_1ANT_INFO_SRC_MAX; i++) {
4393 if (coex_sta->bt_info_c2h_cnt[i]) {
4394 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4395 "\r\n %-35s = %02x %02x %02x %02x %02x %02x %02x (%d)",
4396 glbt_info_src_8822b_1ant[i],
4397 coex_sta->bt_info_c2h[i][0],
4398 coex_sta->bt_info_c2h[i][1],
4399 coex_sta->bt_info_c2h[i][2],
4400 coex_sta->bt_info_c2h[i][3],
4401 coex_sta->bt_info_c2h[i][4],
4402 coex_sta->bt_info_c2h[i][5],
4403 coex_sta->bt_info_c2h[i][6],
4404 coex_sta->bt_info_c2h_cnt[i]);
4405 CL_PRINTF(cli_buf);
4406 }
4407 }
4408
4409 if (btc->manual_control)
4410 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s",
4411 "============[mechanisms] (before Manual)============");
4412 else
4413 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s",
4414 "============[Mechanisms]============");
4415
4416 CL_PRINTF(cli_buf);
4417
4418 ps_tdma_case = coex_dm->cur_ps_tdma;
4419 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4420 "\r\n %-35s = %02x %02x %02x %02x %02x (case-%d, %s)",
4421 "TDMA",
4422 coex_dm->ps_tdma_para[0], coex_dm->ps_tdma_para[1],
4423 coex_dm->ps_tdma_para[2], coex_dm->ps_tdma_para[3],
4424 coex_dm->ps_tdma_para[4], ps_tdma_case,
4425 (coex_dm->cur_ps_tdma_on ? "TDMA-On" : "TDMA-Off"));
4426 CL_PRINTF(cli_buf);
4427
4428 switch (coex_sta->wl_coex_mode) {
4429 case BT_8822B_1ANT_WLINK_2G1PORT:
4430 default:
4431 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4432 "\r\n %-35s = %s", "Coex_Mode", "2G-SP");
4433 break;
4434 case BT_8822B_1ANT_WLINK_2GMPORT:
4435 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4436 "\r\n %-35s = %s", "Coex_Mode", "2G-MP");
4437 break;
4438 case BT_8822B_1ANT_WLINK_25GMPORT:
4439 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4440 "\r\n %-35s = %s", "Coex_Mode", "25G-MP");
4441 break;
4442 case BT_8822B_1ANT_WLINK_5G:
4443 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4444 "\r\n %-35s = %s", "Coex_Mode", "5G");
4445 break;
4446 case BT_8822B_1ANT_WLINK_2GGO:
4447 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4448 "\r\n %-35s = %s", "Coex_Mode", "2G-P2PGo");
4449 break;
4450 case BT_8822B_1ANT_WLINK_2GGC:
4451 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4452 "\r\n %-35s = %s", "Coex_Mode", "2G-P2PGC");
4453 break;
4454 case BT_8822B_1ANT_WLINK_BTMR:
4455 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4456 "\r\n %-35s = %s", "Coex_Mode", "BT-MR");
4457 break;
4458 }
4459
4460 CL_PRINTF(cli_buf);
4461
4462 u32tmp[0] = btc->btc_read_4byte(btc, 0x6c0);
4463 u32tmp[1] = btc->btc_read_4byte(btc, 0x6c4);
4464 u32tmp[2] = btc->btc_read_4byte(btc, 0x6c8);
4465 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4466 "\r\n %-35s = %d/ 0x%x/ 0x%x/ 0x%x",
4467 "Table/0x6c0/0x6c4/0x6c8", coex_sta->coex_table_type,
4468 u32tmp[0], u32tmp[1], u32tmp[2]);
4469 CL_PRINTF(cli_buf);
4470
4471 u8tmp[0] = btc->btc_read_1byte(btc, 0x778);
4472 u32tmp[0] = btc->btc_read_4byte(btc, 0x6cc);
4473 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4474 "\r\n %-35s = 0x%x/ 0x%x/ 0x%04x/ %d/ %d",
4475 "0x778/0x6cc/ScBd(W->B)/RunCnt/Rsn", u8tmp[0], u32tmp[0],
4476 coex_sta->score_board_WB, coex_sta->coex_run_cnt,
4477 coex_sta->coex_run_reason);
4478 CL_PRINTF(cli_buf);
4479
4480 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %s/ %s/ %s/ %d/ %d",
4481 "AntDiv/BtCtrlLPS/LPRA/PsFail/g_busy",
4482 ((board_info->ant_div_cfg) ? "On" : "Off"),
4483 ((coex_sta->force_lps_ctrl) ? "On" : "Off"),
4484 ((coex_dm->cur_low_penalty_ra) ? "On" : "Off"),
4485 coex_sta->cnt_set_ps_state_fail, coex_sta->gl_wifi_busy);
4486 CL_PRINTF(cli_buf);
4487
4488 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d/ %d/ %d/ %d/ %d",
4489 "Null All/Retry/Ack/BT_Empty/BT_Late",
4490 coex_sta->wl_fw_dbg_info[1], coex_sta->wl_fw_dbg_info[2],
4491 coex_sta->wl_fw_dbg_info[3], coex_sta->wl_fw_dbg_info[4],
4492 coex_sta->wl_fw_dbg_info[5]);
4493 CL_PRINTF(cli_buf);
4494
4495 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d/ %d/ %s/ %d",
4496 "cnt TDMA_Togg/LK5ms/LK5ms_off/fw",
4497 coex_sta->wl_fw_dbg_info[6], coex_sta->wl_fw_dbg_info[7],
4498 ((coex_sta->is_no_wl_5ms_extend) ? "Yes" : "No"),
4499 coex_sta->cnt_wl_fw_notify);
4500 CL_PRINTF(cli_buf);
4501
4502 u32tmp[0] = halbtc8822b1ant_read_indirect_reg(btc, 0x38);
4503 lte_coex_on = ((u32tmp[0] & BIT(7)) >> 7) ? TRUE : FALSE;
4504
4505 if (lte_coex_on) {
4506 u32tmp[0] = halbtc8822b1ant_read_indirect_reg(btc, 0xa0);
4507 u32tmp[1] = halbtc8822b1ant_read_indirect_reg(btc, 0xa4);
4508
4509 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = 0x%x/ 0x%x",
4510 "LTE Coex Table W_L/B_L", u32tmp[0] & 0xffff,
4511 u32tmp[1] & 0xffff);
4512 CL_PRINTF(cli_buf);
4513
4514 u32tmp[0] = halbtc8822b1ant_read_indirect_reg(btc, 0xa8);
4515 u32tmp[1] = halbtc8822b1ant_read_indirect_reg(btc, 0xac);
4516 u32tmp[2] = halbtc8822b1ant_read_indirect_reg(btc, 0xb0);
4517 u32tmp[3] = halbtc8822b1ant_read_indirect_reg(btc, 0xb4);
4518
4519 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4520 "\r\n %-35s = 0x%x/ 0x%x/ 0x%x/ 0x%x",
4521 "LTE Break Table W_L/B_L/L_W/L_B",
4522 u32tmp[0] & 0xffff, u32tmp[1] & 0xffff,
4523 u32tmp[2] & 0xffff, u32tmp[3] & 0xffff);
4524 CL_PRINTF(cli_buf);
4525 }
4526
4527 /* Hw setting */
4528 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s",
4529 "============[Hw setting]============");
4530 CL_PRINTF(cli_buf);
4531
4532 u32tmp[0] = halbtc8822b1ant_read_indirect_reg(btc, 0x38);
4533 u32tmp[1] = halbtc8822b1ant_read_indirect_reg(btc, 0x54);
4534 u8tmp[0] = btc->btc_read_1byte(btc, 0x73);
4535
4536 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %s/ %s",
4537 "LTE Coex/Path Owner", ((lte_coex_on) ? "On" : "Off"),
4538 ((u8tmp[0] & BIT(2)) ? "WL" : "BT"));
4539 CL_PRINTF(cli_buf);
4540
4541 if (lte_coex_on) {
4542 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4543 "\r\n %-35s = %d/ %d/ %d/ %d",
4544 "LTE 3Wire/OPMode/UART/UARTMode",
4545 (int)((u32tmp[0] & BIT(6)) >> 6),
4546 (int)((u32tmp[0] & (BIT(5) | BIT(4))) >> 4),
4547 (int)((u32tmp[0] & BIT(3)) >> 3),
4548 (int)(u32tmp[0] & (BIT(2) | BIT(1) | BIT(0))));
4549 CL_PRINTF(cli_buf);
4550
4551 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d/ %d",
4552 "LTE_Busy/UART_Busy",
4553 (int)((u32tmp[1] & BIT(1)) >> 1),
4554 (int)(u32tmp[1] & BIT(0)));
4555 CL_PRINTF(cli_buf);
4556 }
4557 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4558 "\r\n %-35s = %s (BB:%s)/ %s (BB:%s)/ %s (gnt_err = %d)",
4559 "GNT_WL_Ctrl/GNT_BT_Ctrl/Dbg",
4560 ((u32tmp[0] & BIT(12)) ? "SW" : "HW"),
4561 ((u32tmp[0] & BIT(8)) ? "SW" : "HW"),
4562 ((u32tmp[0] & BIT(14)) ? "SW" : "HW"),
4563 ((u32tmp[0] & BIT(10)) ? "SW" : "HW"),
4564 ((u8tmp[0] & BIT(3)) ? "On" : "Off"),
4565 coex_sta->gnt_error_cnt);
4566 CL_PRINTF(cli_buf);
4567
4568 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d/ %d",
4569 "GNT_WL/GNT_BT", (int)((u32tmp[1] & BIT(2)) >> 2),
4570 (int)((u32tmp[1] & BIT(3)) >> 3));
4571 CL_PRINTF(cli_buf);
4572
4573 u32tmp[0] = btc->btc_read_4byte(btc, 0xcb0);
4574 u32tmp[1] = btc->btc_read_4byte(btc, 0xcb4);
4575 u8tmp[0] = btc->btc_read_1byte(btc, 0xcba);
4576 u8tmp[1] = btc->btc_read_1byte(btc, 0xcbd);
4577 u8tmp[2] = btc->btc_read_1byte(btc, 0xc58);
4578
4579 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4580 "\r\n %-35s = 0x%04x/ 0x%04x/ 0x%02x/ 0x%02x/ 0x%02x %s",
4581 "0xcb0/0xcb4/0xcba/0xcbd/0xc58", u32tmp[0], u32tmp[1],
4582 u8tmp[0], u8tmp[1], u8tmp[2],
4583 ((u8tmp[1] & 0x1) == 0x1 ? "(BT_WL5G)" : "(WL2G)"));
4584 CL_PRINTF(cli_buf);
4585
4586 u32tmp[0] = btc->btc_read_4byte(btc, 0x430);
4587 u32tmp[1] = btc->btc_read_4byte(btc, 0x434);
4588 u16tmp[0] = btc->btc_read_2byte(btc, 0x42a);
4589 u8tmp[0] = btc->btc_read_1byte(btc, 0x426);
4590 u8tmp[1] = btc->btc_read_1byte(btc, 0x45e);
4591 u8tmp[2] = btc->btc_read_1byte(btc, 0x455);
4592 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4593 "\r\n %-35s = 0x%x/ 0x%x/ 0x%x/ 0x%x/ 0x%x/ 0x%x",
4594 "430/434/42a/426/45e[3]/455",
4595 u32tmp[0], u32tmp[1], u16tmp[0], u8tmp[0],
4596 (int)((u8tmp[1] & BIT(3)) >> 3), u8tmp[2]);
4597 CL_PRINTF(cli_buf);
4598
4599 u32tmp[0] = btc->btc_read_4byte(btc, 0x4c);
4600 u8tmp[2] = btc->btc_read_1byte(btc, 0x64);
4601 u8tmp[0] = btc->btc_read_1byte(btc, 0x4c6);
4602 u8tmp[1] = btc->btc_read_1byte(btc, 0x40);
4603
4604 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4605 "\r\n %-35s = 0x%x/ 0x%x/ 0x%x/ 0x%x",
4606 "4c[24:23]/64[0]/4c6[4]/40[5]",
4607 (int)(u32tmp[0] & (BIT(24) | BIT(23))) >> 23, u8tmp[2] & 0x1,
4608 (int)((u8tmp[0] & BIT(4)) >> 4),
4609 (int)((u8tmp[1] & BIT(5)) >> 5));
4610 CL_PRINTF(cli_buf);
4611
4612 u32tmp[0] = btc->btc_read_4byte(btc, 0x550);
4613 u8tmp[0] = btc->btc_read_1byte(btc, 0x522);
4614 u8tmp[1] = btc->btc_read_1byte(btc, 0x953);
4615 u8tmp[2] = btc->btc_read_1byte(btc, 0xc50);
4616
4617 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4618 "\r\n %-35s = 0x%x/ 0x%x/ %s/ 0x%x",
4619 "0x550/0x522/4-RxAGC/0xc50", u32tmp[0], u8tmp[0],
4620 (u8tmp[1] & 0x2) ? "On" : "Off", u8tmp[2]);
4621 CL_PRINTF(cli_buf);
4622
4623 fa_ofdm = btc->btc_phydm_query_PHY_counter(btc, PHYDM_INFO_FA_OFDM);
4624 fa_cck = btc->btc_phydm_query_PHY_counter(btc, PHYDM_INFO_FA_CCK);
4625 cca_ofdm = btc->btc_phydm_query_PHY_counter(btc, PHYDM_INFO_CCA_OFDM);
4626 cca_cck = btc->btc_phydm_query_PHY_counter(btc, PHYDM_INFO_CCA_CCK);
4627
4628 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4629 "\r\n %-35s = 0x%x/ 0x%x/ 0x%x/ 0x%x",
4630 "CCK-CCA/CCK-FA/OFDM-CCA/OFDM-FA", cca_cck, fa_cck, cca_ofdm,
4631 fa_ofdm);
4632 CL_PRINTF(cli_buf);
4633
4634 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d/ %d/ %d/ %d",
4635 "CRC_OK CCK/11g/11n/11ac",
4636 coex_sta->crc_ok_cck, coex_sta->crc_ok_11g,
4637 coex_sta->crc_ok_11n, coex_sta->crc_ok_11n_vht);
4638 CL_PRINTF(cli_buf);
4639
4640 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d/ %d/ %d/ %d",
4641 "CRC_Err CCK/11g/11n/11ac",
4642 coex_sta->crc_err_cck, coex_sta->crc_err_11g,
4643 coex_sta->crc_err_11n, coex_sta->crc_err_11n_vht);
4644 CL_PRINTF(cli_buf);
4645
4646 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4647 "\r\n %-35s = %d/ %d/ %s-%d/ %d (Tx macid: %d)",
4648 "Rate RxD/RxRTS/TxD/TxRetry_ratio",
4649 coex_sta->wl_rx_rate, coex_sta->wl_rts_rx_rate,
4650 (coex_sta->wl_tx_rate & 0x80 ? "SGI" : "LGI"),
4651 coex_sta->wl_tx_rate & 0x7f,
4652 coex_sta->wl_tx_retry_ratio,
4653 coex_sta->wl_tx_macid);
4654 CL_PRINTF(cli_buf);
4655
4656 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %s/ %s/ %s/ %s/ %d",
4657 "HiPr/ Locking/ warn/ Locked/ Noisy",
4658 (coex_sta->wifi_high_pri_task1 ? "Yes" : "No"),
4659 (coex_sta->cck_lock ? "Yes" : "No"),
4660 (coex_sta->cck_lock_warn ? "Yes" : "No"),
4661 (coex_sta->cck_lock_ever ? "Yes" : "No"),
4662 coex_sta->wl_noisy_level);
4663 CL_PRINTF(cli_buf);
4664
4665 u8tmp[0] = btc->btc_read_1byte(btc, 0xf8e);
4666 u8tmp[1] = btc->btc_read_1byte(btc, 0xf8f);
4667 u8tmp[2] = btc->btc_read_1byte(btc, 0xd14);
4668 u8tmp[3] = btc->btc_read_1byte(btc, 0xd54);
4669
4670 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d/ %d/ %d/ %d",
4671 "EVM_A/ EVM_B/ SNR_A/ SNR_B",
4672 (u8tmp[0] > 127 ? u8tmp[0] - 256 : u8tmp[0]),
4673 (u8tmp[1] > 127 ? u8tmp[1] - 256 : u8tmp[1]),
4674 (u8tmp[2] > 127 ? u8tmp[2] - 256 : u8tmp[2]),
4675 (u8tmp[3] > 127 ? u8tmp[3] - 256 : u8tmp[3]));
4676 CL_PRINTF(cli_buf);
4677
4678 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d/ %d",
4679 "0x770(Hi-pri rx/tx)", coex_sta->high_priority_rx,
4680 coex_sta->high_priority_tx);
4681 CL_PRINTF(cli_buf);
4682
4683 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d/ %d %s",
4684 "0x774(Lo-pri rx/tx)", coex_sta->low_priority_rx,
4685 coex_sta->low_priority_tx,
4686 (bt_link_info->slave_role ? "(Slave!!)" : " "));
4687 CL_PRINTF(cli_buf);
4688
4689 btc->btc_disp_dbg_msg(btc, BTC_DBG_DISP_COEX_STATISTICS);
4690 }
4691
ex_halbtc8822b1ant_ips_notify(struct btc_coexist * btc,u8 type)4692 void ex_halbtc8822b1ant_ips_notify(struct btc_coexist *btc, u8 type)
4693 {
4694 struct coex_sta_8822b_1ant *coex_sta = &btc->coex_sta_8822b_1ant;
4695
4696 if (btc->manual_control || btc->stop_coex_dm)
4697 return;
4698
4699 if (type == BTC_IPS_ENTER) {
4700 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4701 "[BTCoex], IPS ENTER notify\n");
4702 BTC_TRACE(trace_buf);
4703 coex_sta->under_ips = TRUE;
4704
4705 /* Write WL "Active" in Score-board for LPS off */
4706 halbtc8822b1ant_write_scbd(btc, BT_8822B_1ANT_SCBD_ACTIVE |
4707 BT_8822B_1ANT_SCBD_ONOFF |
4708 BT_8822B_1ANT_SCBD_SCAN |
4709 BT_8822B_1ANT_SCBD_UNDERTEST |
4710 BT_8822B_1ANT_SCBD_RXGAIN,
4711 FALSE);
4712
4713 halbtc8822b1ant_set_ant_path(btc, BTC_ANT_PATH_AUTO, FC_EXCU,
4714 BT_8822B_1ANT_PHASE_WOFF);
4715 halbtc8822b1ant_action_coex_all_off(btc);
4716 } else if (type == BTC_IPS_LEAVE) {
4717 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4718 "[BTCoex], IPS LEAVE notify\n");
4719 BTC_TRACE(trace_buf);
4720 halbtc8822b1ant_write_scbd(btc, BT_8822B_1ANT_SCBD_ACTIVE |
4721 BT_8822B_1ANT_SCBD_ONOFF,
4722 TRUE);
4723
4724 /*leave IPS : run ini hw config (exclude wifi only)*/
4725 halbtc8822b1ant_init_hw_config(btc, FALSE, FALSE);
4726 /*sw all off*/
4727 halbtc8822b1ant_init_coex_dm(btc);
4728
4729 coex_sta->under_ips = FALSE;
4730 }
4731 }
4732
ex_halbtc8822b1ant_lps_notify(struct btc_coexist * btc,u8 type)4733 void ex_halbtc8822b1ant_lps_notify(struct btc_coexist *btc, u8 type)
4734 {
4735 struct coex_sta_8822b_1ant *coex_sta = &btc->coex_sta_8822b_1ant;
4736
4737 if (btc->manual_control || btc->stop_coex_dm)
4738 return;
4739
4740 if (type == BTC_LPS_ENABLE) {
4741 const u16 type_is_active = BT_8822B_1ANT_SCBD_ACTIVE;
4742
4743 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4744 "[BTCoex], LPS ENABLE notify\n");
4745 BTC_TRACE(trace_buf);
4746 coex_sta->under_lps = TRUE;
4747
4748 if (coex_sta->force_lps_ctrl) { /* LPS No-32K */
4749 /* Write WL "Active" in Score-board for PS-TDMA */
4750 halbtc8822b1ant_write_scbd(btc, type_is_active, TRUE);
4751 } else {
4752 /* Write WL "Non-Active" in Score-board for Native-PS */
4753 halbtc8822b1ant_write_scbd(btc, type_is_active, FALSE);
4754
4755 halbtc8822b1ant_run_coex(btc, BT_8822B_1ANT_RSN_LPS);
4756 }
4757 } else if (type == BTC_LPS_DISABLE) {
4758 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4759 "[BTCoex], LPS DISABLE notify\n");
4760 BTC_TRACE(trace_buf);
4761 coex_sta->under_lps = FALSE;
4762
4763 /* Write WL "Active" in Score-board for LPS off */
4764 halbtc8822b1ant_write_scbd(btc, BT_8822B_1ANT_SCBD_ACTIVE,
4765 TRUE);
4766
4767 if (!coex_sta->force_lps_ctrl) {
4768 halbtc8822b1ant_query_bt_info(btc);
4769 halbtc8822b1ant_run_coex(btc, BT_8822B_1ANT_RSN_LPS);
4770 }
4771 }
4772 }
4773
ex_halbtc8822b1ant_scan_notify(struct btc_coexist * btc,u8 type)4774 void ex_halbtc8822b1ant_scan_notify(struct btc_coexist *btc, u8 type)
4775 {
4776 struct coex_sta_8822b_1ant *coex_sta = &btc->coex_sta_8822b_1ant;
4777 boolean wifi_connected = FALSE;
4778
4779 if (btc->manual_control || btc->stop_coex_dm)
4780 return;
4781
4782 coex_sta->freeze_coexrun_by_btinfo = FALSE;
4783
4784 btc->btc_get(btc, BTC_GET_BL_WIFI_CONNECTED, &wifi_connected);
4785
4786 if (wifi_connected)
4787 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4788 "[BTCoex], ********** WL connected before SCAN\n");
4789 else
4790 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4791 "[BTCoex], ********** WL is not connected before SCAN\n");
4792
4793 BTC_TRACE(trace_buf);
4794
4795 if (type != BTC_SCAN_FINISH) {
4796 halbtc8822b1ant_write_scbd(btc, BT_8822B_1ANT_SCBD_ACTIVE |
4797 BT_8822B_1ANT_SCBD_SCAN |
4798 BT_8822B_1ANT_SCBD_ONOFF,
4799 TRUE);
4800 }
4801
4802 if (type == BTC_SCAN_START_5G) {
4803 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4804 "[BTCoex], SCAN START notify (5G)\n");
4805 BTC_TRACE(trace_buf);
4806
4807 halbtc8822b1ant_set_ant_path(btc, BTC_ANT_PATH_AUTO, FC_EXCU,
4808 BT_8822B_1ANT_PHASE_5G);
4809 halbtc8822b1ant_run_coex(btc, BT_8822B_1ANT_RSN_5GSCANSTART);
4810 } else if ((type == BTC_SCAN_START_2G) || (type == BTC_SCAN_START)) {
4811 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4812 "[BTCoex], SCAN START notify (2G)\n");
4813 BTC_TRACE(trace_buf);
4814
4815 if (!wifi_connected)
4816 coex_sta->wifi_high_pri_task2 = TRUE;
4817
4818 /* Force antenna setup for no scan result issue */
4819 halbtc8822b1ant_set_ant_path(btc, BTC_ANT_PATH_AUTO, FC_EXCU,
4820 BT_8822B_1ANT_PHASE_2G);
4821
4822 halbtc8822b1ant_run_coex(btc, BT_8822B_1ANT_RSN_2GSCANSTART);
4823 } else {
4824 btc->btc_get(btc, BTC_GET_U1_AP_NUM, &coex_sta->scan_ap_num);
4825
4826 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4827 "[BTCoex], SCAN FINISH notify (Scan-AP = %d)\n",
4828 coex_sta->scan_ap_num);
4829 BTC_TRACE(trace_buf);
4830
4831 coex_sta->wifi_high_pri_task2 = FALSE;
4832
4833 halbtc8822b1ant_run_coex(btc, BT_8822B_1ANT_RSN_SCANFINISH);
4834 }
4835 }
4836
ex_halbtc8822b1ant_scan_notify_without_bt(struct btc_coexist * btc,u8 type)4837 void ex_halbtc8822b1ant_scan_notify_without_bt(struct btc_coexist *btc, u8 type)
4838 {
4839 struct wifi_link_info_8822b_1ant *wifi_link_info_ext =
4840 &btc->wifi_link_info_8822b_1ant;
4841 struct rfe_type_8822b_1ant *rfe_type = &btc->rfe_type_8822b_1ant;
4842
4843 if (!rfe_type->ext_switch_exist)
4844 return;
4845
4846 if (type == BTC_SCAN_START) {
4847 if (wifi_link_info_ext->is_all_under_5g)
4848 btc->btc_write_1byte_bitmask(btc, 0xcbd, 0x3, 1);
4849 else /* under 2.4G */
4850 btc->btc_write_1byte_bitmask(btc, 0xcbd, 0x3, 2);
4851 } else if (type == BTC_SCAN_START_2G) {
4852 btc->btc_write_1byte_bitmask(btc, 0xcbd, 0x3, 2);
4853 }
4854 }
4855
ex_halbtc8822b1ant_switchband_notify(struct btc_coexist * btc,u8 type)4856 void ex_halbtc8822b1ant_switchband_notify(struct btc_coexist *btc,
4857 u8 type)
4858 {
4859 struct coex_sta_8822b_1ant *coex_sta = &btc->coex_sta_8822b_1ant;
4860
4861 if (btc->manual_control || btc->stop_coex_dm)
4862 return;
4863
4864 coex_sta->switch_band_notify_to = type;
4865
4866 if (type == BTC_SWITCH_TO_5G) {
4867 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4868 "[BTCoex], switchband_notify --- BTC_SWITCH_TO_5G\n");
4869 BTC_TRACE(trace_buf);
4870
4871 halbtc8822b1ant_run_coex(btc, BT_8822B_1ANT_RSN_5GSWITCHBAND);
4872 } else if (type == BTC_SWITCH_TO_24G_NOFORSCAN) {
4873 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4874 "[BTCoex], switchband_notify --- BTC_SWITCH_TO_24G_NOFORSCAN\n");
4875 BTC_TRACE(trace_buf);
4876
4877 halbtc8822b1ant_run_coex(btc, BT_8822B_1ANT_RSN_2GSWITCHBAND);
4878 } else {
4879 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4880 "[BTCoex], switchband_notify --- BTC_SWITCH_TO_2G\n");
4881 BTC_TRACE(trace_buf);
4882
4883 ex_halbtc8822b1ant_scan_notify(btc, BTC_SCAN_START_2G);
4884 }
4885
4886 coex_sta->switch_band_notify_to = BTC_NOT_SWITCH;
4887 }
4888
4889 void
ex_halbtc8822b1ant_switchband_notify_without_bt(struct btc_coexist * btc,u8 type)4890 ex_halbtc8822b1ant_switchband_notify_without_bt(struct btc_coexist *btc,
4891 u8 type)
4892 {
4893 struct rfe_type_8822b_1ant *rfe_type = &btc->rfe_type_8822b_1ant;
4894
4895 if (!rfe_type->ext_switch_exist)
4896 return;
4897
4898 if (type == BTC_SWITCH_TO_5G)
4899 btc->btc_write_1byte_bitmask(btc, 0xcbd, 0x3, 1);
4900 else if (type == BTC_SWITCH_TO_24G_NOFORSCAN)
4901 btc->btc_write_1byte_bitmask(btc, 0xcbd, 0x3, 2);
4902 else
4903 ex_halbtc8822b1ant_scan_notify_without_bt(btc,
4904 BTC_SCAN_START_2G);
4905 }
4906
ex_halbtc8822b1ant_connect_notify(struct btc_coexist * btc,u8 type)4907 void ex_halbtc8822b1ant_connect_notify(struct btc_coexist *btc, u8 type)
4908 {
4909 struct coex_sta_8822b_1ant *coex_sta = &btc->coex_sta_8822b_1ant;
4910 struct coex_dm_8822b_1ant *coex_dm = &btc->coex_dm_8822b_1ant;
4911
4912 if (btc->manual_control || btc->stop_coex_dm)
4913 return;
4914
4915 halbtc8822b1ant_write_scbd(btc, BT_8822B_1ANT_SCBD_ACTIVE |
4916 BT_8822B_1ANT_SCBD_SCAN |
4917 BT_8822B_1ANT_SCBD_ONOFF,
4918 TRUE);
4919
4920 if (type == BTC_ASSOCIATE_5G_START) {
4921 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4922 "[BTCoex], CONNECT START notify (5G)\n");
4923 BTC_TRACE(trace_buf);
4924
4925 halbtc8822b1ant_set_ant_path(btc, BTC_ANT_PATH_AUTO, FC_EXCU,
4926 BT_8822B_1ANT_PHASE_5G);
4927
4928 halbtc8822b1ant_run_coex(btc, BT_8822B_1ANT_RSN_5GCONSTART);
4929 } else if (type == BTC_ASSOCIATE_5G_FINISH) {
4930 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4931 "[BTCoex], CONNECT FINISH notify (5G)\n");
4932 BTC_TRACE(trace_buf);
4933
4934 halbtc8822b1ant_set_ant_path(btc, BTC_ANT_PATH_AUTO, FC_EXCU,
4935 BT_8822B_1ANT_PHASE_5G);
4936
4937 halbtc8822b1ant_run_coex(btc, BT_8822B_1ANT_RSN_5GCONFINISH);
4938 } else if (type == BTC_ASSOCIATE_START) {
4939 coex_sta->wifi_high_pri_task1 = TRUE;
4940 coex_dm->arp_cnt = 0;
4941 coex_sta->connect_ap_period_cnt = 2;
4942
4943 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4944 "[BTCoex], CONNECT START notify (2G)\n");
4945 BTC_TRACE(trace_buf);
4946
4947 /* Force antenna setup for no scan result issue */
4948 halbtc8822b1ant_set_ant_path(btc, BTC_ANT_PATH_AUTO, FC_EXCU,
4949 BT_8822B_1ANT_PHASE_2G);
4950
4951 halbtc8822b1ant_run_coex(btc, BT_8822B_1ANT_RSN_2GCONSTART);
4952
4953 /* To keep TDMA case during connect process,
4954 * to avoid changed by Btinfo and runcoexmechanism
4955 */
4956 coex_sta->freeze_coexrun_by_btinfo = TRUE;
4957 } else {
4958 coex_sta->wifi_high_pri_task1 = FALSE;
4959 coex_sta->freeze_coexrun_by_btinfo = FALSE;
4960
4961 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4962 "[BTCoex], CONNECT FINISH notify (2G)\n");
4963 BTC_TRACE(trace_buf);
4964
4965 halbtc8822b1ant_run_coex(btc, BT_8822B_1ANT_RSN_2GCONFINISH);
4966 }
4967 }
4968
ex_halbtc8822b1ant_media_status_notify(struct btc_coexist * btc,u8 type)4969 void ex_halbtc8822b1ant_media_status_notify(struct btc_coexist *btc, u8 type)
4970 {
4971 struct coex_sta_8822b_1ant *coex_sta = &btc->coex_sta_8822b_1ant;
4972 struct coex_dm_8822b_1ant *coex_dm = &btc->coex_dm_8822b_1ant;
4973 boolean wifi_under_b_mode = FALSE;
4974
4975 if (btc->manual_control || btc->stop_coex_dm)
4976 return;
4977
4978 if (type == BTC_MEDIA_CONNECT_5G) {
4979 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4980 "[BTCoex], media_status_notify --- 5G\n");
4981 BTC_TRACE(trace_buf);
4982
4983 halbtc8822b1ant_write_scbd(btc, BT_8822B_1ANT_SCBD_ACTIVE,
4984 TRUE);
4985
4986 halbtc8822b1ant_set_ant_path(btc, BTC_ANT_PATH_AUTO, FC_EXCU,
4987 BT_8822B_1ANT_PHASE_5G);
4988
4989 halbtc8822b1ant_run_coex(btc, BT_8822B_1ANT_RSN_5GMEDIA);
4990 } else if (type == BTC_MEDIA_CONNECT) {
4991 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4992 "[BTCoex], media_status_notify --- 2G\n");
4993 BTC_TRACE(trace_buf);
4994
4995 halbtc8822b1ant_write_scbd(btc, BT_8822B_1ANT_SCBD_ACTIVE,
4996 TRUE);
4997
4998 /* Force antenna setup for no scan result issue */
4999 halbtc8822b1ant_set_ant_path(btc, BTC_ANT_PATH_AUTO,
5000 FC_EXCU,
5001 BT_8822B_1ANT_PHASE_2G);
5002
5003 btc->btc_get(btc, BTC_GET_BL_WIFI_UNDER_B_MODE,
5004 &wifi_under_b_mode);
5005
5006 /* Set CCK Tx/Rx high Pri except 11b mode */
5007 if (wifi_under_b_mode)
5008 btc->btc_write_1byte_bitmask(btc, 0x6cf, BIT(4), 0x0);
5009 else
5010 btc->btc_write_1byte_bitmask(btc, 0x6cf, BIT(4), 0x1);
5011
5012 halbtc8822b1ant_run_coex(btc, BT_8822B_1ANT_RSN_2GMEDIA);
5013 } else {
5014 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
5015 "[BTCoex], media disconnect notify\n");
5016 BTC_TRACE(trace_buf);
5017 coex_dm->arp_cnt = 0;
5018
5019 btc->btc_write_1byte_bitmask(btc, 0x6cf, BIT(4), 0x0);
5020
5021 coex_sta->cck_lock_ever = FALSE;
5022 coex_sta->cck_lock_warn = FALSE;
5023 coex_sta->cck_lock = FALSE;
5024
5025 halbtc8822b1ant_run_coex(btc, BT_8822B_1ANT_RSN_MEDIADISCON);
5026 }
5027
5028 halbtc8822b1ant_update_wifi_ch_info(btc, type);
5029 }
5030
ex_halbtc8822b1ant_specific_packet_notify(struct btc_coexist * btc,u8 type)5031 void ex_halbtc8822b1ant_specific_packet_notify(struct btc_coexist *btc, u8 type)
5032 {
5033 struct coex_sta_8822b_1ant *coex_sta = &btc->coex_sta_8822b_1ant;
5034 struct coex_dm_8822b_1ant *coex_dm = &btc->coex_dm_8822b_1ant;
5035 boolean under_4way = FALSE;
5036
5037 if (btc->manual_control || btc->stop_coex_dm)
5038 return;
5039
5040 if (type & BTC_5G_BAND) {
5041 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
5042 "[BTCoex], 5g special packet notify\n");
5043 BTC_TRACE(trace_buf);
5044
5045 halbtc8822b1ant_run_coex(btc, BT_8822B_1ANT_RSN_5GSPECIALPKT);
5046 return;
5047 }
5048
5049 btc->btc_get(btc, BTC_GET_BL_WIFI_4_WAY_PROGRESS, &under_4way);
5050
5051 if (under_4way) {
5052 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
5053 "[BTCoex], specific Packet ---- under_4way!!\n");
5054 BTC_TRACE(trace_buf);
5055
5056 coex_sta->wifi_high_pri_task1 = TRUE;
5057 coex_sta->specific_pkt_period_cnt = 2;
5058 } else if (type == BTC_PACKET_ARP) {
5059 coex_dm->arp_cnt++;
5060
5061 if (coex_sta->wifi_high_pri_task1) {
5062 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
5063 "[BTCoex], specific Packet ARP notify -cnt = %d\n",
5064 coex_dm->arp_cnt);
5065 BTC_TRACE(trace_buf);
5066 }
5067
5068 } else {
5069 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
5070 "[BTCoex], specific Packet DHCP or EAPOL notify [Type = %d]\n",
5071 type);
5072 BTC_TRACE(trace_buf);
5073
5074 coex_sta->wifi_high_pri_task1 = TRUE;
5075 coex_sta->specific_pkt_period_cnt = 2;
5076 }
5077
5078 if (coex_sta->wifi_high_pri_task1) {
5079 halbtc8822b1ant_write_scbd(btc, BT_8822B_1ANT_SCBD_SCAN, TRUE);
5080 halbtc8822b1ant_run_coex(btc, BT_8822B_1ANT_RSN_2GSPECIALPKT);
5081 }
5082 }
5083
ex_halbtc8822b1ant_bt_info_notify(struct btc_coexist * btc,u8 * tmp_buf,u8 length)5084 void ex_halbtc8822b1ant_bt_info_notify(struct btc_coexist *btc, u8 *tmp_buf,
5085 u8 length)
5086 {
5087 struct coex_sta_8822b_1ant *coex_sta = &btc->coex_sta_8822b_1ant;
5088 struct btc_bt_link_info *bt_link_info = &btc->bt_link_info;
5089 u8 i, rsp_source = 0, type;
5090 boolean wifi_connected = FALSE, wifi_busy = FALSE;
5091 static boolean is_scoreboard_scan;
5092 const u16 type_is_scan = BT_8822B_1ANT_SCBD_SCAN;
5093
5094 rsp_source = tmp_buf[0] & 0xf;
5095 if (rsp_source >= BT_8822B_1ANT_INFO_SRC_MAX)
5096 rsp_source = BT_8822B_1ANT_INFO_SRC_WIFI_FW;
5097 coex_sta->bt_info_c2h_cnt[rsp_source]++;
5098
5099 if (rsp_source == BT_8822B_1ANT_INFO_SRC_BT_SCBD) {
5100 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
5101 "[BTCoex], BT Scoreboard change notify by WL FW c2h, 0xaa = 0x%02x, 0xab = 0x%02x\n",
5102 tmp_buf[1], tmp_buf[2]);
5103 BTC_TRACE(trace_buf);
5104 halbtc8822b1ant_monitor_bt_enable(btc);
5105 halbtc8822b1ant_run_coex(btc, BT_8822B_1ANT_RSN_BTINFO);
5106 return;
5107 }
5108
5109 if (rsp_source == BT_8822B_1ANT_INFO_SRC_BT_RSP ||
5110 rsp_source == BT_8822B_1ANT_INFO_SRC_BT_ACT) {
5111 if (coex_sta->bt_disabled) {
5112 coex_sta->bt_disabled = FALSE;
5113 coex_sta->is_bt_reenable = TRUE;
5114 coex_sta->cnt_bt_reenable = 15;
5115
5116 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
5117 "[BTCoex], BT enable detected by bt_info\n");
5118 BTC_TRACE(trace_buf);
5119 }
5120 }
5121
5122 if (rsp_source == BT_8822B_1ANT_INFO_SRC_WIFI_FW) {
5123 #if 0
5124 halbtc8822b1ant_update_bt_link_info(btc);
5125 halbtc8822b1ant_run_coex(btc, BT_8822B_1ANT_RSN_BTINFO);
5126 #endif
5127 return;
5128 }
5129
5130 if (length != 7) {
5131 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
5132 "[BTCoex], Bt_info length = %d invalid!!\n",
5133 length);
5134 BTC_TRACE(trace_buf);
5135 return;
5136 }
5137
5138 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
5139 "[BTCoex], Bt_info[%d], len=%d, data=[%02x %02x %02x %02x %02x %02x]\n",
5140 tmp_buf[0], length, tmp_buf[1], tmp_buf[2], tmp_buf[3],
5141 tmp_buf[4], tmp_buf[5], tmp_buf[6]);
5142 BTC_TRACE(trace_buf);
5143
5144 for (i = 0; i < 7; i++)
5145 coex_sta->bt_info_c2h[rsp_source][i] = tmp_buf[i];
5146
5147 if (coex_sta->bt_info_c2h[rsp_source][1] == coex_sta->bt_info_lb2 &&
5148 coex_sta->bt_info_c2h[rsp_source][2] == coex_sta->bt_info_lb3 &&
5149 coex_sta->bt_info_c2h[rsp_source][3] == coex_sta->bt_info_hb0 &&
5150 coex_sta->bt_info_c2h[rsp_source][4] == coex_sta->bt_info_hb1 &&
5151 coex_sta->bt_info_c2h[rsp_source][5] == coex_sta->bt_info_hb2 &&
5152 coex_sta->bt_info_c2h[rsp_source][6] == coex_sta->bt_info_hb3) {
5153 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
5154 "[BTCoex], Return because Btinfo duplicate!!\n");
5155 BTC_TRACE(trace_buf);
5156 return;
5157 }
5158
5159 coex_sta->bt_info_lb2 = coex_sta->bt_info_c2h[rsp_source][1];
5160 coex_sta->bt_info_lb3 = coex_sta->bt_info_c2h[rsp_source][2];
5161 coex_sta->bt_info_hb0 = coex_sta->bt_info_c2h[rsp_source][3];
5162 coex_sta->bt_info_hb1 = coex_sta->bt_info_c2h[rsp_source][4];
5163 coex_sta->bt_info_hb2 = coex_sta->bt_info_c2h[rsp_source][5];
5164 coex_sta->bt_info_hb3 = coex_sta->bt_info_c2h[rsp_source][6];
5165
5166 /* if 0xff, it means BT is under WHCK test */
5167 coex_sta->bt_whck_test =
5168 ((coex_sta->bt_info_lb2 == 0xff) ? TRUE : FALSE);
5169
5170 coex_sta->bt_create_connection =
5171 ((coex_sta->bt_info_lb3 & BIT(7)) ? TRUE : FALSE);
5172
5173 /* unit: %, value-100 to translate to unit: dBm */
5174 coex_sta->bt_rssi = coex_sta->bt_info_hb0 * 2 + 10;
5175
5176 coex_sta->c2h_bt_remote_name_req =
5177 ((coex_sta->bt_info_lb3 & BIT(5)) ? TRUE : FALSE);
5178
5179 coex_sta->is_A2DP_3M =
5180 ((coex_sta->bt_info_lb3 & BIT(4)) ? TRUE : FALSE);
5181
5182 coex_sta->acl_busy =
5183 ((coex_sta->bt_info_lb2 & BIT(3)) ? TRUE : FALSE);
5184
5185 coex_sta->voice_over_HOGP =
5186 ((coex_sta->bt_info_hb1 & BIT(4)) ? TRUE : FALSE);
5187
5188 coex_sta->c2h_bt_inquiry_page =
5189 ((coex_sta->bt_info_lb2 & BIT(2)) ? TRUE : FALSE);
5190
5191 if ((coex_sta->bt_info_lb2 & 0x49) == 0x49)
5192 coex_sta->a2dp_bit_pool = (coex_sta->bt_info_hb3 & 0x7f);
5193 else
5194 coex_sta->a2dp_bit_pool = 0;
5195
5196 coex_sta->is_bt_a2dp_sink =
5197 (coex_sta->bt_info_hb3 & BIT(7)) ? TRUE : FALSE;
5198
5199 coex_sta->bt_retry_cnt = coex_sta->bt_info_lb3 & 0xf;
5200
5201 bt_link_info->slave_role = coex_sta->bt_info_hb2 & 0x8;
5202
5203 coex_sta->bt_a2dp_active = ((coex_sta->bt_info_hb2 & BIT(2)) == BIT(2));
5204
5205 coex_sta->forbidden_slot = coex_sta->bt_info_hb2 & 0x7;
5206
5207 coex_sta->hid_busy_num = (coex_sta->bt_info_hb2 & 0x30) >> 4;
5208
5209 coex_sta->hid_pair_cnt = (coex_sta->bt_info_hb2 & 0xc0) >> 6;
5210
5211 if (coex_sta->hid_pair_cnt > 0 && coex_sta->hid_busy_num >= 2)
5212 coex_sta->bt_418_hid_exist = TRUE;
5213 else if (coex_sta->hid_pair_cnt == 0)
5214 coex_sta->bt_418_hid_exist = FALSE;
5215
5216 coex_sta->is_bt_opp_exist =
5217 (coex_sta->bt_info_hb2 & BIT(0)) ? TRUE : FALSE;
5218
5219 if (coex_sta->bt_retry_cnt >= 1)
5220 coex_sta->pop_event_cnt++;
5221
5222 if (coex_sta->c2h_bt_remote_name_req)
5223 coex_sta->cnt_remote_name_req++;
5224
5225 if (coex_sta->bt_info_hb1 & BIT(1))
5226 coex_sta->cnt_reinit++;
5227
5228 if ((coex_sta->bt_info_hb1 & BIT(2)) ||
5229 (coex_sta->bt_create_connection &&
5230 coex_sta->wl_pnp_wakeup_downcnt > 0)) {
5231 coex_sta->cnt_setup_link++;
5232 coex_sta->is_setup_link = TRUE;
5233
5234 if (coex_sta->is_bt_reenable)
5235 coex_sta->bt_relink_downcount = 6;
5236 else
5237 coex_sta->bt_relink_downcount = 2;
5238 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
5239 "[BTCoex], Re-Link start in BT info!!\n");
5240 BTC_TRACE(trace_buf);
5241 }
5242
5243 if (coex_sta->bt_info_hb1 & BIT(3))
5244 coex_sta->cnt_ign_wlan_act++;
5245
5246 if (coex_sta->bt_info_hb1 & BIT(6))
5247 coex_sta->cnt_role_switch++;
5248
5249 if (coex_sta->bt_info_hb1 & BIT(7))
5250 coex_sta->is_bt_multi_link = TRUE;
5251 else
5252 coex_sta->is_bt_multi_link = FALSE;
5253
5254 if (coex_sta->bt_info_hb1 & BIT(0))
5255 coex_sta->is_hid_rcu = TRUE;
5256 else
5257 coex_sta->is_hid_rcu = FALSE;
5258
5259 if (coex_sta->bt_info_hb1 & BIT(5))
5260 coex_sta->is_ble_scan_en = TRUE;
5261 else
5262 coex_sta->is_ble_scan_en = FALSE;
5263
5264 if (coex_sta->bt_create_connection) {
5265 coex_sta->cnt_page++;
5266
5267 btc->btc_get(btc, BTC_GET_BL_WIFI_BUSY, &wifi_busy);
5268
5269 if (coex_sta->is_wifi_linkscan_process ||
5270 coex_sta->wifi_high_pri_task1 ||
5271 coex_sta->wifi_high_pri_task2 || wifi_busy) {
5272 is_scoreboard_scan = TRUE;
5273 halbtc8822b1ant_write_scbd(btc, type_is_scan, TRUE);
5274 } else {
5275 halbtc8822b1ant_write_scbd(btc, type_is_scan, FALSE);
5276 }
5277 } else {
5278 if (is_scoreboard_scan) {
5279 halbtc8822b1ant_write_scbd(btc, type_is_scan, FALSE);
5280 is_scoreboard_scan = FALSE;
5281 }
5282 }
5283
5284 /* Here we need to resend some wifi info to BT */
5285 /* because bt is reset and loss of the info. */
5286 btc->btc_get(btc, BTC_GET_BL_WIFI_CONNECTED, &wifi_connected);
5287 /* Re-Init */
5288 if ((coex_sta->bt_info_hb1 & BIT(1))) {
5289 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
5290 "[BTCoex], BT ext info bit1 check, send wifi BW&Chnl to BT!!\n");
5291 BTC_TRACE(trace_buf);
5292 if (wifi_connected)
5293 type = BTC_MEDIA_CONNECT;
5294 else
5295 type = BTC_MEDIA_DISCONNECT;
5296 halbtc8822b1ant_update_wifi_ch_info(btc, type);
5297 }
5298
5299 /* If Ignore_WLanAct && not SetUp_Link */
5300 if ((coex_sta->bt_info_hb1 & BIT(3)) &&
5301 (!(coex_sta->bt_info_hb1 & BIT(2)))) {
5302 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
5303 "[BTCoex], BT ext info bit3 check, set BT NOT to ignore Wlan active!!\n");
5304 BTC_TRACE(trace_buf);
5305 halbtc8822b1ant_ignore_wlan_act(btc, FC_EXCU, FALSE);
5306 }
5307
5308 halbtc8822b1ant_update_bt_link_info(btc);
5309 halbtc8822b1ant_run_coex(btc, BT_8822B_1ANT_RSN_BTINFO);
5310 }
5311
ex_halbtc8822b1ant_wl_fwdbginfo_notify(struct btc_coexist * btc,u8 * tmp_buf,u8 length)5312 void ex_halbtc8822b1ant_wl_fwdbginfo_notify(struct btc_coexist *btc,
5313 u8 *tmp_buf, u8 length)
5314 {
5315 struct coex_sta_8822b_1ant *coex_sta = &btc->coex_sta_8822b_1ant;
5316 u8 i = 0;
5317 static u8 tmp_buf_pre[10];
5318
5319 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
5320 "[BTCoex], WiFi Fw Dbg info = %d %d %d %d %d %d %d %d (len = %d)\n",
5321 tmp_buf[0], tmp_buf[1], tmp_buf[2], tmp_buf[3], tmp_buf[4],
5322 tmp_buf[5], tmp_buf[6], tmp_buf[7], length);
5323 BTC_TRACE(trace_buf);
5324
5325 if (tmp_buf[0] == 0x8) {
5326 for (i = 1; i <= 7; i++) {
5327 coex_sta->wl_fw_dbg_info[i] =
5328 (tmp_buf[i] >= tmp_buf_pre[i]) ?
5329 (tmp_buf[i] - tmp_buf_pre[i]) :
5330 (255 - tmp_buf_pre[i] + tmp_buf[i]);
5331
5332 tmp_buf_pre[i] = tmp_buf[i];
5333 }
5334 }
5335
5336 coex_sta->cnt_wl_fw_notify++;
5337 halbtc8822b1ant_ccklock_action(btc);
5338 }
5339
ex_halbtc8822b1ant_rx_rate_change_notify(struct btc_coexist * btc,BOOLEAN is_data_frame,u8 btc_rate_id)5340 void ex_halbtc8822b1ant_rx_rate_change_notify(struct btc_coexist *btc,
5341 BOOLEAN is_data_frame,
5342 u8 btc_rate_id)
5343 {
5344 struct coex_sta_8822b_1ant *coex_sta = &btc->coex_sta_8822b_1ant;
5345
5346 if (is_data_frame) {
5347 coex_sta->wl_rx_rate = btc_rate_id;
5348
5349 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
5350 "[BTCoex], rx_rate_change_notify data rate id = %d, RTS_Rate = %d\n",
5351 coex_sta->wl_rx_rate, coex_sta->wl_rts_rx_rate);
5352 BTC_TRACE(trace_buf);
5353 } else {
5354 coex_sta->wl_rts_rx_rate = btc_rate_id;
5355
5356 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
5357 "[BTCoex], rts_rate_change_notify RTS rate id = %d, RTS_Rate = %d\n",
5358 coex_sta->wl_rts_rx_rate, coex_sta->wl_rts_rx_rate);
5359 BTC_TRACE(trace_buf);
5360 }
5361
5362 halbtc8822b1ant_ccklock_detect(btc);
5363 }
5364
ex_halbtc8822b1ant_tx_rate_change_notify(struct btc_coexist * btc,u8 tx_rate,u8 tx_retry_ratio,u8 macid)5365 void ex_halbtc8822b1ant_tx_rate_change_notify(struct btc_coexist *btc,
5366 u8 tx_rate, u8 tx_retry_ratio,
5367 u8 macid)
5368 {
5369 struct coex_sta_8822b_1ant *coex_sta = &btc->coex_sta_8822b_1ant;
5370
5371 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
5372 "[BTCoex], tx_rate_change_notify Tx_Rate = %d, Tx_Retry_Ratio = %d, macid =%d\n",
5373 tx_rate, tx_retry_ratio, macid);
5374 BTC_TRACE(trace_buf);
5375
5376 coex_sta->wl_tx_rate = tx_rate;
5377 coex_sta->wl_tx_retry_ratio = tx_retry_ratio;
5378 coex_sta->wl_tx_macid = macid;
5379 }
5380
ex_halbtc8822b1ant_rf_status_notify(struct btc_coexist * btc,u8 type)5381 void ex_halbtc8822b1ant_rf_status_notify(struct btc_coexist *btc, u8 type)
5382 {
5383 struct coex_sta_8822b_1ant *coex_sta = &btc->coex_sta_8822b_1ant;
5384
5385 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE, "[BTCoex], RF Status notify\n");
5386 BTC_TRACE(trace_buf);
5387
5388 if (type == BTC_RF_ON) {
5389 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
5390 "[BTCoex], RF is turned ON!!\n");
5391 BTC_TRACE(trace_buf);
5392 btc->stop_coex_dm = FALSE;
5393 btc->wl_rf_state_off = FALSE;
5394
5395 } else if (type == BTC_RF_OFF) {
5396 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
5397 "[BTCoex], RF is turned OFF!!\n");
5398 BTC_TRACE(trace_buf);
5399
5400 halbtc8822b1ant_write_scbd(btc, BT_8822B_1ANT_SCBD_ACTIVE |
5401 BT_8822B_1ANT_SCBD_ONOFF |
5402 BT_8822B_1ANT_SCBD_SCAN |
5403 BT_8822B_1ANT_SCBD_UNDERTEST,
5404 FALSE);
5405
5406 halbtc8822b1ant_tdma(btc, FC_EXCU, FALSE, 0);
5407
5408 halbtc8822b1ant_set_ant_path(btc, BTC_ANT_PATH_AUTO, FC_EXCU,
5409 BT_8822B_1ANT_PHASE_WOFF);
5410 /* for test : s3 bt disppear , fail rate 1/600*/
5411 halbtc8822b1ant_ignore_wlan_act(btc, FC_EXCU, TRUE);
5412
5413 btc->stop_coex_dm = TRUE;
5414 btc->wl_rf_state_off = TRUE;
5415
5416 /* must place in the last step */
5417 halbtc8822b1ant_update_wifi_ch_info(btc, BTC_MEDIA_DISCONNECT);
5418 }
5419 }
5420
ex_halbtc8822b1ant_halt_notify(struct btc_coexist * btc)5421 void ex_halbtc8822b1ant_halt_notify(struct btc_coexist *btc)
5422 {
5423 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE, "[BTCoex], Halt notify\n");
5424 BTC_TRACE(trace_buf);
5425
5426 ex_halbtc8822b1ant_media_status_notify(btc, BTC_MEDIA_DISCONNECT);
5427
5428 halbtc8822b1ant_ignore_wlan_act(btc, FC_EXCU, TRUE);
5429
5430 halbtc8822b1ant_set_ant_path(btc, BTC_ANT_PATH_AUTO, FC_EXCU,
5431 BT_8822B_1ANT_PHASE_WOFF);
5432
5433 halbtc8822b1ant_write_scbd(btc, BT_8822B_1ANT_SCBD_ACTIVE |
5434 BT_8822B_1ANT_SCBD_ONOFF |
5435 BT_8822B_1ANT_SCBD_SCAN |
5436 BT_8822B_1ANT_SCBD_UNDERTEST |
5437 BT_8822B_1ANT_SCBD_RXGAIN,
5438 FALSE);
5439
5440 btc->stop_coex_dm = TRUE;
5441
5442 /* must place in the last step */
5443 halbtc8822b1ant_update_wifi_ch_info(btc, BTC_MEDIA_DISCONNECT);
5444 }
5445
ex_halbtc8822b1ant_pnp_notify(struct btc_coexist * btc,u8 pnp_state)5446 void ex_halbtc8822b1ant_pnp_notify(struct btc_coexist *btc, u8 pnp_state)
5447 {
5448 struct coex_sta_8822b_1ant *coex_sta = &btc->coex_sta_8822b_1ant;
5449 struct wifi_link_info_8822b_1ant *wifi_link_info_ext =
5450 &btc->wifi_link_info_8822b_1ant;
5451 static u8 pre_pnp_state;
5452 u8 phase;
5453
5454 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE, "[BTCoex], Pnp notify\n");
5455 BTC_TRACE(trace_buf);
5456
5457 if (pnp_state == BTC_WIFI_PNP_SLEEP ||
5458 pnp_state == BTC_WIFI_PNP_SLEEP_KEEP_ANT) {
5459 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
5460 "[BTCoex], Pnp notify to SLEEP\n");
5461 BTC_TRACE(trace_buf);
5462
5463 halbtc8822b1ant_write_scbd(btc, BT_8822B_1ANT_SCBD_ACTIVE |
5464 BT_8822B_1ANT_SCBD_ONOFF |
5465 BT_8822B_1ANT_SCBD_SCAN |
5466 BT_8822B_1ANT_SCBD_UNDERTEST |
5467 BT_8822B_1ANT_SCBD_RXGAIN,
5468 FALSE);
5469
5470 if (pnp_state == BTC_WIFI_PNP_SLEEP_KEEP_ANT) {
5471 if (wifi_link_info_ext->is_all_under_5g)
5472 phase = BT_8822B_1ANT_PHASE_5G;
5473 else
5474 phase = BT_8822B_1ANT_PHASE_2G;
5475 } else {
5476 phase = BT_8822B_1ANT_PHASE_WOFF;
5477 }
5478 halbtc8822b1ant_set_ant_path(btc, BTC_ANT_PATH_AUTO, FC_EXCU,
5479 phase);
5480
5481 btc->stop_coex_dm = TRUE;
5482 } else {
5483 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
5484 "[BTCoex], Pnp notify to WAKE UP\n");
5485 BTC_TRACE(trace_buf);
5486 coex_sta->wl_pnp_wakeup_downcnt = 3;
5487
5488 /*WoWLAN*/
5489 if (pre_pnp_state == BTC_WIFI_PNP_SLEEP_KEEP_ANT ||
5490 pnp_state == BTC_WIFI_PNP_WOWLAN) {
5491 coex_sta->run_time_state = TRUE;
5492 btc->stop_coex_dm = FALSE;
5493 halbtc8822b1ant_run_coex(btc, BT_8822B_1ANT_RSN_PNP);
5494 }
5495 }
5496
5497 pre_pnp_state = pnp_state;
5498 }
5499
ex_halbtc8822b1ant_coex_dm_reset(struct btc_coexist * btc)5500 void ex_halbtc8822b1ant_coex_dm_reset(struct btc_coexist *btc)
5501 {
5502 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
5503 "[BTCoex], *****************Coex DM Reset*****************\n");
5504 BTC_TRACE(trace_buf);
5505
5506 halbtc8822b1ant_init_hw_config(btc, FALSE, FALSE);
5507 halbtc8822b1ant_init_coex_dm(btc);
5508 }
5509
ex_halbtc8822b1ant_periodical(struct btc_coexist * btc)5510 void ex_halbtc8822b1ant_periodical(struct btc_coexist *btc)
5511 {
5512 struct coex_sta_8822b_1ant *coex_sta = &btc->coex_sta_8822b_1ant;
5513 boolean bt_relink_finish = FALSE, is_defreeze = FALSE;
5514 static u8 freeze_cnt;
5515
5516 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
5517 "[BTCoex], ==========================Periodical===========================\n");
5518 BTC_TRACE(trace_buf);
5519
5520 if (!btc->auto_report)
5521 halbtc8822b1ant_query_bt_info(btc);
5522
5523 halbtc8822b1ant_monitor_bt_ctr(btc);
5524 halbtc8822b1ant_monitor_wifi_ctr(btc);
5525 halbtc8822b1ant_update_wifi_link_info(btc,
5526 BT_8822B_1ANT_RSN_PERIODICAL);
5527 halbtc8822b1ant_monitor_bt_enable(btc);
5528
5529 if (coex_sta->bt_relink_downcount != 0) {
5530 coex_sta->bt_relink_downcount--;
5531 if (coex_sta->bt_relink_downcount == 0) {
5532 coex_sta->is_setup_link = FALSE;
5533 bt_relink_finish = TRUE;
5534 }
5535 }
5536
5537 if (coex_sta->freeze_coexrun_by_btinfo) {
5538 freeze_cnt++;
5539
5540 if (freeze_cnt >= 5) {
5541 freeze_cnt = 0;
5542 coex_sta->freeze_coexrun_by_btinfo = FALSE;
5543 is_defreeze = TRUE;
5544 }
5545 } else {
5546 freeze_cnt = 0;
5547 }
5548
5549 /* for 4-way, DHCP, EAPOL packet */
5550 if (coex_sta->specific_pkt_period_cnt > 0) {
5551 coex_sta->specific_pkt_period_cnt--;
5552
5553 if (!coex_sta->freeze_coexrun_by_btinfo &&
5554 coex_sta->specific_pkt_period_cnt == 0)
5555 coex_sta->wifi_high_pri_task1 = FALSE;
5556
5557 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
5558 "[BTCoex], Hi-Pri Task1 = %s\n",
5559 (coex_sta->wifi_high_pri_task1 ? "Yes" : "No"));
5560 BTC_TRACE(trace_buf);
5561 }
5562
5563 /*for A2DP glitch during connecting AP*/
5564 if (coex_sta->connect_ap_period_cnt > 0)
5565 coex_sta->connect_ap_period_cnt--;
5566
5567 if (coex_sta->wl_pnp_wakeup_downcnt > 0) {
5568 coex_sta->wl_pnp_wakeup_downcnt--;
5569 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
5570 "[BTCoex], wl_pnp_wakeup_downcnt = %d!!\n",
5571 coex_sta->wl_pnp_wakeup_downcnt);
5572 BTC_TRACE(trace_buf);
5573 }
5574
5575 if (coex_sta->cnt_bt_reenable > 0) {
5576 coex_sta->cnt_bt_reenable--;
5577 if (coex_sta->cnt_bt_reenable == 0) {
5578 coex_sta->is_bt_reenable = FALSE;
5579 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
5580 "[BTCoex], BT renable 30s finish!!\n");
5581 BTC_TRACE(trace_buf);
5582 }
5583 }
5584
5585 if (halbtc8822b1ant_moniter_wifibt_status(btc) || bt_relink_finish ||
5586 coex_sta->is_set_ps_state_fail || is_defreeze)
5587 halbtc8822b1ant_run_coex(btc, BT_8822B_1ANT_RSN_PERIODICAL);
5588 }
5589
ex_halbtc8822b1ant_dbg_control(struct btc_coexist * btc,u8 op_code,u8 op_len,u8 * pdata)5590 void ex_halbtc8822b1ant_dbg_control(struct btc_coexist *btc, u8 op_code,
5591 u8 op_len, u8 *pdata)
5592 {
5593 }
5594 #endif
5595
5596 #endif /* #if (BT_SUPPORT == 1 && COEX_SUPPORT == 1) */
5597