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