1 /******************************************************************************
2 *
3 * Copyright(c) 2016 - 2017 Realtek Corporation.
4 *
5 * This program is free software; you can redistribute it and/or modify it
6 * under the terms of version 2 of the GNU General Public License as
7 * published by the Free Software Foundation.
8 *
9 * This program is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
12 * more details.
13 *
14 *****************************************************************************/
15
16 #include "mp_precomp.h"
17
18 #if (BT_SUPPORT == 1 && COEX_SUPPORT == 1)
19
20 static u8 *trace_buf = &gl_btc_trace_buf[0];
21 static const u32 coex_ver_date = 20211210;
22 static const u32 coex_ver = 0x27;
23
24 static u8
rtw_btc_rssi_state(struct btc_coexist * btc,u8 pre_state,u8 rssi,u8 rssi_thresh)25 rtw_btc_rssi_state(struct btc_coexist *btc, u8 pre_state,
26 u8 rssi, u8 rssi_thresh)
27 {
28 const struct btc_chip_para *chip_para = btc->chip_para;
29 u8 next_state, tol = chip_para->rssi_tolerance;
30
31 if (pre_state == BTC_RSSI_STATE_LOW ||
32 pre_state == BTC_RSSI_STATE_STAY_LOW) {
33 if (rssi >= (rssi_thresh + tol))
34 next_state = BTC_RSSI_STATE_HIGH;
35 else
36 next_state = BTC_RSSI_STATE_STAY_LOW;
37 } else {
38 if (rssi < rssi_thresh)
39 next_state = BTC_RSSI_STATE_LOW;
40 else
41 next_state = BTC_RSSI_STATE_STAY_HIGH;
42 }
43
44 return next_state;
45 }
46
47 static void
rtw_btc_limited_tx(struct btc_coexist * btc,boolean force_exec,boolean tx_limit_en,boolean ampdu_limit_en)48 rtw_btc_limited_tx(struct btc_coexist *btc, boolean force_exec,
49 boolean tx_limit_en, boolean ampdu_limit_en)
50 {
51 struct btc_coex_sta *coex_sta = &btc->coex_sta;
52 struct btc_wifi_link_info_ext *link_info_ext = &btc->wifi_link_info_ext;
53 const struct btc_chip_para *chip_para = btc->chip_para;
54 boolean wl_b_mode = FALSE;
55
56 if (!chip_para->scbd_support)
57 return;
58
59 /* Force Max Tx retry limit = 8 */
60 if (!force_exec && tx_limit_en == coex_sta->wl_tx_limit_en &&
61 ampdu_limit_en == coex_sta->wl_ampdu_limit_en)
62 return;
63
64 /* backup MAC reg */
65 if (!coex_sta->wl_tx_limit_en) {
66 coex_sta->wl_arfb1 = btc->btc_read_4byte(btc, REG_DARFRC);
67 coex_sta->wl_arfb2 = btc->btc_read_4byte(btc, REG_DARFRCH);
68
69 coex_sta->wl_txlimit = btc->btc_read_2byte(btc,
70 REG_RETRY_LIMIT);
71 }
72
73 if (!coex_sta->wl_ampdu_limit_en)
74 coex_sta->wl_ampdulen =
75 btc->btc_read_1byte(btc, REG_AMPDU_MAX_TIME_V1);
76
77 coex_sta->wl_tx_limit_en = tx_limit_en;
78 coex_sta->wl_ampdu_limit_en = ampdu_limit_en;
79
80 if (tx_limit_en) {
81 /* Set BT polluted packet on for Tx rate adaptive
82 * Set queue life time to avoid can't reach tx retry limit
83 * if tx is always break by GNT_BT.
84 */
85 btc->btc_write_1byte_bitmask(btc, REG_TX_HANG_CTRL,
86 BIT_EN_GNT_BT_AWAKE, 0x1);
87
88 /* queue life time can't on if 2-port */
89 if (link_info_ext->num_of_active_port <= 1)
90 btc->btc_write_1byte_bitmask(btc, REG_LIFETIME_EN, 0xf,
91 0xf);
92 else
93 btc->btc_write_1byte_bitmask(btc, REG_LIFETIME_EN, 0xf,
94 0x0);
95
96 /* Max Tx retry limit = 8*/
97 btc->btc_write_2byte(btc, REG_RETRY_LIMIT, 0x0808);
98
99 btc->btc_get(btc, BTC_GET_BL_WIFI_UNDER_B_MODE, &wl_b_mode);
100
101 /* Auto rate fallback step within 8 retry*/
102 if (wl_b_mode) {
103 btc->btc_write_4byte(btc, REG_DARFRC, 0x1000000);
104 btc->btc_write_4byte(btc, REG_DARFRCH, 0x1010101);
105 } else {
106 btc->btc_write_4byte(btc, REG_DARFRC, 0x1000000);
107 btc->btc_write_4byte(btc, REG_DARFRCH, 0x4030201);
108 }
109 } else {
110 /* Set BT polluted packet on for Tx rate adaptive not
111 *including Tx retry break by PTA, 0x45c[19] =1
112 */
113 btc->btc_write_1byte_bitmask(btc, REG_TX_HANG_CTRL,
114 BIT_EN_GNT_BT_AWAKE, 0x0);
115
116 /* Set queue life time to avoid can't reach tx retry limit
117 * if tx is always break by GNT_BT.
118 */
119 btc->btc_write_1byte_bitmask(btc, REG_LIFETIME_EN, 0xf, 0x0);
120
121 /* Recovery Max Tx retry limit*/
122 btc->btc_write_2byte(btc, REG_RETRY_LIMIT,
123 coex_sta->wl_txlimit);
124 btc->btc_write_4byte(btc, REG_DARFRC, coex_sta->wl_arfb1);
125 btc->btc_write_4byte(btc, REG_DARFRCH, coex_sta->wl_arfb2);
126 }
127
128 if (ampdu_limit_en)
129 btc->btc_write_1byte(btc, REG_AMPDU_MAX_TIME_V1, 0x20);
130 else
131 btc->btc_write_1byte(btc, REG_AMPDU_MAX_TIME_V1,
132 coex_sta->wl_ampdulen);
133 }
134
135 static void
rtw_btc_limited_rx(struct btc_coexist * btc,boolean force_exec,boolean rej_ap_agg_pkt,boolean bt_ctrl_agg_buf_size,u8 agg_buf_size)136 rtw_btc_limited_rx(struct btc_coexist *btc, boolean force_exec,
137 boolean rej_ap_agg_pkt, boolean bt_ctrl_agg_buf_size,
138 u8 agg_buf_size)
139 {
140 struct btc_coex_sta *coex_sta = &btc->coex_sta;
141 boolean reject_rx_agg = rej_ap_agg_pkt;
142 boolean bt_ctrl_rx_agg_size = bt_ctrl_agg_buf_size;
143 u8 rx_agg_size = agg_buf_size;
144
145 if (!force_exec &&
146 bt_ctrl_agg_buf_size == coex_sta->wl_rxagg_limit_en &&
147 agg_buf_size == coex_sta->wl_rxagg_size)
148 return;
149
150 coex_sta->wl_rxagg_limit_en = bt_ctrl_agg_buf_size;
151 coex_sta->wl_rxagg_size = agg_buf_size;
152
153 /*btc->btc_set(btc, BTC_SET_BL_TO_REJ_AP_AGG_PKT, &reject_rx_agg);*/
154 /* decide BT control aggregation buf size or not */
155 btc->btc_set(btc, BTC_SET_BL_BT_CTRL_AGG_SIZE, &bt_ctrl_rx_agg_size);
156 /* aggregation buf size, only work
157 * when BT control Rx aggregation size
158 */
159 btc->btc_set(btc, BTC_SET_U1_AGG_BUF_SIZE, &rx_agg_size);
160 /* real update aggregation setting */
161 btc->btc_set(btc, BTC_SET_ACT_AGGREGATE_CTRL, NULL);
162
163 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
164 "[BTCoex], aggregation size = %d!!\n", agg_buf_size);
165 BTC_TRACE(trace_buf);
166 }
167
168 static void
rtw_btc_low_penalty_ra(struct btc_coexist * btc,boolean force_exec,boolean low_penalty_ra,u8 thres)169 rtw_btc_low_penalty_ra(struct btc_coexist *btc, boolean force_exec,
170 boolean low_penalty_ra, u8 thres)
171 {
172 struct btc_coex_sta *coex_sta = &btc->coex_sta;
173 struct btc_coex_dm *coex_dm = &btc->coex_dm;
174
175 if (!force_exec) {
176 if (low_penalty_ra == coex_dm->cur_low_penalty_ra &&
177 thres == coex_sta->wl_ra_thres)
178 return;
179 }
180
181 if (low_penalty_ra)
182 btc->btc_phydm_modify_RA_PCR_threshold(btc, 0, thres);
183 else
184 btc->btc_phydm_modify_RA_PCR_threshold(btc, 0, 0);
185
186 coex_dm->cur_low_penalty_ra = low_penalty_ra;
187 coex_sta->wl_ra_thres = thres;
188 }
189
190 static void
rtw_btc_limited_wl(struct btc_coexist * btc)191 rtw_btc_limited_wl(struct btc_coexist *btc)
192 {
193 struct btc_coex_dm *coex_dm = &btc->coex_dm;
194 struct btc_coex_sta *coex_sta = &btc->coex_sta;
195 struct btc_wifi_link_info_ext *link_info_ext = &btc->wifi_link_info_ext;
196
197 if (link_info_ext->is_all_under_5g ||
198 link_info_ext->num_of_active_port == 0 ||
199 coex_dm->bt_status == BTC_BTSTATUS_NCON_IDLE) {
200 rtw_btc_low_penalty_ra(btc, NM_EXCU, FALSE, 0);
201 rtw_btc_limited_tx(btc, NM_EXCU, FALSE, FALSE);
202 rtw_btc_limited_rx(btc, NM_EXCU, FALSE, TRUE, 64);
203 } else if (link_info_ext->num_of_active_port > 1) {
204 rtw_btc_low_penalty_ra(btc, NM_EXCU, TRUE, 30);
205 rtw_btc_limited_tx(btc, NM_EXCU, TRUE, TRUE);
206 rtw_btc_limited_rx(btc, NM_EXCU, FALSE, TRUE, 16);
207 } else {
208 if (link_info_ext->is_p2p_connected)
209 rtw_btc_low_penalty_ra(btc, NM_EXCU, TRUE, 30);
210 else
211 rtw_btc_low_penalty_ra(btc, NM_EXCU, TRUE, 15);
212
213 if (coex_sta->bt_hid_exist || coex_sta->bt_hid_pair_num > 0 ||
214 coex_sta->bt_hfp_exist)
215 rtw_btc_limited_tx(btc, NM_EXCU, TRUE, TRUE);
216 else
217 rtw_btc_limited_tx(btc, NM_EXCU, TRUE, FALSE);
218
219 /*COEX-361, solve wifi poor performance when BLE HID exists*/
220 if ((coex_sta->bt_ble_hid_exist || coex_sta->bt_hfp_exist) &&
221 coex_sta->wl_iot_peer != BTC_IOT_PEER_ATHEROS &&
222 btc->board_info.btdm_ant_num == 1)
223 rtw_btc_limited_rx(btc, NM_EXCU, FALSE, TRUE, 4);
224 else
225 rtw_btc_limited_rx(btc, NM_EXCU, FALSE, TRUE, 64);
226 }
227
228
229 }
230
231 static void
rtw_btc_mailbox_operation(struct btc_coexist * btc,u8 h2c_id,u8 h2c_len,u8 * h2c_para)232 rtw_btc_mailbox_operation(struct btc_coexist *btc, u8 h2c_id, u8 h2c_len,
233 u8 *h2c_para)
234 {
235 const struct btc_chip_para *chip_para = btc->chip_para;
236 u8 buf[6] = {0};
237
238 if (chip_para->mailbox_support) {
239 btc->btc_fill_h2c(btc, h2c_id, h2c_len, h2c_para);
240 return;
241 }
242
243 switch (h2c_id) {
244 case 0x61:
245 buf[0] = 3;
246 buf[1] = 0x1; /* polling enable, 1=enable, 0=disable */
247 buf[2] = 0x2; /* polling time in seconds */
248 buf[3] = 0x1; /* auto report enable, 1=enable, 0=disable */
249
250 btc->btc_set(btc, BTC_SET_ACT_CTRL_BT_INFO, (void *)&buf[0]);
251 break;
252 case 0x62:
253 buf[0] = 4;
254 buf[1] = 0x3; /* OP_Code */
255 buf[2] = 0x2; /* OP_Code_Length */
256 buf[3] = (h2c_para[0] != 0) ? 0x1 : 0x0; /* OP_Code_Content */
257 buf[4] = h2c_para[0];/* pwr_level */
258
259 btc->btc_set(btc, BTC_SET_ACT_CTRL_BT_COEX, (void *)&buf[0]);
260 break;
261 case 0x63:
262 buf[0] = 3;
263 buf[1] = 0x1; /* OP_Code */
264 buf[2] = 0x1; /* OP_Code_Length */
265 buf[3] = (h2c_para[0] == 0x1) ? 0x1 : 0x0; /* OP_Code_Content */
266
267 btc->btc_set(btc, BTC_SET_ACT_CTRL_BT_COEX, (void *)&buf[0]);
268 break;
269 case 0x66:
270 buf[0] = 5;
271 buf[1] = 0x5; /* OP_Code */
272 buf[2] = 0x3; /* OP_Code_Length */
273 buf[3] = h2c_para[0]; /* OP_Code_Content */
274 buf[4] = h2c_para[1];
275 buf[5] = h2c_para[2];
276
277 btc->btc_set(btc, BTC_SET_ACT_CTRL_BT_COEX, (void *)&buf[0]);
278 break;
279 }
280 }
281
282 static boolean
rtw_btc_freerun_check(struct btc_coexist * btc)283 rtw_btc_freerun_check(struct btc_coexist *btc)
284 {
285 struct btc_coex_sta *coex_sta = &btc->coex_sta;
286 struct btc_coex_dm *coex_dm = &btc->coex_dm;
287 struct btc_wifi_link_info_ext *link_info_ext = &btc->wifi_link_info_ext;
288 u8 bt_rssi;
289
290 if (coex_sta->force_freerun)
291 return TRUE;
292
293 if (coex_sta->force_tdd)
294 return FALSE;
295
296 if (coex_sta->bt_disabled)
297 return FALSE;
298
299 if (btc->board_info.btdm_ant_num == 1 ||
300 btc->board_info.ant_distance <= 5 || !coex_sta->wl_gl_busy)
301 return FALSE;
302
303 if (btc->board_info.ant_distance >= 40 ||
304 coex_sta->bt_hid_pair_num >= 2)
305 return TRUE;
306
307 /* ant_distance = 5 ~ 40 */
308 if (BTC_RSSI_HIGH(coex_dm->wl_rssi_state[1]) &&
309 BTC_RSSI_HIGH(coex_dm->bt_rssi_state[0]))
310 return TRUE;
311
312 if (link_info_ext->traffic_dir == BTC_WIFI_TRAFFIC_TX)
313 bt_rssi = coex_dm->bt_rssi_state[0];
314 else
315 bt_rssi = coex_dm->bt_rssi_state[1];
316
317 if (BTC_RSSI_HIGH(coex_dm->wl_rssi_state[3]) &&
318 BTC_RSSI_HIGH(bt_rssi) &&
319 coex_sta->cnt_wl[BTC_CNT_WL_SCANAP] <= 5)
320 return TRUE;
321
322 return FALSE;
323 }
324
325 static void
rtw_btc_wl_leakap(struct btc_coexist * btc,boolean enable)326 rtw_btc_wl_leakap(struct btc_coexist *btc, boolean enable)
327 {
328 struct btc_coex_sta *coex_sta = &btc->coex_sta;
329 u8 h2c_para[2] = {0xc, 0};
330
331 if (coex_sta->wl_leak_ap == enable)
332 return;
333
334 if (enable) {
335 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
336 "[BTCoex], turn on Leak-AP Rx Protection!!\n");
337
338 h2c_para[1] = 0x0;
339 } else {
340 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
341 "[BTCoex], turn off Leak-AP Rx Protection!!\n");
342
343 h2c_para[1] = 0x1;
344 }
345
346 BTC_TRACE(trace_buf);
347 btc->btc_fill_h2c(btc, 0x69, 2, h2c_para);
348 coex_sta->wl_leak_ap = enable;
349 coex_sta->cnt_wl[BTC_CNT_WL_LEAKAP_NORX] = 0;
350 }
351
352 static void
rtw_btc_wl_ccklock_action(struct btc_coexist * btc)353 rtw_btc_wl_ccklock_action(struct btc_coexist *btc)
354 {
355 struct btc_coex_sta *coex_sta = &btc->coex_sta;
356 u8 h2c_parameter[2] = {0}, ap_leak_rx_cnt = 0;
357 boolean wifi_busy = FALSE;
358
359 if (btc->manual_control || btc->stop_coex_dm)
360 return;
361
362 if (!coex_sta->wl_gl_busy ||
363 coex_sta->wl_iot_peer == BTC_IOT_PEER_CISCO) {
364 coex_sta->cnt_wl[BTC_CNT_WL_LEAKAP_NORX] = 0;
365 return;
366 }
367
368 ap_leak_rx_cnt = coex_sta->wl_fw_dbg_info[7];
369 /* Get realtime wifi_busy status */
370 btc->btc_get(btc, BTC_GET_BL_WIFI_BUSY, &wifi_busy);
371
372 if (coex_sta->wl_leak_ap && coex_sta->wl_force_lps_ctrl &&
373 !coex_sta->wl_cck_lock_ever) {
374 if (ap_leak_rx_cnt <= 5 && wifi_busy)
375 coex_sta->cnt_wl[BTC_CNT_WL_LEAKAP_NORX]++;
376 else
377 coex_sta->cnt_wl[BTC_CNT_WL_LEAKAP_NORX] = 0;
378
379 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
380 "[BTCoex], Leak-AP Rx extend cnt = %d!!\n",
381 coex_sta->cnt_wl[BTC_CNT_WL_LEAKAP_NORX]);
382 BTC_TRACE(trace_buf);
383
384 /* If 7-streak ap_leak_rx_cnt <= 5, turn off leak-AP for TP*/
385 if (coex_sta->cnt_wl[BTC_CNT_WL_LEAKAP_NORX] >= 7)
386 rtw_btc_wl_leakap(btc, FALSE);
387 } else if (!coex_sta->wl_leak_ap && coex_sta->wl_cck_lock) {
388 rtw_btc_wl_leakap(btc, TRUE);
389 }
390 }
391
392 static void
rtw_btc_wl_ccklock_detect(struct btc_coexist * btc)393 rtw_btc_wl_ccklock_detect(struct btc_coexist *btc)
394 {
395 struct btc_coex_sta *coex_sta = &btc->coex_sta;
396 struct btc_coex_dm *coex_dm = &btc->coex_dm;
397 struct btc_wifi_link_info_ext *link_info_ext = &btc->wifi_link_info_ext;
398 boolean is_cck_lock_rate = FALSE;
399
400 if (coex_dm->bt_status == BTC_BTSTATUS_INQ_PAGE ||
401 coex_sta->bt_setup_link)
402 return;
403
404 if (coex_sta->wl_rx_rate <= BTC_CCK_2 ||
405 coex_sta->wl_rts_rx_rate <= BTC_CCK_2)
406 is_cck_lock_rate = TRUE;
407
408 if (link_info_ext->is_connected && coex_sta->wl_gl_busy &&
409 BTC_RSSI_HIGH(coex_dm->wl_rssi_state[3]) &&
410 (coex_dm->bt_status == BTC_BTSTATUS_ACL_BUSY ||
411 coex_dm->bt_status == BTC_BTSTATUS_ACL_SCO_BUSY ||
412 coex_dm->bt_status == BTC_BTSTATUS_SCO_BUSY)) {
413 if (is_cck_lock_rate) {
414 coex_sta->wl_cck_lock = TRUE;
415
416 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
417 "[BTCoex], cck locking...\n");
418 BTC_TRACE(trace_buf);
419 } else {
420 coex_sta->wl_cck_lock = FALSE;
421
422 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
423 "[BTCoex], cck unlock...\n");
424 BTC_TRACE(trace_buf);
425 }
426 } else {
427 coex_sta->wl_cck_lock = FALSE;
428 }
429
430 /* CCK lock identification */
431 if (coex_sta->wl_cck_lock && !coex_sta->wl_cck_lock_pre)
432 btc->btc_set_timer(btc, BTC_TIMER_WL_CCKLOCK, 6);
433
434 coex_sta->wl_cck_lock_pre = coex_sta->wl_cck_lock;
435 }
436
437 static void
rtw_btc_set_extend_btautoslot(struct btc_coexist * btc,u8 thres)438 rtw_btc_set_extend_btautoslot(struct btc_coexist *btc, u8 thres)
439 {
440 struct btc_coex_sta *coex_sta = &btc->coex_sta;
441 u8 h2c_para[2] = {0x9, 0x32};
442
443 if (coex_sta->bt_ext_autoslot_thres == thres)
444 return;
445
446 h2c_para[1] = thres; /* thres must be 50 ~ 80*/
447
448 coex_sta->bt_ext_autoslot_thres = h2c_para[1];
449
450 btc->btc_fill_h2c(btc, 0x69, 2, h2c_para);
451 }
452
453 static void
rtw_btc_set_tdma_timer_base(struct btc_coexist * btc,u8 type)454 rtw_btc_set_tdma_timer_base(struct btc_coexist *btc, u8 type)
455 {
456 struct btc_coex_sta *coex_sta = &btc->coex_sta;
457 u16 tbtt_interval = 100;
458 u8 h2c_para[2] = {0xb, 0x1};
459
460 btc->btc_get(btc, BTC_GET_U2_BEACON_PERIOD, &tbtt_interval);
461
462 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
463 "[BTCoex], tbtt_interval = %d\n", tbtt_interval);
464 BTC_TRACE(trace_buf);
465
466 /* Add for JIRA coex-256 */
467 if (type == 3 && tbtt_interval >= 100) { /* 50ms-slot */
468 if (coex_sta->tdma_timer_base == 3)
469 return;
470
471 h2c_para[1] = (tbtt_interval / 50) - 1;
472 h2c_para[1] = h2c_para[1] | 0xc0; /* 50ms-slot */
473 coex_sta->tdma_timer_base = 3;
474 } else if (tbtt_interval < 80 && tbtt_interval > 0) {
475 if (coex_sta->tdma_timer_base == 2)
476 return;
477 h2c_para[1] = (100 / tbtt_interval);
478
479 if (100 % tbtt_interval != 0)
480 h2c_para[1] = h2c_para[1] + 1;
481
482 h2c_para[1] = h2c_para[1] & 0x3f;
483 coex_sta->tdma_timer_base = 2;
484 } else if (tbtt_interval >= 180) {
485 if (coex_sta->tdma_timer_base == 1)
486 return;
487 h2c_para[1] = (tbtt_interval / 100);
488
489 if (tbtt_interval % 100 <= 80)
490 h2c_para[1] = h2c_para[1] - 1;
491
492 h2c_para[1] = h2c_para[1] & 0x3f;
493 h2c_para[1] = h2c_para[1] | 0x80;
494 coex_sta->tdma_timer_base = 1;
495 } else {
496 if (coex_sta->tdma_timer_base == 0)
497 return;
498 h2c_para[1] = 0x1;
499 coex_sta->tdma_timer_base = 0;
500 }
501
502 btc->btc_fill_h2c(btc, 0x69, 2, h2c_para);
503
504 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
505 "[BTCoex], %s(): h2c_0x69 = 0x%x\n", __func__, h2c_para[1]);
506 BTC_TRACE(trace_buf);
507 }
508
509 static void
rtw_btc_set_wl_pri_mask(struct btc_coexist * btc,u8 bitmap,u8 data)510 rtw_btc_set_wl_pri_mask(struct btc_coexist *btc, u8 bitmap, u8 data)
511 {
512 u32 addr;
513
514 addr = REG_BT_COEX_TABLE_H + (bitmap / 8);
515 bitmap = bitmap % 8;
516
517 btc->btc_write_1byte_bitmask(btc, addr, BIT(bitmap), data);
518 }
519
520 static void
rtw_btc_set_bt_golden_rx_range(struct btc_coexist * btc,boolean force_exec,u8 profile_id,u8 shift_level)521 rtw_btc_set_bt_golden_rx_range(struct btc_coexist *btc, boolean force_exec,
522 u8 profile_id, u8 shift_level)
523 {
524 struct btc_coex_sta *coex_sta = &btc->coex_sta;
525 u16 para;
526
527 if (profile_id > 3)
528 return;
529
530 if (!force_exec &&
531 shift_level == coex_sta->bt_golden_rx_shift[profile_id])
532 return;
533
534 coex_sta->bt_golden_rx_shift[profile_id] = shift_level;
535
536 para = (profile_id << 8) | ((0x100 - shift_level) & 0xff);
537
538 btc->btc_set(btc, BTC_SET_BL_BT_GOLDEN_RX_RANGE, ¶);
539
540 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
541 "[BTCoex], %s(): para = 0x%04x\n", __func__, para);
542 BTC_TRACE(trace_buf);
543 }
544
545 static void
rtw_btc_query_bt_info(struct btc_coexist * btc)546 rtw_btc_query_bt_info(struct btc_coexist *btc)
547 {
548 struct btc_coex_sta *coex_sta = &btc->coex_sta;
549 u8 h2c_parameter[1] = {0x1};
550
551 if (coex_sta->bt_disabled)
552 return;
553
554 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE, "[BTCoex], %s()\n", __func__);
555 BTC_TRACE(trace_buf);
556
557 rtw_btc_mailbox_operation(btc, 0x61, 1, h2c_parameter);
558 }
559
560 static void
rtw_btc_gnt_debug(struct btc_coexist * btc,boolean isenable)561 rtw_btc_gnt_debug(struct btc_coexist *btc, boolean isenable)
562 {
563 if (!isenable)
564 btc->btc_write_1byte_bitmask(btc, 0x73, 0x8, 0x0);
565 else
566 btc->chip_para->chip_setup(btc, BTC_CSETUP_GNT_DEBUG);
567 }
568
569 static void
rtw_btc_gnt_workaround(struct btc_coexist * btc,boolean force_exec,u8 mode)570 rtw_btc_gnt_workaround(struct btc_coexist *btc, boolean force_exec, u8 mode)
571 {
572 struct btc_coex_sta *coex_sta = &btc->coex_sta;
573
574 if (!force_exec) {
575 if (coex_sta->gnt_workaround_state == coex_sta->wl_coex_mode)
576 return;
577 }
578
579 coex_sta->gnt_workaround_state = coex_sta->wl_coex_mode;
580
581 btc->chip_para->chip_setup(btc, BTC_CSETUP_GNT_FIX);
582 }
583
584 static void
rtw_btc_monitor_bt_enable(struct btc_coexist * btc)585 rtw_btc_monitor_bt_enable(struct btc_coexist *btc)
586 {
587 struct btc_coex_sta *coex_sta = &btc->coex_sta;
588 struct btc_coex_dm *coex_dm = &btc->coex_dm;
589 const struct btc_chip_para *chip_para = btc->chip_para;
590 boolean bt_disabled = FALSE;
591 u16 scbd;
592 u32 scbd_32;
593
594 if (chip_para->scbd_support) {
595 if (chip_para->scbd_bit_num == BTC_SCBD_16_BIT) {
596 btc->btc_read_scbd(btc, &scbd);
597 bt_disabled = (scbd & BTC_SCBD_BT_ONOFF) ? FALSE : TRUE;
598 } else {
599 btc->btc_read_scbd_32bit(btc, &scbd_32);
600 bt_disabled = (scbd_32 & BTC_SCBD_BT_ONOFF) ? FALSE : TRUE;
601 }
602
603 } else {
604 if (coex_sta->cnt_bt[BTC_CNT_BT_DISABLE] >= 2)
605 bt_disabled = TRUE;
606 }
607
608 btc->btc_set(btc, BTC_SET_BL_BT_DISABLE, &bt_disabled);
609
610 if (coex_sta->bt_disabled != bt_disabled) {
611 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
612 "[BTCoex], BT is from %s to %s!!\n",
613 (coex_sta->bt_disabled ? "disabled" : "enabled"),
614 (bt_disabled ? "disabled" : "enabled"));
615 BTC_TRACE(trace_buf);
616 coex_sta->bt_disabled = bt_disabled;
617
618 coex_sta->bt_supported_feature = 0;
619 coex_sta->bt_supported_version = 0;
620 coex_sta->bt_ble_scan_type = 0;
621 coex_sta->bt_ble_scan_para[0] = 0;
622 coex_sta->bt_ble_scan_para[1] = 0;
623 coex_sta->bt_ble_scan_para[2] = 0;
624 coex_sta->bt_reg_vendor_ac = 0xffff;
625 coex_sta->bt_reg_vendor_ae = 0xffff;
626 coex_sta->bt_a2dp_vendor_id = 0;
627 coex_sta->bt_a2dp_device_name = 0;
628 coex_sta->bt_iqk_state = 0;
629 coex_dm->cur_bt_lna_lvl = 0;
630 btc->bt_info.bt_get_fw_ver = 0;
631
632 /*for win10 BT disable->enable trigger wifi scan issue */
633 if (!coex_sta->bt_disabled) {
634 coex_sta->bt_reenable = TRUE;
635 btc->btc_set_timer(btc, BTC_TIMER_BT_REENABLE, 15);
636 } else {
637 coex_sta->bt_reenable = FALSE;
638 }
639 }
640 }
641
642 static void
rtw_btc_update_bt_sut_info(struct btc_coexist * btc)643 rtw_btc_update_bt_sut_info(struct btc_coexist *btc)
644 {
645 struct btc_coex_sta *coex_sta = &btc->coex_sta;
646 u32 val = 0;
647
648 if (coex_sta->bt_profile_num == 0) {
649 /* clear golden rx range if no PAN exist */
650 if (coex_sta->bt_golden_rx_shift[3] != 0)
651 rtw_btc_set_bt_golden_rx_range(btc, FC_EXCU, 3, 0);
652 return;
653 }
654
655 if (coex_sta->bt_a2dp_exist)
656 rtw_btc_set_bt_golden_rx_range(btc, FC_EXCU, 2, 0);
657 else
658 coex_sta->bt_sut_pwr_lvl[2] = 0xff;
659
660 if (coex_sta->bt_hfp_exist)
661 rtw_btc_set_bt_golden_rx_range(btc, FC_EXCU, 0, 0);
662 else
663 coex_sta->bt_sut_pwr_lvl[0] = 0xff;
664
665 if (coex_sta->bt_hid_exist)
666 rtw_btc_set_bt_golden_rx_range(btc, FC_EXCU, 1, 0);
667 else
668 coex_sta->bt_sut_pwr_lvl[1] = 0xff;
669
670 if (coex_sta->bt_pan_exist) {
671 rtw_btc_set_bt_golden_rx_range(btc, FC_EXCU, 3,
672 coex_sta->bt_golden_rx_shift[3]);
673 } else {
674 coex_sta->bt_golden_rx_shift[3] = 0;
675 coex_sta->bt_sut_pwr_lvl[3] = 0xff;
676 }
677 }
678
679 static void
rtw_btc_update_wl_link_info(struct btc_coexist * btc,u8 reason)680 rtw_btc_update_wl_link_info(struct btc_coexist *btc, u8 reason)
681 {
682 struct btc_coex_sta *coex_sta = &btc->coex_sta;
683 struct btc_coex_dm *coex_dm = &btc->coex_dm;
684 struct btc_wifi_link_info_ext *linfo_ext = &btc->wifi_link_info_ext;
685 struct btc_wifi_link_info linfo;
686 const struct btc_chip_para *chip_para = btc->chip_para;
687 u8 wifi_central_chnl = 0, num_of_wifi_link = 0, i, rssi_state;
688 u32 wifi_link_status = 0, wifi_bw;
689 s32 wl_rssi;
690 boolean isunder5G = FALSE, ismcc25g = FALSE, is_p2p_connected = FALSE,
691 plus_bt = FALSE;
692
693 btc->btc_get(btc, BTC_GET_BL_WIFI_SCAN, &linfo_ext->is_scan);
694 btc->btc_get(btc, BTC_GET_BL_WIFI_LINK, &linfo_ext->is_link);
695 btc->btc_get(btc, BTC_GET_BL_WIFI_ROAM, &linfo_ext->is_roam);
696 btc->btc_get(btc, BTC_GET_BL_WIFI_LW_PWR_STATE, &linfo_ext->is_32k);
697 btc->btc_get(btc, BTC_GET_BL_WIFI_4_WAY_PROGRESS, &linfo_ext->is_4way);
698 btc->btc_get(btc, BTC_GET_BL_WIFI_CONNECTED, &linfo_ext->is_connected);
699 btc->btc_get(btc, BTC_GET_U4_WIFI_TRAFFIC_DIR, &linfo_ext->traffic_dir);
700 btc->btc_get(btc, BTC_GET_U4_WIFI_BW, &linfo_ext->wifi_bw);
701 btc->btc_get(btc, BTC_GET_U4_WIFI_LINK_STATUS, &wifi_link_status);
702 linfo_ext->port_connect_status = wifi_link_status & 0xffff;
703
704 btc->btc_get(btc, BTC_GET_BL_WIFI_LINK_INFO, &linfo);
705 btc->wifi_link_info = linfo;
706
707 btc->btc_get(btc, BTC_GET_U1_WIFI_CENTRAL_CHNL, &wifi_central_chnl);
708 coex_sta->wl_center_ch = wifi_central_chnl;
709
710 btc->btc_get(btc, BTC_GET_S4_WIFI_RSSI, &wl_rssi);
711 for (i = 0; i < 4; i++) {
712 rssi_state = coex_dm->wl_rssi_state[i];
713 rssi_state = rtw_btc_rssi_state(btc, rssi_state,
714 (u8)(wl_rssi & 0xff),
715 chip_para->wl_rssi_step[i]);
716 coex_dm->wl_rssi_state[i] = rssi_state;
717 }
718
719 if (coex_sta->wl_linkscan_proc || coex_sta->wl_hi_pri_task1 ||
720 coex_sta->wl_hi_pri_task2 || coex_sta->wl_gl_busy) {
721 if (chip_para->scbd_bit_num == BTC_SCBD_16_BIT)
722 btc->btc_write_scbd(btc, BTC_SCBD_SCAN, TRUE);
723 else
724 btc->btc_write_scbd_32bit(btc, BTC_SCBD_SCAN, TRUE);
725 } else {
726 if (chip_para->scbd_bit_num == BTC_SCBD_16_BIT)
727 btc->btc_write_scbd(btc, BTC_SCBD_SCAN, FALSE);
728 else
729 btc->btc_write_scbd_32bit(btc, BTC_SCBD_SCAN, FALSE);
730 }
731
732 /* Check scan/connect/special-pkt action first */
733 switch (reason) {
734 case BTC_RSN_5GSCANSTART:
735 case BTC_RSN_5GSWITCHBAND:
736 case BTC_RSN_5GCONSTART:
737
738 isunder5G = TRUE;
739 break;
740 case BTC_RSN_2GSCANSTART:
741 case BTC_RSN_2GSWITCHBAND:
742 case BTC_RSN_2GCONSTART:
743
744 isunder5G = FALSE;
745 break;
746 case BTC_RSN_2GCONFINISH:
747 case BTC_RSN_5GCONFINISH:
748 case BTC_RSN_2GMEDIA:
749 case BTC_RSN_5GMEDIA:
750 case BTC_RSN_BTINFO:
751 case BTC_RSN_PERIODICAL:
752 case BTC_RSN_TIMERUP:
753 case BTC_RSN_WLSTATUS:
754 case BTC_RSN_2GSPECIALPKT:
755 case BTC_RSN_5GSPECIALPKT:
756 default:
757 switch (linfo.link_mode) {
758 case BTC_LINK_5G_MCC_GO_STA:
759 case BTC_LINK_5G_MCC_GC_STA:
760 case BTC_LINK_5G_SCC_GO_STA:
761 case BTC_LINK_5G_SCC_GC_STA:
762
763 isunder5G = TRUE;
764 break;
765 case BTC_LINK_2G_MCC_GO_STA:
766 case BTC_LINK_2G_MCC_GC_STA:
767 case BTC_LINK_2G_SCC_GO_STA:
768 case BTC_LINK_2G_SCC_GC_STA:
769
770 isunder5G = FALSE;
771 break;
772 case BTC_LINK_25G_MCC_GO_STA:
773 case BTC_LINK_25G_MCC_GC_STA:
774
775 isunder5G = FALSE;
776 ismcc25g = TRUE;
777 break;
778 case BTC_LINK_ONLY_STA:
779 if (linfo.sta_center_channel > 14)
780 isunder5G = TRUE;
781 else
782 isunder5G = FALSE;
783 break;
784 case BTC_LINK_ONLY_GO:
785 case BTC_LINK_ONLY_GC:
786 case BTC_LINK_ONLY_AP:
787 default:
788 if (linfo.p2p_center_channel > 14)
789 isunder5G = TRUE;
790 else
791 isunder5G = FALSE;
792 break;
793 }
794 break;
795 }
796
797 linfo_ext->is_all_under_5g = isunder5G;
798 linfo_ext->is_mcc_25g = ismcc25g;
799
800 if (wifi_link_status & WIFI_STA_CONNECTED)
801 num_of_wifi_link++;
802
803 if (wifi_link_status & WIFI_AP_CONNECTED)
804 num_of_wifi_link++;
805
806 if (wifi_link_status & WIFI_P2P_GO_CONNECTED) {
807 if (!(wifi_link_status & WIFI_AP_CONNECTED))
808 num_of_wifi_link++;
809 is_p2p_connected = TRUE;
810 }
811
812 if (wifi_link_status & WIFI_P2P_GC_CONNECTED) {
813 num_of_wifi_link++;
814 is_p2p_connected = TRUE;
815 }
816
817 linfo_ext->num_of_active_port = num_of_wifi_link;
818 linfo_ext->is_p2p_connected = is_p2p_connected;
819
820 if (linfo.link_mode == BTC_LINK_ONLY_GO && linfo.bhotspot)
821 linfo_ext->is_ap_mode = TRUE;
822 else
823 linfo_ext->is_ap_mode = FALSE;
824
825 if (linfo_ext->is_p2p_connected && coex_sta->bt_link_exist)
826 plus_bt = TRUE;
827
828 btc->btc_set(btc, BTC_SET_BL_MIRACAST_PLUS_BT, &plus_bt);
829
830 if (linfo_ext->is_scan || linfo_ext->is_link ||
831 linfo_ext->is_roam || linfo_ext->is_4way ||
832 reason == BTC_RSN_2GSCANSTART ||
833 reason == BTC_RSN_2GSWITCHBAND ||
834 reason == BTC_RSN_2GCONSTART ||
835 reason == BTC_RSN_2GSPECIALPKT)
836 coex_sta->wl_linkscan_proc = TRUE;
837 else
838 coex_sta->wl_linkscan_proc = FALSE;
839
840 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
841 "[BTCoex], scan = %d, link = %d, roam = %d 4way = %d!!!\n",
842 linfo_ext->is_scan, linfo_ext->is_link,
843 linfo_ext->is_roam,
844 linfo_ext->is_4way);
845 BTC_TRACE(trace_buf);
846
847 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
848 "[BTCoex], wifi_link_info: link_mode=%d, STA_Ch=%d, P2P_Ch=%d, AnyClient_Join_Go=%d !\n",
849 linfo.link_mode,
850 linfo.sta_center_channel,
851 linfo.p2p_center_channel,
852 linfo.bany_client_join_go);
853 BTC_TRACE(trace_buf);
854
855 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
856 "[BTCoex], wifi_link_info: center_ch=%d, is_all_under_5g=%d, is_mcc_25g=%d!\n",
857 coex_sta->wl_center_ch,
858 linfo_ext->is_all_under_5g,
859 linfo_ext->is_mcc_25g);
860 BTC_TRACE(trace_buf);
861
862 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
863 "[BTCoex], wifi_link_info: port_connect_status=0x%x, active_port_cnt=%d, P2P_Connect=%d!\n",
864 linfo_ext->port_connect_status,
865 linfo_ext->num_of_active_port,
866 linfo_ext->is_p2p_connected);
867 BTC_TRACE(trace_buf);
868
869 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
870 "[BTCoex], Update reason = %s\n",
871 run_reason_string[reason]);
872 BTC_TRACE(trace_buf);
873
874 if (btc->manual_control || btc->stop_coex_dm)
875 return;
876
877 /* coex-276 P2P-Go beacon request can't release issue
878 * Only PCIe/USB can set 0x454[6] = 1 to solve this issue,
879 * WL SDIO/USB interface need driver support.
880 */
881 #ifdef PLATFORM_WINDOWS
882 if (btc->chip_interface != BTC_INTF_SDIO)
883 btc->btc_write_1byte_bitmask(btc, REG_CCK_CHECK,
884 BIT_EN_BCN_PKT_REL, 0x1);
885 else
886 btc->btc_write_1byte_bitmask(btc, REG_CCK_CHECK,
887 BIT_EN_BCN_PKT_REL, 0x0);
888 #endif
889 }
890
891 static void
rtw_btc_update_bt_link_info(struct btc_coexist * btc)892 rtw_btc_update_bt_link_info(struct btc_coexist *btc)
893 {
894 struct btc_coex_sta *coex_sta = &btc->coex_sta;
895 struct btc_coex_dm *coex_dm = &btc->coex_dm;
896 const struct btc_chip_para *chip_para = btc->chip_para;
897 boolean bt_busy = FALSE, increase_scan_dev_num = FALSE,
898 scan_type_change = FALSE;
899 u8 i, scan_type, rssi_state;
900
901 /* update wl/bt rssi by btinfo */
902 for (i = 0; i < 4; i++) {
903 rssi_state = coex_dm->bt_rssi_state[i];
904 rssi_state = rtw_btc_rssi_state(btc, rssi_state,
905 coex_sta->bt_rssi,
906 chip_para->bt_rssi_step[i]);
907 coex_dm->bt_rssi_state[i] = rssi_state;
908 }
909
910 if (coex_sta->bt_ble_scan_en) {
911 scan_type = btc->btc_get_ble_scan_type_from_bt(btc);
912
913 if (scan_type != coex_sta->bt_ble_scan_type)
914 scan_type_change = TRUE;
915
916 coex_sta->bt_ble_scan_type = scan_type;
917 }
918
919 if (scan_type_change) {
920 u32 *p = NULL;
921
922 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
923 "[BTCoex], BTinfo HiByte1[5] check, query BLE Scan type!!\n");
924 BTC_TRACE(trace_buf);
925
926 if ((coex_sta->bt_ble_scan_type & 0x1) == 0x1) {
927 coex_sta->bt_init_scan = TRUE;
928 p = &coex_sta->bt_ble_scan_para[0];
929 *p = btc->btc_get_ble_scan_para_from_bt(btc, 0x1);
930 } else {
931 coex_sta->bt_init_scan = FALSE;
932 }
933
934 if ((coex_sta->bt_ble_scan_type & 0x2) == 0x2) {
935 p = &coex_sta->bt_ble_scan_para[1];
936 *p = btc->btc_get_ble_scan_para_from_bt(btc, 0x2);
937 }
938
939 if ((coex_sta->bt_ble_scan_type & 0x4) == 0x4) {
940 p = &coex_sta->bt_ble_scan_para[2];
941 *p = btc->btc_get_ble_scan_para_from_bt(btc, 0x4);
942 }
943 }
944
945 coex_sta->bt_profile_num = 0;
946
947 /* set link exist status */
948 if (!(coex_sta->bt_info_lb2 & BTC_INFO_CONNECTION)) {
949 coex_sta->bt_link_exist = FALSE;
950 coex_sta->bt_pan_exist = FALSE;
951 coex_sta->bt_a2dp_exist = FALSE;
952 coex_sta->bt_hid_exist = FALSE;
953 coex_sta->bt_hfp_exist = FALSE;
954 coex_sta->bt_msft_mr_exist = FALSE;
955 } else { /* connection exists */
956 coex_sta->bt_link_exist = TRUE;
957 if (coex_sta->bt_info_lb2 & BTC_INFO_FTP) {
958 coex_sta->bt_pan_exist = TRUE;
959 coex_sta->bt_profile_num++;
960 } else {
961 coex_sta->bt_pan_exist = FALSE;
962 }
963
964 if (coex_sta->bt_info_lb2 & BTC_INFO_A2DP) {
965 coex_sta->bt_a2dp_exist = TRUE;
966 coex_sta->bt_profile_num++;
967 } else {
968 coex_sta->bt_a2dp_exist = FALSE;
969 }
970
971 if (coex_sta->bt_info_lb2 & BTC_INFO_HID) {
972 coex_sta->bt_hid_exist = TRUE;
973 coex_sta->bt_profile_num++;
974 } else {
975 coex_sta->bt_hid_exist = FALSE;
976 }
977
978 if (coex_sta->bt_info_lb2 & BTC_INFO_SCO_ESCO) {
979 coex_sta->bt_hfp_exist = TRUE;
980 coex_sta->bt_profile_num++;
981 } else {
982 coex_sta->bt_hfp_exist = FALSE;
983 }
984 }
985
986 if (coex_sta->bt_info_lb2 & BTC_INFO_INQ_PAGE) {
987 coex_dm->bt_status = BTC_BTSTATUS_INQ_PAGE;
988 } else if (!(coex_sta->bt_info_lb2 & BTC_INFO_CONNECTION)) {
989 coex_dm->bt_status = BTC_BTSTATUS_NCON_IDLE;
990 coex_sta->bt_multi_link_remain = FALSE;
991 } else if (coex_sta->bt_info_lb2 == BTC_INFO_CONNECTION) {
992 if (coex_sta->bt_msft_mr_exist)
993 coex_dm->bt_status = BTC_BTSTATUS_ACL_BUSY;
994 else
995 coex_dm->bt_status = BTC_BTSTATUS_CON_IDLE;
996 } else if ((coex_sta->bt_info_lb2 & BTC_INFO_SCO_ESCO) ||
997 (coex_sta->bt_info_lb2 & BTC_INFO_SCO_BUSY)) {
998 if (coex_sta->bt_info_lb2 & BTC_INFO_ACL_BUSY)
999 coex_dm->bt_status = BTC_BTSTATUS_ACL_SCO_BUSY;
1000 else
1001 coex_dm->bt_status = BTC_BTSTATUS_SCO_BUSY;
1002 } else if (coex_sta->bt_info_lb2 & BTC_INFO_ACL_BUSY) {
1003 coex_dm->bt_status = BTC_BTSTATUS_ACL_BUSY;
1004 } else {
1005 coex_dm->bt_status = BTC_BTSTATUS_MAX;
1006 }
1007
1008 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE, "[BTCoex], %s(), %s!!!\n",
1009 __func__, bt_status_string[coex_dm->bt_status]);
1010 BTC_TRACE(trace_buf);
1011
1012 if (coex_dm->bt_status == BTC_BTSTATUS_ACL_BUSY ||
1013 coex_dm->bt_status == BTC_BTSTATUS_SCO_BUSY ||
1014 coex_dm->bt_status == BTC_BTSTATUS_ACL_SCO_BUSY) {
1015 bt_busy = TRUE;
1016 increase_scan_dev_num = TRUE;
1017 } else {
1018 bt_busy = FALSE;
1019 increase_scan_dev_num = FALSE;
1020 }
1021
1022 btc->btc_set(btc, BTC_SET_BL_BT_TRAFFIC_BUSY, &bt_busy);
1023 btc->btc_set(btc, BTC_SET_BL_INC_SCAN_DEV_NUM, &increase_scan_dev_num);
1024
1025 if (coex_sta->bt_profile_num != coex_sta->bt_profile_num_pre) {
1026 rtw_btc_update_bt_sut_info(btc);
1027 coex_sta->bt_profile_num_pre = coex_sta->bt_profile_num;
1028
1029 if (!coex_sta->bt_a2dp_exist) {
1030 coex_sta->bt_a2dp_vendor_id = 0;
1031 coex_sta->bt_a2dp_device_name = 0;
1032 coex_sta->bt_a2dp_flush_time = 0;
1033 }
1034 }
1035
1036 coex_sta->cnt_bt[BTC_CNT_BT_INFOUPDATE]++;
1037 }
1038
1039 static void
rtw_btc_update_wl_ch_info(struct btc_coexist * btc,u8 type)1040 rtw_btc_update_wl_ch_info(struct btc_coexist *btc, u8 type)
1041 {
1042 struct btc_coex_sta *coex_sta = &btc->coex_sta;
1043 struct btc_coex_dm *coex_dm = &btc->coex_dm;
1044 const struct btc_chip_para *chip_para = btc->chip_para;
1045 struct btc_wifi_link_info_ext *link_info_ext = &btc->wifi_link_info_ext;
1046 struct btc_wifi_link_info *link_info = &btc->wifi_link_info;
1047 u8 h2c_para[3] = {0}, i, wl_center_ch = 0;
1048
1049 if (btc->manual_control)
1050 return;
1051
1052 if (btc->stop_coex_dm || btc->wl_rf_state_off) {
1053 wl_center_ch = 0;
1054 } else if (type != BTC_MEDIA_DISCONNECT ||
1055 (type == BTC_MEDIA_DISCONNECT &&
1056 link_info_ext->num_of_active_port > 0)) {
1057 if (link_info_ext->num_of_active_port == 1) {
1058 if (link_info_ext->is_p2p_connected)
1059 wl_center_ch = link_info->p2p_center_channel;
1060 else
1061 wl_center_ch = link_info->sta_center_channel;
1062 } else { /* port > 2 */
1063 if (link_info->p2p_center_channel > 14 &&
1064 link_info->sta_center_channel > 14)
1065 wl_center_ch = link_info->p2p_center_channel;
1066 else if (link_info->p2p_center_channel <= 14)
1067 wl_center_ch = link_info->p2p_center_channel;
1068 else if (link_info->sta_center_channel <= 14)
1069 wl_center_ch = link_info->sta_center_channel;
1070 }
1071 }
1072
1073 if (wl_center_ch == 0) {
1074 h2c_para[0] = 0x0;
1075 h2c_para[1] = 0x0;
1076 h2c_para[2] = 0x0;
1077 } else if(btc->board_info.btdm_ant_num == 1 && wl_center_ch <= 14) {
1078 h2c_para[0] = 0x1;
1079 h2c_para[1] = wl_center_ch;
1080 /* 8723f shared ant, BT should avoid wifi channel */
1081 if (link_info_ext->wifi_bw == BTC_WIFI_BW_HT40)
1082 h2c_para[2] = 0x28;
1083 else
1084 h2c_para[2] = 0x14;
1085 } else if (wl_center_ch <= 14) {
1086 h2c_para[0] = 0x1;
1087 h2c_para[1] = wl_center_ch;
1088
1089 if (link_info_ext->wifi_bw == BTC_WIFI_BW_HT40)
1090 h2c_para[2] = chip_para->bt_afh_span_bw40;
1091 else
1092 h2c_para[2] = chip_para->bt_afh_span_bw20;
1093 } else if (chip_para->afh_5g_num > 1) { /* for 5G */
1094 for (i = 0; i < chip_para->afh_5g_num; i++) {
1095 if (wl_center_ch == chip_para->afh_5g[i].wl_5g_ch) {
1096 h2c_para[0] = 0x3;
1097 h2c_para[1] = chip_para->afh_5g[i].bt_skip_ch;
1098 h2c_para[2] = chip_para->afh_5g[i].bt_skip_span;
1099 break;
1100 }
1101 }
1102 }
1103
1104 /* Only send mailbox if ch info change */
1105 if (coex_dm->wl_chnl_info[0] != h2c_para[0] &&
1106 coex_dm->wl_chnl_info[1] != h2c_para[1] &&
1107 coex_dm->wl_chnl_info[2] != h2c_para[2]) {
1108
1109 coex_dm->wl_chnl_info[0] = h2c_para[0];
1110 coex_dm->wl_chnl_info[1] = h2c_para[1];
1111 coex_dm->wl_chnl_info[2] = h2c_para[2];
1112 rtw_btc_mailbox_operation(btc, 0x66, 3, h2c_para);
1113 }
1114
1115 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
1116 "[BTCoex], %s: para[0:2] = 0x%x 0x%x 0x%x\n",
1117 __func__, h2c_para[0], h2c_para[1], h2c_para[2]);
1118 BTC_TRACE(trace_buf);
1119 }
1120
1121 static void
rtw_btc_set_wl_tx_power(struct btc_coexist * btc,boolean force_exec,u8 wl_pwr_dec_lvl)1122 rtw_btc_set_wl_tx_power(struct btc_coexist *btc,
1123 boolean force_exec, u8 wl_pwr_dec_lvl)
1124 {
1125 const struct btc_chip_para *chip_para = btc->chip_para;
1126 struct btc_coex_dm *coex_dm = &btc->coex_dm;
1127
1128 if (!force_exec && wl_pwr_dec_lvl == coex_dm->cur_wl_pwr_lvl)
1129 return;
1130
1131 coex_dm->cur_wl_pwr_lvl = wl_pwr_dec_lvl;
1132
1133 chip_para->chip_setup(btc, BTC_CSETUP_WL_TX_POWER);
1134
1135 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE, "[BTCoex], %s(): level = %d\n",
1136 __func__, wl_pwr_dec_lvl);
1137 BTC_TRACE(trace_buf);
1138 }
1139
1140 static void
rtw_btc_set_bt_tx_power(struct btc_coexist * btc,boolean force_exec,u8 bt_pwr_dec_lvl)1141 rtw_btc_set_bt_tx_power(struct btc_coexist *btc,
1142 boolean force_exec, u8 bt_pwr_dec_lvl)
1143 {
1144 struct btc_coex_dm *coex_dm = &btc->coex_dm;
1145 u8 h2c_para[1] = {0};
1146
1147 if (!force_exec && bt_pwr_dec_lvl == coex_dm->cur_bt_pwr_lvl)
1148 return;
1149
1150 h2c_para[0] = (0x100 - bt_pwr_dec_lvl) & 0xff;
1151
1152 rtw_btc_mailbox_operation(btc, 0x62, 1, h2c_para);
1153
1154 coex_dm->cur_bt_pwr_lvl = bt_pwr_dec_lvl;
1155
1156 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
1157 "[BTCoex], %s(), bt_tx_power = 0x%x, level = %d\n",
1158 __func__, h2c_para[0], bt_pwr_dec_lvl);
1159 BTC_TRACE(trace_buf);
1160 }
1161
1162 static void
rtw_btc_set_wl_rx_gain(struct btc_coexist * btc,boolean force_exec,boolean low_gain_en)1163 rtw_btc_set_wl_rx_gain(struct btc_coexist *btc, boolean force_exec,
1164 boolean low_gain_en)
1165 {
1166 struct btc_coex_dm *coex_dm = &btc->coex_dm;
1167 const struct btc_chip_para *chip_para = btc->chip_para;
1168
1169 if (!force_exec && low_gain_en == coex_dm->cur_wl_rx_low_gain_en)
1170 return;
1171
1172 coex_dm->cur_wl_rx_low_gain_en = low_gain_en;
1173
1174 if (low_gain_en)
1175 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE, "[BTCoex], Hi-L Rx!\n");
1176 else
1177 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE, "[BTCoex], Nm-L Rx!\n");
1178
1179 BTC_TRACE(trace_buf);
1180
1181 chip_para->chip_setup(btc, BTC_CSETUP_WL_RX_GAIN);
1182 }
1183
1184 static void
rtw_btc_set_bt_rx_gain(struct btc_coexist * btc,boolean force_exec,u8 lna_lvl)1185 rtw_btc_set_bt_rx_gain(struct btc_coexist *btc, boolean force_exec, u8 lna_lvl)
1186 {
1187 struct btc_coex_dm *coex_dm = &btc->coex_dm;
1188 const struct btc_chip_para *chip_para = btc->chip_para;
1189
1190 if (!force_exec && lna_lvl == coex_dm->cur_bt_lna_lvl)
1191 return;
1192
1193 if (lna_lvl < 7) {
1194 btc->btc_set(btc, BTC_SET_BL_BT_LNA_CONSTRAIN_LEVEL, &lna_lvl);
1195 /* use scoreboard[4] to notify BT Rx gain table change */
1196 if (chip_para->scbd_bit_num == BTC_SCBD_16_BIT)
1197 btc->btc_write_scbd(btc, BTC_SCBD_RXGAIN, TRUE);
1198 else
1199 btc->btc_write_scbd_32bit(btc, BTC_SCBD_RXGAIN, TRUE);
1200 } else {
1201 if (chip_para->scbd_bit_num == BTC_SCBD_16_BIT)
1202 btc->btc_write_scbd(btc, BTC_SCBD_RXGAIN, FALSE);
1203 else
1204 btc->btc_write_scbd_32bit(btc, BTC_SCBD_RXGAIN, FALSE);
1205 }
1206
1207 coex_dm->cur_bt_lna_lvl = lna_lvl;
1208
1209 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
1210 "[BTCoex], %s(): bt_rx_LNA_level = %d\n",
1211 __func__, lna_lvl);
1212 BTC_TRACE(trace_buf);
1213 }
1214
1215 static void
rtw_btc_set_rf_para(struct btc_coexist * btc,boolean force_exec,struct btc_rf_para para)1216 rtw_btc_set_rf_para(struct btc_coexist *btc, boolean force_exec,
1217 struct btc_rf_para para)
1218 {
1219 struct btc_coex_sta *coex_sta = &btc->coex_sta;
1220 u8 tmp = 0;
1221
1222 if (coex_sta->coex_freerun) {
1223 if (coex_sta->cnt_wl[BTC_CNT_WL_SCANAP] <= 5)
1224 tmp = 3;
1225 }
1226
1227 rtw_btc_set_wl_tx_power(btc, force_exec, para.wl_pwr_dec_lvl);
1228 rtw_btc_set_bt_tx_power(btc, force_exec, para.bt_pwr_dec_lvl + tmp);
1229 rtw_btc_set_wl_rx_gain(btc, force_exec, para.wl_low_gain_en);
1230 rtw_btc_set_bt_rx_gain(btc, force_exec, para.bt_lna_lvl);
1231 }
1232
1233 static void
rtw_btc_coex_ctrl_owner(struct btc_coexist * btc,boolean wifi_control)1234 rtw_btc_coex_ctrl_owner(struct btc_coexist *btc, boolean wifi_control)
1235 {
1236 u8 val;
1237
1238 val = (wifi_control) ? 1 : 0; /* 0x70[26] */
1239 btc->btc_write_1byte_bitmask(btc, REG_SYS_SDIO_CTRL3, BIT(2), val);
1240
1241 if (!wifi_control)
1242 btc->chip_para->chip_setup(btc, BTC_CSETUP_BT_CTRL_ACT);
1243 }
1244
1245 static void
rtw_btc_set_gnt_bt(struct btc_coexist * btc,u8 state)1246 rtw_btc_set_gnt_bt(struct btc_coexist *btc, u8 state)
1247 {
1248 if (btc->chip_para->lte_indirect_access) {
1249 btc->btc_write_linderct(btc, REG_LTE_IDR_COEX_CTRL, 0xc000, state);
1250 btc->btc_write_linderct(btc, REG_LTE_IDR_COEX_CTRL, 0x0c00, state);
1251 } else {
1252 switch (state) {
1253 case BTC_GNT_HW_PTA:
1254 btc->btc_write_1byte_bitmask(btc, 0x765, 0x1e, 0x0);
1255 btc->btc_write_1byte_bitmask(btc, REG_SYS_SDIO_CTRL3,
1256 0x70, 0x0);
1257 break;
1258 case BTC_GNT_SW_LOW:
1259 btc->btc_write_1byte_bitmask(btc, 0x765, 0x1e, 0xf);
1260 btc->btc_write_1byte_bitmask(btc, REG_SYS_SDIO_CTRL3,
1261 0x70, 0x1);
1262 break;
1263 case BTC_GNT_SW_HIGH:
1264 btc->btc_write_1byte_bitmask(btc, 0x765, 0x1e, 0xf);
1265 btc->btc_write_1byte_bitmask(btc, REG_SYS_SDIO_CTRL3,
1266 0x70, 0x7);
1267 break;
1268 default:
1269 break;
1270 }
1271 }
1272 }
1273
1274 static void
rtw_btc_set_gnt_wl(struct btc_coexist * btc,u8 state)1275 rtw_btc_set_gnt_wl(struct btc_coexist *btc, u8 state)
1276 {
1277 if (btc->chip_para->lte_indirect_access) {
1278 btc->btc_write_linderct(btc, REG_LTE_IDR_COEX_CTRL, 0x3000, state);
1279 btc->btc_write_linderct(btc, REG_LTE_IDR_COEX_CTRL, 0x0300, state);
1280 } else {
1281 switch (state) {
1282 case BTC_GNT_HW_PTA:
1283 btc->btc_write_1byte_bitmask(btc, REG_SYS_SDIO_CTRL3,
1284 BIT(4), 0x0);
1285 btc->btc_write_1byte_bitmask(btc, REG_SYS_SDIO_CTRL3,
1286 BIT(7), 0x0);
1287 break;
1288 case BTC_GNT_SW_LOW:
1289 btc->btc_write_1byte_bitmask(btc, REG_SYS_SDIO_CTRL3,
1290 BIT(4), 0x1);
1291 btc->btc_write_1byte_bitmask(btc, REG_SYS_SDIO_CTRL3,
1292 BIT(7), 0x0);
1293 break;
1294 case BTC_GNT_SW_HIGH:
1295 btc->btc_write_1byte_bitmask(btc, REG_SYS_SDIO_CTRL3,
1296 BIT(4), 0x1);
1297 btc->btc_write_1byte_bitmask(btc, REG_SYS_SDIO_CTRL3,
1298 BIT(7), 0x1);
1299 break;
1300 default:
1301 break;
1302 }
1303 }
1304 }
1305
1306 #ifdef PLATFORM_WINDOWS
1307 static void
rtw_btc_mimo_ps(struct btc_coexist * btc,boolean force_exec,u8 state)1308 rtw_btc_mimo_ps(struct btc_coexist *btc, boolean force_exec,
1309 u8 state)
1310 {
1311 struct btc_coex_sta *coex_sta = &btc->coex_sta;
1312
1313 if (!force_exec && state == coex_sta->wl_mimo_ps)
1314 return;
1315
1316 coex_sta->wl_mimo_ps = state;
1317
1318 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
1319 "[BTCoex], %s(): state = %d\n", __func__, state);
1320 BTC_TRACE(trace_buf);
1321
1322 btc->btc_set(btc, BTC_SET_MIMO_PS_MODE, &state);
1323 }
1324 #endif
1325
1326 static void
rtw_btc_wltoggle_tableA(IN struct btc_coexist * btc,IN boolean force_exec,IN u32 table_case)1327 rtw_btc_wltoggle_tableA(IN struct btc_coexist *btc,
1328 IN boolean force_exec, IN u32 table_case)
1329 {
1330 const struct btc_chip_para *chip_para = btc->chip_para;
1331 u8 h2c_para[6] = {0};
1332 u32 table_wl = 0x5a5a5a5a;
1333
1334 h2c_para[0] = 0xd; /* op_code, 0xd= wlan slot toggle-A*/
1335 h2c_para[1] = 0x1; /* no definition */
1336
1337 if (btc->board_info.btdm_ant_num == 1) {
1338 if (table_case < chip_para->table_sant_num)
1339 table_wl = chip_para->table_sant[table_case].wl;
1340 } else {
1341 if (table_case < chip_para->table_nsant_num)
1342 table_wl = chip_para->table_nsant[table_case].wl;
1343 }
1344
1345 /* tell WL FW WL slot toggle table-A*/
1346 h2c_para[2] = (u8)(table_wl & 0xff);
1347 h2c_para[3] = (u8)((table_wl & 0xff00) >> 8);
1348 h2c_para[4] = (u8)((table_wl & 0xff0000) >> 16);
1349 h2c_para[5] = (u8)((table_wl & 0xff000000) >> 24);
1350
1351 btc->btc_fill_h2c(btc, 0x69, 6, h2c_para);
1352
1353 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
1354 "[BTCoex], %s(): H2C = [%02x %02x %02x %02x %02x %02x]\n",
1355 __func__, h2c_para[0], h2c_para[1], h2c_para[2],
1356 h2c_para[3], h2c_para[4], h2c_para[5]);
1357 BTC_TRACE(trace_buf);
1358 }
1359
1360 static void
rtw_btc_wltoggle_tableB(IN struct btc_coexist * btc,IN boolean force_exec,IN u8 interval,IN u32 table)1361 rtw_btc_wltoggle_tableB(IN struct btc_coexist *btc, IN boolean force_exec,
1362 IN u8 interval, IN u32 table)
1363 {
1364 struct btc_coex_sta *coex_sta = &btc->coex_sta;
1365 u8 cur_h2c_para[6] = {0};
1366 u8 i, match_cnt = 0;
1367
1368 cur_h2c_para[0] = 0x7; /* op_code, 0x7= wlan slot toggle-B*/
1369 cur_h2c_para[1] = interval;
1370 cur_h2c_para[2] = (u8)(table & 0xff);
1371 cur_h2c_para[3] = (u8)((table & 0xff00) >> 8);
1372 cur_h2c_para[4] = (u8)((table & 0xff0000) >> 16);
1373 cur_h2c_para[5] = (u8)((table & 0xff000000) >> 24);
1374
1375 if (ARRAY_SIZE(coex_sta->wl_toggle_para) != 6)
1376 return;
1377
1378 coex_sta->wl_toggle_interval = interval;
1379
1380 for (i = 0; i <= 5; i++)
1381 coex_sta->wl_toggle_para[i] = cur_h2c_para[i];
1382
1383 btc->btc_fill_h2c(btc, 0x69, 6, cur_h2c_para);
1384
1385 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
1386 "[BTCoex], %s(): H2C = [%02x %02x %02x %02x %02x %02x]\n",
1387 __func__, cur_h2c_para[0], cur_h2c_para[1], cur_h2c_para[2],
1388 cur_h2c_para[3], cur_h2c_para[4], cur_h2c_para[5]);
1389 BTC_TRACE(trace_buf);
1390 }
1391
1392 static void
rtw_btc_set_table(struct btc_coexist * btc,boolean force_exec,u32 val0x6c0,u32 val0x6c4)1393 rtw_btc_set_table(struct btc_coexist *btc, boolean force_exec, u32 val0x6c0,
1394 u32 val0x6c4)
1395 {
1396 struct btc_coex_sta *coex_sta = &btc->coex_sta;
1397 struct btc_coex_dm *coex_dm = &btc->coex_dm;
1398
1399 /* If last tdma is wl slot toggle, force write table*/
1400 if (!force_exec && coex_sta->coex_run_reason != BTC_RSN_LPS) {
1401 if (val0x6c0 == btc->btc_read_4byte(btc, REG_BT_COEX_TABLE0) &&
1402 val0x6c4 == btc->btc_read_4byte(btc, REG_BT_COEX_TABLE1))
1403 return;
1404 }
1405
1406 btc->btc_write_4byte(btc, REG_BT_COEX_TABLE0, val0x6c0);
1407 btc->btc_write_4byte(btc, REG_BT_COEX_TABLE1, val0x6c4);
1408 btc->btc_write_4byte(btc, REG_BT_COEX_BRK_TABLE, 0xf0ffffff);
1409
1410 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
1411 "[BTCoex], %s(): 0x6c0 = %x, 0x6c4 = %x\n",
1412 __func__, val0x6c0, val0x6c4);
1413 BTC_TRACE(trace_buf);
1414 }
1415
1416 static void
rtw_btc_table(struct btc_coexist * btc,boolean force_exec,u8 type)1417 rtw_btc_table(struct btc_coexist *btc, boolean force_exec, u8 type)
1418 {
1419 struct btc_coex_sta *coex_sta = &btc->coex_sta;
1420 const struct btc_chip_para *chip_para = btc->chip_para;
1421 u32 table_wl = 0x0;
1422
1423 coex_sta->coex_table_type = type;
1424
1425 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
1426 "[BTCoex], ***** Coex_Table - %d *****\n", type);
1427 BTC_TRACE(trace_buf);
1428
1429 if (btc->board_info.btdm_ant_num == 1) {
1430 if (type < chip_para->table_sant_num)
1431 rtw_btc_set_table(btc, force_exec,
1432 chip_para->table_sant[type].bt,
1433 chip_para->table_sant[type].wl);
1434 } else {
1435 type = type - 100;
1436 if (type < chip_para->table_nsant_num)
1437 rtw_btc_set_table(btc, force_exec,
1438 chip_para->table_nsant[type].bt,
1439 chip_para->table_nsant[type].wl);
1440 }
1441
1442 if (coex_sta->wl_slot_toggle_change)
1443 rtw_btc_wltoggle_tableA(btc, FC_EXCU, type);
1444 }
1445
1446 static void
rtw_btc_ignore_wlan_act(struct btc_coexist * btc,boolean force_exec,boolean enable)1447 rtw_btc_ignore_wlan_act(struct btc_coexist *btc, boolean force_exec,
1448 boolean enable)
1449 {
1450 struct btc_coex_dm *coex_dm = &btc->coex_dm;
1451 u8 h2c_para[1] = {0};
1452
1453 if (btc->manual_control || btc->stop_coex_dm)
1454 return;
1455
1456 if (!force_exec && enable == coex_dm->cur_ignore_wlan_act)
1457 return;
1458
1459 if (enable)
1460 h2c_para[0] = 0x1; /* function enable */
1461
1462 rtw_btc_mailbox_operation(btc, 0x63, 1, h2c_para);
1463
1464 coex_dm->cur_ignore_wlan_act = enable;
1465 }
1466
1467 static void
rtw_btc_lps_rpwm(struct btc_coexist * btc,boolean force_exec,u8 lps_val,u8 rpwm_val)1468 rtw_btc_lps_rpwm(struct btc_coexist *btc, boolean force_exec, u8 lps_val,
1469 u8 rpwm_val)
1470 {
1471 struct btc_coex_dm *coex_dm = &btc->coex_dm;
1472
1473 if (!force_exec) {
1474 if (lps_val == coex_dm->cur_lps &&
1475 rpwm_val == coex_dm->cur_rpwm)
1476 return;
1477 }
1478
1479 btc->btc_set(btc, BTC_SET_U1_LPS_VAL, &lps_val);
1480 btc->btc_set(btc, BTC_SET_U1_RPWM_VAL, &rpwm_val);
1481
1482 coex_dm->cur_lps = lps_val;
1483 coex_dm->cur_rpwm = rpwm_val;
1484 }
1485
1486 static void
rtw_btc_power_save_state(struct btc_coexist * btc,u8 ps_type,u8 lps_val,u8 rpwm_val)1487 rtw_btc_power_save_state(struct btc_coexist *btc, u8 ps_type, u8 lps_val,
1488 u8 rpwm_val)
1489 {
1490 struct btc_coex_sta *coex_sta = &btc->coex_sta;
1491 boolean low_pwr_dis = FALSE;
1492 u8 lps_mode = 0x0;
1493 u8 h2c_para[5] = {0, 0, 0, 0, 0};
1494
1495 btc->btc_get(btc, BTC_GET_U1_LPS_MODE, &lps_mode);
1496
1497 switch (ps_type) {
1498 case BTC_PS_WIFI_NATIVE:
1499 /* recover to original 32k low power setting */
1500 coex_sta->wl_force_lps_ctrl = FALSE;
1501 btc->btc_set(btc, BTC_SET_ACT_PRE_NORMAL_LPS, NULL);
1502
1503 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
1504 "[BTCoex], %s(): BTC_PS_WIFI_NATIVE\n", __func__);
1505 break;
1506 case BTC_PS_LPS_ON:
1507 /* WQCCE-1763: 8725A LPS lock issue*/
1508 if (coex_sta->coex_run_reason == BTC_RSN_LPS)
1509 break;
1510
1511 coex_sta->wl_force_lps_ctrl = TRUE;
1512 /*set tdma off if LPS off */
1513 if (!lps_mode)
1514 btc->btc_fill_h2c(btc, 0x60, 5, h2c_para);
1515 rtw_btc_lps_rpwm(btc, NM_EXCU, lps_val, rpwm_val);
1516 /* when coex force to enter LPS, do not enter 32k low power. */
1517 low_pwr_dis = TRUE;
1518 btc->btc_set(btc, BTC_SET_ACT_DISABLE_LOW_POWER, &low_pwr_dis);
1519 /* power save must executed before psTdma. */
1520 btc->btc_set(btc, BTC_SET_ACT_ENTER_LPS, NULL);
1521
1522 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
1523 "[BTCoex], %s(): BTC_PS_LPS_ON\n", __func__);
1524 break;
1525 case BTC_PS_LPS_OFF:
1526 coex_sta->wl_force_lps_ctrl = TRUE;
1527 /*set tdma off if LPS on */
1528 if (lps_mode)
1529 btc->btc_fill_h2c(btc, 0x60, 5, h2c_para);
1530 if (btc->btc_set(btc, BTC_SET_ACT_LEAVE_LPS, NULL))
1531 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
1532 "[BTCoex], %s(): BTC_PS_LPS_OFF\n",
1533 __func__);
1534 else
1535 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
1536 "[BTCoex], %s(): BTC_PS_LPS_OFF Fail!!\n",
1537 __func__);
1538 break;
1539 default:
1540 break;
1541 }
1542
1543 BTC_TRACE(trace_buf);
1544 }
1545
1546 static void
rtw_btc_set_tdma(struct btc_coexist * btc,u8 byte1,u8 byte2,u8 byte3,u8 byte4,u8 byte5)1547 rtw_btc_set_tdma(struct btc_coexist *btc, u8 byte1, u8 byte2, u8 byte3,
1548 u8 byte4, u8 byte5)
1549 {
1550 struct btc_coex_sta *coex_sta = &btc->coex_sta;
1551 struct btc_coex_dm *coex_dm = &btc->coex_dm;
1552 struct btc_wifi_link_info_ext *linfo_ext = &btc->wifi_link_info_ext;
1553 u8 ps_type = BTC_PS_WIFI_NATIVE,
1554 real_byte1 = byte1, real_byte5 = byte5;
1555
1556 if (linfo_ext->is_ap_mode && (byte1 & BIT(4) && !(byte1 & BIT(5)))) {
1557 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
1558 "[BTCoex], %s(): AP mode\n", __func__);
1559 BTC_TRACE(trace_buf);
1560
1561 real_byte1 &= ~BIT(4);
1562 real_byte1 |= BIT(5);
1563
1564 real_byte5 |= BIT(5);
1565 real_byte5 &= ~BIT(6);
1566
1567 ps_type = BTC_PS_WIFI_NATIVE;
1568 rtw_btc_power_save_state(btc, ps_type, 0x0, 0x0);
1569 } else if (byte1 & BIT(4) && !(byte1 & BIT(5))) {
1570 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
1571 "[BTCoex], %s(): Force LPS (byte1 = 0x%x)\n",
1572 __func__, byte1);
1573 BTC_TRACE(trace_buf);
1574
1575 if (btc->chip_para->pstdma_type == BTC_PSTDMA_FORCE_LPSOFF)
1576 ps_type = BTC_PS_LPS_OFF;
1577 else
1578 ps_type = BTC_PS_LPS_ON;
1579 rtw_btc_power_save_state(btc, ps_type, 0x50, 0x4);
1580 } else {
1581 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
1582 "[BTCoex], %s(): native power save (byte1 = 0x%x)\n",
1583 __func__, byte1);
1584 BTC_TRACE(trace_buf);
1585
1586 ps_type = BTC_PS_WIFI_NATIVE;
1587 rtw_btc_power_save_state(btc, ps_type, 0x0, 0x0);
1588 }
1589
1590 coex_dm->ps_tdma_para[0] = real_byte1;
1591 coex_dm->ps_tdma_para[1] = byte2;
1592 coex_dm->ps_tdma_para[2] = byte3;
1593 coex_dm->ps_tdma_para[3] = byte4;
1594 coex_dm->ps_tdma_para[4] = real_byte5;
1595
1596 btc->btc_fill_h2c(btc, 0x60, 5, coex_dm->ps_tdma_para);
1597
1598 /* Always forec excute rtw_btc_set_table To avoid
1599 * coex table error if wl slot toggle mode on ->off
1600 * ex: 5508031054 next state -> rtw_btc_table + 5108031054
1601 * rtw_btc_table may be changed by 5508031054
1602 */
1603 if (real_byte1 & BIT(2)) {
1604 coex_sta->wl_slot_toggle = TRUE;
1605 coex_sta->wl_slot_toggle_change = FALSE;
1606 } else {
1607 coex_sta->wl_slot_toggle_change = coex_sta->wl_slot_toggle;
1608 coex_sta->wl_slot_toggle = FALSE;
1609 }
1610
1611 if (ps_type == BTC_PS_WIFI_NATIVE)
1612 btc->btc_set(btc, BTC_SET_ACT_POST_NORMAL_LPS, NULL);
1613 }
1614
1615 static
rtw_btc_tdma(struct btc_coexist * btc,boolean force_exec,u32 tcase)1616 void rtw_btc_tdma(struct btc_coexist *btc, boolean force_exec, u32 tcase)
1617 {
1618 struct btc_coex_sta *coex_sta = &btc->coex_sta;
1619 struct btc_coex_dm *coex_dm = &btc->coex_dm;
1620 const struct btc_chip_para *chip_para = btc->chip_para;
1621 u8 type;
1622 boolean turn_on, wifi_busy = FALSE;
1623
1624 btc->btc_get(btc, BTC_GET_BL_WIFI_BUSY, &wifi_busy);
1625
1626 btc->btc_set_atomic(btc, &coex_dm->setting_tdma, TRUE);
1627 /* tcase: bit0~7 --> tdma case index
1628 * bit8 --> for 4-slot (50ms) mode
1629 */
1630
1631 if (tcase & TDMA_4SLOT)/* 4-slot (50ms) mode */
1632 rtw_btc_set_tdma_timer_base(btc, 3);
1633 else
1634 rtw_btc_set_tdma_timer_base(btc, 0);
1635
1636 type = (u8)(tcase & 0xff);
1637 turn_on = (type == 0 || type == 100) ? FALSE : TRUE;
1638
1639 /* To avoid TDMA H2C fail before Last LPS enter */
1640 if (!force_exec && coex_sta->coex_run_reason != BTC_RSN_LPS) {
1641 if (turn_on == coex_dm->cur_ps_tdma_on &&
1642 type == coex_dm->cur_ps_tdma) {
1643 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
1644 "[BTCoex], Skip TDMA because no change TDMA(%s, %d)\n",
1645 (coex_dm->cur_ps_tdma_on ? "on" : "off"),
1646 coex_dm->cur_ps_tdma);
1647 BTC_TRACE(trace_buf);
1648
1649 btc->btc_set_atomic(btc, &coex_dm->setting_tdma, FALSE);
1650 return;
1651 }
1652 }
1653
1654 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
1655 "[BTCoex], ***** TDMA - %d *****\n", type);
1656 BTC_TRACE(trace_buf);
1657
1658 /* TRUE -> Page scan > ACL */
1659 if (!wifi_busy ||
1660 (coex_sta->bt_a2dp_exist && coex_sta->bt_inq_page_remain)) {
1661 if (chip_para->scbd_bit_num == BTC_SCBD_16_BIT)
1662 btc->btc_write_scbd(btc, BTC_SCBD_TDMA, FALSE);
1663 else
1664 btc->btc_write_scbd_32bit(btc, BTC_SCBD_TDMA, FALSE);
1665 } else {
1666 if (chip_para->scbd_bit_num == BTC_SCBD_16_BIT)
1667 btc->btc_write_scbd(btc, BTC_SCBD_TDMA, TRUE);
1668 else
1669 btc->btc_write_scbd_32bit(btc, BTC_SCBD_TDMA, TRUE);
1670 }
1671
1672 if (btc->board_info.btdm_ant_num == 1) {
1673 if (type < chip_para->tdma_sant_num)
1674 rtw_btc_set_tdma(btc,
1675 chip_para->tdma_sant[type].para[0],
1676 chip_para->tdma_sant[type].para[1],
1677 chip_para->tdma_sant[type].para[2],
1678 chip_para->tdma_sant[type].para[3],
1679 chip_para->tdma_sant[type].para[4]);
1680 } else {
1681 type = type - 100;
1682 if (type < chip_para->tdma_nsant_num)
1683 rtw_btc_set_tdma(btc,
1684 chip_para->tdma_nsant[type].para[0],
1685 chip_para->tdma_nsant[type].para[1],
1686 chip_para->tdma_nsant[type].para[2],
1687 chip_para->tdma_nsant[type].para[3],
1688 chip_para->tdma_nsant[type].para[4]);
1689 }
1690
1691 coex_dm->cur_ps_tdma_on = turn_on;
1692 coex_dm->cur_ps_tdma = type;
1693
1694 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE, "change TDMA(%s, %d)\n",
1695 (coex_dm->cur_ps_tdma_on ? "on" : "off"),
1696 coex_dm->cur_ps_tdma);
1697 BTC_TRACE(trace_buf);
1698
1699 btc->btc_set_atomic(btc, &coex_dm->setting_tdma, FALSE);
1700 }
1701
1702 static
rtw_btc_set_ant_switch(struct btc_coexist * btc,boolean force_exec,u8 ctrl_type,u8 pos_type)1703 void rtw_btc_set_ant_switch(struct btc_coexist *btc, boolean force_exec,
1704 u8 ctrl_type, u8 pos_type)
1705 {
1706 struct btc_coex_dm *coex_dm = &btc->coex_dm;
1707
1708 if (!force_exec) {
1709 if (((ctrl_type << 8) + pos_type) == coex_dm->cur_switch_status)
1710 return;
1711 }
1712
1713 coex_dm->cur_switch_status = (ctrl_type << 8) + pos_type;
1714
1715 btc->chip_para->chip_setup(btc, BTC_CSETUP_ANT_SWITCH);
1716 }
1717
1718 static
rtw_btc_set_ant_path(struct btc_coexist * btc,boolean force_exec,u8 phase)1719 void rtw_btc_set_ant_path(struct btc_coexist *btc, boolean force_exec,
1720 u8 phase)
1721 {
1722 struct btc_coex_sta *coex_sta = &btc->coex_sta;
1723 struct btc_coex_dm *coex_dm = &btc->coex_dm;
1724 struct btc_rfe_type *rfe_type = &btc->rfe_type;
1725 struct btc_wifi_link_info_ext *linfo_ext = &btc->wifi_link_info_ext;
1726 const struct btc_chip_para *chip_para = btc->chip_para;
1727 u8 ctrl_type = BTC_SWITCH_CTRL_MAX,
1728 pos_type = BTC_SWITCH_TO_MAX, cnt = 0;
1729 u16 scbd = 0;
1730 u32 scbd_32 = 0;
1731 boolean is_btk = 0, is_wlk = 0;
1732
1733 if (!force_exec && coex_dm->cur_ant_pos_type == phase)
1734 return;
1735
1736 coex_dm->cur_ant_pos_type = phase;
1737
1738 /* To avoid switch coex_ctrl_owner during BT IQK */
1739 if (btc->chip_para->scbd_support && coex_sta->bt_iqk_state != 0xff) {
1740
1741 while (++cnt < 60) {
1742 /* BT RFK */
1743 if (chip_para->scbd_bit_num == BTC_SCBD_16_BIT) {
1744 if (btc->btc_read_scbd(btc, &scbd) & BIT(5))
1745 is_btk = TRUE;
1746 else
1747 is_btk = FALSE;
1748 } else {
1749 if (btc->btc_read_scbd_32bit(btc, &scbd_32) & BIT(5))
1750 is_btk = TRUE;
1751 else
1752 is_btk = FALSE;
1753 }
1754 /* WL RFK */
1755 if ((phase != BTC_ANT_WOFF) &&
1756 ((btc->btc_read_1byte(btc, 0x49c) & BIT(0)) ||
1757 coex_sta->wl_rfk))
1758 is_wlk = TRUE;
1759 else
1760 is_wlk = FALSE;
1761
1762 if ((!is_btk && !is_wlk) || scbd == 0x7ff)
1763 break;
1764
1765 delay_ms(10);
1766 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
1767 "[BTCoex], Ant Setup Delay by IQK\n, wlk=%d, btk=%d, cnt=%d\n",
1768 is_wlk, is_btk, cnt);
1769 BTC_TRACE(trace_buf);
1770 }
1771 /* wait timeout */
1772 if (cnt >= 60)
1773 coex_sta->bt_iqk_state = 0xff;
1774 }
1775
1776 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
1777 "[BTCoex], coex_sta->bt_disabled = 0x%x\n",
1778 coex_sta->bt_disabled);
1779 BTC_TRACE(trace_buf);
1780
1781 switch (phase) {
1782 case BTC_ANT_POWERON:
1783 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
1784 "[BTCoex], %s() - PHASE_COEX_POWERON\n", __func__);
1785 BTC_TRACE(trace_buf);
1786
1787 /* set Path control owner to BT at power-on step */
1788 if (coex_sta->bt_disabled)
1789 rtw_btc_coex_ctrl_owner(btc, BTC_OWNER_WL);
1790 else
1791 rtw_btc_coex_ctrl_owner(btc, BTC_OWNER_BT);
1792
1793 /*Caution: Don't indirect access while power on phase */
1794
1795 ctrl_type = BTC_SWITCH_CTRL_BY_BBSW;
1796 pos_type = BTC_SWITCH_TO_BT;
1797 break;
1798 case BTC_ANT_INIT:
1799 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
1800 "[BTCoex], %s() - PHASE_COEX_INIT\n", __func__);
1801 BTC_TRACE(trace_buf);
1802
1803 if (coex_sta->bt_disabled) {
1804 /* set GNT_BT to SW low */
1805 rtw_btc_set_gnt_bt(btc, BTC_GNT_SW_LOW);
1806 /* set GNT_WL to SW high */
1807 rtw_btc_set_gnt_wl(btc, BTC_GNT_SW_HIGH);
1808 } else {
1809 /* set GNT_BT to SW high */
1810 rtw_btc_set_gnt_bt(btc, BTC_GNT_SW_HIGH);
1811 /* set GNT_WL to SW low */
1812 rtw_btc_set_gnt_wl(btc, BTC_GNT_SW_LOW);
1813 }
1814
1815 /* set Path control owner to WL at initial step */
1816 rtw_btc_coex_ctrl_owner(btc, BTC_OWNER_WL);
1817
1818 ctrl_type = BTC_SWITCH_CTRL_BY_BBSW;
1819 pos_type = BTC_SWITCH_TO_BT;
1820 break;
1821 case BTC_ANT_WONLY:
1822 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
1823 "[BTCoex], %s() - PHASE_WLANONLY_INIT\n", __func__);
1824 BTC_TRACE(trace_buf);
1825
1826 /* set GNT_BT to SW Low */
1827 rtw_btc_set_gnt_bt(btc, BTC_GNT_SW_LOW);
1828 /* Set GNT_WL to SW high */
1829 rtw_btc_set_gnt_wl(btc, BTC_GNT_SW_HIGH);
1830 /* set Path control owner to WL at initial step */
1831 rtw_btc_coex_ctrl_owner(btc, BTC_OWNER_WL);
1832
1833 ctrl_type = BTC_SWITCH_CTRL_BY_BBSW;
1834 pos_type = BTC_SWITCH_TO_WLG;
1835 break;
1836 case BTC_ANT_WOFF:
1837 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
1838 "[BTCoex], %s() - PHASE_WLAN_OFF\n", __func__);
1839 BTC_TRACE(trace_buf);
1840
1841 /* set Path control owner to BT */
1842 rtw_btc_coex_ctrl_owner(btc, BTC_OWNER_BT);
1843
1844 ctrl_type = BTC_SWITCH_CTRL_BY_BT;
1845 pos_type = BTC_SWITCH_TO_NOCARE;
1846 break;
1847 case BTC_ANT_2G:
1848 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
1849 "[BTCoex], %s() - PHASE_2G_RUNTIME\n", __func__);
1850 BTC_TRACE(trace_buf);
1851
1852 /* set GNT_BT to PTA */
1853 rtw_btc_set_gnt_bt(btc, BTC_GNT_HW_PTA);
1854 /* Set GNT_WL to PTA */
1855 rtw_btc_set_gnt_wl(btc, BTC_GNT_HW_PTA);
1856
1857 /* set Path control owner to WL at runtime step */
1858 rtw_btc_coex_ctrl_owner(btc, BTC_OWNER_WL);
1859
1860 ctrl_type = BTC_SWITCH_CTRL_BY_PTA;
1861 pos_type = BTC_SWITCH_TO_NOCARE;
1862 break;
1863 case BTC_ANT_5G:
1864 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
1865 "[BTCoex], %s() - PHASE_5G_RUNTIME\n", __func__);
1866 BTC_TRACE(trace_buf);
1867
1868 if (linfo_ext->is_ap_mode &&
1869 strcmp(btc->chip_para->chip_name, "8723f") != 0) {
1870 /* set GNT_BT to SW PTA
1871 8723f cannot set GNT_BT PTA control when SW control*/
1872 rtw_btc_set_gnt_bt(btc, BTC_GNT_HW_PTA);
1873 } else {
1874 /* set GNT_BT to SW Hi */
1875 rtw_btc_set_gnt_bt(btc, BTC_GNT_SW_HIGH);
1876 }
1877
1878 /* Set GNT_WL to SW Hi */
1879 rtw_btc_set_gnt_wl(btc, BTC_GNT_SW_HIGH);
1880
1881 /* set Path control owner to WL at runtime step */
1882 rtw_btc_coex_ctrl_owner(btc, BTC_OWNER_WL);
1883
1884 ctrl_type = BTC_SWITCH_CTRL_BY_BBSW;
1885 pos_type = BTC_SWITCH_TO_WLA;
1886 break;
1887 case BTC_ANT_2G_FREERUN:
1888 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
1889 "[BTCoex], %s() - PHASE_2G_FREERUN\n", __func__);
1890 BTC_TRACE(trace_buf);
1891
1892 /*8723f cannot set GNT_BT PTA control when SW control*/
1893 if (strcmp(btc->chip_para->chip_name, "8723f") == 0) {
1894 /* Set GNT_BT to SW Hi */
1895 rtw_btc_set_gnt_bt(btc, BTC_GNT_SW_HIGH);
1896 } else {
1897 /* set GNT_BT to SW PTA */
1898 rtw_btc_set_gnt_bt(btc, BTC_GNT_HW_PTA);
1899 }
1900
1901 /* Set GNT_WL to SW Hi */
1902 rtw_btc_set_gnt_wl(btc, BTC_GNT_SW_HIGH);
1903
1904 /* set Path control owner to WL at runtime step */
1905 rtw_btc_coex_ctrl_owner(btc, BTC_OWNER_WL);
1906
1907 ctrl_type = BTC_SWITCH_CTRL_BY_BBSW;
1908 pos_type = BTC_SWITCH_TO_WLG_BT;
1909 break;
1910 case BTC_ANT_2G_WLBT:
1911 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
1912 "[BTCoex], %s() - PHASE_2G_WLBT\n", __func__);
1913 BTC_TRACE(trace_buf);
1914
1915 /* set GNT_BT to HW PTA */
1916 rtw_btc_set_gnt_bt(btc, BTC_GNT_HW_PTA);
1917 /* Set GNT_WL to HW PTA */
1918 rtw_btc_set_gnt_wl(btc, BTC_GNT_HW_PTA);
1919 /* set Path control owner to WL at runtime step */
1920 rtw_btc_coex_ctrl_owner(btc, BTC_OWNER_WL);
1921
1922 ctrl_type = BTC_SWITCH_CTRL_BY_BBSW;
1923 pos_type = BTC_SWITCH_TO_WLG_BT;
1924 break;
1925 case BTC_ANT_2G_WL:
1926 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
1927 "[BTCoex], %s() - PHASE_2G_WL\n", __func__);
1928 BTC_TRACE(trace_buf);
1929
1930 /* set GNT_BT to PTA */
1931 rtw_btc_set_gnt_bt(btc, BTC_GNT_HW_PTA);
1932 /* Set GNT_WL to PTA */
1933 rtw_btc_set_gnt_wl(btc, BTC_GNT_HW_PTA);
1934 /* set Path control owner to WL at runtime step */
1935 rtw_btc_coex_ctrl_owner(btc, BTC_OWNER_WL);
1936
1937 ctrl_type = BTC_SWITCH_CTRL_BY_BBSW;
1938 pos_type = BTC_SWITCH_TO_WLG;
1939 break;
1940 case BTC_ANT_2G_BT:
1941 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
1942 "[BTCoex], %s() - PHASE_2G_WL\n", __func__);
1943 BTC_TRACE(trace_buf);
1944
1945 /* set GNT_BT to PTA */
1946 rtw_btc_set_gnt_bt(btc, BTC_GNT_HW_PTA);
1947 /* Set GNT_WL to PTA */
1948 rtw_btc_set_gnt_wl(btc, BTC_GNT_HW_PTA);
1949 /* set Path control owner to WL at runtime step */
1950 rtw_btc_coex_ctrl_owner(btc, BTC_OWNER_WL);
1951
1952 ctrl_type = BTC_SWITCH_CTRL_BY_BBSW;
1953 pos_type = BTC_SWITCH_TO_BT;
1954 break;
1955 case BTC_ANT_BTMP:
1956 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
1957 "[BTCoex], %s() - PHASE_BTMP\n", __func__);
1958 BTC_TRACE(trace_buf);
1959
1960 /* set GNT_BT to SW Hi */
1961 rtw_btc_set_gnt_bt(btc, BTC_GNT_SW_HIGH);
1962 /* Set GNT_WL to SW Lo */
1963 rtw_btc_set_gnt_wl(btc, BTC_GNT_SW_LOW);
1964 /* set Path control owner to WL */
1965 rtw_btc_coex_ctrl_owner(btc, BTC_OWNER_WL);
1966
1967 btc->stop_coex_dm = TRUE;
1968
1969 ctrl_type = BTC_SWITCH_CTRL_BY_BBSW;
1970 pos_type = BTC_SWITCH_TO_BT;
1971 break;
1972 case BTC_ANT_MCC:
1973 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
1974 "[BTCoex], %s() - PHASE_MCC\n", __func__);
1975 BTC_TRACE(trace_buf);
1976
1977 /* set GNT_BT to PTA */
1978 rtw_btc_set_gnt_bt(btc, BTC_GNT_HW_PTA);
1979 /* Set GNT_WL to PTA */
1980 rtw_btc_set_gnt_wl(btc, BTC_GNT_HW_PTA);
1981 /* set Path control owner to WL at runtime step */
1982 rtw_btc_coex_ctrl_owner(btc, BTC_OWNER_WL);
1983
1984 ctrl_type = BTC_SWITCH_CTRL_BY_FW;
1985 pos_type = BTC_SWITCH_TO_NOCARE;
1986 break;
1987 }
1988
1989 if (ctrl_type < BTC_SWITCH_CTRL_MAX && pos_type < BTC_SWITCH_TO_MAX &&
1990 rfe_type->ant_switch_exist)
1991 rtw_btc_set_ant_switch(btc, force_exec, ctrl_type, pos_type);
1992 }
1993
rtw_btc_algorithm(struct btc_coexist * btc)1994 static u8 rtw_btc_algorithm(struct btc_coexist *btc)
1995 {
1996 struct btc_coex_sta *coex_sta = &btc->coex_sta;
1997 u8 algorithm = BTC_COEX_NOPROFILE;
1998 u8 profile_map = 0;
1999
2000 if (coex_sta->bt_hfp_exist)
2001 profile_map = profile_map | BTC_BTPROFILE_HFP;
2002
2003 if (coex_sta->bt_hid_exist)
2004 profile_map = profile_map | BTC_BTPROFILE_HID;
2005
2006 if (coex_sta->bt_a2dp_exist)
2007 profile_map = profile_map | BTC_BTPROFILE_A2DP;
2008
2009 if (coex_sta->bt_pan_exist)
2010 profile_map = profile_map | BTC_BTPROFILE_PAN;
2011
2012 switch (profile_map) {
2013 case BTC_BTPROFILE_NONE:
2014 algorithm = BTC_COEX_NOPROFILE;
2015 break;
2016 case BTC_BTPROFILE_HFP:
2017 algorithm = BTC_COEX_HFP;
2018 break;
2019 case BTC_BTPROFILE_HID:
2020 algorithm = BTC_COEX_HID;
2021 break;
2022 case (BTC_BTPROFILE_HID | BTC_BTPROFILE_HFP):
2023 algorithm = BTC_COEX_HFP;
2024 break;
2025 case BTC_BTPROFILE_A2DP:
2026 /* OPP may disappear during CPT_for_WiFi test */
2027 if (coex_sta->bt_multi_link && coex_sta->bt_hid_pair_num > 0)
2028 algorithm = BTC_COEX_A2DP_HID;
2029 else if (coex_sta->bt_multi_link)
2030 algorithm = BTC_COEX_A2DP_PAN;
2031 else
2032 algorithm = BTC_COEX_A2DP;
2033 break;
2034 case (BTC_BTPROFILE_A2DP | BTC_BTPROFILE_HFP):
2035 algorithm = BTC_COEX_A2DP_HID;
2036 break;
2037 case (BTC_BTPROFILE_A2DP | BTC_BTPROFILE_HID):
2038 algorithm = BTC_COEX_A2DP_HID;
2039 break;
2040 case (BTC_BTPROFILE_A2DP | BTC_BTPROFILE_HID | BTC_BTPROFILE_HFP):
2041 algorithm = BTC_COEX_A2DP_HID;
2042 break;
2043 case BTC_BTPROFILE_PAN:
2044 algorithm = BTC_COEX_PAN;
2045 break;
2046 case (BTC_BTPROFILE_PAN | BTC_BTPROFILE_HFP):
2047 algorithm = BTC_COEX_PAN_HID;
2048 break;
2049 case (BTC_BTPROFILE_PAN | BTC_BTPROFILE_HID):
2050 algorithm = BTC_COEX_PAN_HID;
2051 break;
2052 case (BTC_BTPROFILE_PAN | BTC_BTPROFILE_HID | BTC_BTPROFILE_HFP):
2053 algorithm = BTC_COEX_PAN_HID;
2054 break;
2055 case (BTC_BTPROFILE_PAN | BTC_BTPROFILE_A2DP):
2056 algorithm = BTC_COEX_A2DP_PAN;
2057 break;
2058 case (BTC_BTPROFILE_PAN | BTC_BTPROFILE_A2DP | BTC_BTPROFILE_HFP):
2059 algorithm = BTC_COEX_A2DP_PAN_HID;
2060 break;
2061 case (BTC_BTPROFILE_PAN | BTC_BTPROFILE_A2DP | BTC_BTPROFILE_HID):
2062 algorithm = BTC_COEX_A2DP_PAN_HID;
2063 break;
2064 case BTC_BTPROFILE_MAX:
2065 algorithm = BTC_COEX_A2DP_PAN_HID;
2066 break;
2067 }
2068
2069 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2070 "[BTCoex], BT Profile = %s => Algorithm = %s\n",
2071 bt_profile_string[profile_map],
2072 coex_algo_string[algorithm]);
2073 BTC_TRACE(trace_buf);
2074
2075 return algorithm;
2076 }
2077
rtw_btc_action_coex_all_off(struct btc_coexist * btc)2078 static void rtw_btc_action_coex_all_off(struct btc_coexist *btc)
2079 {
2080 u8 table_case, tdma_case;
2081
2082 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE, "[BTCoex], %s()\n", __func__);
2083 BTC_TRACE(trace_buf);
2084
2085 rtw_btc_set_rf_para(btc, NM_EXCU, btc->chip_para->wl_rf_para_rx[0]);
2086
2087 /* To avoid rtw_btc_set_ant_path here */
2088 if (btc->board_info.btdm_ant_num == 1) { /* Shared-Ant */
2089 table_case = 2;
2090 tdma_case = 0;
2091 } else { /* Non-Shared-Ant */
2092 table_case = 100;
2093 tdma_case = 100;
2094 }
2095
2096 rtw_btc_table(btc, NM_EXCU, table_case);
2097 rtw_btc_tdma(btc, NM_EXCU, tdma_case);
2098 }
2099
rtw_btc_action_freerun(struct btc_coexist * btc)2100 static void rtw_btc_action_freerun(struct btc_coexist *btc)
2101 {
2102 struct btc_coex_sta *coex_sta = &btc->coex_sta;
2103 struct btc_coex_dm *coex_dm = &btc->coex_dm;
2104 const struct btc_chip_para *cpara = btc->chip_para;
2105 struct btc_wifi_link_info_ext *link_info_ext = &btc->wifi_link_info_ext;
2106 u8 level = 0, i, base = 0;
2107 boolean bt_afh_loss = TRUE;
2108 u32 ap_cnt;
2109
2110 if (btc->board_info.btdm_ant_num != 2)
2111 return;
2112
2113 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE, "[BTCoex], %s()\n", __func__);
2114 BTC_TRACE(trace_buf);
2115
2116 coex_sta->coex_freerun = TRUE;
2117
2118 for (i = 0; i <= 8; i++) {
2119 if (coex_sta->bt_afh_map[i] != 0xff) {
2120 bt_afh_loss = FALSE;
2121 break;
2122 }
2123 }
2124
2125 ap_cnt = coex_sta->cnt_wl[BTC_CNT_WL_SCANAP];
2126
2127 if (bt_afh_loss)
2128 rtw_btc_update_wl_ch_info(btc, BTC_MEDIA_CONNECT);
2129
2130 rtw_btc_set_ant_path(btc, NM_EXCU, BTC_ANT_2G_FREERUN);
2131
2132 if (cpara->scbd_bit_num == BTC_SCBD_16_BIT)
2133 btc->btc_write_scbd(btc, BTC_SCBD_FIX2M, FALSE);
2134 else
2135 btc->btc_write_scbd_32bit(btc, BTC_SCBD_FIX2M, FALSE);
2136
2137 /* select array index base for profile */
2138 if (coex_sta->bt_hid_exist && !coex_sta->bt_multi_link)
2139 base = 2;
2140 else if (coex_sta->bt_a2dp_exist && !coex_sta->bt_multi_link)
2141 base = 10;
2142 else if (coex_sta->bt_hid_exist && coex_sta->bt_a2dp_exist
2143 && coex_sta->bt_profile_num == 2)
2144 base = 18;
2145
2146 if (ap_cnt > 10) /* for office case */
2147 base = base + 4;
2148
2149 /* decrease more BT Tx power for clear case */
2150 if (BTC_RSSI_HIGH(coex_dm->wl_rssi_state[0]))
2151 level = 0;
2152 else if (BTC_RSSI_HIGH(coex_dm->wl_rssi_state[1]))
2153 level = 1;
2154 else if (BTC_RSSI_HIGH(coex_dm->wl_rssi_state[2]))
2155 level = 2;
2156 else
2157 level = 3;
2158
2159 level = level + base;
2160
2161 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2162 "[BTCoex], level = %d\n",
2163 level);
2164 BTC_TRACE(trace_buf);
2165
2166 if (level > cpara->wl_rf_para_tx_num - 1)
2167 level = cpara->wl_rf_para_tx_num - 1;
2168
2169 if (coex_sta->wl_coex_mode != BTC_WLINK_2G1PORT)
2170 rtw_btc_set_rf_para(btc, NM_EXCU, cpara->wl_rf_para_rx[0]);
2171 else if (link_info_ext->traffic_dir == BTC_WIFI_TRAFFIC_TX)
2172 rtw_btc_set_rf_para(btc, NM_EXCU, cpara->wl_rf_para_tx[level]);
2173 else
2174 rtw_btc_set_rf_para(btc, NM_EXCU, cpara->wl_rf_para_rx[level]);
2175
2176 rtw_btc_table(btc, NM_EXCU, 100);
2177 rtw_btc_tdma(btc, NM_EXCU, 100);
2178 }
2179
rtw_btc_action_rf4ce(struct btc_coexist * btc)2180 static void rtw_btc_action_rf4ce(struct btc_coexist *btc)
2181 {
2182 struct btc_coex_sta *coex_sta = &btc->coex_sta;
2183 const struct btc_chip_para *chip_para = btc->chip_para;
2184 u8 table_case, tdma_case;
2185
2186 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE, "[BTCoex], %s()\n", __func__);
2187 BTC_TRACE(trace_buf);
2188
2189 rtw_btc_set_rf_para(btc, NM_EXCU, chip_para->wl_rf_para_rx[0]);
2190 rtw_btc_set_ant_path(btc, NM_EXCU, BTC_ANT_2G);
2191
2192 switch (coex_sta->ext_chip_mode) {
2193 case 0:
2194 table_case = 112;
2195 tdma_case = 115;
2196
2197 if (coex_sta->bt_slave)
2198 rtw_btc_set_extend_btautoslot(btc, 0x3c);
2199 else
2200 rtw_btc_set_extend_btautoslot(btc, 0x32);
2201
2202 rtw_btc_table(btc, NM_EXCU, table_case);
2203 rtw_btc_tdma(btc, NM_EXCU, tdma_case);
2204 break;
2205 case 1:
2206 table_case = 112;
2207 tdma_case = 121;
2208
2209 rtw_btc_table(btc, NM_EXCU, table_case);
2210 rtw_btc_tdma(btc, NM_EXCU, tdma_case);
2211 break;
2212 }
2213 }
2214
rtw_btc_action_ext_chip(struct btc_coexist * btc)2215 static void rtw_btc_action_ext_chip(struct btc_coexist *btc)
2216 {
2217 struct btc_coex_sta *coex_sta = &btc->coex_sta;
2218
2219 if (btc->board_info.ext_chip_id == BTC_EXT_CHIP_RF4CE)
2220 rtw_btc_action_rf4ce(btc);
2221 }
2222
rtw_btc_action_rf4ce_new_tdma(struct btc_coexist * btc,u8 type)2223 u8 rtw_btc_action_rf4ce_new_tdma(struct btc_coexist *btc, u8 type)
2224 {
2225 struct btc_coex_sta *coex_sta = &btc->coex_sta;
2226 const struct btc_chip_para *chip_para = btc->chip_para;
2227 u8 table_case, tdma_case;
2228
2229 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE, "[BTCoex], %s()\n", __func__);
2230 BTC_TRACE(trace_buf);
2231
2232 switch (type) {
2233 case 0: /*BT idle*/
2234 if (coex_sta->ext_chip_mode == BTC_EXTMODE_VOICE)
2235 tdma_case = 121;
2236 else
2237 tdma_case = 117;
2238 break;
2239 case 1: /*BT relink*/
2240 if (coex_sta->ext_chip_mode == BTC_EXTMODE_VOICE)
2241 tdma_case = 121;
2242 else
2243 tdma_case = 117;
2244 break;
2245 case 2: /*WIFI linkscan*/
2246 if (coex_sta->ext_chip_mode == BTC_EXTMODE_VOICE) {
2247 tdma_case = 125;
2248 } else{
2249 if (coex_sta->bt_slave)
2250 rtw_btc_set_extend_btautoslot(btc, 0x3c);
2251 else
2252 rtw_btc_set_extend_btautoslot(btc, 0x32);
2253
2254 tdma_case = 124;
2255 }
2256 break;
2257 case 3: /*WIFI only*/
2258 if (coex_sta->ext_chip_mode == BTC_EXTMODE_VOICE) {
2259 tdma_case = 121;
2260 } else{
2261 if (coex_sta->bt_slave)
2262 rtw_btc_set_extend_btautoslot(btc, 0x3c);
2263 else
2264 rtw_btc_set_extend_btautoslot(btc, 0x32);
2265
2266 tdma_case = 115;
2267 }
2268 break;
2269 default:
2270 tdma_case = 0;
2271 break;
2272 }
2273 return tdma_case;
2274 }
2275
rtw_btc_ext_chip_new_tdma(struct btc_coexist * btc,u8 type)2276 u8 rtw_btc_ext_chip_new_tdma(struct btc_coexist *btc, u8 type)
2277 {
2278 struct btc_coex_sta *coex_sta = &btc->coex_sta;
2279 u8 tdma_case = 0;
2280
2281 if (btc->board_info.ext_chip_id == BTC_EXT_CHIP_RF4CE)
2282 tdma_case = rtw_btc_action_rf4ce_new_tdma(btc, type);
2283
2284 return tdma_case;
2285 }
2286
rtw_btc_action_bt_whql_test(struct btc_coexist * btc)2287 static void rtw_btc_action_bt_whql_test(struct btc_coexist *btc)
2288 {
2289 u8 table_case, tdma_case;
2290
2291 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE, "[BTCoex], %s()\n", __func__);
2292 BTC_TRACE(trace_buf);
2293
2294 rtw_btc_set_ant_path(btc, NM_EXCU, BTC_ANT_2G);
2295 rtw_btc_set_rf_para(btc, NM_EXCU, btc->chip_para->wl_rf_para_rx[0]);
2296
2297 if (btc->board_info.btdm_ant_num == 1) { /* Shared-Ant */
2298 table_case = 2;
2299 tdma_case = 0;
2300 } else { /* Non-Shared-Ant */
2301 table_case = 100;
2302 tdma_case = 100;
2303 }
2304
2305 rtw_btc_table(btc, NM_EXCU, table_case);
2306 rtw_btc_tdma(btc, NM_EXCU, tdma_case);
2307 }
2308
rtw_btc_action_bt_relink(struct btc_coexist * btc)2309 static void rtw_btc_action_bt_relink(struct btc_coexist *btc)
2310 {
2311 struct btc_coex_sta *coex_sta = &btc->coex_sta;
2312 u8 table_case, tdma_case;
2313 u32 slot_type = 0;
2314
2315 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE, "[BTCoex], %s()\n", __func__);
2316 BTC_TRACE(trace_buf);
2317
2318 rtw_btc_set_ant_path(btc, NM_EXCU, BTC_ANT_2G);
2319 rtw_btc_set_rf_para(btc, NM_EXCU, btc->chip_para->wl_rf_para_rx[0]);
2320
2321 if (btc->board_info.btdm_ant_num == 1) { /* Shared-Ant */
2322 if (coex_sta->wl_gl_busy) {
2323 table_case = 26;
2324
2325 if (coex_sta->bt_hid_exist &&
2326 coex_sta->bt_profile_num == 1) {
2327 slot_type = TDMA_4SLOT;
2328 tdma_case = 20;
2329 } else {
2330 tdma_case = 20;
2331 }
2332 } else {
2333 table_case = 1;
2334 tdma_case = 0;
2335 }
2336 } else { /* Non-Shared-Ant */
2337 if (coex_sta->wl_gl_busy)
2338 table_case = 115;
2339 else
2340 table_case = 100;
2341 tdma_case = 100;
2342
2343 if (coex_sta->wl_gl_busy &&
2344 btc->board_info.ext_chip_id != BTC_EXT_CHIP_NONE)
2345 tdma_case = rtw_btc_ext_chip_new_tdma(btc, 1);
2346 }
2347
2348 rtw_btc_table(btc, NM_EXCU, table_case);
2349 rtw_btc_tdma(btc, NM_EXCU, tdma_case | slot_type);
2350 }
2351
rtw_btc_action_bt_idle(struct btc_coexist * btc)2352 static void rtw_btc_action_bt_idle(struct btc_coexist *btc)
2353 {
2354 struct btc_coex_sta *coex_sta = &btc->coex_sta;
2355 struct btc_coex_dm *coex_dm = &btc->coex_dm;
2356 struct btc_rfe_type *rfe_type = &btc->rfe_type;
2357 struct btc_wifi_link_info *link_info = &btc->wifi_link_info;
2358 u8 table_case = 0xff, tdma_case = 0xff;
2359
2360 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE, "[BTCoex], %s()\n", __func__);
2361 BTC_TRACE(trace_buf);
2362
2363 rtw_btc_set_rf_para(btc, NM_EXCU, btc->chip_para->wl_rf_para_rx[0]);
2364
2365 if (rfe_type->ant_switch_with_bt &&
2366 coex_dm->bt_status == BTC_BTSTATUS_NCON_IDLE) {
2367 if (btc->board_info.btdm_ant_num == 1 &&
2368 BTC_RSSI_HIGH(coex_dm->wl_rssi_state[3]) &&
2369 coex_sta->wl_gl_busy) {
2370 table_case = 0;
2371 tdma_case = 0;
2372 } else if (btc->board_info.btdm_ant_num == 2) {
2373 table_case = 100;
2374 tdma_case = 100;
2375 }
2376
2377 if (table_case != 0xff && tdma_case != 0xff) {
2378 rtw_btc_set_ant_path(btc, NM_EXCU, BTC_ANT_2G_FREERUN);
2379 goto exit;
2380 }
2381 }
2382
2383 rtw_btc_set_ant_path(btc, NM_EXCU, BTC_ANT_2G);
2384 #if 0
2385 #ifndef PLATFORM_WINDOWS
2386 if (coex_sta->wl_noisy_level > 0) {
2387 if (btc->board_info.btdm_ant_num == 1) { /* Shared-Ant */
2388 table_case = 1;
2389 tdma_case = 0;
2390 } else { /* Non-Shared-Ant */
2391 table_case = 123;
2392 tdma_case = 0;
2393 }
2394 goto exit;
2395 }
2396 #endif
2397 #endif
2398 if (btc->board_info.btdm_ant_num == 1) { /* Shared-Ant */
2399 if (!coex_sta->wl_gl_busy) {
2400 table_case = 10;
2401 tdma_case = 3;
2402 } else if (coex_sta->bt_mesh) {
2403 table_case = 26;
2404 tdma_case = 7;
2405 } else if (coex_dm->bt_status == BTC_BTSTATUS_NCON_IDLE) {
2406 table_case = 11;
2407
2408 if (coex_sta->bt_ctr_ok &&
2409 (coex_sta->lo_pri_rx + coex_sta->lo_pri_tx > 250))
2410 tdma_case = 17;
2411 else
2412 tdma_case = 7;
2413 } else {
2414 table_case = 12;
2415 tdma_case = 7;
2416 }
2417 } else { /* Non-Shared-Ant */
2418 if (!coex_sta->wl_gl_busy) {
2419 table_case = 112;
2420 tdma_case = 104;
2421 } else if ((coex_sta->bt_ble_scan_type & 0x2) &&
2422 coex_dm->bt_status == BTC_BTSTATUS_NCON_IDLE) {
2423 table_case = 114;
2424 tdma_case = 103;
2425 } else {
2426 table_case = 112;
2427 tdma_case = 103;
2428 }
2429 if (coex_sta->wl_gl_busy &&
2430 btc->board_info.ext_chip_id != BTC_EXT_CHIP_NONE)
2431 tdma_case = rtw_btc_ext_chip_new_tdma(btc, 0);
2432 }
2433
2434 exit:
2435 rtw_btc_table(btc, NM_EXCU, table_case);
2436 rtw_btc_tdma(btc, NM_EXCU, tdma_case);
2437 }
2438
rtw_btc_action_bt_inquiry(struct btc_coexist * btc)2439 static void rtw_btc_action_bt_inquiry(struct btc_coexist *btc)
2440 {
2441 struct btc_coex_sta *coex_sta = &btc->coex_sta;
2442 struct btc_wifi_link_info_ext *link_info_ext = &btc->wifi_link_info_ext;
2443 boolean wl_hi_pri = FALSE;
2444 u8 table_case, tdma_case;
2445 u32 slot_type = 0;
2446
2447 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE, "[BTCoex], %s()\n", __func__);
2448 BTC_TRACE(trace_buf);
2449
2450 rtw_btc_set_ant_path(btc, NM_EXCU, BTC_ANT_2G);
2451 rtw_btc_set_rf_para(btc, NM_EXCU, btc->chip_para->wl_rf_para_rx[0]);
2452
2453 if (coex_sta->wl_linkscan_proc || coex_sta->wl_hi_pri_task1 ||
2454 coex_sta->wl_hi_pri_task2)
2455 wl_hi_pri = TRUE;
2456
2457 if (btc->board_info.btdm_ant_num == 1) { /* Shared-Ant */
2458 if (wl_hi_pri) {
2459 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2460 "[BTCoex], bt inq/page + wifi hi-pri task\n");
2461
2462 table_case = 15;
2463
2464 if (coex_sta->bt_profile_num > 0)
2465 tdma_case = 10;
2466 else if (coex_sta->wl_hi_pri_task1)
2467 tdma_case = 6;
2468 else if (!coex_sta->bt_page)
2469 tdma_case = 8;
2470 else
2471 tdma_case = 9;
2472 } else if (coex_sta->wl_gl_busy) {
2473 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2474 "[BTCoex], bt inq/page + wifi busy\n");
2475 #if 0
2476 table_case = 15;
2477 tdma_case = 20;
2478 #else
2479 if (coex_sta->bt_profile_num == 0) {
2480 table_case = 12;
2481 tdma_case = 18;
2482 } else if (coex_sta->bt_profile_num == 1 &&
2483 !coex_sta->bt_a2dp_exist) {
2484 slot_type = TDMA_4SLOT;
2485 table_case = 12;
2486 tdma_case = 20;
2487 } else {
2488 slot_type = TDMA_4SLOT;
2489 table_case = 12;
2490 tdma_case = 26;
2491 }
2492 #endif
2493 } else if (link_info_ext->is_connected) {
2494 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2495 "[BTCoex], bt inq/page + wifi connected\n");
2496
2497 table_case = 9;
2498 tdma_case = 27;
2499 } else {
2500 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2501 "[BTCoex], bt inq/page + wifi not-connected\n");
2502
2503 table_case = 1;
2504 tdma_case = 0;
2505 }
2506 } else { /* Non_Shared-Ant */
2507 if (wl_hi_pri) {
2508 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2509 "[BTCoex], bt inq/page + wifi hi-pri task\n");
2510
2511 table_case = 100;
2512 tdma_case = 100;
2513 } else if (coex_sta->wl_gl_busy) {
2514 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2515 "[BTCoex], bt inq/page + wifi busy\n");
2516
2517 table_case = 114;
2518 tdma_case = 121;
2519 } else if (link_info_ext->is_connected) {
2520 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2521 "[BTCoex], bt inq/page + wifi connected\n");
2522
2523 table_case = 101;
2524 tdma_case = 100;
2525 } else {
2526 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
2527 "[BTCoex], bt inq/page + wifi not-connected\n");
2528
2529 table_case = 101;
2530 tdma_case = 100;
2531 }
2532 }
2533
2534 BTC_TRACE(trace_buf);
2535
2536 rtw_btc_table(btc, NM_EXCU, table_case);
2537 rtw_btc_tdma(btc, NM_EXCU, tdma_case | slot_type);
2538 }
2539
rtw_btc_action_bt_hfp(struct btc_coexist * btc)2540 static void rtw_btc_action_bt_hfp(struct btc_coexist *btc)
2541 {
2542 struct btc_coex_sta *coex_sta = &btc->coex_sta;
2543 u8 table_case, tdma_case;
2544
2545 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE, "[BTCoex], %s()\n", __func__);
2546 BTC_TRACE(trace_buf);
2547
2548 rtw_btc_set_ant_path(btc, NM_EXCU, BTC_ANT_2G);
2549 rtw_btc_set_rf_para(btc, NM_EXCU, btc->chip_para->wl_rf_para_rx[0]);
2550
2551 if (btc->board_info.btdm_ant_num == 1) { /* Shared-Ant */
2552 if (coex_sta->wl_cck_lock_ever) {
2553 coex_sta->wl_coex_mode = BTC_WLINK_2GFREE;
2554 table_case = 33;
2555 tdma_case = 0;
2556 } else {
2557 table_case = 10;
2558 tdma_case = 5;
2559 }
2560 } else { /* Non-Shared-Ant */
2561 if (coex_sta->bt_multi_link) {
2562 table_case = 112;
2563 tdma_case = 117;
2564 } else {
2565 table_case = 105;
2566 tdma_case = 100;
2567 }
2568 }
2569
2570 rtw_btc_table(btc, NM_EXCU, table_case);
2571 rtw_btc_tdma(btc, NM_EXCU, tdma_case);
2572 }
2573
rtw_btc_action_bt_hid(struct btc_coexist * btc)2574 static void rtw_btc_action_bt_hid(struct btc_coexist *btc)
2575 {
2576 struct btc_coex_sta *coex_sta = &btc->coex_sta;
2577 u8 table_case, tdma_case;
2578 boolean is_toggle_table = FALSE, is_bt_ctr_hi = FALSE;
2579 u32 slot_type = 0;
2580
2581 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE, "[BTCoex], %s()\n", __func__);
2582 BTC_TRACE(trace_buf);
2583
2584 rtw_btc_set_ant_path(btc, NM_EXCU, BTC_ANT_2G);
2585 rtw_btc_set_rf_para(btc, NM_EXCU, btc->chip_para->wl_rf_para_rx[0]);
2586
2587 if (coex_sta->bt_ctr_ok &&
2588 (coex_sta->lo_pri_rx + coex_sta->lo_pri_tx > 360))
2589 is_bt_ctr_hi = TRUE;
2590
2591 if (btc->board_info.btdm_ant_num == 1) { /* Shared-Ant */
2592 if (coex_sta->wl_cck_lock_ever) {
2593 coex_sta->wl_coex_mode = BTC_WLINK_2GFREE;
2594 table_case = 33;
2595 tdma_case = 0;
2596 } else if (coex_sta->bt_ble_exist) { /* RCU */
2597 table_case = 26;
2598 tdma_case = 2;
2599 } else { /* Legacy HID */
2600 if (coex_sta->bt_a2dp_active ||
2601 coex_sta->bt_a2dp_active_remain) {
2602 table_case = 9;
2603 tdma_case = 18;
2604 } else if (coex_sta->bt_profile_num == 1 &&
2605 (coex_sta->bt_multi_link &&
2606 (is_bt_ctr_hi ||
2607 coex_sta->bt_slave ||
2608 coex_sta->bt_multi_link_remain))) {
2609 slot_type = TDMA_4SLOT;
2610
2611 if (coex_sta->wl_gl_busy &&
2612 (coex_sta->wl_rx_rate <= 3 ||
2613 coex_sta->wl_rts_rx_rate <= 3))
2614 table_case = 13;
2615 else
2616 table_case = 12;
2617
2618 tdma_case = 26;
2619 } else if (coex_sta->bt_418_hid_exist &&
2620 coex_sta->wl_gl_busy) {
2621 slot_type = TDMA_4SLOT;
2622 table_case = 32;
2623 tdma_case = 27;
2624 } else if (coex_sta->bt_ble_hid_exist &&
2625 coex_sta->wl_gl_busy) {
2626 table_case = 32;
2627 tdma_case = 9;
2628 } else {
2629 table_case = 9;
2630 tdma_case = 9;
2631 }
2632 }
2633 } else { /* Non-Shared-Ant */
2634 if (coex_sta->bt_ble_exist) { /* BLE */
2635 table_case = 110;
2636 tdma_case = 105;
2637 } else if (coex_sta->bt_a2dp_active) {
2638 table_case = 113;
2639 tdma_case = 118;
2640 } else {
2641 table_case = 113;
2642 tdma_case = 104;
2643 }
2644 }
2645
2646 rtw_btc_table(btc, NM_EXCU, table_case);
2647 if (is_toggle_table) {
2648 rtw_btc_wltoggle_tableA(btc, FC_EXCU, table_case);
2649 rtw_btc_wltoggle_tableB(btc, NM_EXCU, 1, 0x5a5a5aaa);
2650 }
2651
2652 rtw_btc_tdma(btc, NM_EXCU, tdma_case | slot_type);
2653 }
2654
rtw_btc_action_bt_a2dp(struct btc_coexist * btc)2655 static void rtw_btc_action_bt_a2dp(struct btc_coexist *btc)
2656 {
2657 struct btc_coex_sta *coex_sta = &btc->coex_sta;
2658 struct btc_coex_dm *coex_dm = &btc->coex_dm;
2659 u8 table_case, tdma_case;
2660 u32 slot_type = 0;
2661
2662 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE, "[BTCoex], %s()\n", __func__);
2663 BTC_TRACE(trace_buf);
2664
2665 rtw_btc_set_ant_path(btc, NM_EXCU, BTC_ANT_2G);
2666 rtw_btc_set_rf_para(btc, NM_EXCU, btc->chip_para->wl_rf_para_rx[0]);
2667
2668 slot_type = TDMA_4SLOT;
2669
2670 if (btc->board_info.btdm_ant_num == 1) { /* Shared-Ant */
2671 if (coex_sta->wl_gl_busy && coex_sta->wl_noisy_level == 0)
2672 table_case = 12;
2673 else
2674 table_case = 9;
2675
2676 if (coex_sta->wl_connecting || !coex_sta->wl_gl_busy)
2677 tdma_case = 14;
2678 else
2679 tdma_case = 13;
2680 } else { /* Non-Shared-Ant */
2681 table_case = 121;
2682 tdma_case = 113;
2683 }
2684
2685 rtw_btc_table(btc, NM_EXCU, table_case);
2686 rtw_btc_tdma(btc, NM_EXCU, tdma_case | slot_type);
2687 }
2688
rtw_btc_action_bt_a2dpsink(struct btc_coexist * btc)2689 static void rtw_btc_action_bt_a2dpsink(struct btc_coexist *btc)
2690 {
2691 struct btc_coex_sta *coex_sta = &btc->coex_sta;
2692 struct btc_coex_dm *coex_dm = &btc->coex_dm;
2693 struct btc_wifi_link_info_ext *linfo_ext = &btc->wifi_link_info_ext;
2694 u8 table_case, tdma_case;
2695
2696 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE, "[BTCoex], %s()\n", __func__);
2697 BTC_TRACE(trace_buf);
2698
2699 rtw_btc_set_ant_path(btc, NM_EXCU, BTC_ANT_2G);
2700 rtw_btc_set_rf_para(btc, NM_EXCU, btc->chip_para->wl_rf_para_rx[0]);
2701
2702 if (btc->board_info.btdm_ant_num == 1) { /* Shared-Ant */
2703 if (linfo_ext->is_ap_mode) {
2704 table_case = 2;
2705 tdma_case = 0;
2706 } else if (coex_sta->wl_gl_busy) {
2707 table_case = 28;
2708 tdma_case = 20;
2709 } else {
2710 table_case = 28;
2711 tdma_case = 26;
2712 }
2713 } else { /* Non-Shared-Ant */
2714 if (linfo_ext->is_ap_mode) {
2715 table_case = 100;
2716 tdma_case = 100;
2717 } else {
2718 table_case = 119;
2719 tdma_case = 120;
2720 }
2721 }
2722
2723 rtw_btc_table(btc, NM_EXCU, table_case);
2724 rtw_btc_tdma(btc, NM_EXCU, tdma_case);
2725 }
2726
rtw_btc_action_bt_pan(struct btc_coexist * btc)2727 static void rtw_btc_action_bt_pan(struct btc_coexist *btc)
2728 {
2729 struct btc_coex_sta *coex_sta = &btc->coex_sta;
2730 u8 table_case, tdma_case;
2731
2732 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE, "[BTCoex], %s()\n", __func__);
2733 BTC_TRACE(trace_buf);
2734
2735 rtw_btc_set_ant_path(btc, NM_EXCU, BTC_ANT_2G);
2736 rtw_btc_set_rf_para(btc, NM_EXCU, btc->chip_para->wl_rf_para_rx[0]);
2737
2738 if (btc->board_info.btdm_ant_num == 1) { /* Shared-Ant */
2739 if (coex_sta->wl_gl_busy && coex_sta->wl_noisy_level == 0)
2740 table_case = 14;
2741 else
2742 table_case = 10;
2743
2744 if (coex_sta->wl_gl_busy)
2745 tdma_case = 17;
2746 else
2747 tdma_case = 20;
2748 } else { /* Non-Shared-Ant */
2749 table_case = 112;
2750
2751 if (coex_sta->wl_gl_busy)
2752 tdma_case = 117;
2753 else
2754 tdma_case = 119;
2755 }
2756
2757 if (coex_sta->bt_slave && coex_sta->wl_gl_busy)
2758 rtw_btc_set_bt_golden_rx_range(btc, NM_EXCU, 3, 20);
2759 else
2760 rtw_btc_set_bt_golden_rx_range(btc, NM_EXCU, 3, 0);
2761
2762 rtw_btc_table(btc, NM_EXCU, table_case);
2763 rtw_btc_tdma(btc, NM_EXCU, tdma_case);
2764 }
2765
rtw_btc_action_bt_a2dp_hid(struct btc_coexist * btc)2766 static void rtw_btc_action_bt_a2dp_hid(struct btc_coexist *btc)
2767 {
2768 struct btc_coex_sta *coex_sta = &btc->coex_sta;
2769 struct btc_coex_dm *coex_dm = &btc->coex_dm;
2770 u8 table_case = 0, tdma_case = 0, interval = 0;
2771 boolean is_toggle_table = FALSE;
2772 u32 slot_type = 0, tableB = 0;
2773
2774 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE, "[BTCoex], %s()\n", __func__);
2775 BTC_TRACE(trace_buf);
2776
2777 rtw_btc_set_ant_path(btc, NM_EXCU, BTC_ANT_2G);
2778 rtw_btc_set_rf_para(btc, NM_EXCU, btc->chip_para->wl_rf_para_rx[0]);
2779
2780 if (coex_sta->wl_iot_peer != BTC_IOT_PEER_CISCO)
2781 slot_type = TDMA_4SLOT;
2782
2783 if (btc->board_info.btdm_ant_num == 1) { /* Shared-Ant */
2784 if (coex_sta->bt_ble_exist) {
2785 table_case = 26; /* for RCU */
2786 } else if (coex_sta->bt_418_hid_exist) { /*for 4/18 HID*/
2787 table_case = 9;
2788 tableB = 0x5a5a5aaa;
2789 interval = 1;
2790 } else {
2791 table_case = 9; /*for 2/18 HID, BLE HID*/
2792 }
2793
2794 if (coex_sta->wl_connecting || !coex_sta->wl_gl_busy) {
2795 tdma_case = 14;
2796 } else if (coex_sta->bt_418_hid_exist) {
2797 is_toggle_table = TRUE;
2798 tdma_case = 23;
2799 } else {
2800 tdma_case = 13;
2801 }
2802 } else { /* Non-Shared-Ant */
2803 if (coex_sta->bt_ble_exist)
2804 table_case = 110;
2805 else
2806 table_case = 121;
2807
2808 tdma_case = 113;
2809 }
2810
2811 rtw_btc_table(btc, NM_EXCU, table_case);
2812 if (is_toggle_table) {
2813 rtw_btc_wltoggle_tableA(btc, FC_EXCU, table_case);
2814 rtw_btc_wltoggle_tableB(btc, NM_EXCU, interval, tableB);
2815 }
2816
2817 rtw_btc_tdma(btc, NM_EXCU, tdma_case | slot_type);
2818 }
2819
rtw_btc_action_bt_a2dp_pan(struct btc_coexist * btc)2820 static void rtw_btc_action_bt_a2dp_pan(struct btc_coexist *btc)
2821 {
2822 struct btc_coex_sta *coex_sta = &btc->coex_sta;
2823 struct btc_coex_dm *coex_dm = &btc->coex_dm;
2824 const struct btc_chip_para *chip_para = btc->chip_para;
2825 u8 table_case, tdma_case;
2826 boolean wl_cpt_test = FALSE, bt_cpt_test = FALSE;
2827
2828 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE, "[BTCoex], %s()\n", __func__);
2829 BTC_TRACE(trace_buf);
2830
2831 if (btc->board_info.customer_id == RT_CID_LENOVO_CHINA &&
2832 coex_sta->cnt_wl[BTC_CNT_WL_SCANAP] <= 10 &&
2833 coex_sta->wl_iot_peer == BTC_IOT_PEER_ATHEROS) {
2834 if (BTC_RSSI_LOW(coex_dm->wl_rssi_state[2]))
2835 wl_cpt_test = TRUE;
2836 else
2837 bt_cpt_test = TRUE;
2838 }
2839
2840 if (wl_cpt_test)
2841 rtw_btc_set_rf_para(btc, NM_EXCU, chip_para->wl_rf_para_rx[1]);
2842 else
2843 rtw_btc_set_rf_para(btc, NM_EXCU, chip_para->wl_rf_para_rx[0]);
2844
2845 rtw_btc_set_ant_path(btc, NM_EXCU, BTC_ANT_2G);
2846 if (btc->board_info.btdm_ant_num == 1) { /* Shared-Ant */
2847 if (wl_cpt_test) {
2848 if (coex_sta->wl_gl_busy) {
2849 table_case = 20;
2850 tdma_case = 17;
2851 } else {
2852 table_case = 10;
2853 tdma_case = 15;
2854 }
2855 } else if (bt_cpt_test) {
2856 table_case = 26;
2857 tdma_case = 26;
2858 } else {
2859 if (coex_sta->wl_gl_busy &&
2860 coex_sta->wl_noisy_level == 0)
2861 table_case = 14;
2862 else
2863 table_case = 10;
2864
2865 if (coex_sta->wl_gl_busy)
2866 tdma_case = 15;
2867 else
2868 tdma_case = 20;
2869 }
2870 } else { /* Non-Shared-Ant */
2871 table_case = 112;
2872
2873 if (coex_sta->wl_gl_busy)
2874 tdma_case = 115;
2875 else
2876 tdma_case = 120;
2877 }
2878
2879 if (coex_sta->bt_slave)
2880 rtw_btc_set_extend_btautoslot(btc, 0x3c);
2881 else
2882 rtw_btc_set_extend_btautoslot(btc, 0x32);
2883
2884 rtw_btc_table(btc, NM_EXCU, table_case);
2885 rtw_btc_tdma(btc, NM_EXCU, tdma_case);
2886 }
2887
rtw_btc_action_bt_pan_hid(struct btc_coexist * btc)2888 static void rtw_btc_action_bt_pan_hid(struct btc_coexist *btc)
2889 {
2890 struct btc_coex_sta *coex_sta = &btc->coex_sta;
2891 u8 table_case, tdma_case;
2892
2893 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE, "[BTCoex], %s()\n", __func__);
2894 BTC_TRACE(trace_buf);
2895
2896 rtw_btc_set_ant_path(btc, NM_EXCU, BTC_ANT_2G);
2897 rtw_btc_set_rf_para(btc, NM_EXCU, btc->chip_para->wl_rf_para_rx[0]);
2898
2899 if (btc->board_info.btdm_ant_num == 1) { /* Shared-Ant */
2900 table_case = 9;
2901
2902 if (coex_sta->wl_gl_busy)
2903 tdma_case = 18;
2904 else
2905 tdma_case = 19;
2906 } else { /* Non-Shared-Ant */
2907 table_case = 113;
2908
2909 if (coex_sta->wl_gl_busy)
2910 tdma_case = 117;
2911 else
2912 tdma_case = 119;
2913 }
2914
2915 rtw_btc_table(btc, NM_EXCU, table_case);
2916 rtw_btc_tdma(btc, NM_EXCU, tdma_case);
2917 }
2918
rtw_btc_action_bt_a2dp_pan_hid(struct btc_coexist * btc)2919 static void rtw_btc_action_bt_a2dp_pan_hid(struct btc_coexist *btc)
2920 {
2921 struct btc_coex_sta *coex_sta = &btc->coex_sta;
2922 u8 table_case, tdma_case;
2923
2924 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE, "[BTCoex], %s()\n", __func__);
2925 BTC_TRACE(trace_buf);
2926
2927 rtw_btc_set_ant_path(btc, NM_EXCU, BTC_ANT_2G);
2928 rtw_btc_set_rf_para(btc, NM_EXCU, btc->chip_para->wl_rf_para_rx[0]);
2929
2930 if (btc->board_info.btdm_ant_num == 1) { /* Shared-Ant */
2931 table_case = 10;
2932
2933 if (coex_sta->wl_gl_busy)
2934 tdma_case = 15;
2935 else
2936 tdma_case = 20;
2937 } else { /* Non-Shared-Ant */
2938 table_case = 113;
2939
2940 if (coex_sta->wl_gl_busy)
2941 tdma_case = 115;
2942 else
2943 tdma_case = 120;
2944 }
2945
2946 if (coex_sta->bt_slave)
2947 rtw_btc_set_extend_btautoslot(btc, 0x3c);
2948 else
2949 rtw_btc_set_extend_btautoslot(btc, 0x32);
2950
2951 rtw_btc_table(btc, NM_EXCU, table_case);
2952 rtw_btc_tdma(btc, NM_EXCU, tdma_case);
2953 }
2954
rtw_btc_action_wl_off(struct btc_coexist * btc)2955 static void rtw_btc_action_wl_off(struct btc_coexist *btc)
2956 {
2957 const struct btc_chip_para *chip_para = btc->chip_para;
2958
2959 rtw_btc_tdma(btc, FC_EXCU, 0);
2960 rtw_btc_ignore_wlan_act(btc, FC_EXCU, TRUE);
2961 rtw_btc_set_ant_path(btc, FC_EXCU, BTC_ANT_WOFF);
2962 rtw_btc_set_rf_para(btc, NM_EXCU, btc->chip_para->wl_rf_para_rx[0]);
2963
2964 btc->stop_coex_dm = TRUE;
2965 btc->wl_rf_state_off = TRUE;
2966
2967 /* must place in the last step */
2968 rtw_btc_update_wl_ch_info(btc, BTC_MEDIA_DISCONNECT);
2969 if (chip_para->scbd_bit_num == BTC_SCBD_16_BIT)
2970 btc->btc_write_scbd(btc, BTC_SCBD_ALL, FALSE);
2971 else
2972 btc->btc_write_scbd_32bit(btc, BTC_SCBD_ALL_32BIT, FALSE);
2973 }
2974
rtw_btc_action_wl_under5g(struct btc_coexist * btc)2975 static void rtw_btc_action_wl_under5g(struct btc_coexist *btc)
2976 {
2977 u8 table_case, tdma_case;
2978 const struct btc_chip_para *chip_para = btc->chip_para;
2979
2980 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE, "[BTCoex], %s()\n", __func__);
2981 BTC_TRACE(trace_buf);
2982
2983 rtw_btc_set_ant_path(btc, FC_EXCU, BTC_ANT_5G);
2984 rtw_btc_set_rf_para(btc, NM_EXCU, btc->chip_para->wl_rf_para_rx[0]);
2985
2986 if (chip_para->scbd_bit_num == BTC_SCBD_16_BIT)
2987 btc->btc_write_scbd(btc, BTC_SCBD_FIX2M, FALSE);
2988 else
2989 btc->btc_write_scbd_32bit(btc, BTC_SCBD_FIX2M, FALSE);
2990
2991 if (btc->board_info.btdm_ant_num == 1) { /* Shared-Ant */
2992 table_case = 0;
2993 tdma_case = 0;
2994 } else { /* Non-Shared-Ant */
2995 table_case = 100;
2996 tdma_case = 100;
2997 }
2998
2999 rtw_btc_table(btc, NM_EXCU, table_case);
3000 rtw_btc_tdma(btc, NM_EXCU, tdma_case);
3001 }
3002
rtw_btc_action_wl_only(struct btc_coexist * btc)3003 static void rtw_btc_action_wl_only(struct btc_coexist *btc)
3004 {
3005 struct btc_coex_sta *coex_sta = &btc->coex_sta;
3006 u8 table_case, tdma_case;
3007
3008 rtw_btc_set_ant_path(btc, NM_EXCU, BTC_ANT_2G);
3009 rtw_btc_set_rf_para(btc, NM_EXCU, btc->chip_para->wl_rf_para_rx[0]);
3010
3011 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE, "[BTCoex], %s()\n", __func__);
3012 BTC_TRACE(trace_buf);
3013
3014 if (btc->board_info.btdm_ant_num == 1) { /* Shared-Ant */
3015 table_case = 2;
3016 tdma_case = 0;
3017 } else { /* Non-Shared-Ant */
3018 table_case = 100;
3019 tdma_case = 100;
3020 if (coex_sta->wl_gl_busy &&
3021 btc->board_info.ext_chip_id != BTC_EXT_CHIP_NONE)
3022 tdma_case = rtw_btc_ext_chip_new_tdma(btc, 3);
3023 }
3024
3025 rtw_btc_table(btc, NM_EXCU, table_case);
3026 rtw_btc_tdma(btc, NM_EXCU, tdma_case);
3027 }
3028
rtw_btc_action_wl_native_lps(struct btc_coexist * btc)3029 static void rtw_btc_action_wl_native_lps(struct btc_coexist *btc)
3030 {
3031 struct btc_coex_sta *coex_sta = &btc->coex_sta;
3032 struct btc_wifi_link_info_ext *link_info_ext = &btc->wifi_link_info_ext;
3033 u8 table_case, tdma_case;
3034
3035 if (link_info_ext->is_all_under_5g)
3036 return;
3037
3038 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE, "[BTCoex], %s()\n", __func__);
3039 BTC_TRACE(trace_buf);
3040
3041 rtw_btc_set_ant_path(btc, NM_EXCU, BTC_ANT_2G);
3042 rtw_btc_set_rf_para(btc, NM_EXCU, btc->chip_para->wl_rf_para_rx[0]);
3043
3044 if (btc->board_info.btdm_ant_num == 1) { /* Shared-Ant */
3045 table_case = 28; /*0x6c0 for A2DP, 0x6c4 for non-A2DP*/
3046 tdma_case = 0;
3047 } else { /* Non-Shared-Ant */
3048 table_case = 100;
3049 tdma_case = 100;
3050 }
3051
3052 rtw_btc_table(btc, NM_EXCU, table_case);
3053 rtw_btc_tdma(btc, NM_EXCU, tdma_case);
3054 }
3055
rtw_btc_action_wl_linkscan(struct btc_coexist * btc)3056 static void rtw_btc_action_wl_linkscan(struct btc_coexist *btc)
3057 {
3058 struct btc_coex_sta *coex_sta = &btc->coex_sta;
3059 struct btc_wifi_link_info_ext *link_info_ext = &btc->wifi_link_info_ext;
3060 u8 table_case, tdma_case;
3061 u32 slot_type = 0;
3062
3063 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE, "[BTCoex], %s()\n", __func__);
3064 BTC_TRACE(trace_buf);
3065
3066 rtw_btc_set_ant_path(btc, NM_EXCU, BTC_ANT_2G);
3067 rtw_btc_set_rf_para(btc, NM_EXCU, btc->chip_para->wl_rf_para_rx[0]);
3068
3069 if (btc->board_info.btdm_ant_num == 1) { /* Shared-Ant */
3070 if (coex_sta->bt_pan_exist) {
3071 table_case = 34;
3072 tdma_case = 8;
3073 } else if (coex_sta->bt_a2dp_exist) {
3074 slot_type = TDMA_4SLOT;
3075 table_case = 9;
3076 tdma_case = 11;
3077 } else if (coex_sta->bt_hid_exist) {
3078 if (link_info_ext->is_connected) {
3079 table_case = 36;
3080 } else {
3081 table_case = 35;
3082 }
3083 tdma_case = 5;
3084 } else {
3085 table_case = 9;
3086 tdma_case = 7;
3087 }
3088 } else { /* Non-Shared-Ant */
3089 if (coex_sta->bt_pan_exist) {
3090 table_case = 124;
3091 tdma_case = 108;
3092 } else if (coex_sta->bt_a2dp_exist) {
3093 slot_type = TDMA_4SLOT;
3094 table_case = 124;
3095 tdma_case = 126;
3096 } else {
3097 table_case = 112;
3098 tdma_case = 107;
3099 }
3100 if (coex_sta->wl_gl_busy &&
3101 btc->board_info.ext_chip_id != BTC_EXT_CHIP_NONE)
3102 tdma_case = rtw_btc_ext_chip_new_tdma(btc, 2);
3103 }
3104
3105 rtw_btc_table(btc, NM_EXCU, table_case);
3106 rtw_btc_tdma(btc, NM_EXCU, tdma_case | slot_type);
3107 }
3108
rtw_btc_action_wl_not_connected(struct btc_coexist * btc)3109 static void rtw_btc_action_wl_not_connected(struct btc_coexist *btc)
3110 {
3111 struct btc_wifi_link_info_ext *link_info_ext = &btc->wifi_link_info_ext;
3112 struct btc_coex_sta *coex_sta = &btc->coex_sta;
3113 u8 table_case, tdma_case;
3114
3115 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE, "[BTCoex], %s()\n", __func__);
3116 BTC_TRACE(trace_buf);
3117
3118 /* CCK Rx, Tx response, Tx beacon = low pri */
3119 if (link_info_ext->num_of_active_port == 0)
3120 rtw_btc_set_wl_pri_mask(btc, BTC_WLPRI_RX_CCK, 0);
3121
3122 coex_sta->wl_cck_lock_ever = FALSE;
3123 coex_sta->wl_cck_lock = FALSE;
3124 coex_sta->cnt_wl[BTC_CNT_WL_2G_TDDTRY] = FALSE;
3125 coex_sta->cnt_wl[BTC_CNT_WL_2G_FDDSTAY] = FALSE;
3126
3127 rtw_btc_set_ant_path(btc, NM_EXCU, BTC_ANT_2G);
3128 rtw_btc_set_rf_para(btc, NM_EXCU, btc->chip_para->wl_rf_para_rx[0]);
3129
3130 if (btc->board_info.btdm_ant_num == 1) { /* Shared-Ant */
3131 table_case = 1;
3132 tdma_case = 0;
3133 } else { /* Non-Shared-Ant */
3134 table_case = 100;
3135 tdma_case = 100;
3136 }
3137
3138 rtw_btc_table(btc, NM_EXCU, table_case);
3139 rtw_btc_tdma(btc, NM_EXCU, tdma_case);
3140 }
3141
rtw_btc_action_wl_connected(struct btc_coexist * btc)3142 static void rtw_btc_action_wl_connected(struct btc_coexist *btc)
3143 {
3144 struct btc_coex_sta *coex_sta = &btc->coex_sta;
3145 u8 algorithm;
3146
3147 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE, "[BTCoex], %s()\n", __func__);
3148 BTC_TRACE(trace_buf);
3149
3150 /*Leap-AP protection will reopen when connecting AP*/
3151 rtw_btc_wl_leakap(btc, TRUE);
3152
3153 if ((btc->board_info.btdm_ant_num == 2) &&
3154 (btc->board_info.ext_chip_id != BTC_EXT_CHIP_NONE)) {
3155 rtw_btc_action_ext_chip(btc);
3156 return;
3157 }
3158
3159 algorithm = rtw_btc_algorithm(btc);
3160
3161 switch (algorithm) {
3162 case BTC_COEX_HFP:
3163 if (rtw_btc_freerun_check(btc))
3164 rtw_btc_action_freerun(btc);
3165 else
3166 rtw_btc_action_bt_hfp(btc);
3167 break;
3168 case BTC_COEX_HID:
3169 if (rtw_btc_freerun_check(btc))
3170 rtw_btc_action_freerun(btc);
3171 else
3172 rtw_btc_action_bt_hid(btc);
3173 break;
3174 case BTC_COEX_A2DP:
3175 if (rtw_btc_freerun_check(btc))
3176 rtw_btc_action_freerun(btc);
3177 else if (coex_sta->bt_a2dp_sink)
3178 rtw_btc_action_bt_a2dpsink(btc);
3179 else
3180 rtw_btc_action_bt_a2dp(btc);
3181 break;
3182 case BTC_COEX_PAN:
3183 rtw_btc_action_bt_pan(btc);
3184 break;
3185 case BTC_COEX_A2DP_HID:
3186 if (rtw_btc_freerun_check(btc))
3187 rtw_btc_action_freerun(btc);
3188 else
3189 rtw_btc_action_bt_a2dp_hid(btc);
3190 break;
3191 case BTC_COEX_A2DP_PAN:
3192 rtw_btc_action_bt_a2dp_pan(btc);
3193 break;
3194 case BTC_COEX_PAN_HID:
3195 rtw_btc_action_bt_pan_hid(btc);
3196 break;
3197 case BTC_COEX_A2DP_PAN_HID:
3198 rtw_btc_action_bt_a2dp_pan_hid(btc);
3199 break;
3200 default:
3201 case BTC_COEX_NOPROFILE:
3202 rtw_btc_action_bt_idle(btc);
3203 break;
3204 }
3205 }
3206
rtw_btc_action_wl_mcc25g(struct btc_coexist * btc)3207 static void rtw_btc_action_wl_mcc25g(struct btc_coexist *btc)
3208 {
3209 struct btc_coex_sta *coex_sta = &btc->coex_sta;
3210 const struct btc_chip_para *chip_para = btc->chip_para;
3211 u8 table_case, tdma_case;
3212
3213 rtw_btc_set_ant_path(btc, NM_EXCU, BTC_ANT_MCC);
3214 rtw_btc_set_rf_para(btc, NM_EXCU, btc->chip_para->wl_rf_para_rx[0]);
3215
3216 if (chip_para->scbd_bit_num == BTC_SCBD_16_BIT)
3217 btc->btc_write_scbd(btc, BTC_SCBD_FIX2M, FALSE);
3218 else
3219 btc->btc_write_scbd_32bit(btc, BTC_SCBD_FIX2M, FALSE);
3220
3221 if (btc->board_info.btdm_ant_num == 1) { /* Shared-Ant */
3222 if (coex_sta->bt_setup_link) {
3223 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3224 "[BTCoex], %s(): BT Relink\n", __func__);
3225
3226 table_case = 24;
3227 tdma_case = 0;
3228 } else if (coex_sta->bt_inq_page) {
3229 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3230 "[BTCoex], %s(): BT Inq-Pag\n", __func__);
3231
3232 table_case = 23;
3233 tdma_case = 0;
3234 } else {
3235 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3236 "[BTCoex], %s(): BT on\n", __func__);
3237
3238 if (coex_sta->wl_gl_busy) {
3239 if (coex_sta->wl_rx_rate <= 3 ||
3240 coex_sta->wl_rts_rx_rate <= 3)
3241 table_case = 31;
3242 else if (coex_sta->bt_hid_exist ||
3243 coex_sta->bt_hfp_exist)
3244 table_case = 26;
3245 else
3246 table_case = 27;
3247 } else {
3248 table_case = 27;
3249 }
3250
3251 tdma_case = 0;
3252 }
3253 } else { /* Non-Shared-Ant */
3254 if (coex_sta->bt_setup_link) {
3255 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3256 "[BTCoex], %s(): BT Relink\n", __func__);
3257
3258 table_case = 100;
3259 tdma_case = 100;
3260 } else if (coex_sta->bt_inq_page) {
3261 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3262 "[BTCoex], %s(): BT Inq-Pag\n", __func__);
3263
3264 table_case = 118;
3265 tdma_case = 100;
3266 } else {
3267 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3268 "[BTCoex], %s(): BT on!!\n", __func__);
3269
3270 table_case = 118;
3271 tdma_case = 100;
3272 }
3273 }
3274
3275 BTC_TRACE(trace_buf);
3276
3277 rtw_btc_table(btc, NM_EXCU, table_case);
3278 rtw_btc_tdma(btc, NM_EXCU, tdma_case);
3279 }
3280
rtw_btc_action_wl_scc2g(struct btc_coexist * btc)3281 static void rtw_btc_action_wl_scc2g(struct btc_coexist *btc)
3282 {
3283 struct btc_coex_sta *coex_sta = &btc->coex_sta;
3284 u8 table_case = 0xff, tdma_case = 0xff;
3285 boolean is_toggle_table = FALSE;
3286 u32 slot_type = 0;
3287
3288 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE, "[BTCoex], %s()\n", __func__);
3289 BTC_TRACE(trace_buf);
3290
3291 if (coex_sta->bt_profile_num == 1) {
3292 if (coex_sta->bt_hid_exist || coex_sta->bt_hfp_exist) {
3293 if (coex_sta->bt_a2dp_active) {
3294 table_case = 9;
3295 tdma_case = 21;
3296 } else if (coex_sta->bt_418_hid_exist) {
3297 table_case = 10;
3298 tdma_case = 24;
3299 is_toggle_table = TRUE;
3300 slot_type = TDMA_4SLOT;
3301 } else {
3302 table_case = 2;
3303 tdma_case = 0;
3304 }
3305 } else if (coex_sta->bt_a2dp_exist) {
3306 table_case = 10;
3307 tdma_case = 22;
3308 slot_type = TDMA_4SLOT;
3309 } else { /* PAN or OPP */
3310 table_case = 10;
3311 tdma_case = 21;
3312 }
3313 } else {
3314 if ((coex_sta->bt_hid_exist || coex_sta->bt_hfp_exist) &&
3315 coex_sta->bt_a2dp_exist) {
3316 table_case = 9;
3317 tdma_case = 22;
3318
3319 slot_type = TDMA_4SLOT;
3320 if (coex_sta->bt_418_hid_exist)
3321 is_toggle_table = TRUE;
3322 } else if (coex_sta->bt_pan_exist && coex_sta->bt_a2dp_exist) {
3323 table_case = 10;
3324 tdma_case = 22;
3325 slot_type = TDMA_4SLOT;
3326 } else { /* hid + pan */
3327 table_case = 9;
3328 tdma_case = 21;
3329 }
3330 }
3331
3332 rtw_btc_table(btc, NM_EXCU, table_case);
3333 if (is_toggle_table) {
3334 rtw_btc_wltoggle_tableA(btc, FC_EXCU, table_case);
3335 rtw_btc_wltoggle_tableB(btc, NM_EXCU, 1, 0x5a5a5aaa);
3336 }
3337
3338 rtw_btc_tdma(btc, NM_EXCU, tdma_case | slot_type);
3339 }
3340
rtw_btc_action_wl_p2p2g(struct btc_coexist * btc)3341 static void rtw_btc_action_wl_p2p2g(struct btc_coexist *btc)
3342 {
3343 struct btc_coex_sta *coex_sta = &btc->coex_sta;
3344 struct btc_rfe_type *rfe_type = &btc->rfe_type;
3345 struct btc_wifi_link_info *link_info = &btc->wifi_link_info;
3346 const struct btc_chip_para *chip_para = btc->chip_para;
3347 u8 table_case = 0xff, tdma_case = 0xff, ant_phase;
3348
3349 if (rfe_type->ant_switch_with_bt)
3350 ant_phase = BTC_ANT_2G_FREERUN;
3351 else
3352 ant_phase = BTC_ANT_2G;
3353
3354 rtw_btc_set_rf_para(btc, NM_EXCU, btc->chip_para->wl_rf_para_rx[0]);
3355
3356 if (chip_para->scbd_bit_num == BTC_SCBD_16_BIT)
3357 btc->btc_write_scbd(btc, BTC_SCBD_FIX2M, FALSE);
3358 else
3359 btc->btc_write_scbd_32bit(btc, BTC_SCBD_FIX2M, FALSE);
3360
3361 if (coex_sta->bt_disabled) {
3362 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3363 "[BTCoex], %s(): BT Disable!!\n", __func__);
3364 BTC_TRACE(trace_buf);
3365 rtw_btc_set_ant_path(btc, NM_EXCU, BTC_ANT_2G);
3366
3367 table_case = 0;
3368 tdma_case = 0;
3369 } else if (btc->board_info.btdm_ant_num == 2) { /* Non-Shared-Ant */
3370 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3371 "[BTCoex], %s(): Non_Shared_Ant!!\n", __func__);
3372 BTC_TRACE(trace_buf);
3373
3374 rtw_btc_action_freerun(btc);
3375 return;
3376 } else if (coex_sta->bt_setup_link) {
3377 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3378 "[BTCoex], %s(): BT Relink!!\n", __func__);
3379
3380 rtw_btc_set_ant_path(btc, NM_EXCU, ant_phase);
3381
3382 table_case = 1;
3383 tdma_case = 0;
3384 } else if (coex_sta->bt_inq_page) {
3385 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3386 "[BTCoex], %s(): BT Inq-Page!!\n", __func__);
3387 BTC_TRACE(trace_buf);
3388
3389 rtw_btc_set_ant_path(btc, NM_EXCU, ant_phase);
3390
3391 table_case = 15;
3392 tdma_case = 2;
3393 } else if (coex_sta->bt_profile_num == 0) {
3394 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3395 "[BTCoex], %s(): BT idle!!\n", __func__);
3396 BTC_TRACE(trace_buf);
3397
3398 rtw_btc_set_ant_path(btc, NM_EXCU, ant_phase);
3399
3400 if (btc->chip_interface == BTC_INTF_PCI &&
3401 (link_info->link_mode == BTC_LINK_ONLY_GO ||
3402 link_info->link_mode == BTC_LINK_ONLY_GC) &&
3403 coex_sta->wl_gl_busy)
3404 table_case = 3;
3405 else
3406 table_case = 1;
3407
3408 tdma_case = 0;
3409 } else if (coex_sta->wl_linkscan_proc) {
3410 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3411 "[BTCoex], %s(): WL scan!!\n", __func__);
3412 BTC_TRACE(trace_buf);
3413
3414 rtw_btc_action_wl_linkscan(btc);
3415 } else {
3416 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3417 "[BTCoex], %s(): BT busy!!\n", __func__);
3418 BTC_TRACE(trace_buf);
3419
3420 switch (link_info->link_mode) {
3421 case BTC_LINK_2G_SCC_GC_STA:
3422 case BTC_LINK_2G_SCC_GO_STA:
3423 rtw_btc_set_ant_path(btc, NM_EXCU, BTC_ANT_2G);
3424 rtw_btc_action_wl_scc2g(btc);
3425 break;
3426 case BTC_LINK_ONLY_GO:
3427 case BTC_LINK_ONLY_GC:
3428 rtw_btc_set_ant_path(btc, NM_EXCU, BTC_ANT_2G);
3429 #ifdef PLATFORM_WINDOWS
3430 if (btc->chip_interface == BTC_INTF_PCI &&
3431 coex_sta->bt_a2dp_exist && !coex_sta->bt_multi_link)
3432 table_case = 3;
3433 else
3434 #endif
3435 table_case = 2;
3436
3437 tdma_case = 0;
3438 break;
3439 default:
3440 rtw_btc_set_ant_path(btc, NM_EXCU, ant_phase);
3441 table_case = 2;
3442 tdma_case = 0;
3443 break;
3444 }
3445 }
3446
3447 if (table_case != 0xff && tdma_case != 0xff) {
3448 rtw_btc_table(btc, NM_EXCU, table_case);
3449 rtw_btc_tdma(btc, NM_EXCU, tdma_case);
3450 }
3451 }
3452
rtw_btc_run_coex(struct btc_coexist * btc,u8 reason)3453 static void rtw_btc_run_coex(struct btc_coexist *btc, u8 reason)
3454 {
3455 struct btc_coex_dm *coex_dm = &btc->coex_dm;
3456 struct btc_coex_sta *coex_sta = &btc->coex_sta;
3457 struct btc_wifi_link_info_ext *link_info_ext = &btc->wifi_link_info_ext;
3458 struct btc_wifi_link_info *link_info = &btc->wifi_link_info;
3459 const struct btc_chip_para *chip_para = btc->chip_para;
3460
3461 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3462 "[BTCoex], %s(): reason = %d\n", __func__, reason);
3463 BTC_TRACE(trace_buf);
3464
3465 coex_sta->coex_run_reason = reason;
3466
3467 /* update wifi_link_info_ext variable */
3468 rtw_btc_update_wl_link_info(btc, reason);
3469
3470 rtw_btc_monitor_bt_enable(btc);
3471
3472 if (btc->manual_control) {
3473 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3474 "[BTCoex], return for Manual CTRL!!\n");
3475 BTC_TRACE(trace_buf);
3476 return;
3477 }
3478
3479 if (btc->stop_coex_dm) {
3480 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3481 "[BTCoex], return for Stop Coex DM!!\n");
3482 BTC_TRACE(trace_buf);
3483 return;
3484 }
3485
3486 if (coex_sta->wl_under_ips) {
3487 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3488 "[BTCoex], return for wifi is under IPS!!\n");
3489 BTC_TRACE(trace_buf);
3490 return;
3491 }
3492
3493 if (coex_sta->wl_under_lps && link_info_ext->is_32k) {
3494 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3495 "[BTCoex], return for wifi is under LPS-32K!!\n");
3496 BTC_TRACE(trace_buf);
3497 return;
3498 }
3499
3500 if (coex_sta->coex_freeze && reason == BTC_RSN_BTINFO &&
3501 !coex_sta->bt_setup_link) {
3502 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3503 "[BTCoex], return for coex_freeze!!\n");
3504 BTC_TRACE(trace_buf);
3505 return;
3506 }
3507
3508 coex_sta->cnt_wl[BTC_CNT_WL_COEXRUN]++;
3509 coex_sta->coex_freerun = FALSE;
3510
3511 /* Pure-5G Coex Process */
3512 if (link_info_ext->is_all_under_5g) {
3513 coex_sta->wl_coex_mode = BTC_WLINK_5G;
3514 rtw_btc_action_wl_under5g(btc);
3515 goto exit;
3516 }
3517
3518 if (link_info_ext->is_mcc_25g) {
3519 coex_sta->wl_coex_mode = BTC_WLINK_25GMPORT;
3520 rtw_btc_action_wl_mcc25g(btc);
3521 goto exit;
3522 }
3523
3524 /* if multi-port, P2P-GO, P2P-GC */
3525 if (link_info_ext->num_of_active_port > 1 ||
3526 (link_info->link_mode == BTC_LINK_ONLY_GO &&
3527 !link_info_ext->is_ap_mode) ||
3528 link_info->link_mode == BTC_LINK_ONLY_GC) {
3529 if (link_info->link_mode == BTC_LINK_ONLY_GO)
3530 coex_sta->wl_coex_mode = BTC_WLINK_2GGO;
3531 else if (link_info->link_mode == BTC_LINK_ONLY_GC)
3532 coex_sta->wl_coex_mode = BTC_WLINK_2GGC;
3533 else
3534 coex_sta->wl_coex_mode = BTC_WLINK_2GMPORT;
3535 rtw_btc_action_wl_p2p2g(btc);
3536 goto exit;
3537 }
3538
3539 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3540 "[BTCoex], WiFi is single-port 2G!!\n");
3541 BTC_TRACE(trace_buf);
3542
3543 coex_sta->wl_coex_mode = BTC_WLINK_2G1PORT;
3544
3545 if (coex_sta->bt_disabled) {
3546 if (!link_info_ext->is_connected)
3547 rtw_btc_action_wl_not_connected(btc);
3548 else
3549 rtw_btc_action_wl_only(btc);
3550 goto exit;
3551 }
3552
3553 if (coex_sta->wl_under_lps && !coex_sta->wl_force_lps_ctrl) {
3554 rtw_btc_action_wl_native_lps(btc);
3555 goto exit;
3556 }
3557
3558 if (coex_sta->bt_whck_test) {
3559 rtw_btc_action_bt_whql_test(btc);
3560 goto exit;
3561 }
3562
3563 if (coex_sta->bt_setup_link) {
3564 rtw_btc_action_bt_relink(btc);
3565 goto exit;
3566 }
3567
3568 if (coex_sta->bt_inq_page) {
3569 rtw_btc_action_bt_inquiry(btc);
3570 goto exit;
3571 }
3572
3573 if ((coex_dm->bt_status == BTC_BTSTATUS_NCON_IDLE ||
3574 coex_dm->bt_status == BTC_BTSTATUS_CON_IDLE) &&
3575 link_info_ext->is_connected) {
3576 rtw_btc_action_bt_idle(btc);
3577 goto exit;
3578 }
3579
3580 if (coex_sta->wl_linkscan_proc && !coex_sta->coex_freerun) {
3581 rtw_btc_action_wl_linkscan(btc);
3582 goto exit;
3583 }
3584
3585 if (link_info_ext->is_connected) {
3586 rtw_btc_action_wl_connected(btc);
3587 goto exit;
3588 } else {
3589 rtw_btc_action_wl_not_connected(btc);
3590 goto exit;
3591 }
3592
3593 exit:
3594 #ifdef PLATFORM_WINDOWS
3595 /* 0:original, 1:1R */
3596 if (coex_sta->wl_coex_mode == BTC_WLINK_2GFREE &&
3597 chip_para->rx_path_num >= 2)
3598 rtw_btc_mimo_ps(btc, FC_EXCU, 1);
3599 else
3600 rtw_btc_mimo_ps(btc, FC_EXCU, 0);
3601 #endif
3602
3603 rtw_btc_gnt_workaround(btc, NM_EXCU, coex_sta->wl_coex_mode);
3604 rtw_btc_limited_wl(btc);
3605 }
3606
rtw_btc_init_coex_var(struct btc_coexist * btc)3607 static void rtw_btc_init_coex_var(struct btc_coexist *btc)
3608 {
3609 struct btc_coex_sta *coex_sta = &btc->coex_sta;
3610 struct btc_coex_dm *coex_dm = &btc->coex_dm;
3611 const struct btc_chip_para *chip_para = btc->chip_para;
3612 u8 i;
3613
3614 /* Reset Coex variable */
3615 btc->btc_set(btc, BTC_SET_RESET_COEX_VAR, NULL);
3616
3617 /* Init Coex variables that are not zero */
3618 for (i = 0; i < ARRAY_SIZE(coex_dm->bt_rssi_state); i++)
3619 coex_dm->bt_rssi_state[i] = BTC_RSSI_STATE_LOW;
3620
3621 for (i = 0; i < ARRAY_SIZE(coex_dm->wl_rssi_state); i++)
3622 coex_dm->wl_rssi_state[i] = BTC_RSSI_STATE_LOW;
3623
3624 for (i = 0; i < ARRAY_SIZE(coex_sta->bt_sut_pwr_lvl); i++)
3625 coex_sta->bt_sut_pwr_lvl[i] = 0xff;
3626
3627 coex_sta->bt_reg_vendor_ac = 0xffff;
3628 coex_sta->bt_reg_vendor_ae = 0xffff;
3629
3630 coex_sta->gnt_workaround_state = BTC_WLINK_MAX;
3631 btc->bt_info.bt_get_fw_ver = 0;
3632 }
3633
3634 static void
rtw_btc_init_hw_config(struct btc_coexist * btc,boolean wifi_only)3635 rtw_btc_init_hw_config(struct btc_coexist *btc, boolean wifi_only)
3636 {
3637 struct btc_coex_sta *coex_sta = &btc->coex_sta;
3638 const struct btc_chip_para *chip_para = btc->chip_para;
3639 u8 table_case = 1, tdma_case = 0;
3640
3641 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE, "[BTCoex], %s()\n", __func__);
3642 BTC_TRACE(trace_buf);
3643
3644 /* init coex_dm, coex_sta variable to sync with chip status */
3645 rtw_btc_init_coex_var(btc);
3646
3647 /* 0xf0[15:12] --> chip kt info */
3648 coex_sta->kt_ver = (btc->btc_read_1byte(btc, 0xf1) & 0xf0) >> 4;
3649
3650 rtw_btc_monitor_bt_enable(btc);
3651
3652 /* TBTT enable */
3653 btc->btc_write_1byte_bitmask(btc, REG_BCN_CTRL, BIT_EN_BCN_FUNCTION,
3654 0x1);
3655
3656 /* Setup RF front end type */
3657 btc->chip_para->chip_setup(btc, BTC_CSETUP_RFE_TYPE);
3658
3659 /* Init coex relared register */
3660 btc->chip_para->chip_setup(btc, BTC_CSETUP_INIT_HW);
3661
3662 /* set Tx response = Hi-Pri (ex: Transmitting ACK,BA,CTS) */
3663 rtw_btc_set_wl_pri_mask(btc, BTC_WLPRI_TX_RSP, 1);
3664
3665 /* set Tx beacon = Hi-Pri */
3666 rtw_btc_set_wl_pri_mask(btc, BTC_WLPRI_TX_BEACON, 1);
3667
3668 /* set Tx beacon queue = Hi-Pri */
3669 rtw_btc_set_wl_pri_mask(btc, BTC_WLPRI_TX_BEACONQ, 1);
3670
3671 /* Antenna config */
3672 if (btc->wl_rf_state_off) {
3673 rtw_btc_set_ant_path(btc, FC_EXCU, BTC_ANT_WOFF);
3674 if (chip_para->scbd_bit_num == BTC_SCBD_16_BIT)
3675 btc->btc_write_scbd(btc, BTC_SCBD_ALL, FALSE);
3676 else
3677 btc->btc_write_scbd_32bit(btc, BTC_SCBD_ALL_32BIT, FALSE);
3678 btc->stop_coex_dm = TRUE;
3679
3680 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
3681 "[BTCoex], %s(): RF Off\n", __func__);
3682 BTC_TRACE(trace_buf);
3683 } else if (wifi_only) {
3684 rtw_btc_set_ant_path(btc, FC_EXCU, BTC_ANT_WONLY);
3685 if (chip_para->scbd_bit_num == BTC_SCBD_16_BIT)
3686 btc->btc_write_scbd(btc, BTC_SCBD_ACTIVE | BTC_SCBD_ON, TRUE);
3687 else
3688 btc->btc_write_scbd_32bit(btc, BTC_SCBD_ACTIVE | BTC_SCBD_ON, TRUE);
3689 btc->stop_coex_dm = TRUE;
3690 } else {
3691 rtw_btc_set_ant_path(btc, FC_EXCU, BTC_ANT_INIT);
3692 if (chip_para->scbd_bit_num == BTC_SCBD_16_BIT)
3693 btc->btc_write_scbd(btc, BTC_SCBD_ACTIVE | BTC_SCBD_ON, TRUE);
3694 else
3695 btc->btc_write_scbd_32bit(btc, BTC_SCBD_ACTIVE | BTC_SCBD_ON, TRUE);
3696 btc->stop_coex_dm = FALSE;
3697 coex_sta->coex_freeze = TRUE;
3698 }
3699
3700 /* PTA parameter */
3701 rtw_btc_table(btc, FC_EXCU, table_case);
3702 rtw_btc_tdma(btc, FC_EXCU, tdma_case);
3703
3704 rtw_btc_query_bt_info(btc);
3705 }
3706
rtw_btc_ex_power_on_setting(struct btc_coexist * btc)3707 void rtw_btc_ex_power_on_setting(struct btc_coexist *btc)
3708 {
3709 struct btc_coex_sta *coex_sta = &btc->coex_sta;
3710 struct btc_board_info *board_info = &btc->board_info;
3711 u8 table_case = 1;
3712
3713 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE, "[BTCoex], %s()\n", __func__);
3714 BTC_TRACE(trace_buf);
3715
3716 btc->stop_coex_dm = TRUE;
3717 btc->wl_rf_state_off = FALSE;
3718
3719 /* enable BB, REG_SYS_FUNC_EN to write reg correctly. */
3720 btc->btc_write_1byte_bitmask(btc, REG_SYS_FUNC_EN,
3721 BIT_FEN_BB_GLB_RST | BIT_FEN_BB_RSTB, 0x3);
3722
3723 rtw_btc_monitor_bt_enable(btc);
3724
3725 /* Setup RF front end type */
3726 btc->chip_para->chip_setup(btc, BTC_CSETUP_RFE_TYPE);
3727
3728 /* Set Antenna Path to BT side */
3729 rtw_btc_set_ant_path(btc, FC_EXCU, BTC_ANT_POWERON);
3730
3731 rtw_btc_table(btc, FC_EXCU, table_case);
3732
3733 /* SD1 Chunchu red x issue */
3734 btc->btc_write_1byte(btc, 0xff1a, 0x0);
3735
3736 rtw_btc_gnt_debug(btc, TRUE);
3737
3738 board_info->btdm_ant_pos = BTC_ANTENNA_AT_MAIN_PORT;
3739 }
3740
rtw_btc_ex_pre_load_firmware(struct btc_coexist * btc)3741 void rtw_btc_ex_pre_load_firmware(struct btc_coexist *btc) {}
3742
rtw_btc_ex_init_hw_config(struct btc_coexist * btc,boolean wifi_only)3743 void rtw_btc_ex_init_hw_config(struct btc_coexist *btc, boolean wifi_only)
3744 {
3745 rtw_btc_init_hw_config(btc, wifi_only);
3746 }
3747
rtw_btc_ex_init_coex_dm(struct btc_coexist * btc)3748 void rtw_btc_ex_init_coex_dm(struct btc_coexist *btc)
3749 {
3750 }
3751
rtw_btc_ex_display_simple_coex_info(struct btc_coexist * btc)3752 void rtw_btc_ex_display_simple_coex_info(struct btc_coexist *btc)
3753 {
3754 struct btc_coex_sta *coex_sta = &btc->coex_sta;
3755 struct btc_coex_dm *coex_dm = &btc->coex_dm;
3756 const struct btc_chip_para *chip_para = btc->chip_para;
3757 struct btc_rfe_type *rfe_type = &btc->rfe_type;
3758 struct btc_board_info *board_info = &btc->board_info;
3759
3760 u8 *cli_buf = btc->cli_buf;
3761 u32 bt_patch_ver = 0, bt_coex_ver = 0, val = 0;
3762
3763 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE, "[BTCoex], %s()\n", __func__);
3764 BTC_TRACE(trace_buf);
3765
3766 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n _____[BT Coexist info]____");
3767 CL_PRINTF(cli_buf);
3768
3769 if (btc->manual_control) {
3770 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
3771 "\r\n __[Under Manual Control]_");
3772 CL_PRINTF(cli_buf);
3773 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
3774 "\r\n _________________________");
3775 CL_PRINTF(cli_buf);
3776 }
3777
3778 if (btc->stop_coex_dm) {
3779 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
3780 "\r\n ____[Coex is STOPPED]____");
3781 CL_PRINTF(cli_buf);
3782 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
3783 "\r\n _________________________");
3784 CL_PRINTF(cli_buf);
3785 }
3786
3787 if (!coex_sta->bt_disabled &&
3788 (coex_sta->bt_supported_version == 0 ||
3789 coex_sta->bt_supported_version == 0xffff) &&
3790 coex_sta->cnt_wl[BTC_CNT_WL_COEXINFO2] % 3 == 0) {
3791 btc->btc_get(btc, BTC_GET_U4_SUPPORTED_FEATURE,
3792 &coex_sta->bt_supported_feature);
3793
3794 btc->btc_get(btc, BTC_GET_U4_SUPPORTED_VERSION,
3795 &coex_sta->bt_supported_version);
3796
3797 val = btc->btc_get_bt_reg(btc, 3, 0xac);
3798 coex_sta->bt_reg_vendor_ac = (u16)(val & 0xffff);
3799
3800 val = btc->btc_get_bt_reg(btc, 3, 0xae);
3801 coex_sta->bt_reg_vendor_ae = (u16)(val & 0xffff);
3802
3803 btc->btc_get(btc, BTC_GET_U4_BT_PATCH_VER, &bt_patch_ver);
3804 btc->bt_info.bt_get_fw_ver = bt_patch_ver;
3805 }
3806
3807 /* BT coex. info. */
3808 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
3809 "\r\n %-35s = %d/ %d/ %s / %d",
3810 "Ant PG Num/ Mech/ Pos/ RFE", board_info->pg_ant_num,
3811 board_info->btdm_ant_num,
3812 (board_info->btdm_ant_pos ==
3813 BTC_ANTENNA_AT_MAIN_PORT ? "Main" : "Aux"),
3814 rfe_type->rfe_module_type);
3815 CL_PRINTF(cli_buf);
3816
3817 bt_coex_ver = ((coex_sta->bt_supported_version & 0xff00) >> 8);
3818
3819 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
3820 "\r\n %-35s = %d_%02x/ %d_%02x/ 0x%02x/ 0x%02x (%s)",
3821 "Ver Coex/ Para/ BT_Dez/ BT_Rpt",
3822 coex_ver_date, coex_ver, chip_para->para_ver_date,
3823 chip_para->para_ver, chip_para->bt_desired_ver, bt_coex_ver,
3824 (bt_coex_ver == 0xff ? "Unknown" :
3825 (coex_sta->bt_disabled ? "BT-disable" :
3826 (bt_coex_ver >= chip_para->bt_desired_ver ?
3827 "Match" : "Mis-Match"))));
3828 CL_PRINTF(cli_buf);
3829
3830 /* BT Status */
3831 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %s", "BT status",
3832 ((coex_sta->bt_disabled) ? ("disabled") :
3833 ((coex_sta->bt_inq_page) ? ("inquiry/page") :
3834 ((coex_dm->bt_status == BTC_BTSTATUS_NCON_IDLE) ?
3835 "non-connected idle" :
3836 ((coex_dm->bt_status == BTC_BTSTATUS_CON_IDLE) ?
3837 "connected-idle" : "busy")))));
3838 CL_PRINTF(cli_buf);
3839
3840 /* HW Settings */
3841 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d/ %d",
3842 "0x770(Hi-pri rx/tx)", coex_sta->hi_pri_rx,
3843 coex_sta->hi_pri_tx);
3844 CL_PRINTF(cli_buf);
3845
3846 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d/ %d %s",
3847 "0x774(Lo-pri rx/tx)", coex_sta->lo_pri_rx,
3848 coex_sta->lo_pri_tx, (coex_sta->bt_slave ?
3849 "(Slave!!)" : ""));
3850 CL_PRINTF(cli_buf);
3851
3852 coex_sta->cnt_wl[BTC_CNT_WL_COEXINFO2]++;
3853 }
3854
rtw_btc_ex_display_coex_info(struct btc_coexist * btc)3855 void rtw_btc_ex_display_coex_info(struct btc_coexist *btc)
3856 {
3857 struct btc_coex_sta *coex_sta = &btc->coex_sta;
3858 struct btc_coex_dm *coex_dm = &btc->coex_dm;
3859 const struct btc_chip_para *chip_para = btc->chip_para;
3860 struct btc_rfe_type *rfe_type = &btc->rfe_type;
3861 struct btc_board_info *board_info = &btc->board_info;
3862
3863 u8 *cli_buf = btc->cli_buf, i, ps_tdma_case = 0;
3864 u16 scbd;
3865 u32 phy_ver = 0, fw_ver = 0,
3866 bt_coex_ver = 0, val = 0,
3867 fa_ofdm, fa_cck, cca_ofdm, cca_cck,
3868 ok_11b, ok_11g, ok_11n, ok_11vht,
3869 err_11b, err_11g, err_11n, err_11vht,
3870 scbd_32, bt_slot_max , bt_slot_min, bt_slot_sum = 0;
3871 boolean is_bt_reply = FALSE;
3872 u8 * const p = &coex_sta->bt_afh_map[0];
3873
3874 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE, "[BTCoex], %s()\n", __func__);
3875 BTC_TRACE(trace_buf);
3876
3877 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
3878 "\r\n ============[BT Coexist info %s]============",
3879 chip_para->chip_name);
3880 CL_PRINTF(cli_buf);
3881
3882 if (btc->manual_control) {
3883 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
3884 "\r\n ============[Under Manual Control]============");
3885 CL_PRINTF(cli_buf);
3886 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
3887 "\r\n ==========================================");
3888 CL_PRINTF(cli_buf);
3889 } else if (btc->stop_coex_dm) {
3890 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
3891 "\r\n ============[Coex is STOPPED]============");
3892 CL_PRINTF(cli_buf);
3893 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
3894 "\r\n ==========================================");
3895 CL_PRINTF(cli_buf);
3896 } else if (coex_sta->coex_freeze) {
3897 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
3898 "\r\n ============[coex_freeze]============");
3899 CL_PRINTF(cli_buf);
3900 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
3901 "\r\n ==========================================");
3902 CL_PRINTF(cli_buf);
3903 }
3904
3905 if (!coex_sta->bt_disabled &&
3906 coex_sta->cnt_wl[BTC_CNT_WL_COEXINFO1] % 3 == 0) {
3907 if (coex_sta->bt_supported_version == 0 ||
3908 coex_sta->bt_supported_version == 0xffff) {
3909 btc->btc_get(btc, BTC_GET_U4_SUPPORTED_VERSION,
3910 &coex_sta->bt_supported_version);
3911
3912 if (coex_sta->bt_supported_version > 0 &&
3913 coex_sta->bt_supported_version < 0xffff)
3914 is_bt_reply = TRUE;
3915 } else {
3916 is_bt_reply = TRUE;
3917 }
3918
3919 if (coex_dm->bt_status != BTC_BTSTATUS_NCON_IDLE) {
3920 btc->btc_get_bt_afh_map_from_bt(btc, 0, p);
3921 val = btc->btc_get_bt_reg(btc, 1, 0xa);
3922 coex_sta->bt_reg_modem_a = (u16)((val & 0x1c0) >> 6);
3923 val = btc->btc_get_bt_reg(btc, 0, 0x2);
3924 coex_sta->bt_reg_rf_2 = (u16)val;
3925 }
3926 }
3927
3928 if (is_bt_reply) {
3929 if (coex_sta->bt_supported_feature == 0) {
3930 btc->btc_get(btc, BTC_GET_U4_SUPPORTED_FEATURE,
3931 &coex_sta->bt_supported_feature);
3932
3933 if (coex_sta->bt_supported_feature & BIT(11))
3934 coex_sta->bt_slave_latency = TRUE;
3935 else
3936 coex_sta->bt_slave_latency = FALSE;
3937 }
3938
3939 if (strcmp(btc->chip_para->chip_name, "8723f") == 0) {
3940 /*8723f cannot read ae because ALIGNMENT_UNIT = 4byte
3941 8723f should read bt vendor reg 0xdac*/
3942 if (coex_sta->bt_reg_vendor_dac == 0xffffffff) {
3943 val = btc->btc_get_bt_reg(btc, 3, 0xdac);
3944 coex_sta->bt_reg_vendor_dac = val;
3945 }
3946 } else {
3947 if (coex_sta->bt_reg_vendor_ac == 0xffff) {
3948 val = btc->btc_get_bt_reg(btc, 3, 0xac);
3949 coex_sta->bt_reg_vendor_ac = (u16)(val & 0xffff);
3950 }
3951
3952 if (coex_sta->bt_reg_vendor_ae == 0xffff) {
3953 val = btc->btc_get_bt_reg(btc, 3, 0xae);
3954 coex_sta->bt_reg_vendor_ae = (u16)(val & 0xffff);
3955 }
3956 }
3957
3958 val = btc->btc_get_bt_reg(btc, 4, 0x200);
3959 coex_sta->bt_reg_le_200 = (u16)(val & 0xffff);
3960
3961 if (btc->bt_info.bt_get_fw_ver == 0)
3962 btc->btc_get(btc, BTC_GET_U4_BT_PATCH_VER,
3963 &btc->bt_info.bt_get_fw_ver);
3964
3965 if (coex_sta->bt_a2dp_exist &&
3966 coex_sta->bt_a2dp_vendor_id == 0 &&
3967 coex_sta->bt_a2dp_device_name == 0) {
3968 btc->btc_get(btc, BTC_GET_U4_BT_DEVICE_INFO, &val);
3969 coex_sta->bt_a2dp_vendor_id = (u8)(val & 0xff);
3970 coex_sta->bt_a2dp_device_name = (val & 0xffffff00) >> 8;
3971 }
3972
3973 if (coex_sta->bt_a2dp_exist &&
3974 coex_sta->bt_a2dp_flush_time == 0) {
3975 btc->btc_get(btc, BTC_GET_U4_BT_A2DP_FLUSH_VAL, &val);
3976 coex_sta->bt_a2dp_flush_time = val;
3977 }
3978 }
3979
3980 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d/ %s/ %s / %d/ %d",
3981 "Ant PG Num/ Mech/ Pos/ RFE/ Dist", board_info->pg_ant_num,
3982 (board_info->btdm_ant_num == 1 ? "Shared" : "Non-Shared"),
3983 (board_info->btdm_ant_pos == BTC_ANTENNA_AT_MAIN_PORT ?
3984 "Main" : "Aux"), rfe_type->rfe_module_type,
3985 board_info->ant_distance);
3986 CL_PRINTF(cli_buf);
3987
3988 btc->btc_get(btc, BTC_GET_U4_WIFI_FW_VER, &fw_ver);
3989 btc->btc_get(btc, BTC_GET_U4_WIFI_PHY_VER, &phy_ver);
3990 bt_coex_ver = ((coex_sta->bt_supported_version & 0xff00) >> 8);
3991
3992 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
3993 "\r\n %-35s = %d_%02x/ %d_%02x/ 0x%02x/ 0x%02x (%s)",
3994 "Ver Coex/ Para/ BT_Dez/ BT_Rpt",
3995 coex_ver_date, coex_ver, chip_para->para_ver_date,
3996 chip_para->para_ver, chip_para->bt_desired_ver, bt_coex_ver,
3997 (bt_coex_ver == 0xff ? "Unknown" :
3998 (coex_sta->bt_disabled ? "BT-disable" :
3999 (bt_coex_ver >= chip_para->bt_desired_ver ?
4000 "Match" : "Mis-Match"))));
4001 CL_PRINTF(cli_buf);
4002
4003 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4004 "\r\n %-35s = 0x%x(%s)/ 0x%08x/ v%d/ %c",
4005 "W_FW/ B_FW/ Phy/ Kt", fw_ver,
4006 (fw_ver >= chip_para->wl_desired_ver ? "Match" : "Mis-Match"),
4007 btc->bt_info.bt_get_fw_ver, phy_ver, coex_sta->kt_ver + 65);
4008 CL_PRINTF(cli_buf);
4009
4010 /* wifi status */
4011 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s",
4012 "============[Wifi Status]============");
4013 CL_PRINTF(cli_buf);
4014 btc->btc_disp_dbg_msg(btc, BTC_DBG_DISP_WIFI_STATUS);
4015
4016 /*EXT CHIP status*/
4017 if (btc->board_info.ext_chip_id != BTC_EXT_CHIP_NONE) {
4018 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s",
4019 "============[EXT CHIP Status]============");
4020 CL_PRINTF(cli_buf);
4021 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %s/ %s",
4022 "EXT CHIP ID/EXT CHIP mode",
4023 ((btc->board_info.ext_chip_id ==
4024 BTC_EXT_CHIP_RF4CE) ? "RF4CE" : "unknown"),
4025 ((coex_sta->ext_chip_mode ==
4026 BTC_EXTMODE_VOICE) ? "VOICE" : "NORMAL"));
4027 CL_PRINTF(cli_buf);
4028 }
4029
4030 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s",
4031 "============[BT Status]============");
4032 CL_PRINTF(cli_buf);
4033 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %s/ %ddBm/ %d/ %d",
4034 "BT status/ rssi/ retryCnt/ popCnt",
4035 ((coex_sta->bt_disabled) ? ("disabled") :
4036 ((coex_sta->bt_inq_page) ? ("inquiry-page") :
4037 ((coex_dm->bt_status == BTC_BTSTATUS_NCON_IDLE) ?
4038 "non-connecte-idle" : ((coex_dm->bt_status ==
4039 BTC_BTSTATUS_CON_IDLE) ? "connected-idle" : "busy")))),
4040 coex_sta->bt_rssi - 100, coex_sta->cnt_bt[BTC_CNT_BT_RETRY],
4041 coex_sta->cnt_bt[BTC_CNT_BT_POPEVENT]);
4042 CL_PRINTF(cli_buf);
4043
4044 if (coex_sta->bt_profile_num != 0) {
4045 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4046 "\r\n %-35s = %s%s%s%s%s%s (multilink = %d)",
4047 "Profiles", ((coex_sta->bt_a2dp_exist) ?
4048 ((coex_sta->bt_a2dp_sink) ? "A2DP sink," :
4049 "A2DP,") : ""),
4050 ((coex_sta->bt_hfp_exist) ? "HFP," : ""),
4051 ((coex_sta->bt_hid_exist) ?
4052 ((coex_sta->bt_ble_exist) ? "HID(RCU)" :
4053 ((coex_sta->bt_hid_slot >= 2) ? "HID(4/18)," :
4054 (coex_sta->bt_ble_hid_exist ? "HID(BLE)" :
4055 "HID(2/18),"))) : ""), ((coex_sta->bt_pan_exist) ?
4056 ((coex_sta->bt_opp_exist) ? "OPP," : "PAN,") :
4057 ""), ((coex_sta->bt_ble_voice) ? "Voice," : ""),
4058 ((coex_sta->bt_msft_mr_exist) ? "MR" : ""),
4059 coex_sta->bt_multi_link);
4060 CL_PRINTF(cli_buf);
4061
4062 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4063 "\r\n %-35s = %d/ %d/ %d/ %d",
4064 "SUT Power[3:0]",
4065 coex_sta->bt_sut_pwr_lvl[3],
4066 coex_sta->bt_sut_pwr_lvl[2],
4067 coex_sta->bt_sut_pwr_lvl[1],
4068 coex_sta->bt_sut_pwr_lvl[0]);
4069
4070 CL_PRINTF(cli_buf);
4071 } else {
4072 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %s",
4073 "Profiles",
4074 (coex_sta->bt_msft_mr_exist) ? "MR" : "None");
4075
4076 CL_PRINTF(cli_buf);
4077 }
4078
4079 /* for 8822b, Scoreboard[10]: 0: CQDDR off, 1: CQDDR on
4080 * for 8822c, Scoreboard[10]: 0: CQDDR on, 1:CQDDR fix 2M
4081 */
4082
4083 if (coex_sta->bt_a2dp_exist) {
4084 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4085 "\r\n %-35s = %s/ %d/ 0x%x/ 0x%x/ %d",
4086 "CQDDR/Bitpool/V_ID/D_name/Flush",
4087 (chip_para->new_scbd10_def ?
4088 ((coex_sta->bt_fix_2M) ? "fix_2M" : "CQDDR_On") :
4089 ((coex_sta->bt_fix_2M) ? "CQDDR_On" : "CQDDR_Off")),
4090 coex_sta->bt_a2dp_bitpool,
4091 coex_sta->bt_a2dp_vendor_id,
4092 coex_sta->bt_a2dp_device_name,
4093 coex_sta->bt_a2dp_flush_time);
4094
4095 CL_PRINTF(cli_buf);
4096 }
4097
4098 if (coex_sta->bt_hid_exist) {
4099 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d",
4100 "HID PairNum", coex_sta->bt_hid_pair_num);
4101 CL_PRINTF(cli_buf);
4102 }
4103
4104 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %s/ %d/ %s/ 0x%x",
4105 "Role/RoleSwCnt/IgnWla/Feature",
4106 ((coex_sta->bt_slave) ? "Slave" : "Master"),
4107 coex_sta->cnt_bt[BTC_CNT_BT_ROLESWITCH],
4108 ((coex_dm->cur_ignore_wlan_act) ? "Yes" : "No"),
4109 coex_sta->bt_supported_feature);
4110 CL_PRINTF(cli_buf);
4111
4112 if (coex_sta->bt_ble_scan_en) {
4113 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4114 "\r\n %-35s = 0x%x/ 0x%x/ 0x%x/ 0x%x",
4115 "BLEScan Type/TV/Init/Ble",
4116 coex_sta->bt_ble_scan_type,
4117 (coex_sta->bt_ble_scan_type & 0x1 ?
4118 coex_sta->bt_ble_scan_para[0] : 0x0),
4119 (coex_sta->bt_ble_scan_type & 0x2 ?
4120 coex_sta->bt_ble_scan_para[1] : 0x0),
4121 (coex_sta->bt_ble_scan_type & 0x4 ?
4122 coex_sta->bt_ble_scan_para[2] : 0x0));
4123 CL_PRINTF(cli_buf);
4124 }
4125
4126 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4127 "\r\n %-35s = %d/ %d/ %d/ %d/ %d/ %d/ %d %s",
4128 "Init/ReLink/IgnWl/Pag/Inq/iqkO/iqkX",
4129 coex_sta->cnt_bt[BTC_CNT_BT_REINIT],
4130 coex_sta->cnt_bt[BTC_CNT_BT_SETUPLINK],
4131 coex_sta->cnt_bt[BTC_CNT_BT_IGNWLANACT],
4132 coex_sta->cnt_bt[BTC_CNT_BT_PAGE],
4133 coex_sta->cnt_bt[BTC_CNT_BT_INQ],
4134 coex_sta->cnt_bt[BTC_CNT_BT_IQK],
4135 coex_sta->cnt_bt[BTC_CNT_BT_IQKFAIL],
4136 (coex_sta->bt_setup_link ? "(Relink!!)" : ""));
4137 CL_PRINTF(cli_buf);
4138
4139 if (coex_sta->bt_reg_vendor_ae != 0xffff ||
4140 coex_sta->bt_reg_vendor_ac != 0xffff ||
4141 coex_sta->bt_reg_vendor_dac != 0xffffffff) {
4142 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4143 "\r\n %-35s = 0x%x/ 0x%x/ 0x%x/ 0x%x/ 0x%x/ %s",
4144 "ae/ac/dac/m_a[8:6]/ScBd(B->W)/path",
4145 coex_sta->bt_reg_vendor_ae,
4146 coex_sta->bt_reg_vendor_ac,
4147 coex_sta->bt_reg_vendor_dac,
4148 coex_sta->bt_reg_modem_a,
4149 ((chip_para->scbd_bit_num == BTC_SCBD_16_BIT) ?
4150 btc->btc_read_scbd(btc, &scbd) :
4151 btc->btc_read_scbd_32bit(btc, &scbd_32)),
4152 ((coex_sta->bt_reg_vendor_ae & BIT(4)) ? "S1" : "S0"
4153 ));
4154 CL_PRINTF(cli_buf);
4155
4156 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4157 "\r\n %-35s = 0x%x/ 0x%x",
4158 "rf_2/rf_9",
4159 coex_sta->bt_reg_rf_2,
4160 coex_sta->bt_reg_rf_9);
4161 } else {
4162 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4163 "\r\n %-35s = x/ x/ x/ 0x%x",
4164 "0xae[4]/0xac[1:0]/0xdac/ScBd(B->W)",
4165 ((chip_para->scbd_bit_num == BTC_SCBD_16_BIT) ?
4166 btc->btc_read_scbd(btc, &scbd) :
4167 btc->btc_read_scbd_32bit(btc, &scbd_32)));
4168 }
4169 CL_PRINTF(cli_buf);
4170
4171 /* COEX-662: LE reg 0x200[3:0] -> forbidden slot num */
4172 if (coex_sta->bt_reg_le_200 == 0xffff)
4173 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4174 "\r\n %-35s = x",
4175 "LE_FBDSLT_num");
4176 else
4177 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4178 "\r\n %-35s = 0x%x",
4179 "LE_FBDSLT_num",
4180 coex_sta->bt_reg_le_200 & 0xf);
4181 CL_PRINTF(cli_buf);
4182
4183 if (coex_dm->bt_status != BTC_BTSTATUS_NCON_IDLE) {
4184 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4185 "\r\n %-35s = %02x%02x%02x%02x %02x%02x%02x%02x %02x%02x",
4186 "AFH MAP", coex_sta->bt_afh_map[0],
4187 coex_sta->bt_afh_map[1], coex_sta->bt_afh_map[2],
4188 coex_sta->bt_afh_map[3], coex_sta->bt_afh_map[4],
4189 coex_sta->bt_afh_map[5], coex_sta->bt_afh_map[6],
4190 coex_sta->bt_afh_map[7], coex_sta->bt_afh_map[8],
4191 coex_sta->bt_afh_map[9]);
4192 CL_PRINTF(cli_buf);
4193 }
4194
4195 for (i = 0; i < BTC_BTINFO_SRC_BT_IQK; i++) {
4196 if (coex_sta->cnt_bt_info_c2h[i]) {
4197 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4198 "\r\n %-35s = %02x %02x %02x %02x %02x %02x %02x (%d)",
4199 glbt_info_src[i],
4200 coex_sta->bt_info_c2h[i][0],
4201 coex_sta->bt_info_c2h[i][1],
4202 coex_sta->bt_info_c2h[i][2],
4203 coex_sta->bt_info_c2h[i][3],
4204 coex_sta->bt_info_c2h[i][4],
4205 coex_sta->bt_info_c2h[i][5],
4206 coex_sta->bt_info_c2h[i][6],
4207 coex_sta->cnt_bt_info_c2h[i]);
4208 CL_PRINTF(cli_buf);
4209 }
4210 }
4211
4212 if (btc->manual_control) {
4213 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s",
4214 "============[mechanisms] (under Manual)============");
4215 CL_PRINTF(cli_buf);
4216
4217 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4218 "\r\n %-35s = %02x %02x %02x %02x %02x",
4219 "TDMA_Now",
4220 coex_dm->fw_tdma_para[0], coex_dm->fw_tdma_para[1],
4221 coex_dm->fw_tdma_para[2], coex_dm->fw_tdma_para[3],
4222 coex_dm->fw_tdma_para[4]);
4223 CL_PRINTF(cli_buf);
4224 } else {
4225 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s",
4226 "============[Mechanisms]============");
4227 CL_PRINTF(cli_buf);
4228
4229 ps_tdma_case = coex_dm->cur_ps_tdma;
4230 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4231 "\r\n %-35s = %02x %02x %02x %02x %02x (case-%d, TDMA-%s, Ext-%d, Tog-%d)",
4232 "TDMA",
4233 coex_dm->ps_tdma_para[0], coex_dm->ps_tdma_para[1],
4234 coex_dm->ps_tdma_para[2], coex_dm->ps_tdma_para[3],
4235 coex_dm->ps_tdma_para[4], ps_tdma_case,
4236 (coex_dm->cur_ps_tdma_on ? "On" : "Off"),
4237 coex_sta->bt_ext_autoslot_thres,
4238 coex_sta->wl_toggle_interval);
4239 CL_PRINTF(cli_buf);
4240 }
4241
4242 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %s/ %s/ %d",
4243 "Coex_Mode/Free_Run/Timer_base",
4244 coex_mode_string[coex_sta->wl_coex_mode],
4245 ((coex_sta->coex_freerun) ? "Yes" : "No"),
4246 coex_sta->tdma_timer_base);
4247
4248 CL_PRINTF(cli_buf);
4249
4250 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4251 "\r\n %-35s = %d/ 0x%x/ 0x%x/ 0x%x",
4252 "Table/0x6c0/0x6c4/0x6c8", coex_sta->coex_table_type,
4253 btc->btc_read_4byte(btc, REG_BT_COEX_TABLE0),
4254 btc->btc_read_4byte(btc, REG_BT_COEX_TABLE1),
4255 btc->btc_read_4byte(btc, REG_BT_COEX_BRK_TABLE));
4256 CL_PRINTF(cli_buf);
4257
4258 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4259 "\r\n %-35s = 0x%x/ 0x%x/ 0x%x/ %d/ %s",
4260 "0x778/0x6cc/ScBd(W->B)/RunCnt/Rsn",
4261 btc->btc_read_1byte(btc, REG_BT_STAT_CTRL),
4262 btc->btc_read_4byte(btc, REG_BT_COEX_TABLE_H),
4263 ((chip_para->scbd_bit_num == BTC_SCBD_16_BIT) ?
4264 coex_sta->score_board_WB : coex_sta->score_board_WB_32bit),
4265 coex_sta->cnt_wl[BTC_CNT_WL_COEXRUN],
4266 run_reason_string[coex_sta->coex_run_reason]);
4267 CL_PRINTF(cli_buf);
4268
4269 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4270 "\r\n %-35s = %02x %02x %02x (RF-Ch = %d)", "AFH Map to BT",
4271 coex_dm->wl_chnl_info[0], coex_dm->wl_chnl_info[1],
4272 coex_dm->wl_chnl_info[2], coex_sta->wl_center_ch);
4273 CL_PRINTF(cli_buf);
4274
4275 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %s/ %s/ %s/ %d",
4276 "AntDiv/BtCtrlLPS/LPRA/g_busy",
4277 ((board_info->ant_div_cfg) ? "On" : "Off"),
4278 ((coex_sta->wl_force_lps_ctrl) ? "On" : "Off"),
4279 ((coex_dm->cur_low_penalty_ra) ? "On" : "Off"),
4280 coex_sta->wl_gl_busy);
4281 CL_PRINTF(cli_buf);
4282
4283 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d/ %d/ %d/ %d/ %d",
4284 "Null All/Retry/Ack/BT_Empty/BT_Late",
4285 coex_sta->wl_fw_dbg_info[1], coex_sta->wl_fw_dbg_info[2],
4286 coex_sta->wl_fw_dbg_info[3], coex_sta->wl_fw_dbg_info[4],
4287 coex_sta->wl_fw_dbg_info[5]);
4288 CL_PRINTF(cli_buf);
4289
4290 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d/ %d/ %s/ %d",
4291 "Cnt TDMA_Togg/LkRx/LKAP_On/fw",
4292 coex_sta->wl_fw_dbg_info[6],
4293 coex_sta->wl_fw_dbg_info[7],
4294 ((coex_sta->wl_leak_ap) ? "Yes" : "No"),
4295 coex_sta->cnt_wl[BTC_CNT_WL_FW_NOTIFY]);
4296 CL_PRINTF(cli_buf);
4297
4298 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d/ %d/ %s/ %d",
4299 "WL_TxPw/BT_TxPw/WL_Rx/BT_LNA_Lvl",
4300 coex_dm->cur_wl_pwr_lvl, coex_dm->cur_bt_pwr_lvl,
4301 ((coex_dm->cur_wl_rx_low_gain_en) ? "On" : "Off"),
4302 coex_dm->cur_bt_lna_lvl);
4303 CL_PRINTF(cli_buf);
4304
4305 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d/ %d/ %s",
4306 "MIMO_PS On/Recover/BlackAP",
4307 coex_sta->cnt_wl[BTC_CNT_WL_2G_FDDSTAY],
4308 coex_sta->cnt_wl[BTC_CNT_WL_2G_TDDTRY],
4309 ((coex_sta->wl_blacklist_ap) ? "Yes": "No"));
4310 CL_PRINTF(cli_buf);
4311
4312 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4313 "\r\n %-35s = %02d %02d %02d %02d %02d %02d %02d %02d %02d %02d",
4314 "BT slot length1 (ms)",
4315 coex_dm->bt_slot_length1[0], coex_dm->bt_slot_length1[1],
4316 coex_dm->bt_slot_length1[2], coex_dm->bt_slot_length1[3],
4317 coex_dm->bt_slot_length1[4], coex_dm->bt_slot_length1[5],
4318 coex_dm->bt_slot_length1[6], coex_dm->bt_slot_length1[7],
4319 coex_dm->bt_slot_length1[8], coex_dm->bt_slot_length1[9]);
4320 CL_PRINTF(cli_buf);
4321
4322 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4323 "\r\n %-35s = %02d %02d %02d %02d %02d %02d %02d %02d %02d %02d",
4324 "BT slot length2 (ms)",
4325 coex_dm->bt_slot_length2[0], coex_dm->bt_slot_length2[1],
4326 coex_dm->bt_slot_length2[2], coex_dm->bt_slot_length2[3],
4327 coex_dm->bt_slot_length2[4], coex_dm->bt_slot_length2[5],
4328 coex_dm->bt_slot_length2[6], coex_dm->bt_slot_length2[7],
4329 coex_dm->bt_slot_length2[8], coex_dm->bt_slot_length2[9]);
4330 CL_PRINTF(cli_buf);
4331
4332 for(i = 0; i < 10; i++){
4333 bt_slot_sum += coex_dm->bt_slot_length1[i];
4334 bt_slot_sum += coex_dm->bt_slot_length2[i];
4335 }
4336
4337 bt_slot_min = coex_dm->bt_slot_length1[0];
4338 for(i = 0; i < 10; i++){
4339 if (bt_slot_min > coex_dm->bt_slot_length1[i])
4340 bt_slot_min = coex_dm->bt_slot_length1[i];
4341 if (bt_slot_min > coex_dm->bt_slot_length2[i])
4342 bt_slot_min = coex_dm->bt_slot_length2[i];
4343 }
4344
4345 bt_slot_max = coex_dm->bt_slot_length1[0];
4346 for(i = 0; i < 10; i++){
4347 if (bt_slot_max < coex_dm->bt_slot_length1[i])
4348 bt_slot_max = coex_dm->bt_slot_length1[i];
4349 if (bt_slot_max < coex_dm->bt_slot_length2[i])
4350 bt_slot_max = coex_dm->bt_slot_length2[i];
4351 }
4352 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4353 "\r\n %-35s = %02d %02d %02d",
4354 "BT slot avg/BT slot max/BT slot min",
4355 bt_slot_sum/20, bt_slot_max, bt_slot_min);
4356 CL_PRINTF(cli_buf);
4357
4358 /* Hw setting */
4359 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s",
4360 "============[Hw setting]============");
4361 CL_PRINTF(cli_buf);
4362
4363 btc->chip_para->chip_setup(btc, BTC_CSETUP_COEXINFO_HW);
4364
4365 fa_ofdm = btc->btc_phydm_query_PHY_counter(btc, PHYDM_INFO_FA_OFDM);
4366 fa_cck = btc->btc_phydm_query_PHY_counter(btc, PHYDM_INFO_FA_CCK);
4367 cca_ofdm = btc->btc_phydm_query_PHY_counter(btc, PHYDM_INFO_CCA_OFDM);
4368 cca_cck = btc->btc_phydm_query_PHY_counter(btc, PHYDM_INFO_CCA_CCK);
4369
4370 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4371 "\r\n %-35s = %d/ %d/ %d/ %d",
4372 "CCK-CCA/CCK-FA/OFDM-CCA/OFDM-FA", cca_cck, fa_cck, cca_ofdm,
4373 fa_ofdm);
4374 CL_PRINTF(cli_buf);
4375
4376 ok_11b =
4377 btc->btc_phydm_query_PHY_counter(btc, PHYDM_INFO_CRC32_OK_CCK);
4378 ok_11g =
4379 btc->btc_phydm_query_PHY_counter(btc, PHYDM_INFO_CRC32_OK_LEGACY);
4380 ok_11n =
4381 btc->btc_phydm_query_PHY_counter(btc, PHYDM_INFO_CRC32_OK_HT);
4382 ok_11vht =
4383 btc->btc_phydm_query_PHY_counter(btc, PHYDM_INFO_CRC32_OK_VHT);
4384
4385 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d/ %d/ %d/ %d",
4386 "CRC_OK CCK/11g/11n/11ac", ok_11b, ok_11g, ok_11n, ok_11vht);
4387 CL_PRINTF(cli_buf);
4388
4389 err_11b =
4390 btc->btc_phydm_query_PHY_counter(btc, PHYDM_INFO_CRC32_ERROR_CCK);
4391 err_11g =
4392 btc->btc_phydm_query_PHY_counter(btc, PHYDM_INFO_CRC32_ERROR_LEGACY);
4393 err_11n =
4394 btc->btc_phydm_query_PHY_counter(btc, PHYDM_INFO_CRC32_ERROR_HT);
4395 err_11vht =
4396 btc->btc_phydm_query_PHY_counter(btc, PHYDM_INFO_CRC32_ERROR_VHT);
4397
4398 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d/ %d/ %d/ %d",
4399 "CRC_Err CCK/11g/11n/11ac",
4400 err_11b, err_11g, err_11n, err_11vht);
4401 CL_PRINTF(cli_buf);
4402
4403 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE,
4404 "\r\n %-35s = %d/ %d/ %s-%d/ %d (Tx macid: %d)",
4405 "Rate RxD/RxRTS/TxD/TxRetry_ratio",
4406 coex_sta->wl_rx_rate, coex_sta->wl_rts_rx_rate,
4407 (coex_sta->wl_tx_rate & 0x80 ? "SGI" : "LGI"),
4408 coex_sta->wl_tx_rate & 0x7f,
4409 coex_sta->wl_tx_retry_ratio,
4410 coex_sta->wl_tx_macid);
4411 CL_PRINTF(cli_buf);
4412
4413 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %s/ %s/ %s/ %d",
4414 "HiPr/ Locking/ Locked/ Noisy",
4415 (coex_sta->wl_hi_pri_task1 ? "Yes" : "No"),
4416 (coex_sta->wl_cck_lock ? "Yes" : "No"),
4417 (coex_sta->wl_cck_lock_ever ? "Yes" : "No"),
4418 coex_sta->wl_noisy_level);
4419 CL_PRINTF(cli_buf);
4420
4421 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d/ %d",
4422 "0x770(Hi-pri rx/tx)", coex_sta->hi_pri_rx,
4423 coex_sta->hi_pri_tx);
4424 CL_PRINTF(cli_buf);
4425
4426 CL_SPRINTF(cli_buf, BT_TMP_BUF_SIZE, "\r\n %-35s = %d/ %d %s",
4427 "0x774(Lo-pri rx/tx)", coex_sta->lo_pri_rx,
4428 coex_sta->lo_pri_tx, (coex_sta->bt_slave ?
4429 "(Slave!!)" : ""));
4430 CL_PRINTF(cli_buf);
4431
4432 btc->btc_disp_dbg_msg(btc, BTC_DBG_DISP_COEX_STATISTICS);
4433
4434 coex_sta->cnt_wl[BTC_CNT_WL_COEXINFO1]++;
4435
4436 if (coex_sta->cnt_wl[BTC_CNT_WL_COEXINFO1] % 5 == 0)
4437 coex_sta->cnt_bt[BTC_CNT_BT_POPEVENT] = 0;
4438 }
4439
rtw_btc_ex_ips_notify(struct btc_coexist * btc,u8 type)4440 void rtw_btc_ex_ips_notify(struct btc_coexist *btc, u8 type)
4441 {
4442 struct btc_coex_sta *coex_sta = &btc->coex_sta;
4443 const struct btc_chip_para *chip_para = btc->chip_para;
4444
4445 if (btc->manual_control || btc->stop_coex_dm)
4446 return;
4447
4448 if (type == BTC_IPS_ENTER) {
4449 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4450 "[BTCoex], IPS ENTER notify\n");
4451 BTC_TRACE(trace_buf);
4452 coex_sta->wl_under_ips = TRUE;
4453
4454 /* Write WL "Active" in Score-board for LPS off */
4455 if (chip_para->scbd_bit_num == BTC_SCBD_16_BIT)
4456 btc->btc_write_scbd(btc, BTC_SCBD_ALL, FALSE);
4457 else
4458 btc->btc_write_scbd_32bit(btc, BTC_SCBD_ALL_32BIT, FALSE);
4459 btc->chip_para->chip_setup(btc, BTC_CSETUP_WLAN_ACT_IPS);
4460 rtw_btc_set_ant_path(btc, FC_EXCU, BTC_ANT_WOFF);
4461 rtw_btc_action_coex_all_off(btc);
4462 } else if (type == BTC_IPS_LEAVE) {
4463 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4464 "[BTCoex], IPS LEAVE notify\n");
4465 BTC_TRACE(trace_buf);
4466 if (chip_para->scbd_bit_num == BTC_SCBD_16_BIT)
4467 btc->btc_write_scbd(btc, BTC_SCBD_ACTIVE | BTC_SCBD_ON, TRUE);
4468 else
4469 btc->btc_write_scbd_32bit(btc, BTC_SCBD_ACTIVE | BTC_SCBD_ON, TRUE);
4470 /*leave IPS : run ini hw config (exclude wifi only)*/
4471 rtw_btc_init_hw_config(btc, FALSE);
4472
4473 coex_sta->wl_under_ips = FALSE;
4474 }
4475 }
4476
rtw_btc_ex_lps_notify(struct btc_coexist * btc,u8 type)4477 void rtw_btc_ex_lps_notify(struct btc_coexist *btc, u8 type)
4478 {
4479 struct btc_coex_sta *coex_sta = &btc->coex_sta;
4480 const struct btc_chip_para *chip_para = btc->chip_para;
4481
4482 if (btc->manual_control || btc->stop_coex_dm)
4483 return;
4484
4485 if (type == BTC_LPS_ENABLE) {
4486 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4487 "[BTCoex], LPS ENABLE notify\n");
4488 BTC_TRACE(trace_buf);
4489 coex_sta->wl_under_lps = TRUE;
4490
4491 if (coex_sta->wl_force_lps_ctrl) { /* LPS No-32K */
4492 /* Write WL "Active" in Score-board for PS-TDMA */
4493 if (chip_para->scbd_bit_num == BTC_SCBD_16_BIT)
4494 btc->btc_write_scbd(btc, BTC_SCBD_ACTIVE, TRUE);
4495 else
4496 btc->btc_write_scbd_32bit(btc, BTC_SCBD_ACTIVE, TRUE);
4497 } else {
4498 /* Write WL "Non-Active" in Score-board for Native-PS */
4499 if (chip_para->scbd_bit_num == BTC_SCBD_16_BIT) {
4500 btc->btc_write_scbd(btc, BTC_SCBD_ACTIVE, FALSE);
4501 btc->btc_write_scbd(btc, BTC_SCBD_WLBUSY, FALSE);
4502 } else {
4503 btc->btc_write_scbd_32bit(btc, BTC_SCBD_ACTIVE, FALSE);
4504 btc->btc_write_scbd_32bit(btc, BTC_SCBD_WLBUSY, FALSE);
4505 }
4506
4507 rtw_btc_run_coex(btc, BTC_RSN_LPS);
4508 }
4509 } else if (type == BTC_LPS_DISABLE) {
4510 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4511 "[BTCoex], LPS DISABLE notify\n");
4512 BTC_TRACE(trace_buf);
4513 coex_sta->wl_under_lps = FALSE;
4514
4515 /* Write WL "Active" in Score-board for LPS off */
4516 if (chip_para->scbd_bit_num == BTC_SCBD_16_BIT)
4517 btc->btc_write_scbd(btc, BTC_SCBD_ACTIVE, TRUE);
4518 else
4519 btc->btc_write_scbd_32bit(btc, BTC_SCBD_ACTIVE, TRUE);
4520
4521 if (!coex_sta->wl_force_lps_ctrl)
4522 rtw_btc_query_bt_info(btc);
4523
4524 rtw_btc_run_coex(btc, BTC_RSN_LPS);
4525 } else if (type == BTC_LPS_PRE) {
4526 /* COEX-649, prevent LeisurePSLeave() is called in LeisurePSEnter()*/
4527 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4528 "[BTCoex], LPS PRE notify(before enter LPS)\n");
4529 BTC_TRACE(trace_buf);
4530
4531 coex_sta->wl_in_lps_enter = TRUE;
4532 } else if (type == BTC_LPS_RET) {
4533 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4534 "[BTCoex], LPS RET notify(LPS enter end)\n");
4535 BTC_TRACE(trace_buf);
4536
4537 coex_sta->wl_in_lps_enter = FALSE;
4538 rtw_btc_run_coex(btc, BTC_RSN_LPS);
4539 } else {
4540 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4541 "[BTCoex], LPS unknown notify!!\n");
4542 BTC_TRACE(trace_buf);
4543 }
4544 }
4545
rtw_btc_ex_scan_notify(struct btc_coexist * btc,u8 type)4546 void rtw_btc_ex_scan_notify(struct btc_coexist *btc, u8 type)
4547 {
4548 struct btc_coex_sta *coex_sta = &btc->coex_sta;
4549 const struct btc_chip_para *chip_para = btc->chip_para;
4550
4551 if (btc->manual_control || btc->stop_coex_dm)
4552 return;
4553
4554 coex_sta->coex_freeze = FALSE;
4555
4556 if (chip_para->scbd_bit_num == BTC_SCBD_16_BIT)
4557 btc->btc_write_scbd(btc, BTC_SCBD_ACTIVE | BTC_SCBD_ON, TRUE);
4558 else
4559 btc->btc_write_scbd_32bit(btc, BTC_SCBD_ACTIVE | BTC_SCBD_ON, TRUE);
4560
4561 if (type == BTC_SCAN_START_5G) {
4562 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4563 "[BTCoex], SCAN START notify (5G)\n");
4564 BTC_TRACE(trace_buf);
4565
4566 rtw_btc_set_ant_path(btc, FC_EXCU, BTC_ANT_5G);
4567 rtw_btc_run_coex(btc, BTC_RSN_5GSCANSTART);
4568 } else if (type == BTC_SCAN_START_2G || type == BTC_SCAN_START) {
4569 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4570 "[BTCoex], SCAN START notify (2G)\n");
4571 BTC_TRACE(trace_buf);
4572
4573 coex_sta->wl_hi_pri_task2 = TRUE;
4574
4575 /* Force antenna setup for no scan result issue */
4576 rtw_btc_set_ant_path(btc, FC_EXCU, BTC_ANT_2G);
4577 rtw_btc_run_coex(btc, BTC_RSN_2GSCANSTART);
4578 } else {
4579 btc->btc_get(btc, BTC_GET_U1_AP_NUM,
4580 &coex_sta->cnt_wl[BTC_CNT_WL_SCANAP]);
4581
4582 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4583 "[BTCoex], SCAN FINISH notify (Scan-AP = %d)\n",
4584 coex_sta->cnt_wl[BTC_CNT_WL_SCANAP]);
4585 BTC_TRACE(trace_buf);
4586
4587 coex_sta->wl_hi_pri_task2 = FALSE;
4588
4589 rtw_btc_run_coex(btc, BTC_RSN_SCANFINISH);
4590 }
4591 }
4592
rtw_btc_ex_scan_notify_without_bt(struct btc_coexist * btc,u8 type)4593 void rtw_btc_ex_scan_notify_without_bt(struct btc_coexist *btc, u8 type)
4594 {
4595 struct btc_wifi_link_info_ext *link_info_ext = &btc->wifi_link_info_ext;
4596 struct btc_rfe_type *rfe_type = &btc->rfe_type;
4597 u8 ctrl_type = BTC_SWITCH_CTRL_BY_BBSW, pos_type = BTC_SWITCH_TO_WLG;
4598
4599 if (!rfe_type->ant_switch_exist)
4600 return;
4601
4602 if (type == BTC_SCAN_START && link_info_ext->is_all_under_5g)
4603 pos_type = BTC_SWITCH_TO_WLA;
4604
4605 rtw_btc_set_ant_switch(btc, FC_EXCU, ctrl_type, pos_type);
4606 }
4607
rtw_btc_ex_switchband_notify(struct btc_coexist * btc,u8 type)4608 void rtw_btc_ex_switchband_notify(struct btc_coexist *btc, u8 type)
4609 {
4610 struct btc_coex_sta *coex_sta = &btc->coex_sta;
4611
4612 if (btc->manual_control || btc->stop_coex_dm)
4613 return;
4614
4615 if (type == BTC_SWITCH_TO_5G) {
4616 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4617 "[BTCoex], %s(): TO_5G\n", __func__);
4618 BTC_TRACE(trace_buf);
4619
4620 rtw_btc_run_coex(btc, BTC_RSN_5GSWITCHBAND);
4621 } else if (type == BTC_SWITCH_TO_24G_NOFORSCAN) {
4622 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4623 "[BTCoex], %s(): TO_24G_NOFORSCAN\n", __func__);
4624 BTC_TRACE(trace_buf);
4625
4626 rtw_btc_run_coex(btc, BTC_RSN_2GSWITCHBAND);
4627 } else {
4628 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4629 "[BTCoex], %s(): TO_2G\n", __func__);
4630 BTC_TRACE(trace_buf);
4631
4632 rtw_btc_ex_scan_notify(btc, BTC_SCAN_START_2G);
4633 }
4634 }
4635
rtw_btc_ex_switchband_notify_without_bt(struct btc_coexist * btc,u8 type)4636 void rtw_btc_ex_switchband_notify_without_bt(struct btc_coexist *btc, u8 type)
4637 {
4638 struct btc_rfe_type *rfe_type = &btc->rfe_type;
4639 u8 ctrl_type = BTC_SWITCH_CTRL_BY_BBSW, pos_type = BTC_SWITCH_TO_WLG;
4640
4641 if (!rfe_type->ant_switch_exist)
4642 return;
4643
4644 if (type == BTC_SWITCH_TO_5G) {
4645 pos_type = BTC_SWITCH_TO_WLA;
4646 } else if (type == BTC_SWITCH_TO_24G_NOFORSCAN) {
4647 pos_type = BTC_SWITCH_TO_WLG;
4648 } else {
4649 rtw_btc_ex_scan_notify_without_bt(btc, BTC_SCAN_START_2G);
4650 return;
4651 }
4652
4653 rtw_btc_set_ant_switch(btc, FC_EXCU, ctrl_type, pos_type);
4654 }
4655
rtw_btc_ex_connect_notify(struct btc_coexist * btc,u8 type)4656 void rtw_btc_ex_connect_notify(struct btc_coexist *btc, u8 type)
4657 {
4658 struct btc_coex_sta *coex_sta = &btc->coex_sta;
4659 const struct btc_chip_para *chip_para = btc->chip_para;
4660
4661 if (btc->manual_control || btc->stop_coex_dm)
4662 return;
4663
4664 if (chip_para->scbd_bit_num == BTC_SCBD_16_BIT)
4665 btc->btc_write_scbd(btc, BTC_SCBD_ACTIVE | BTC_SCBD_ON, TRUE);
4666 else
4667 btc->btc_write_scbd_32bit(btc, BTC_SCBD_ACTIVE | BTC_SCBD_ON, TRUE);
4668
4669 if (type == BTC_ASSOCIATE_5G_START) {
4670 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4671 "[BTCoex], %s(): 5G start\n", __func__);
4672 BTC_TRACE(trace_buf);
4673
4674 rtw_btc_set_ant_path(btc, FC_EXCU, BTC_ANT_5G);
4675
4676 rtw_btc_run_coex(btc, BTC_RSN_5GCONSTART);
4677 } else if (type == BTC_ASSOCIATE_5G_FINISH) {
4678 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4679 "[BTCoex], %s(): 5G finish\n", __func__);
4680 BTC_TRACE(trace_buf);
4681
4682 rtw_btc_set_ant_path(btc, FC_EXCU, BTC_ANT_5G);
4683
4684 rtw_btc_run_coex(btc, BTC_RSN_5GCONFINISH);
4685 } else if (type == BTC_ASSOCIATE_START) {
4686 coex_sta->wl_hi_pri_task1 = TRUE;
4687 coex_sta->cnt_wl[BTC_CNT_WL_ARP] = 0;
4688 coex_sta->wl_connecting = TRUE;
4689 btc->btc_set_timer(btc, BTC_TIMER_WL_CONNPKT, 2);
4690
4691 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4692 "[BTCoex], %s(): 2G start\n", __func__);
4693 BTC_TRACE(trace_buf);
4694
4695 /* Force antenna setup for no scan result issue */
4696 rtw_btc_set_ant_path(btc, FC_EXCU, BTC_ANT_2G);
4697
4698 rtw_btc_run_coex(btc, BTC_RSN_2GCONSTART);
4699
4700 /* To keep TDMA case during connect process,
4701 * to avoid changed by Btinfo and run_coex
4702 */
4703 coex_sta->coex_freeze = TRUE;
4704 btc->btc_set_timer(btc, BTC_TIMER_WL_COEXFREEZE, 5);
4705 } else {
4706 coex_sta->wl_hi_pri_task1 = FALSE;
4707 coex_sta->coex_freeze = FALSE;
4708
4709 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4710 "[BTCoex], %s(): 2G finish\n", __func__);
4711 BTC_TRACE(trace_buf);
4712
4713 rtw_btc_run_coex(btc, BTC_RSN_2GCONFINISH);
4714 }
4715 }
4716
rtw_btc_ex_media_status_notify(struct btc_coexist * btc,u8 type)4717 void rtw_btc_ex_media_status_notify(struct btc_coexist *btc, u8 type)
4718 {
4719 struct btc_coex_sta *coex_sta = &btc->coex_sta;
4720 const struct btc_chip_para *chip_para = btc->chip_para;
4721 boolean wl_b_mode = FALSE;
4722 u8 i;
4723
4724 if (btc->manual_control || btc->stop_coex_dm)
4725 return;
4726
4727 coex_sta->coex_freeze = FALSE;
4728
4729 btc->btc_get(btc, BTC_GET_BL_WIFI_BSSID, btc->wifi_bssid);
4730
4731 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4732 "[BTCoex], %s(): BSSID = %02x %02X %02X %02x %02X %02X\n",
4733 __func__, btc->wifi_bssid[0],
4734 btc->wifi_bssid[1], btc->wifi_bssid[2],
4735 btc->wifi_bssid[3], btc->wifi_bssid[4],
4736 btc->wifi_bssid[5]);
4737 BTC_TRACE(trace_buf);
4738
4739 /* check if black-list ap */
4740 for (i = 0; i <= 5; i++) {
4741 if (btc->wifi_bssid[i] != btc->wifi_black_bssid[i])
4742 break;
4743 }
4744
4745 if (i <= 5)
4746 coex_sta->wl_blacklist_ap = FALSE;
4747 else
4748 coex_sta->wl_blacklist_ap = TRUE;
4749
4750 if (type == BTC_MEDIA_CONNECT_5G) {
4751 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4752 "[BTCoex], %s(): 5G\n", __func__);
4753 BTC_TRACE(trace_buf);
4754
4755 if (chip_para->scbd_bit_num == BTC_SCBD_16_BIT)
4756 btc->btc_write_scbd(btc, BTC_SCBD_ACTIVE, TRUE);
4757 else
4758 btc->btc_write_scbd_32bit(btc, BTC_SCBD_ACTIVE, TRUE);
4759 rtw_btc_set_ant_path(btc, FC_EXCU, BTC_ANT_5G);
4760
4761 rtw_btc_run_coex(btc, BTC_RSN_5GMEDIA);
4762 } else if (type == BTC_MEDIA_CONNECT) {
4763 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4764 "[BTCoex], %s(): 2G\n", __func__);
4765 BTC_TRACE(trace_buf);
4766
4767 if (chip_para->scbd_bit_num == BTC_SCBD_16_BIT)
4768 btc->btc_write_scbd(btc, BTC_SCBD_ACTIVE, TRUE);
4769 else
4770 btc->btc_write_scbd_32bit(btc, BTC_SCBD_ACTIVE, TRUE);
4771
4772 /* Force antenna setup for no scan result issue */
4773 rtw_btc_set_ant_path(btc, FC_EXCU, BTC_ANT_2G);
4774
4775 btc->btc_get(btc, BTC_GET_BL_WIFI_UNDER_B_MODE, &wl_b_mode);
4776
4777 /* Set CCK Tx/Rx high Pri except 11b mode */
4778 if (wl_b_mode)/* CCK Rx */
4779 rtw_btc_set_wl_pri_mask(btc, BTC_WLPRI_RX_CCK, 0);
4780 else /* CCK Rx */
4781 rtw_btc_set_wl_pri_mask(btc, BTC_WLPRI_RX_CCK, 1);
4782
4783 rtw_btc_run_coex(btc, BTC_RSN_2GMEDIA);
4784 } else {
4785 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4786 "[BTCoex], %s(): disconnect!!\n", __func__);
4787 BTC_TRACE(trace_buf);
4788 coex_sta->cnt_wl[BTC_CNT_WL_ARP] = 0;
4789
4790 rtw_btc_run_coex(btc, BTC_RSN_MEDIADISCON);
4791 }
4792
4793 btc->btc_get(btc, BTC_GET_U1_IOT_PEER, &coex_sta->wl_iot_peer);
4794 rtw_btc_update_wl_ch_info(btc, type);
4795 }
4796
rtw_btc_ex_specific_packet_notify(struct btc_coexist * btc,u8 type)4797 void rtw_btc_ex_specific_packet_notify(struct btc_coexist *btc, u8 type)
4798 {
4799 struct btc_coex_sta *coex_sta = &btc->coex_sta;
4800 boolean under_4way = FALSE;
4801
4802 if (btc->manual_control || btc->stop_coex_dm)
4803 return;
4804
4805 if (type & BTC_5G_BAND) {
4806 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4807 "[BTCoex], %s(): 5G\n", __func__);
4808 BTC_TRACE(trace_buf);
4809
4810 rtw_btc_run_coex(btc, BTC_RSN_5GSPECIALPKT);
4811 return;
4812 }
4813
4814 btc->btc_get(btc, BTC_GET_BL_WIFI_4_WAY_PROGRESS, &under_4way);
4815
4816 if (under_4way) {
4817 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4818 "[BTCoex], %s(): under_4way!!\n", __func__);
4819 BTC_TRACE(trace_buf);
4820
4821 coex_sta->wl_hi_pri_task1 = TRUE;
4822 btc->btc_set_timer(btc, BTC_TIMER_WL_SPECPKT, 2);
4823 } else if (type == BTC_PACKET_ARP) {
4824 coex_sta->cnt_wl[BTC_CNT_WL_ARP]++;
4825
4826 if (coex_sta->wl_hi_pri_task1) {
4827 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4828 "[BTCoex], %s(): ARP cnt = %d\n",
4829 __func__, coex_sta->cnt_wl[BTC_CNT_WL_ARP]);
4830 BTC_TRACE(trace_buf);
4831 }
4832 } else {
4833 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4834 "[BTCoex], %s(): DHCP or EAPOL Type = %d\n",
4835 __func__, type);
4836 BTC_TRACE(trace_buf);
4837
4838 coex_sta->wl_hi_pri_task1 = TRUE;
4839 btc->btc_set_timer(btc, BTC_TIMER_WL_SPECPKT, 2);
4840 }
4841
4842 if (coex_sta->wl_hi_pri_task1)
4843 rtw_btc_run_coex(btc, BTC_RSN_2GSPECIALPKT);
4844 }
4845
rtw_btc_ex_bt_info_notify(struct btc_coexist * btc,u8 * tmp_buf,u8 length)4846 void rtw_btc_ex_bt_info_notify(struct btc_coexist *btc, u8 *tmp_buf, u8 length)
4847 {
4848 struct btc_coex_sta *coex_sta = &btc->coex_sta;
4849 struct btc_coex_dm *coex_dm = &btc->coex_dm;
4850 struct btc_wifi_link_info_ext *link_info_ext = &btc->wifi_link_info_ext;
4851 u8 i, rsp_source = 0, type;
4852
4853 rsp_source = tmp_buf[0] & 0xf;
4854 if (rsp_source >= BTC_BTINFO_SRC_MAX)
4855 return;
4856
4857 /* COEX-649, prevent TDMA parametet change in LeisurePSEnter()*/
4858 if (coex_sta->wl_in_lps_enter) {
4859 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4860 "[BTCoex], %s(): wl_in_LPSenter = %d\n",
4861 __func__, coex_sta->wl_in_lps_enter);
4862 BTC_TRACE(trace_buf);
4863 }
4864
4865 coex_sta->cnt_bt_info_c2h[rsp_source]++;
4866
4867 /* bt_iqk_state-> 1: start, 0: ok, 2:fail */
4868 if (rsp_source == BTC_BTINFO_SRC_BT_IQK) {
4869 coex_sta->bt_iqk_state = tmp_buf[1];
4870 if (coex_sta->bt_iqk_state == 0x0)
4871 coex_sta->cnt_bt[BTC_CNT_BT_IQK]++;
4872 else if (coex_sta->bt_iqk_state == 0x2)
4873 coex_sta->cnt_bt[BTC_CNT_BT_IQKFAIL]++;
4874
4875 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4876 "[BTCoex], BT IQK by bt_info, data0 = 0x%02x\n",
4877 tmp_buf[1]);
4878 BTC_TRACE(trace_buf);
4879 return;
4880 }
4881
4882 if (rsp_source == BTC_BTINFO_SRC_BT_SCBD) {
4883 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4884 "[BTCoex], BT Scoreboard change notify by WL FW c2h, 0xaa = 0x%02x, 0xab = 0x%02x\n",
4885 tmp_buf[1], tmp_buf[2]);
4886 BTC_TRACE(trace_buf);
4887 rtw_btc_monitor_bt_enable(btc);
4888
4889 if (coex_sta->bt_disabled != coex_sta->bt_disabled_pre) {
4890 coex_sta->bt_disabled_pre = coex_sta->bt_disabled;
4891 rtw_btc_run_coex(btc, BTC_RSN_BTINFO);
4892 }
4893 return;
4894 }
4895
4896 if (rsp_source == BTC_BTINFO_SRC_H2C60) {
4897 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4898 "[BTCoex], H2C 0x60 content replied by WL FW: H2C_0x60 = [%02x %02x %02x %02x %02x]\n",
4899 tmp_buf[1], tmp_buf[2], tmp_buf[3], tmp_buf[4],
4900 tmp_buf[5]);
4901 BTC_TRACE(trace_buf);
4902
4903 for (i = 1; i <= 5; i++)
4904 coex_dm->fw_tdma_para[i - 1] = tmp_buf[i];
4905 return;
4906 }
4907
4908 if (rsp_source == BTC_BTINFO_SRC_WL_FW) {
4909 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4910 "[BTCoex], bt_info reply by WL FW\n");
4911 BTC_TRACE(trace_buf);
4912 rtw_btc_update_bt_link_info(btc);
4913 /* rtw_btc_run_coex(btc, BTC_RSN_BTINFO); */
4914 return;
4915 }
4916
4917 if (rsp_source == BTC_BTINFO_SRC_BT_RSP ||
4918 rsp_source == BTC_BTINFO_SRC_BT_ACT) {
4919 if (coex_sta->bt_disabled) {
4920 coex_sta->bt_disabled = FALSE;
4921 coex_sta->bt_reenable = TRUE;
4922 btc->btc_set_timer(btc, BTC_TIMER_BT_REENABLE, 15);
4923
4924 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4925 "[BTCoex], BT enable detected by bt_info\n");
4926 BTC_TRACE(trace_buf);
4927 }
4928 }
4929
4930 if (rsp_source == BTC_BTINFO_SRC_BT_SLOT1) {
4931 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4932 "[BTCoex], BT slot length = [%02x %02x %02x %02x %02x %02x %02x %02x %02x %02x]\n",
4933 tmp_buf[1], tmp_buf[2], tmp_buf[3], tmp_buf[4],
4934 tmp_buf[5], tmp_buf[6], tmp_buf[7], tmp_buf[8],
4935 tmp_buf[9], tmp_buf[10]);
4936 BTC_TRACE(trace_buf);
4937
4938 for (i = 1; i <= 10; i++)
4939 coex_dm->bt_slot_length1[i - 1] = tmp_buf[i];
4940 return;
4941 }
4942
4943 if (rsp_source == BTC_BTINFO_SRC_BT_SLOT2) {
4944 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4945 "[BTCoex], BT slot length = [%02x %02x %02x %02x %02x %02x %02x %02x %02x %02x]\n",
4946 tmp_buf[1], tmp_buf[2], tmp_buf[3], tmp_buf[4],
4947 tmp_buf[5], tmp_buf[6], tmp_buf[7], tmp_buf[8],
4948 tmp_buf[9], tmp_buf[10]);
4949 BTC_TRACE(trace_buf);
4950
4951 for (i = 1; i <= 10; i++)
4952 coex_dm->bt_slot_length2[i - 1] = tmp_buf[i];
4953 return;
4954 }
4955
4956 if (length != 7) {
4957 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4958 "[BTCoex], Bt_info length = %d invalid!!\n",
4959 length);
4960 BTC_TRACE(trace_buf);
4961 return;
4962 }
4963
4964 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4965 "[BTCoex], Bt_info[%d], len=%d, data=[%02x %02x %02x %02x %02x %02x]\n",
4966 tmp_buf[0], length, tmp_buf[1], tmp_buf[2], tmp_buf[3],
4967 tmp_buf[4], tmp_buf[5], tmp_buf[6]);
4968 BTC_TRACE(trace_buf);
4969
4970 for (i = 0; i < 7; i++)
4971 coex_sta->bt_info_c2h[rsp_source][i] = tmp_buf[i];
4972
4973 if (coex_sta->bt_info_c2h[rsp_source][1] == coex_sta->bt_info_lb2 &&
4974 coex_sta->bt_info_c2h[rsp_source][2] == coex_sta->bt_info_lb3 &&
4975 coex_sta->bt_info_c2h[rsp_source][3] == coex_sta->bt_info_hb0 &&
4976 coex_sta->bt_info_c2h[rsp_source][4] == coex_sta->bt_info_hb1 &&
4977 coex_sta->bt_info_c2h[rsp_source][5] == coex_sta->bt_info_hb2 &&
4978 coex_sta->bt_info_c2h[rsp_source][6] == coex_sta->bt_info_hb3) {
4979 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
4980 "[BTCoex], Return because Btinfo duplicate!!\n");
4981 BTC_TRACE(trace_buf);
4982 return;
4983 }
4984
4985 coex_sta->bt_info_lb2 = coex_sta->bt_info_c2h[rsp_source][1];
4986 coex_sta->bt_info_lb3 = coex_sta->bt_info_c2h[rsp_source][2];
4987 coex_sta->bt_info_hb0 = coex_sta->bt_info_c2h[rsp_source][3];
4988 coex_sta->bt_info_hb1 = coex_sta->bt_info_c2h[rsp_source][4];
4989 coex_sta->bt_info_hb2 = coex_sta->bt_info_c2h[rsp_source][5];
4990 coex_sta->bt_info_hb3 = coex_sta->bt_info_c2h[rsp_source][6];
4991
4992 /* ========== BT info Low-Byte2 ========== */
4993 /* if 0xff, it means BT is under WHCK test */
4994 coex_sta->bt_whck_test = (coex_sta->bt_info_lb2 == 0xff);
4995 coex_sta->bt_inq_page = ((coex_sta->bt_info_lb2 & BIT(2)) == BIT(2));
4996
4997 if (coex_sta->bt_inq_page_pre != coex_sta->bt_inq_page) {
4998 coex_sta->bt_inq_page_pre = coex_sta->bt_inq_page;
4999 coex_sta->bt_inq_page_remain = TRUE;
5000
5001 if (!coex_sta->bt_inq_page)
5002 btc->btc_set_timer(btc, BTC_TIMER_BT_INQPAGE, 2);
5003 }
5004 coex_sta->bt_acl_busy = ((coex_sta->bt_info_lb2 & BIT(3)) == BIT(3));
5005
5006 if (coex_sta->bt_info_lb2 & BIT(5)) {
5007 if ((coex_sta->bt_info_hb1 & BIT(0)) == BIT(0)) {
5008 /*BLE HID*/
5009 coex_sta->bt_ble_hid_exist = TRUE;
5010 coex_sta->bt_ble_exist = FALSE;
5011 }
5012 } else if ((coex_sta->bt_info_hb1 & BIT(0)) == BIT(0)) {
5013 /*RCU*/
5014 coex_sta->bt_ble_exist = TRUE;
5015 } else {
5016 coex_sta->bt_ble_hid_exist = FALSE;
5017 coex_sta->bt_ble_exist = FALSE;
5018 }
5019
5020 /* ========== BT info Low-Byte3 ========== */
5021 coex_sta->cnt_bt[BTC_CNT_BT_RETRY] = coex_sta->bt_info_lb3 & 0xf;
5022
5023 if (coex_sta->cnt_bt[BTC_CNT_BT_RETRY] >= 1)
5024 coex_sta->cnt_bt[BTC_CNT_BT_POPEVENT]++;
5025
5026 coex_sta->bt_fix_2M = ((coex_sta->bt_info_lb3 & BIT(4)) == BIT(4));
5027
5028 coex_sta->bt_inq = ((coex_sta->bt_info_lb3 & BIT(5)) == BIT(5));
5029
5030 coex_sta->bt_mesh = ((coex_sta->bt_info_lb3 & BIT(6)) == BIT(6));
5031
5032 if (coex_sta->bt_inq)
5033 coex_sta->cnt_bt[BTC_CNT_BT_INQ]++;
5034
5035 coex_sta->bt_page = ((coex_sta->bt_info_lb3 & BIT(7)) == BIT(7));
5036
5037 if (coex_sta->bt_page)
5038 coex_sta->cnt_bt[BTC_CNT_BT_PAGE]++;
5039
5040 /* ========== BT info High-Byte0 ========== */
5041 /* unit: %, value-100 to translate to unit: dBm */
5042 if (btc->chip_para->bt_rssi_type == BTC_BTRSSI_RATIO) {
5043 coex_sta->bt_rssi = coex_sta->bt_info_hb0 * 2 + 10;
5044 } else { /* coex_sta->bt_info_hb0 is just dbm */
5045 if (coex_sta->bt_info_hb0 <= 127)
5046 coex_sta->bt_rssi = 100;
5047 else if (256 - coex_sta->bt_info_hb0 <= 100)
5048 coex_sta->bt_rssi = 100 - (256 - coex_sta->bt_info_hb0);
5049 else
5050 coex_sta->bt_rssi = 0;
5051 }
5052
5053 /* ========== BT info High-Byte1 ========== */
5054 if (coex_sta->bt_info_hb1 & BIT(1))
5055 coex_sta->cnt_bt[BTC_CNT_BT_REINIT]++;
5056
5057 if ((coex_sta->bt_info_hb1 & BIT(2)) ||
5058 (coex_sta->bt_page && coex_sta->wl_pnp_wakeup)) {
5059 coex_sta->cnt_bt[BTC_CNT_BT_SETUPLINK]++;
5060 coex_sta->bt_setup_link = TRUE;
5061
5062 if (coex_sta->bt_reenable)
5063 btc->btc_set_timer(btc, BTC_TIMER_BT_RELINK, 6);
5064 else
5065 btc->btc_set_timer(btc, BTC_TIMER_BT_RELINK, 1);
5066 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
5067 "[BTCoex], Re-Link start in BT info!!\n");
5068 BTC_TRACE(trace_buf);
5069 }
5070
5071 if (coex_sta->bt_info_hb1 & BIT(3))
5072 coex_sta->cnt_bt[BTC_CNT_BT_IGNWLANACT]++;
5073
5074 coex_sta->bt_ble_voice = ((coex_sta->bt_info_hb1 & BIT(4)) == BIT(4));
5075 coex_sta->bt_ble_scan_en = ((coex_sta->bt_info_hb1 & BIT(5)) == BIT(5));
5076
5077 if (coex_sta->bt_info_hb1 & BIT(6))
5078 coex_sta->cnt_bt[BTC_CNT_BT_ROLESWITCH]++;
5079
5080 coex_sta->bt_multi_link = ((coex_sta->bt_info_hb1 & BIT(7)) == BIT(7));
5081
5082 /* for multi_link = 0 but bt pkt remain exist ->
5083 * Use PS-TDMA to protect WL RX
5084 */
5085 if (!coex_sta->bt_multi_link && coex_sta->bt_multi_link_pre) {
5086 coex_sta->bt_multi_link_remain = TRUE;
5087 btc->btc_set_timer(btc, BTC_TIMER_BT_MULTILINK, 3);
5088 }
5089
5090 coex_sta->bt_multi_link_pre = coex_sta->bt_multi_link;
5091
5092 /* Here we need to resend some wifi info to BT */
5093 /* because bt is reset and loss of the info. */
5094 /* Re-Init */
5095 if ((coex_sta->bt_info_hb1 & BIT(1))) {
5096 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
5097 "[BTCoex], BT Re-init, send wifi BW & Chnl to BT!!\n");
5098 BTC_TRACE(trace_buf);
5099 if (link_info_ext->is_connected)
5100 type = BTC_MEDIA_CONNECT;
5101 else
5102 type = BTC_MEDIA_DISCONNECT;
5103 rtw_btc_update_wl_ch_info(btc, type);
5104 }
5105
5106 /* If Ignore_WLanAct && not SetUp_Link */
5107 if ((coex_sta->bt_info_hb1 & BIT(3)) &&
5108 (!(coex_sta->bt_info_hb1 & BIT(2)))) {
5109 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
5110 "[BTCoex], BT ext info bit3 check, set BT NOT to ignore Wlan active!!\n");
5111 BTC_TRACE(trace_buf);
5112 rtw_btc_ignore_wlan_act(btc, FC_EXCU, FALSE);
5113 }
5114
5115 /* ========== BT info High-Byte2 ========== */
5116 coex_sta->bt_opp_exist = ((coex_sta->bt_info_hb2 & BIT(0)) == BIT(0));
5117
5118 if (coex_sta->bt_info_hb2 & BIT(1))
5119 coex_sta->cnt_bt[BTC_CNT_BT_AFHUPDATE]++;
5120
5121 coex_sta->bt_a2dp_active = ((coex_sta->bt_info_hb2 & BIT(2)) == BIT(2));
5122
5123 /*for a2dp_active = 0 but bt pkt remain exist ->
5124 * Use PS-TDMA to protect WL RX*/
5125 if (!coex_sta->bt_a2dp_active && coex_sta->bt_a2dp_active_pre) {
5126 coex_sta->bt_a2dp_active_remain = TRUE;
5127 btc->btc_set_timer(btc, BTC_TIMER_BT_A2DP_ACT, 5);
5128 }
5129
5130 coex_sta->bt_a2dp_active_pre = coex_sta->bt_a2dp_active;
5131
5132 coex_sta->bt_slave = ((coex_sta->bt_info_hb2 & BIT(3)) == BIT(3));
5133 coex_sta->bt_hid_slot = (coex_sta->bt_info_hb2 & 0x30) >> 4;
5134 coex_sta->bt_hid_pair_num = (coex_sta->bt_info_hb2 & 0xc0) >> 6;
5135
5136 if (coex_sta->bt_hid_pair_num > 0 && coex_sta->bt_hid_slot >= 2) {
5137 coex_sta->bt_418_hid_exist = TRUE;
5138 } else if (coex_sta->bt_hid_pair_num == 0 ||
5139 coex_sta->bt_hid_slot == 1) {
5140 coex_sta->bt_418_hid_exist = FALSE;
5141 }
5142
5143 /* ========== BT info High-Byte3 ========== */
5144 if ((coex_sta->bt_info_lb2 & 0x49) == 0x49)
5145 coex_sta->bt_a2dp_bitpool = (coex_sta->bt_info_hb3 & 0x7f);
5146 else
5147 coex_sta->bt_a2dp_bitpool = 0;
5148
5149 coex_sta->bt_a2dp_sink = ((coex_sta->bt_info_hb3 & BIT(7)) == BIT(7));
5150
5151 rtw_btc_update_bt_link_info(btc);
5152
5153 if (!coex_sta->wl_in_lps_enter)
5154 rtw_btc_run_coex(btc, BTC_RSN_BTINFO);
5155 }
5156
rtw_btc_ex_wl_fwdbginfo_notify(struct btc_coexist * btc,u8 * tmp_buf,u8 length)5157 void rtw_btc_ex_wl_fwdbginfo_notify(struct btc_coexist *btc, u8 *tmp_buf,
5158 u8 length)
5159 {
5160 struct btc_coex_sta *coex_sta = &btc->coex_sta;
5161 u8 i = 0, val = 0;
5162
5163 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
5164 "[BTCoex], WiFi Fw Dbg info = %d %d %d %d %d %d %d %d (len = %d)\n",
5165 tmp_buf[0], tmp_buf[1], tmp_buf[2], tmp_buf[3], tmp_buf[4],
5166 tmp_buf[5], tmp_buf[6], tmp_buf[7], length);
5167 BTC_TRACE(trace_buf);
5168
5169 if (tmp_buf[0] != 0x8)
5170 return;
5171
5172 for (i = 1; i <= 7; i++) {
5173 val = coex_sta->wl_fw_dbg_info_pre[i];
5174 if (tmp_buf[i] >= val)
5175 coex_sta->wl_fw_dbg_info[i] = tmp_buf[i] - val;
5176 else
5177 coex_sta->wl_fw_dbg_info[i] = 255 - val + tmp_buf[i];
5178
5179 coex_sta->wl_fw_dbg_info_pre[i] = tmp_buf[i];
5180 }
5181
5182 /* wl_fwdbginfo_notify is auto send by WL FW if TDMA slot toggle = 20
5183 * coex_sta->wl_fw_dbg_info[6] = TDMA slot toggle
5184 * For debug, TDMA slot toggle should be calculated by 2-second
5185 */
5186 coex_sta->cnt_wl[BTC_CNT_WL_FW_NOTIFY]++;
5187 rtw_btc_wl_ccklock_action(btc);
5188 }
5189
rtw_btc_ex_rx_rate_change_notify(struct btc_coexist * btc,BOOLEAN is_data_frame,u8 btc_rate_id)5190 void rtw_btc_ex_rx_rate_change_notify(struct btc_coexist *btc,
5191 BOOLEAN is_data_frame, u8 btc_rate_id)
5192 {
5193 struct btc_coex_sta *coex_sta = &btc->coex_sta;
5194
5195 if (is_data_frame)
5196 coex_sta->wl_rx_rate = btc_rate_id;
5197
5198 else
5199 coex_sta->wl_rts_rx_rate = btc_rate_id;
5200
5201 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
5202 "[BTCoex], %s(): rate id = %d, RTS_Rate = %d\n", __func__,
5203 coex_sta->wl_rx_rate, coex_sta->wl_rts_rx_rate);
5204 BTC_TRACE(trace_buf);
5205
5206 rtw_btc_wl_ccklock_detect(btc);
5207 }
5208
rtw_btc_ex_tx_rate_change_notify(struct btc_coexist * btc,u8 tx_rate,u8 tx_retry_ratio,u8 macid)5209 void rtw_btc_ex_tx_rate_change_notify(struct btc_coexist *btc, u8 tx_rate,
5210 u8 tx_retry_ratio, u8 macid)
5211 {
5212 struct btc_coex_sta *coex_sta = &btc->coex_sta;
5213
5214 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
5215 "[BTCoex], %s(): Tx_Rate = %d, Tx_Retry_Ratio = %d, macid =%d\n",
5216 __func__, tx_rate, tx_retry_ratio, macid);
5217 BTC_TRACE(trace_buf);
5218
5219 coex_sta->wl_tx_rate = tx_rate;
5220 coex_sta->wl_tx_retry_ratio = tx_retry_ratio;
5221 coex_sta->wl_tx_macid = macid;
5222 }
5223
rtw_btc_ex_rf_status_notify(struct btc_coexist * btc,u8 type)5224 void rtw_btc_ex_rf_status_notify(struct btc_coexist *btc, u8 type)
5225 {
5226 struct btc_coex_sta *coex_sta = &btc->coex_sta;
5227
5228 if (type == BTC_RF_ON) {
5229 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
5230 "[BTCoex], %s(): RF is turned ON!!\n", __func__);
5231 BTC_TRACE(trace_buf);
5232 btc->stop_coex_dm = FALSE;
5233 btc->wl_rf_state_off = FALSE;
5234
5235 } else if (type == BTC_RF_OFF) {
5236 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
5237 "[BTCoex], %s(): RF is turned Off!!\n", __func__);
5238 BTC_TRACE(trace_buf);
5239
5240 rtw_btc_action_wl_off(btc);
5241 }
5242 }
5243
rtw_btc_ex_halt_notify(struct btc_coexist * btc)5244 void rtw_btc_ex_halt_notify(struct btc_coexist *btc)
5245 {
5246 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE, "[BTCoex], %s()\n", __func__);
5247 BTC_TRACE(trace_buf);
5248
5249 rtw_btc_action_wl_off(btc);
5250 }
5251
rtw_btc_ex_pnp_notify(struct btc_coexist * btc,u8 pnp_state)5252 void rtw_btc_ex_pnp_notify(struct btc_coexist *btc, u8 pnp_state)
5253 {
5254 struct btc_coex_sta *coex_sta = &btc->coex_sta;
5255 struct btc_wifi_link_info_ext *link_info_ext = &btc->wifi_link_info_ext;
5256 const struct btc_chip_para *chip_para = btc->chip_para;
5257 u8 phase;
5258
5259 if (pnp_state == BTC_WIFI_PNP_SLEEP ||
5260 pnp_state == BTC_WIFI_PNP_SLEEP_KEEP_ANT) {
5261 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
5262 "[BTCoex], %s(): Sleep\n", __func__);
5263 BTC_TRACE(trace_buf);
5264
5265 if (chip_para->scbd_bit_num == BTC_SCBD_16_BIT)
5266 btc->btc_write_scbd(btc, BTC_SCBD_ALL, FALSE);
5267 else
5268 btc->btc_write_scbd_32bit(btc, BTC_SCBD_ALL_32BIT, FALSE);
5269
5270 if (pnp_state == BTC_WIFI_PNP_SLEEP_KEEP_ANT) {
5271 if (link_info_ext->is_all_under_5g)
5272 phase = BTC_ANT_5G;
5273 else
5274 phase = BTC_ANT_2G;
5275 } else {
5276 phase = BTC_ANT_WOFF;
5277 }
5278 rtw_btc_set_ant_path(btc, FC_EXCU, phase);
5279
5280 btc->stop_coex_dm = TRUE;
5281 } else {
5282 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
5283 "[BTCoex], %s(): Wake up\n", __func__);
5284 BTC_TRACE(trace_buf);
5285 coex_sta->wl_pnp_wakeup = TRUE;
5286 btc->btc_set_timer(btc, BTC_TIMER_WL_PNPWAKEUP, 3);
5287
5288 /*WoWLAN*/
5289 if (coex_sta->wl_pnp_state_pre == BTC_WIFI_PNP_SLEEP_KEEP_ANT ||
5290 pnp_state == BTC_WIFI_PNP_WOWLAN) {
5291 btc->stop_coex_dm = FALSE;
5292 rtw_btc_run_coex(btc, BTC_RSN_PNP);
5293 }
5294 }
5295
5296 coex_sta->wl_pnp_state_pre = pnp_state;
5297 }
5298
rtw_btc_ex_coex_dm_reset(struct btc_coexist * btc)5299 void rtw_btc_ex_coex_dm_reset(struct btc_coexist *btc)
5300 {
5301 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE, "[BTCoex], %s()\n", __func__);
5302 BTC_TRACE(trace_buf);
5303
5304 rtw_btc_init_hw_config(btc, FALSE);
5305 }
5306
rtw_btc_ex_periodical(struct btc_coexist * btc)5307 void rtw_btc_ex_periodical(struct btc_coexist *btc)
5308 {
5309 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
5310 "[BTCoex], ============== Periodical ==============\n");
5311 BTC_TRACE(trace_buf);
5312 }
5313
rtw_btc_ex_timerup_notify(struct btc_coexist * btc,u32 type)5314 void rtw_btc_ex_timerup_notify(struct btc_coexist *btc, u32 type)
5315 {
5316 struct btc_coex_sta *coex_sta = &btc->coex_sta;
5317 const struct btc_chip_para *chip_para = btc->chip_para;
5318 boolean is_change = FALSE;
5319
5320 /* COEX-649, prevent TDMA parametet change in LeisurePSEnter()*/
5321 if (coex_sta->wl_in_lps_enter) {
5322 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
5323 "[BTCoex], %s(): wl_in_LPSenter = %d\n",
5324 __func__, coex_sta->wl_in_lps_enter);
5325 BTC_TRACE(trace_buf);
5326 }
5327
5328 if (type & BIT(BTC_TIMER_WL_STAYBUSY)) {
5329 if (!coex_sta->wl_busy_pre) {
5330 coex_sta->wl_gl_busy = FALSE;
5331 is_change = TRUE;
5332 rtw_btc_update_wl_ch_info(btc, BTC_MEDIA_DISCONNECT);
5333 if (chip_para->scbd_bit_num == BTC_SCBD_16_BIT)
5334 btc->btc_write_scbd(btc, BTC_SCBD_WLBUSY, FALSE);
5335 else
5336 btc->btc_write_scbd_32bit(btc, BTC_SCBD_WLBUSY, FALSE);
5337 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
5338 "[BTCoex], %s(): WL busy -> idle!!\n", __func__);
5339 BTC_TRACE(trace_buf);
5340 }
5341 }
5342
5343 /*avoid no connect finish notify */
5344 if (type & BIT(BTC_TIMER_WL_COEXFREEZE)) {
5345 coex_sta->coex_freeze = FALSE;
5346 coex_sta->wl_hi_pri_task1 = FALSE;
5347 is_change = TRUE;
5348 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
5349 "[BTCoex], %s(): Coex is de-freeze!!\n", __func__);
5350 BTC_TRACE(trace_buf);
5351 }
5352
5353 if (type & BIT(BTC_TIMER_WL_SPECPKT)) {
5354 if (!coex_sta->coex_freeze) {
5355 coex_sta->wl_hi_pri_task1 = FALSE;
5356 is_change = TRUE;
5357 }
5358 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
5359 "[BTCoex], %s(): WL SPECPKT finish!\n", __func__);
5360 BTC_TRACE(trace_buf);
5361 }
5362
5363 /*for A2DP glitch during connecting AP*/
5364 if (type & BIT(BTC_TIMER_WL_CONNPKT)) {
5365 coex_sta->wl_connecting = FALSE;
5366 is_change = TRUE;
5367 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
5368 "[BTCoex], %s(): WL connecting stop!!\n", __func__);
5369 BTC_TRACE(trace_buf);
5370 }
5371
5372 if (type & BIT(BTC_TIMER_WL_PNPWAKEUP)) {
5373 coex_sta->wl_pnp_wakeup = FALSE;
5374 is_change = TRUE;
5375 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
5376 "[BTCoex], %s(): WL pnp wakeup stop!!\n", __func__);
5377 BTC_TRACE(trace_buf);
5378 }
5379
5380 if (type & BIT(BTC_TIMER_WL_CCKLOCK)) {
5381 if (coex_sta->wl_cck_lock_pre) {
5382 coex_sta->wl_cck_lock_ever = TRUE;
5383 is_change = TRUE;
5384 }
5385 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
5386 "[BTCoex], %s(): WL CCK Lock Detect!!\n", __func__);
5387 BTC_TRACE(trace_buf);
5388 }
5389
5390 if (type & BIT(BTC_TIMER_BT_RELINK)) {
5391 coex_sta->bt_setup_link = FALSE;
5392 is_change = TRUE;
5393 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
5394 "[BTCoex], %s(): Re-Link stop!!\n", __func__);
5395 BTC_TRACE(trace_buf);
5396 }
5397
5398 if (type & BIT(BTC_TIMER_BT_REENABLE)) {
5399 coex_sta->bt_reenable = FALSE;
5400 is_change = TRUE;
5401 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
5402 "[BTCoex], %s(): BT renable finish!!\n", __func__);
5403 BTC_TRACE(trace_buf);
5404 }
5405
5406 if (type & BIT(BTC_TIMER_BT_MULTILINK)) {
5407 coex_sta->bt_multi_link_remain = FALSE;
5408 is_change = TRUE;
5409 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
5410 "[BTCoex], %s(): BT multilink disappear !!\n",
5411 __func__);
5412 BTC_TRACE(trace_buf);
5413 }
5414
5415 if (type & BIT(BTC_TIMER_BT_INQPAGE)) {
5416 coex_sta->bt_inq_page_remain = FALSE;
5417 is_change = TRUE;
5418 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
5419 "[BTCoex], %s(): BT inq_page disappear !!\n",
5420 __func__);
5421 BTC_TRACE(trace_buf);
5422 }
5423
5424 if (type & BIT(BTC_TIMER_BT_A2DP_ACT)) {
5425 coex_sta->bt_a2dp_active_remain = FALSE;
5426 is_change = TRUE;
5427 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
5428 "[BTCoex], %s(): BT A2DP active disappear !!\n",
5429 __func__);
5430 BTC_TRACE(trace_buf);
5431 }
5432
5433 if (is_change && !coex_sta->wl_in_lps_enter)
5434 rtw_btc_run_coex(btc, BTC_RSN_TIMERUP);
5435 }
5436
rtw_btc_ex_wl_status_change_notify(struct btc_coexist * btc,u32 type)5437 void rtw_btc_ex_wl_status_change_notify(struct btc_coexist *btc, u32 type)
5438 {
5439 struct btc_coex_sta *coex_sta = &btc->coex_sta;
5440 boolean is_change = FALSE;
5441
5442 if (type & BIT(BTC_WLSTATUS_CHANGE_TOIDLE)) { /* if busy->idle */
5443 coex_sta->wl_busy_pre = FALSE;
5444 btc->btc_set_timer(btc, BTC_TIMER_WL_STAYBUSY, 6);
5445 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
5446 "[BTCoex], %s(): WL busy -> idle!!\n", __func__);
5447 BTC_TRACE(trace_buf);
5448 }
5449
5450 if (type & BIT(BTC_WLSTATUS_CHANGE_TOBUSY)) { /* if idle->busy */
5451 coex_sta->wl_gl_busy = TRUE;
5452 coex_sta->wl_busy_pre = TRUE;
5453 is_change = TRUE;
5454 rtw_btc_update_wl_ch_info(btc, BTC_MEDIA_CONNECT);
5455 #if 0
5456 btc->btc_write_scbd(btc, BTC_SCBD_WLBUSY, TRUE);
5457 #endif
5458 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
5459 "[BTCoex], %s(): WL idle -> busy!!\n", __func__);
5460 BTC_TRACE(trace_buf);
5461 }
5462
5463 if (type & BIT(BTC_WLSTATUS_CHANGE_RSSI)) { /* if RSSI change */
5464 is_change = TRUE;
5465 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
5466 "[BTCoex], %s(): WL RSSI change!!\n", __func__);
5467 BTC_TRACE(trace_buf);
5468 }
5469
5470 if (type & BIT(BTC_WLSTATUS_CHANGE_LINKINFO)) { /* if linkinfo change */
5471 is_change = TRUE;
5472 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
5473 "[BTCoex], %s(): WL LinkInfo change!!\n", __func__);
5474 BTC_TRACE(trace_buf);
5475 }
5476
5477 if (type & BIT(BTC_WLSTATUS_CHANGE_DIR)) { /*if WL UL-DL change*/
5478 is_change = TRUE;
5479 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
5480 "[BTCoex], %s(): WL UL-DL change!!\n", __func__);
5481 BTC_TRACE(trace_buf);
5482 }
5483
5484 if (type & BIT(BTC_WLSTATUS_CHANGE_NOISY)) { /*if noisy level change*/
5485 is_change = TRUE;
5486 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
5487 "[BTCoex], %s():Noisy Level change!!\n", __func__);
5488 BTC_TRACE(trace_buf);
5489 }
5490
5491 if (type & BIT(BTC_WLSTATUS_CHANGE_BTCNT)) { /*if BT counter change*/
5492 is_change = TRUE;
5493 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
5494 "[BTCoex], %s():BT counter change!!\n", __func__);
5495 BTC_TRACE(trace_buf);
5496 }
5497
5498 if (type & BIT(BTC_WLSTATUS_CHANGE_LOCKTRY)) { /*if WL CCK lock try*/
5499 is_change = TRUE;
5500 coex_sta->wl_cck_lock_ever = FALSE;
5501 coex_sta->wl_cck_lock = FALSE;
5502 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
5503 "[BTCoex], %s():WL CCK lock try!!\n", __func__);
5504 BTC_TRACE(trace_buf);
5505 }
5506
5507 if (is_change)
5508 rtw_btc_run_coex(btc, BTC_RSN_WLSTATUS);
5509 }
5510
rtw_btc_ex_wl_rfk_notify(struct btc_coexist * btc,u8 path,u8 type,u8 state)5511 void rtw_btc_ex_wl_rfk_notify(struct btc_coexist *btc, u8 path, u8 type, u8 state)
5512 {
5513 struct btc_coex_sta *coex_sta = &btc->coex_sta;
5514
5515 BTC_SPRINTF(trace_buf, BT_TMP_BUF_SIZE,
5516 "[BTCoex], %s(), RFK path = %d, type = %d, state = %d\n",
5517 __func__, path, type, state);
5518 BTC_TRACE(trace_buf);
5519
5520 if (state == BTC_RFK_START) {
5521 coex_sta->wl_rfk = TRUE;
5522 } else {
5523 coex_sta->wl_rfk = FALSE;
5524
5525 /*Run coex due to RFK end*/
5526 rtw_btc_run_coex(btc, BTC_RSN_RFK);
5527 }
5528 }
5529 #endif
5530 /* #if (BT_SUPPORT == 1 && COEX_SUPPORT == 1) */
5531