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